# -*- 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()