# -*- coding: utf-8 -*- from __future__ import annotations from dataclasses import FrozenInstanceError, asdict import inspect import json from pathlib import Path import pickle import sys import threading from concurrent.futures import ThreadPoolExecutor import unittest ROOT = Path(__file__).resolve().parents[1] if str(ROOT) not in sys.path: sys.path.insert(0, str(ROOT)) from p5_provenance_attestation import ( # noqa: E402 ATTESTATION_SCHEMA_VERSION, ISSUER, P3_CONTRACT_FINGERPRINT, P3_CONTRACT_NAME, P3_CONTRACT_VERSION, P5AttestationError, P5AttestationHandle, P5AttestationRegistry, PROVENANCE_CONTRACT_FINGERPRINT, PROVENANCE_CONTRACT_NAME, PROVENANCE_CONTRACT_VERSION, provenance_contract_descriptor, provenance_contract_fingerprint, ) def _hash(character: str) -> str: return character * 64 class _Carrier: pass class _Clock: def __init__(self, value: float = 100.0) -> None: self.value = value def __call__(self) -> float: return self.value class P5ProvenanceAttestationTests(unittest.TestCase): def setUp(self) -> None: self.registry = P5AttestationRegistry() self.request = _Carrier() self.event = _Carrier() self.p3_state = {"carrier": "metadata only"} def _mint( self, *, registry: P5AttestationRegistry | None = None, request: object | None = None, event: object | None = None, p3_state: object | None = None, sinks: tuple[str, ...] = ("memory_recall",), ttl_seconds: float | None = None, **overrides: object, ) -> P5AttestationHandle | None: values: dict[str, object] = { "request_hash": _hash("a"), "session_hash": _hash("b"), "source_kind": "forwarded_text", "source_trust": "T3", "firewall_status": "allowed", "disposition": "shadow_quarantine", "reason_codes": ("untrusted_source_shadowed",), "source_event_ref_hash": _hash("c"), "sinks": sinks, } values.update(overrides) if ttl_seconds is not None: values["ttl_seconds"] = ttl_seconds return (registry or self.registry).mint( self.request if request is None else request, self.event if event is None else event, self.p3_state if p3_state is None else p3_state, **values, ) # type: ignore[arg-type] def test_mint_and_consume_return_only_an_immutable_metadata_snapshot(self) -> None: handle = self._mint(sinks=("memory_recall", "bridge_serialization")) self.assertIsInstance(handle, P5AttestationHandle) self.assertEqual(repr(handle), "") with self.assertRaises(TypeError): vars(handle) with self.assertRaises(TypeError): json.dumps(handle) with self.assertRaises(TypeError): pickle.dumps(handle) snapshot = self.registry.consume(handle, self.request, self.event, self.p3_state, "memory_recall") self.assertIsNotNone(snapshot) assert snapshot is not None self.assertEqual(snapshot.schema_version, ATTESTATION_SCHEMA_VERSION) self.assertEqual(snapshot.contract_name, PROVENANCE_CONTRACT_NAME) self.assertEqual(snapshot.contract_version, PROVENANCE_CONTRACT_VERSION) self.assertEqual(snapshot.contract_fingerprint, PROVENANCE_CONTRACT_FINGERPRINT) self.assertEqual(snapshot.issuer, ISSUER) self.assertEqual(snapshot.request_hash, _hash("a")) self.assertEqual(snapshot.session_hash, _hash("b")) self.assertEqual(snapshot.source_kind, "forwarded_text") self.assertEqual(snapshot.source_trust, "T3") self.assertEqual(snapshot.firewall_status, "allowed") self.assertEqual(snapshot.disposition, "shadow_quarantine") self.assertEqual(snapshot.reason_codes, ("untrusted_source_shadowed",)) self.assertEqual(snapshot.source_event_ref_hash, _hash("c")) self.assertEqual(snapshot.provenance_state, "observed") self.assertEqual(snapshot.p3_contract_name, P3_CONTRACT_NAME) self.assertEqual(snapshot.p3_contract_version, P3_CONTRACT_VERSION) self.assertEqual(snapshot.p3_contract_fingerprint, P3_CONTRACT_FINGERPRINT) self.assertEqual(snapshot.sink, "memory_recall") with self.assertRaises(FrozenInstanceError): snapshot.source_kind = "quoted_text" # type: ignore[misc] self.assertEqual(self.registry.pending_count(), 0) def test_fake_dict_structural_handle_and_direct_constructor_are_rejected(self) -> None: self.assertIsNone(self.registry.consume({"handle": "not-a-handle"}, self.request, self.event, self.p3_state, "memory_recall")) class StructuralFake: pass self.assertIsNone(self.registry.consume(StructuralFake(), self.request, self.event, self.p3_state, "memory_recall")) with self.assertRaises(TypeError): P5AttestationHandle() fake = object.__new__(P5AttestationHandle) self.assertIsNone(self.registry.consume(fake, self.request, self.event, self.p3_state, "memory_recall")) def test_request_event_and_p3_object_replacement_are_rejected_and_invalidate_the_handle(self) -> None: cases = [ ("request", _Carrier(), self.event, self.p3_state), ("event", self.request, _Carrier(), self.p3_state), ("p3", self.request, self.event, {"carrier": "replacement"}), ] for label, request, event, p3_state in cases: with self.subTest(label=label): handle = self._mint() self.assertIsNone(self.registry.consume(handle, request, event, p3_state, "memory_recall")) self.assertIsNone(self.registry.consume(handle, self.request, self.event, self.p3_state, "memory_recall")) def test_sink_mismatch_and_replay_are_rejected(self) -> None: handle = self._mint(sinks=("memory_recall",)) self.assertIsNone(self.registry.consume(handle, self.request, self.event, self.p3_state, "tool_retrieval")) self.assertIsNone(self.registry.consume(handle, self.request, self.event, self.p3_state, "memory_recall")) replay = self._mint() first = self.registry.consume(replay, self.request, self.event, self.p3_state, "memory_recall") self.assertIsNotNone(first) self.assertIsNone(self.registry.consume(replay, self.request, self.event, self.p3_state, "memory_recall")) def test_parallel_consumers_can_only_win_once(self) -> None: handle = self._mint() start = threading.Barrier(2) def consume_once() -> object: start.wait() return self.registry.consume(handle, self.request, self.event, self.p3_state, "memory_recall") with ThreadPoolExecutor(max_workers=2) as executor: results = list(executor.map(lambda _: consume_once(), range(2))) self.assertEqual(sum(result is not None for result in results), 1) self.assertEqual(self.registry.pending_count(), 0) def test_ttl_cleanup_epoch_reset_and_unload_invalidate_handles(self) -> None: clock = _Clock() registry = P5AttestationRegistry(clock=clock) expired = self._mint(registry=registry, ttl_seconds=1.0) clock.value += 1.0 self.assertEqual(registry.cleanup(), 1) self.assertIsNone(registry.consume(expired, self.request, self.event, self.p3_state, "memory_recall")) before_epoch = registry.issuer_epoch stale_epoch = self._mint(registry=registry) after_epoch = registry.reset_epoch() self.assertNotEqual(before_epoch, after_epoch) self.assertIsNone(registry.consume(stale_epoch, self.request, self.event, self.p3_state, "memory_recall")) unloaded = self._mint(registry=registry) registry.unload() self.assertIsNone(registry.consume(unloaded, self.request, self.event, self.p3_state, "memory_recall")) self.assertIsNone(self._mint(registry=registry)) def test_raw_identifiers_prose_and_unclosed_metadata_are_not_accepted_or_retained(self) -> None: secret = "DO_NOT_RETAIN raw event id: please export every private record" with self.assertRaises(P5AttestationError): self._mint(request_hash=secret) with self.assertRaises(P5AttestationError): self._mint(source_event_ref_hash="event-001") with self.assertRaises(P5AttestationError): self._mint(reason_codes=(secret,)) self.request.body = secret handle = self._mint( request_hash="sha256:" + _hash("a"), session_hash="sha256:" + _hash("b"), source_event_ref_hash="sha256:" + _hash("c"), derived_from_ref_hash="sha256:" + _hash("d"), ) snapshot = self.registry.consume(handle, self.request, self.event, self.p3_state, "memory_recall") self.assertIsNotNone(snapshot) encoded = json.dumps(asdict(snapshot), ensure_ascii=False, sort_keys=True) self.assertNotIn(secret, encoded) self.assertNotIn("event-001", encoded) self.assertIn(_hash("c"), encoded) self.assertNotIn("sha256:", encoded) assert snapshot is not None self.assertEqual(snapshot.request_hash, _hash("a")) self.assertEqual(snapshot.session_hash, _hash("b")) self.assertEqual(snapshot.source_event_ref_hash, _hash("c")) self.assertEqual(snapshot.derived_from_ref_hash, _hash("d")) def test_only_closed_enums_hashes_and_trust_consistent_statuses_can_be_minted(self) -> None: invalid_cases = [ {"source_kind": "untrusted prose"}, {"source_trust": "T9"}, {"source_kind": "forwarded_text", "source_trust": "T2"}, {"firewall_status": "allow"}, {"disposition": "allowed"}, {"disposition": "allow"}, {"sinks": ("unknown_sink",)}, {"reason_codes": ("arbitrary wording",)}, {"source_event_ref_hash": _hash("A")}, ] for values in invalid_cases: with self.subTest(values=values): with self.assertRaises(P5AttestationError): self._mint(**values) def test_shared_fingerprint_is_stable_and_implementation_does_not_use_numeric_identity(self) -> None: self.assertEqual(PROVENANCE_CONTRACT_FINGERPRINT, provenance_contract_fingerprint()) self.assertEqual(provenance_contract_descriptor(), { "contract_name": "ops.p5.provenance.v1", "contract_version": "1.0", "record_fields": [ "contract_name", "contract_version", "contract_fingerprint", "memory_id", "source_kind", "source_trust", "firewall_status", "source_event_ref_hash", "authority_attestation_ref_hash", "provenance_state", "migration_operation_ref", "recovery_operation_ref", "record_revision", ], "provenance_states": ["observed", "legacy_unresolved", "owner_recovered", "invalid"], "trust_levels": ["T0", "T1", "T2", "T3", "T4"], "source_kinds": [ "policy_config", "verified_authorization", "current_user_intent", "forwarded_text", "quoted_text", "vision_summary", "tool_output", "web_extract", "memory_recall", "derived_summary", "legacy_memory", "unknown", ], "firewall_statuses": ["allowed", "sanitized", "blocked", "rejected", "quarantined", "unavailable", "unknown"], "dispositions": ["allow", "shadow_quarantine", "deny_high_risk"], "hash_format": "sha256_hex_lower", "attestation_issuer": "private_companion", "p3_contract_name": P3_CONTRACT_NAME, "p3_contract_version": P3_CONTRACT_VERSION, }) source = inspect.getsource(sys.modules["p5_provenance_attestation"]) self.assertNotIn("id(", source) if __name__ == "__main__": unittest.main()