astrbot_plugin_private_comp.../tests/test_p4_manual_review.py

586 行
26 KiB
Python

# -*- coding: utf-8 -*-
"""Pure P4 manual-review boundary tests: no P4 live effect is exercised."""
from __future__ import annotations
from copy import deepcopy
from datetime import datetime, timedelta, timezone
import importlib
from pathlib import Path
import sys
import types
import unittest
ROOT = Path(__file__).resolve().parents[1]
if str(ROOT) not in sys.path:
sys.path.insert(0, str(ROOT))
from p4_manual_review import (
P3_CONTRACT_NAME,
P3_CONTRACT_VERSION,
P3_LAYERS,
_new_p4_review_attestation_registry,
p3_contract_fingerprint,
parse_owner_allowlist,
runtime_owner_identity,
)
from unified_person_contract import empty_unified_person_store
from unified_person_registry import UnifiedPersonRegistry
sys.path.insert(0, str(Path(__file__).resolve().parent))
import _host_stub # noqa: E402
_host_stub.install()
_PACKAGE = "_p4_manual_review_core_store_companion"
if _PACKAGE not in sys.modules:
package = types.ModuleType(_PACKAGE)
package.__path__ = [str(ROOT)]
sys.modules[_PACKAGE] = package
core_store_module = importlib.import_module(f"{_PACKAGE}.core_store")
core_review_module = importlib.import_module(f"{_PACKAGE}.p4_manual_review")
context_module = importlib.import_module(f"{_PACKAGE}.context_orchestration")
def identity(subject_id: str) -> dict[str, str]:
return {
"companion_instance_id": "companion-a",
"bot_account_id": "bot-a",
"adapter_instance_id": "telegram-main",
"subject_namespace": "telegram.user",
"platform_subject_id": subject_id,
}
def timestamp(value: datetime) -> str:
return value.astimezone(timezone.utc).isoformat(timespec="seconds").replace("+00:00", "Z")
def candidate(
person_id: str,
*,
token: str = "one",
assurance: str = "verified",
created_offset: timedelta = timedelta(),
expires_in: timedelta = timedelta(hours=1),
scope_id: str = "aiocqhttp:group-1",
) -> dict:
created = (datetime.now(timezone.utc) + created_offset).replace(microsecond=0)
created_at = timestamp(created)
return {
"candidate_id": f"candidate-{token}",
"event_id": f"event-{token}",
"person_id": person_id,
"scope_kind": "group",
"scope_id": scope_id,
"created_at": created_at,
"expires_at": timestamp(created + expires_in),
"reason_code": "p3_finalized_observed",
"p3_proof": {
"contract_name": P3_CONTRACT_NAME,
"contract_version": P3_CONTRACT_VERSION,
"contract_fingerprint": p3_contract_fingerprint(),
"completed_layers": list(P3_LAYERS),
"phase": "finalized",
"finalized": True,
"security_status": "allowed",
"response_policy": "inherit",
"security_event_id": "",
"person_id": person_id,
"identity_assurance": assurance,
"scope_kind": "group",
"scope_id": scope_id,
"created_at": created_at,
},
}
class _RuntimeEvent:
def __init__(self, sender_id: object = "owner-a", *, raises: bool = False, group_id: str = "group-1", platform: str = "aiocqhttp") -> None:
self._sender_id = sender_id
self._raises = raises
self._group_id = group_id
self._platform = platform
# These forged event fields must never be read by the owner gate.
self.sender_id = "forged-field-owner"
self.user_id = "forged-field-owner"
def get_group_id(self):
return self._group_id
def get_platform_name(self):
return self._platform
def get_sender_id(self):
if self._raises:
raise RuntimeError("runtime unavailable")
return self._sender_id
def _make_candidate_attestation(raw: dict, operation_id: str, review_module=None):
state = _build_p3_state(raw)
request = object()
event = _RuntimeEvent("sender-42")
registry = (review_module or sys.modules["p4_manual_review"])._new_p4_review_attestation_registry()
handle = registry.mint(request, event, state, raw, operation_id=operation_id)
return handle, request, event, state
def _build_p3_state(raw: dict) -> dict:
state = context_module.new_context_state(scope="group", created_at=raw["created_at"])
context_module.update_security(state, status=raw["p3_proof"]["security_status"], response_policy=raw["p3_proof"]["response_policy"])
for layer in context_module.LAYERS:
context_module.complete_layer(state, layer)
context_module.finalize_state(state)
return state
class _CoreStoreHost(core_store_module.CoreStoreMixin):
def __init__(self, data: dict) -> None:
self.data = data
self.save_calls = 0
self.enable_p4_manual_review = True
def _schedule_data_save(self) -> None:
self.save_calls += 1
class P4ManualReviewOwnerGateTests(unittest.TestCase):
def test_config_allowlist_parses_only_safe_single_line_ids(self) -> None:
self.assertEqual(
("owner-a", "owner-b", "owner-c", "123"),
parse_owner_allowlist([" owner-a, owner-b\nowner-c ", 123, "owner-a"]),
)
self.assertEqual((), parse_owner_allowlist({"owner": "not-a-list"}))
self.assertEqual((), parse_owner_allowlist(["owner-a\x00evil", "\n"]))
def test_runtime_owner_requires_direct_get_sender_id_and_allowlist_match(self) -> None:
accepted = runtime_owner_identity(_RuntimeEvent("owner-a"), "owner-a, owner-b")
self.assertTrue(accepted["accepted"])
self.assertEqual("owner-a", accepted["actor_id"])
cases = [
({"get_sender_id": lambda: "owner-a", "sender_id": "owner-a"}, "p4_review_owner_runtime_missing"),
(_RuntimeEvent("intruder"), "p4_review_owner_not_allowed"),
(_RuntimeEvent("owner-a\nforged"), "p4_review_owner_runtime_invalid"),
(_RuntimeEvent(raises=True), "p4_review_owner_runtime_unavailable"),
(None, "p4_review_owner_runtime_missing"),
]
for event, code in cases:
with self.subTest(code=code):
result = runtime_owner_identity(event, ["owner-a"])
self.assertFalse(result["accepted"])
self.assertEqual(code, result["code"])
class P4ManualReviewAttestationTests(unittest.TestCase):
def _mint(self, *, registry=None, operation_id="attestation-op"):
raw = candidate("person-attestation", token=operation_id)
state = _build_p3_state(raw)
request = object()
event = _RuntimeEvent("sender-42")
registry = registry or _new_p4_review_attestation_registry()
handle = registry.mint(request, event, state, raw, operation_id=operation_id)
self.assertIsNotNone(handle)
return registry, handle, request, event, state, raw
def test_attestation_binds_exact_carriers_candidate_and_operation_once(self) -> None:
registry, handle, request, event, state, raw = self._mint()
snapshot = registry.consume(handle, request, event, state, raw, operation_id="attestation-op")
self.assertIsInstance(snapshot, dict)
self.assertEqual("attestation-op", snapshot["operation_id"])
self.assertIsNone(registry.consume(handle, request, event, state, raw, operation_id="attestation-op"))
def test_wrong_carrier_or_candidate_consumes_handle_and_cannot_retry(self) -> None:
registry, handle, request, event, state, raw = self._mint()
wrong_candidate = deepcopy(raw)
wrong_candidate["reason_code"] = "different_reason"
self.assertIsNone(
registry.consume(handle, request, event, state, wrong_candidate, operation_id="attestation-op")
)
self.assertIsNone(registry.consume(handle, request, event, state, raw, operation_id="attestation-op"))
def test_fake_handle_and_expiry_fail_closed(self) -> None:
registry, handle, request, event, state, raw = self._mint()
self.assertIsNone(registry.consume(object(), request, event, state, raw, operation_id="attestation-op"))
now = [0.0]
expiring = _new_p4_review_attestation_registry(clock=lambda: now[0], default_ttl_seconds=1.0)
expiring_handle, expiring_request, expiring_event, expiring_state, expiring_raw = self._mint(
registry=expiring, operation_id="expiring-op"
)[1:]
now[0] = 2.0
self.assertIsNone(
expiring.consume(
expiring_handle,
expiring_request,
expiring_event,
expiring_state,
expiring_raw,
operation_id="expiring-op",
)
)
class P4ManualReviewRegistryTests(unittest.TestCase):
def setUp(self) -> None:
self.store = {"unified_person": empty_unified_person_store()}
self.registry = UnifiedPersonRegistry(self.store)
def _person(self, subject: str = "reviewer-target", *, assurance: str = "verified") -> str:
result = self.registry.upsert_observed_identity(identity(subject), operation_id=f"observe-{subject}")
self.assertTrue(result["ok"])
person_id = result["person_id"]
self.store["unified_person"]["profiles"][person_id]["identity_assurance"] = assurance
return person_id
def _queue(self, person_id: str, token: str = "one", *, operation_id: str | None = None, **kwargs) -> dict:
raw = candidate(person_id, token=token, **kwargs)
return self._record_candidate(person_id, raw, operation_id=operation_id or f"queue-{token}")
@staticmethod
def _p3_state(raw: dict) -> dict:
state = context_module.new_context_state(scope="group", created_at=raw["created_at"])
context_module.update_security(state, status=raw["p3_proof"]["security_status"], response_policy=raw["p3_proof"]["response_policy"])
for layer in context_module.LAYERS:
context_module.complete_layer(state, layer)
context_module.finalize_state(state)
return state
def _record_candidate(self, person_id: str, raw: dict, *, operation_id: str) -> dict:
attestation, request, event, state = self._mint(raw, operation_id=operation_id)
return self.registry.record_p4_manual_review_candidate(
person_id,
raw,
operation_id=operation_id,
producer_attestation=attestation,
producer_request=request,
producer_event=event,
producer_state=state,
)
def _mint(self, raw: dict, *, operation_id: str):
request = object()
event = _RuntimeEvent("sender-42")
state = self._p3_state(raw)
registry = _new_p4_review_attestation_registry()
attestation = registry.mint(request, event, state, raw, operation_id=operation_id)
return attestation, request, event, state
def test_candidate_queue_is_additive_and_ignores_forged_self_authorization(self) -> None:
person_id = self._person()
profile_before = deepcopy(self.store["unified_person"]["profiles"][person_id])
raw = candidate(person_id)
raw.update({"authorized": True, "approved": True, "owner": "forged-owner"})
result = self._record_candidate(person_id, raw, operation_id="queue-one")
self.assertTrue(result["ok"])
self.assertEqual("p4_review_candidate_recorded", result["code"])
self.assertFalse(result["live_effect_permitted"])
self.assertFalse(result["effect_applied"])
self.assertEqual(profile_before, self.store["unified_person"]["profiles"][person_id])
root = self.store["unified_person"]
self.assertIn("p4_review", root)
self.assertNotIn("p4_shadow", root)
self.assertNotIn("p4_effect", root)
saved = root["p4_review"]["candidates"]["candidate-one"]
self.assertNotIn("authorized", saved)
self.assertNotIn("approved", saved)
self.assertNotIn("owner", saved)
self.assertEqual("p4_manual_review_candidate_recorded", self.registry.audit_events()[-1]["action"])
def test_candidate_requires_observer_token_and_exact_p3_policy(self) -> None:
person_id = self._person("producer-boundary")
raw = candidate(person_id, token="producer-boundary")
denied = self.registry.record_p4_manual_review_candidate(
person_id, raw, operation_id="producer-missing"
)
self.assertEqual("p4_review_producer_unavailable", denied["code"])
original = candidate(person_id, token="producer-forged-policy")
attestation, request, event, state = self._mint(original, operation_id="producer-forged-policy")
forged = deepcopy(original)
forged["p3_proof"]["response_policy"] = "forged-policy"
invalid = self.registry.record_p4_manual_review_candidate(
person_id,
forged,
operation_id="producer-forged-policy",
producer_attestation=attestation,
producer_request=request,
producer_event=event,
producer_state=state,
)
self.assertEqual("p4_review_candidate_p3_proof_invalid", invalid["code"])
def test_missing_unknown_inactive_low_assurance_cross_person_and_expired_candidates_fail_closed(self) -> None:
missing = self.registry.record_p4_manual_review_candidate(
"person-missing", {"candidate_id": "only"}, operation_id="missing-fields"
)
self.assertEqual("p4_review_candidate_missing_required_field", missing["code"])
self.assertNotIn("p4_review", self.store["unified_person"])
person_id = self._person("unknown-check")
unknown = self._record_candidate("person-other", candidate("person-other", token="unknown"), operation_id="unknown")
self.assertEqual("person_not_found", unknown["code"])
cross_person = self._record_candidate(person_id, candidate("person-other", token="cross"), operation_id="cross")
self.assertEqual("p4_review_candidate_person_mismatch", cross_person["code"])
self.store["unified_person"]["profiles"][person_id]["profile_status"] = "suspended"
inactive = self._queue(person_id, "inactive")
self.assertEqual("person_not_active", inactive["code"])
self.store["unified_person"]["profiles"][person_id]["profile_status"] = "active"
self.store["unified_person"]["profiles"][person_id]["identity_assurance"] = "observed"
low_assurance = self._queue(person_id, "low")
self.assertEqual("p4_review_person_assurance_insufficient", low_assurance["code"])
self.store["unified_person"]["profiles"][person_id]["identity_assurance"] = "verified"
expired = self._queue(
person_id,
"expired",
created_offset=timedelta(hours=-2),
expires_in=timedelta(hours=1),
)
self.assertEqual("p4_review_candidate_expired", expired["code"])
self.assertNotIn("p4_review", self.store["unified_person"])
def test_candidate_idempotence_duplicate_and_conflicts_do_not_overwrite(self) -> None:
person_id = self._person("idempotence")
raw = candidate(person_id, token="idempotence")
first = self._record_candidate(person_id, raw, operation_id="candidate-op")
self.assertTrue(first["ok"])
snapshot = deepcopy(self.store)
repeated = self._record_candidate(person_id, deepcopy(raw), operation_id="candidate-op")
self.assertTrue(repeated["ok"])
self.assertTrue(repeated["idempotent"])
self.assertEqual(snapshot, self.store)
duplicate = self._record_candidate(person_id, deepcopy(raw), operation_id="candidate-duplicate-op")
self.assertTrue(duplicate["ok"])
self.assertTrue(duplicate["candidate_duplicate"])
self.assertFalse(duplicate["changed"])
conflict_snapshot = deepcopy(self.store)
conflicting_candidate = deepcopy(raw)
conflicting_candidate["reason_code"] = "different_reason"
conflict = self._record_candidate(person_id, conflicting_candidate, operation_id="candidate-conflict-op")
self.assertEqual("p4_review_candidate_id_conflict", conflict["code"])
self.assertEqual(conflict_snapshot, self.store)
operation_conflict = self._queue(person_id, "other", operation_id="candidate-op")
self.assertEqual("operation_id_conflict", operation_conflict["code"])
self.assertEqual(conflict_snapshot, self.store)
def test_decision_requires_runtime_owner_and_is_audit_only(self) -> None:
person_id = self._person("decision")
self.assertTrue(self._queue(person_id, "decision")["ok"])
profile_before = deepcopy(self.store["unified_person"]["profiles"][person_id])
forged = self.registry.record_p4_manual_review_decision(
{"sender_id": "owner-a", "authorized": True}, ["owner-a"], person_id, "candidate-decision",
operation_id="decision-forged", decision="approve", reason_code="manual_check",
)
self.assertEqual("p4_review_owner_runtime_missing", forged["code"])
approved = self.registry.record_p4_manual_review_decision(
_RuntimeEvent("owner-a"), ["owner-a"], person_id, "candidate-decision",
operation_id="decision-approve", decision="approve", reason_code="manual_check",
)
self.assertTrue(approved["ok"])
self.assertEqual("owner-a", approved["actor_id"])
self.assertFalse(approved["live_effect_permitted"])
self.assertEqual(profile_before, self.store["unified_person"]["profiles"][person_id])
root = self.store["unified_person"]
self.assertNotIn("p4_shadow", root)
self.assertNotIn("p4_effect", root)
decision = root["p4_review"]["decisions"]["candidate-decision"]
self.assertEqual("approve", decision["decision"])
self.assertEqual("owner-a", decision["actor_id"])
audit = self.registry.audit_events()[-1]
self.assertEqual("p4_manual_review_decision_recorded", audit["action"])
self.assertEqual("owner-a", audit["actor_id"])
def test_decision_idempotence_duplicate_and_opposite_decision_conflict(self) -> None:
person_id = self._person("decision-idempotence")
self.assertTrue(self._queue(person_id, "decision-idempotence")["ok"])
event = _RuntimeEvent("owner-a")
first = self.registry.record_p4_manual_review_decision(
event, "owner-a", person_id, "candidate-decision-idempotence",
operation_id="decision-op", decision="reject", reason_code="manual_reject",
)
self.assertTrue(first["ok"])
snapshot = deepcopy(self.store)
repeated = self.registry.record_p4_manual_review_decision(
event, "owner-a", person_id, "candidate-decision-idempotence",
operation_id="decision-op", decision="reject", reason_code="manual_reject",
)
self.assertTrue(repeated["idempotent"])
self.assertEqual(snapshot, self.store)
duplicate = self.registry.record_p4_manual_review_decision(
event, "owner-a", person_id, "candidate-decision-idempotence",
operation_id="decision-duplicate-op", decision="reject", reason_code="manual_reject",
)
self.assertTrue(duplicate["ok"])
self.assertTrue(duplicate["decision_duplicate"])
conflict_snapshot = deepcopy(self.store)
opposite = self.registry.record_p4_manual_review_decision(
event, "owner-a", person_id, "candidate-decision-idempotence",
operation_id="decision-opposite-op", decision="approve", reason_code="manual_approve",
)
self.assertEqual("p4_review_decision_conflict", opposite["code"])
self.assertEqual(conflict_snapshot, self.store)
operation_conflict = self.registry.record_p4_manual_review_decision(
event, "owner-a", person_id, "candidate-decision-idempotence",
operation_id="decision-op", decision="approve", reason_code="manual_approve",
)
self.assertEqual("operation_id_conflict", operation_conflict["code"])
self.assertEqual(conflict_snapshot, self.store)
other_group = _RuntimeEvent("owner-a", group_id="group-2")
cross_group = self.registry.record_p4_manual_review_decision(
other_group,
"owner-a",
person_id,
"candidate-decision-idempotence",
operation_id="decision-cross-group",
decision="reject",
reason_code="manual_reject",
)
self.assertEqual("p4_review_candidate_scope_mismatch", cross_group["code"])
same_operation_cross_group = self.registry.record_p4_manual_review_decision(
other_group,
"owner-a",
person_id,
"candidate-decision-idempotence",
operation_id="decision-op",
decision="reject",
reason_code="manual_reject",
)
self.assertEqual("operation_id_conflict", same_operation_cross_group["code"])
def test_candidate_and_decision_integrity_tampering_fails_closed(self) -> None:
person_id = self._person("integrity")
self.assertTrue(self._queue(person_id, "integrity")["ok"])
root = self.store["unified_person"]
root["p4_review"]["candidates"]["candidate-integrity"]["event_id"] = "event-tampered"
same_operation_candidate = self._record_candidate(
person_id,
candidate(person_id, token="integrity"),
operation_id="queue-integrity",
)
self.assertEqual("p4_review_candidate_integrity_error", same_operation_candidate["code"])
tampered_candidate = self.registry.record_p4_manual_review_decision(
_RuntimeEvent("owner-a"),
"owner-a",
person_id,
"candidate-integrity",
operation_id="integrity-decision",
decision="approve",
reason_code="manual_check",
)
self.assertEqual("p4_review_candidate_integrity_error", tampered_candidate["code"])
person_id = self._person("decision-integrity")
self.assertTrue(self._queue(person_id, "decision-integrity")["ok"])
approved = self.registry.record_p4_manual_review_decision(
_RuntimeEvent("owner-a"),
"owner-a",
person_id,
"candidate-decision-integrity",
operation_id="integrity-decision-ok",
decision="approve",
reason_code="manual_check",
)
self.assertTrue(approved["ok"])
root = self.store["unified_person"]
root["p4_review"]["decisions"]["candidate-decision-integrity"]["event_id"] = "event-tampered"
same_operation_decision = self.registry.record_p4_manual_review_decision(
_RuntimeEvent("owner-a"),
"owner-a",
person_id,
"candidate-decision-integrity",
operation_id="integrity-decision-ok",
decision="approve",
reason_code="manual_check",
)
self.assertEqual("p4_review_decision_integrity_error", same_operation_decision["code"])
tampered_decision = self.registry.record_p4_manual_review_decision(
_RuntimeEvent("owner-a"),
"owner-a",
person_id,
"candidate-decision-integrity",
operation_id="integrity-decision-replay",
decision="approve",
reason_code="manual_check",
)
self.assertEqual("p4_review_decision_integrity_error", tampered_decision["code"])
def test_core_store_allowlist_persists_only_new_review_queue_writes(self) -> None:
person_id = self._person("core-store")
host = _CoreStoreHost(self.store)
raw = candidate(person_id, token="core-store")
handle, request, event, state = _make_candidate_attestation(raw, "core-store-candidate", core_review_module)
queued = host._apply_unified_person_lifecycle(
"record_p4_manual_review_candidate",
person_id,
raw,
operation_id="core-store-candidate",
producer_attestation=handle,
producer_request=request,
producer_event=event,
producer_state=state,
)
self.assertTrue(queued["ok"])
self.assertEqual(1, host.save_calls)
repeated_raw = deepcopy(raw)
repeated_handle, repeated_request, repeated_event, repeated_state = _make_candidate_attestation(repeated_raw, "core-store-candidate", core_review_module)
repeated = host._apply_unified_person_lifecycle(
"record_p4_manual_review_candidate",
person_id,
repeated_raw,
operation_id="core-store-candidate",
producer_attestation=repeated_handle,
producer_request=repeated_request,
producer_event=repeated_event,
producer_state=repeated_state,
)
self.assertTrue(repeated["idempotent"])
self.assertEqual(1, host.save_calls)
decision = host._apply_unified_person_lifecycle(
"record_p4_manual_review_decision",
_RuntimeEvent("owner-a"),
["owner-a"],
person_id,
"candidate-core-store",
operation_id="core-store-decision",
decision="reject",
reason_code="manual_reject",
)
self.assertTrue(decision["ok"])
self.assertEqual(2, host.save_calls)
self.assertEqual(
"unsupported_lifecycle_operation",
host._apply_unified_person_lifecycle("read_p4_manual_review", person_id)["code"],
)
disabled_store = {"unified_person": empty_unified_person_store()}
disabled_host = _CoreStoreHost(disabled_store)
disabled_host.enable_p4_manual_review = False
disabled_person = UnifiedPersonRegistry(disabled_store).upsert_observed_identity(
identity("core-store-disabled"), operation_id="observe-core-store-disabled"
)["person_id"]
denied = disabled_host._apply_unified_person_lifecycle(
"record_p4_manual_review_candidate",
disabled_person,
candidate(disabled_person, token="disabled"),
operation_id="core-store-disabled",
)
self.assertEqual("p4_review_disabled", denied["code"])
self.assertEqual(0, disabled_host.save_calls)
if __name__ == "__main__":
unittest.main()