587 行
26 KiB
Python
587 行
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()
|