405 行
15 KiB
Python
405 行
15 KiB
Python
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()
|