from __future__ import annotations import asyncio import sys import tempfile import types import unittest from pathlib import Path from types import SimpleNamespace from core.chat_import import HistoricalChatImporter from core.models import EntityRef, MemoryRecord, SearchResult, SessionContext from core.operations import PortableMemoryArchive from core.p5c_guard import ( ARCHIVE_OUTPUT_DLP_SINK, DECAY_SUMMARY_EGRESS_SINK, EMBEDDING_EGRESS_SINK, FILE_INGEST_SINK, HISTORICAL_SUMMARY_EGRESS_SINK, P5CControlledDeny, P5C_SINK_FLAGS, PAGE_SEARCH_OUTPUT_DLP_SINK, PLATFORM_HISTORY_INGEST_SINK, PORTABLE_EXPORT_SINK, RERANK_EGRESS_SINK, SESSION_SUMMARY_EGRESS_SINK, TOOL_CALLBACK_SINK, check_p5c_gate, ) from core.qq_history import QQHistoryReader from core.retrieval import RetrievalEngine from core.service import MemoryCompanionService from core.visibility import VisibilityPolicy # The focused P5-C page-boundary test only exercises the early guard and does # not need Quart's request implementation. Keep the existing isolated P5-B # test environment dependency-free. try: import quart # type: ignore # noqa: F401 except ModuleNotFoundError: quart_stub = types.ModuleType("quart") quart_stub.jsonify = lambda payload: payload quart_stub.request = SimpleNamespace() quart_stub.send_file = lambda *_args, **_kwargs: None sys.modules["quart"] = quart_stub import page_api as page_api_module from page_api import PluginPageApi class _Config: def __init__(self, **flags: bool) -> None: self.flags = flags def bool(self, key: str, default: bool = False) -> bool: return bool(self.flags.get(key, default)) def int(self, _key: str, default: int = 0) -> int: return default def float(self, _key: str, default: float = 0.0) -> float: return default def get(self, _key: str, default=None): return default class _PoisonedClaim: def __repr__(self) -> str: # pragma: no cover - only called on a regression raise AssertionError("a supplied principal/capability must not be inspected or logged") class _RerankProvider: def __init__(self) -> None: self.calls = 0 async def rerank(self, **_kwargs): self.calls += 1 return [] class _EmbeddingProvider: def __init__(self) -> None: self.calls = 0 async def get_embedding(self, _text: str): self.calls += 1 return [1.0, 0.0] class _ForbiddenStore: def __init__(self) -> None: self.calls = 0 def __getattr__(self, _name: str): async def forbidden(*_args, **_kwargs): self.calls += 1 raise AssertionError("enabled P5-C gate must stop before data access") return forbidden class P5CGuardTests(unittest.TestCase): def test_every_sink_is_default_off_and_fake_claims_never_allow_enabled_gate(self) -> None: for sink in P5C_SINK_FLAGS: decision = check_p5c_gate(_Config(), sink) self.assertTrue(decision.allowed, sink) self.assertEqual("default_off", decision.reason_code) sink = FILE_INGEST_SINK enabled = _Config(**{P5C_SINK_FLAGS[sink]: True}) with self.assertLogs("MemoryCompanion.P5C", level="WARNING") as logs: decision = check_p5c_gate( enabled, sink, principal={"authenticated": True, "user_id": "secret-user"}, capability=_PoisonedClaim(), ) self.assertFalse(decision.allowed) self.assertEqual("p5c_host_contract_unavailable", decision.reason_code) self.assertEqual({"sink", "outcome", "reason_code", "ref_hash"}, set(decision.audit)) self.assertNotIn("secret-user", "\n".join(logs.output)) self.assertNotIn("PoisonedClaim", "\n".join(logs.output)) class P5CIngressAndProviderTests(unittest.IsolatedAsyncioTestCase): async def test_file_and_qq_gates_stop_before_decode_or_adapter_action(self) -> None: with tempfile.TemporaryDirectory() as temp: config = _Config(enable_p5c_file_ingest_gate=True) importer = HistoricalChatImporter( SimpleNamespace(data_dir=Path(temp), store=object(), config=config) ) decoded = False def decode(_content: bytes): nonlocal decoded decoded = True return "u: 2026-01-01 00:00:00\nsecret", "utf-8" importer._decode_upload = decode with self.assertRaises(P5CControlledDeny): importer.stage_upload(filename="secret.txt", content=b"secret body") self.assertFalse(decoded) load_calls = 0 def forbidden_load(_upload_id: str): nonlocal load_calls load_calls += 1 raise AssertionError("staged upload must not be loaded") importer._load_upload_messages = forbidden_load with self.assertRaises(P5CControlledDeny): await importer.start_import({"upload_id": "forged-upload"}) self.assertEqual(0, load_calls) page_service = SimpleNamespace(config=_Config(enable_p5c_file_ingest_gate=True)) api = PluginPageApi(SimpleNamespace(service=page_service)) api._err = lambda message, status=500: {"error": message, "status": status} async def payload_with_base64(): return {"filename": "secret.txt", "content_base64": "c2VjcmV0"} api._json = payload_with_base64 decoded_bodies = 0 original_decode = page_api_module.base64.b64decode def forbidden_base64_decode(*_args, **_kwargs): nonlocal decoded_bodies decoded_bodies += 1 raise AssertionError("base64 body must not be decoded") page_api_module.base64.b64decode = forbidden_base64_decode try: response = await api.conversation_import_upload() finally: page_api_module.base64.b64decode = original_decode self.assertEqual({"error": "p5c_host_contract_unavailable", "status": 403}, response) self.assertEqual(0, decoded_bodies) adapter_calls = 0 class _Adapter: async def call_action(self, *_args, **_kwargs): nonlocal adapter_calls adapter_calls += 1 raise AssertionError("adapter action must not run") reader = QQHistoryReader( SimpleNamespace( config=_Config(enable_p5c_platform_history_ingest_gate=True), context=SimpleNamespace(platform_manager=SimpleNamespace(get_insts=lambda: [_Adapter()])), ) ) with self.assertRaises(P5CControlledDeny): await reader.read( platform_id="forged-platform", user_id="forged-user", start_at="not-a-date", end_at="also-not-a-date", ) self.assertEqual(0, adapter_calls) async def test_historical_summary_rerank_and_embedding_stop_before_provider(self) -> None: with tempfile.TemporaryDirectory() as temp: importer = HistoricalChatImporter( SimpleNamespace( data_dir=Path(temp), store=object(), config=_Config(enable_p5c_historical_summary_egress_gate=True), ) ) attempts = 0 async def forbidden_attempts(_batch): nonlocal attempts attempts += 1 raise AssertionError("provider lookup must not run") importer._provider_attempts = forbidden_attempts with self.assertRaises(P5CControlledDeny): await importer._call_json_provider({}, prompt="secret prompt", task="historical_chat_summary") self.assertEqual(0, attempts) record = MemoryRecord( id="m1", memory_type="manual_memory", subject=EntityRef(kind="user", id="u1"), scope="private", session_id="s1", content="secret memory body", ) reranker = _RerankProvider() rerank_engine = RetrievalEngine( object(), VisibilityPolicy(enable_acl_rules=False), retrieval_mode="rerank", rerank_provider=reranker, p5c_config=_Config(enable_p5c_rerank_egress_gate=True), ) ranked = [SearchResult(memory=record, score=1.0)] self.assertEqual(ranked, await rerank_engine._maybe_rerank_results("secret query", ranked, 1)) self.assertEqual(0, reranker.calls) embedder = _EmbeddingProvider() embedding_engine = RetrievalEngine( object(), VisibilityPolicy(enable_acl_rules=False), embedding_enabled=True, embedding_provider=embedder, embedding_provider_id="embed", p5c_config=_Config(enable_p5c_embedding_egress_gate=True), ) candidates, scores, info = await embedding_engine._embedding_candidate_memories( "secret query", include_pending=False ) self.assertEqual(([], {}), (candidates, scores)) self.assertEqual("p5c_host_contract_unavailable", info["embedding_reason"]) self.assertEqual(0, embedder.calls) async def test_session_decay_and_background_embedding_do_not_treat_p5b_as_egress_grant(self) -> None: service = object.__new__(MemoryCompanionService) service.config = _Config( enable_p5c_session_summary_egress_gate=True, enable_p5c_embedding_egress_gate=True, enable_p5_b1_recall_gate=True, ) service._summary_locks = {} service._summary_lock_ts = {} service._cleanup_stale_summary_locks = lambda: None service._p3_gate_reason = lambda *_args, **_kwargs: "" service.summarizer = SimpleNamespace(interval_elapsed=lambda *_args, **_kwargs: True) class _WindowStore: async def unsummarized_timeline_window(self, **_kwargs): return { "rows": [{"id": "row-1", "content": "secret timeline body"}], "total": 1, "first_occurred_at": "2026-01-01T00:00:00+00:00", } async def get_summary_failure(self, _session_id): return None service.store = _WindowStore() summary_provider_calls = 0 async def forbidden_summary_provider(_ctx): nonlocal summary_provider_calls summary_provider_calls += 1 raise AssertionError("summary provider lookup must not run") service._summary_provider_attempts = forbidden_summary_provider self.assertEqual("", await service.maybe_summarize_session(SessionContext(session_id="s1", scope="private"), force=True)) self.assertEqual(0, summary_provider_calls) record = MemoryRecord( id="m2", memory_type="manual_memory", subject=EntityRef(kind="user", id="u1"), scope="private", session_id="s1", content="secret embedding body", ) provider = _EmbeddingProvider() self.assertFalse(await service._embed_memory_record(provider, "embed", record)) self.assertEqual(0, provider.calls) service.config = _Config(enable_p5c_decay_summary_egress_gate=True) with self.assertRaises(P5CControlledDeny): await service._summarize_decay_records_with_provider( provider, ctx=SessionContext(session_id="s1", scope="private"), items=[{"record": record, "score": 1.0}], ) self.assertEqual(0, provider.calls) class P5COutputTests(unittest.IsolatedAsyncioTestCase): async def test_archive_default_off_keeps_uninitialized_service_compatible(self) -> None: # P3 compatibility constructs this service without __init__. P5-C # must treat the absent config as default-off rather than raising. service = object.__new__(MemoryCompanionService) service._p5_b2_archive_read_gate_reason = lambda: "p3_unavailable" async def archive_scope(*, scope=None): return {"scope": scope or {}} service.bridge_get_archive_scope = archive_scope response = await service.bridge_search_archive_memories( "query", scope={"session_id": "private:test"}, limit=1 ) self.assertEqual([], response["memories"]) self.assertEqual(["p3_unavailable"], response["warnings"]) async def test_archive_portable_and_page_output_gates_return_safe_controlled_denials(self) -> None: service = object.__new__(MemoryCompanionService) service.config = _Config(enable_p5c_archive_output_dlp=True) service.store = _ForbiddenStore() archive = await service.bridge_search_archive_memories( "secret query", scope={"user_id": "forged-user", "session_id": "forged-session"} ) scope = await service.bridge_get_archive_scope(scope={"user_id": "forged-user"}) evidence = await service.bridge_get_archive_evidence( ["secret-memory"], scope={"user_id": "forged-user"} ) context = await service.bridge_get_archive_session_context( scope={"user_id": "forged-user"}, start_at="2026-01-01", end_at="2026-01-02" ) self.assertEqual([], archive["memories"]) self.assertNotIn("user_id", scope) self.assertEqual([], evidence["memories"]) self.assertEqual([], context["items"]) self.assertEqual(0, service.store.calls) store = _ForbiddenStore() with tempfile.TemporaryDirectory() as temp: portable = PortableMemoryArchive( store, Path(temp), config=_Config(enable_p5c_portable_export_gate=True), ) export = await portable.export() self.assertFalse(export["ok"]) self.assertEqual("", export["path"]) self.assertFalse((Path(temp) / "exports").exists()) self.assertEqual(0, store.calls) page_service = SimpleNamespace(config=_Config(enable_p5c_page_search_output_dlp=True)) api = PluginPageApi(SimpleNamespace(service=page_service)) json_reads = 0 async def forbidden_json(): nonlocal json_reads json_reads += 1 raise AssertionError("page JSON must not be parsed for authorization") api._json = forbidden_json api._err = lambda message, status=500: {"error": message, "status": status} response = await api.search() self.assertEqual({"error": "p5c_host_contract_unavailable", "status": 403}, response) self.assertEqual(0, json_reads) async def test_tool_callback_gate_stops_before_event_identity_lookup(self) -> None: service = object.__new__(MemoryCompanionService) service.config = _Config(enable_p5c_tool_callback_gate=True) identity_calls = 0 class _Identity: async def resolve_event_context(self, _event): nonlocal identity_calls identity_calls += 1 raise AssertionError("tool callback gate must not inspect event identity") service.identity = _Identity() result = await service.tool_recall(object(), "secret tool parameter") self.assertEqual( {"ok": False, "error": "p5c_host_contract_unavailable", "memories": []}, result ) self.assertEqual(0, identity_calls) if __name__ == "__main__": unittest.main()