astrbot_plugin_memory_compa.../tests/test_p5c_gates.py

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