test(c6): verify dual-plugin entertainment boundaries
这个提交存在于:
父节点
159bf5a63d
当前提交
5705a44be3
共有 1 个文件被更改,包括 240 次插入 和 0 次删除
|
|
@ -0,0 +1,240 @@
|
|||
from __future__ import annotations
|
||||
|
||||
import asyncio
|
||||
import tempfile
|
||||
import unittest
|
||||
from pathlib import Path
|
||||
from unittest.mock import patch
|
||||
|
||||
from core import bot_personal_contract
|
||||
from core.bridge import MemoryCompanionBridge
|
||||
from core.capability_probe import CapabilityCache, build_capability_snapshot
|
||||
from core.models import MemoryRecord
|
||||
from core.service import MemoryCompanionService
|
||||
from core.store import MemoryStore
|
||||
|
||||
|
||||
def run(coro):
|
||||
return asyncio.run(coro)
|
||||
|
||||
|
||||
def archive(index: str = "1", **overrides):
|
||||
value = {
|
||||
"memory_type": "bot_observed_activity",
|
||||
"memory_domain": bot_personal_contract.BOT_PERSONAL_MEMORY_DOMAIN,
|
||||
"subject": "bot_self",
|
||||
"date": "2026-07-30",
|
||||
"window": "afternoon",
|
||||
"occurred_at": "2026-07-30T15:00:00+08:00",
|
||||
"source_kind": "observed",
|
||||
"source_refs": [f"companion:event:{index}"],
|
||||
"certainty": 0.9,
|
||||
"evidence_level": "L2",
|
||||
"status": "active",
|
||||
"version": 1,
|
||||
"idempotency_key": f"c6:test:{index}",
|
||||
"payload_schema_version": bot_personal_contract.BOT_PERSONAL_PAYLOAD_SCHEMA_VERSION,
|
||||
"payload": {"summary": "safe archive summary", "activity": "rest"},
|
||||
}
|
||||
value.update(overrides)
|
||||
return value
|
||||
|
||||
|
||||
class _Recorder:
|
||||
def __init__(self, result=None):
|
||||
self.calls = []
|
||||
self.result = result or {"ok": True, "record_id": "c6-record", "version": 1}
|
||||
|
||||
async def record_external_event(self, **kwargs):
|
||||
self.calls.append(kwargs)
|
||||
return "external-record"
|
||||
|
||||
async def record_bot_personal_archive(self, dto):
|
||||
self.calls.append(dto)
|
||||
return self.result
|
||||
|
||||
|
||||
class _ProfileProvider:
|
||||
async def read_bot_personal_profile(self, **_kwargs):
|
||||
return {
|
||||
"ok": True,
|
||||
"state": "ready",
|
||||
"items": [
|
||||
{
|
||||
"record_id": "bot-1",
|
||||
"memory_domain": bot_personal_contract.BOT_PERSONAL_MEMORY_DOMAIN,
|
||||
"memory_type": "bot_observed_activity",
|
||||
"summary": "safe summary",
|
||||
"payload": {"secret": "must not cross"},
|
||||
"content": "raw content must not cross",
|
||||
}
|
||||
],
|
||||
}
|
||||
|
||||
|
||||
class C6DualPluginBoundaryTests(unittest.TestCase):
|
||||
def test_capability_probe_exposes_contract_domain_version_types_and_pending(self):
|
||||
bridge = MemoryCompanionBridge(object())
|
||||
pending = bridge.capability_status()
|
||||
self.assertEqual("unprobed", pending["capability_state"])
|
||||
self.assertTrue(pending["pending"])
|
||||
self.assertFalse(pending["available"])
|
||||
|
||||
snapshot = bridge.probe_capability_snapshot()
|
||||
self.assertEqual("available", snapshot["capability_state"])
|
||||
self.assertTrue(snapshot["available"])
|
||||
self.assertFalse(snapshot["degraded"])
|
||||
self.assertEqual(bot_personal_contract.BOT_PERSONAL_MEMORY_DOMAIN, snapshot["domain"])
|
||||
self.assertEqual(str(bot_personal_contract.CONTRACT_REVISION), snapshot["contract_version"])
|
||||
self.assertEqual(
|
||||
list(bot_personal_contract.BOT_PERSONAL_MEMORY_TYPES), snapshot["memory_types"]
|
||||
)
|
||||
self.assertEqual(list(bot_personal_contract.WINDOW_SLUGS), snapshot["windows"])
|
||||
self.assertIn("record_bot_personal_archive", snapshot["methods"])
|
||||
|
||||
def test_missing_contract_metadata_is_bounded_and_degraded(self):
|
||||
snapshot = build_capability_snapshot(
|
||||
contract_module=object(), state="degraded", warnings=["contract_missing"], error_code="bridge_missing"
|
||||
)
|
||||
self.assertEqual("degraded", snapshot["state"])
|
||||
self.assertTrue(snapshot["degraded"])
|
||||
self.assertFalse(snapshot["pending"])
|
||||
self.assertEqual("bridge_missing", snapshot["error_code"])
|
||||
self.assertEqual([], snapshot["domains"])
|
||||
self.assertEqual([], snapshot["memory_types"])
|
||||
self.assertEqual(["contract_missing"], snapshot["warnings"])
|
||||
self.assertTrue(all(isinstance(value, (str, bool, list, dict)) for value in snapshot.values()))
|
||||
|
||||
def test_compatibility_writes_keep_bot_user_and_group_contexts_separate(self):
|
||||
recorder = _Recorder()
|
||||
bridge = MemoryCompanionBridge(recorder)
|
||||
|
||||
run(bridge.record_creative_work(content="C6 creative", session_id="bot:creative"))
|
||||
run(
|
||||
bridge.record_event(
|
||||
content="user fact",
|
||||
memory_type="user_fact",
|
||||
scope="private",
|
||||
session_id="private:user-1",
|
||||
visibility="private_pair",
|
||||
reality_level="real_user_fact",
|
||||
subject={"kind": "user", "id": "user-1", "role": "current_sender"},
|
||||
)
|
||||
)
|
||||
run(
|
||||
bridge.record_event(
|
||||
content="group fact",
|
||||
memory_type="group_memory",
|
||||
scope="group",
|
||||
session_id="group:42",
|
||||
group_id="42",
|
||||
visibility="group_public",
|
||||
reality_level="observed_utterance",
|
||||
subject={"kind": "user", "id": "user-2", "role": "group_member"},
|
||||
)
|
||||
)
|
||||
|
||||
creative, user, group = recorder.calls
|
||||
self.assertEqual(("creative_work", "bot_self", "fictional_content"),
|
||||
(creative["memory_type"], creative["visibility"], creative["reality_level"]))
|
||||
self.assertEqual(("private", "private:user-1", ""),
|
||||
(user["scope"], user["session_id"], user["group_id"]))
|
||||
self.assertEqual(("group", "group:42", "42"),
|
||||
(group["scope"], group["session_id"], group["group_id"]))
|
||||
self.assertNotEqual(creative["visibility"], user["visibility"])
|
||||
self.assertNotEqual(user["scope"], group["scope"])
|
||||
self.assertNotEqual(user["session_id"], group["session_id"])
|
||||
|
||||
def test_entertainment_compatibility_writes_remain_bot_personal_records(self):
|
||||
recorder = _Recorder()
|
||||
bridge = MemoryCompanionBridge(recorder)
|
||||
|
||||
run(bridge.record_search_action(content="news summary", session_id="bot:news"))
|
||||
run(bridge.record_image_action(content="image summary", session_id="bot:image"))
|
||||
run(bridge.record_qzone_action(content="qzone summary", session_id="bot:qzone"))
|
||||
run(bridge.record_reading(content="reading summary", session_id="bot:reading"))
|
||||
run(bridge.record_schedule_fragment(content="outfit summary", session_id="bot:outfit"))
|
||||
|
||||
self.assertEqual(
|
||||
["search_action", "image_action", "qzone_action", "reading_memory", "schedule_fragment"],
|
||||
[item["memory_type"] for item in recorder.calls],
|
||||
)
|
||||
self.assertTrue(all(item["visibility"] == "bot_self" for item in recorder.calls))
|
||||
self.assertEqual(
|
||||
["bot_action", "bot_action", "bot_action", "bot_action", "persona_life"],
|
||||
[item["reality_level"] for item in recorder.calls],
|
||||
)
|
||||
self.assertTrue(all(item["source_plugin"] == "external" for item in recorder.calls))
|
||||
|
||||
def test_bot_personal_archive_is_read_only_and_isolated_from_user_and_group_records(self):
|
||||
with tempfile.TemporaryDirectory() as directory:
|
||||
service = object.__new__(MemoryCompanionService)
|
||||
service.store = MemoryStore(Path(directory) / "memory.db")
|
||||
service.store.initialize()
|
||||
service._schedule_memory_embedding = lambda *args, **kwargs: None
|
||||
try:
|
||||
bot = run(service.record_bot_personal_archive(archive("bot")))
|
||||
run(service.store.insert_memory(MemoryRecord(
|
||||
id="user-1", memory_type="user_fact", scope="private", session_id="private:user",
|
||||
visibility="private_pair", content="user fact", metadata={"memory_domain": "user_memory"},
|
||||
)))
|
||||
run(service.store.insert_memory(MemoryRecord(
|
||||
id="group-1", memory_type="group_memory", scope="group", session_id="group:42",
|
||||
group_id="42", visibility="group_public", content="group fact",
|
||||
metadata={"memory_domain": "group_memory"},
|
||||
)))
|
||||
profile = run(service.read_bot_personal_profile(limit=10))
|
||||
self.assertTrue(profile["read_only"])
|
||||
self.assertEqual([bot["record_id"]], [item["record_id"] for item in profile["items"]])
|
||||
self.assertTrue(all(item["memory_domain"] == bot_personal_contract.BOT_PERSONAL_MEMORY_DOMAIN
|
||||
for item in profile["items"]))
|
||||
self.assertNotIn("payload", profile["items"][0])
|
||||
self.assertNotIn("content", profile["items"][0])
|
||||
finally:
|
||||
service.store.close()
|
||||
|
||||
def test_bridge_failure_states_are_identifiable_without_leaking_exception_text(self):
|
||||
missing = run(MemoryCompanionBridge(object()).record_bot_personal_archive(archive()))
|
||||
self.assertEqual(("degraded", "bridge_method_unavailable"),
|
||||
(missing["state"], missing["error_code"]))
|
||||
|
||||
class Broken:
|
||||
async def record_bot_personal_archive(self, _dto):
|
||||
raise asyncio.TimeoutError()
|
||||
|
||||
timed_out = run(MemoryCompanionBridge(Broken()).record_bot_personal_archive(archive("timeout")))
|
||||
self.assertEqual(("degraded", "bridge_exception"),
|
||||
(timed_out["state"], timed_out["error_code"]))
|
||||
self.assertNotIn("TimeoutError", str(timed_out))
|
||||
|
||||
failed = _Recorder({"ok": False, "state": "failed", "error_code": "archive_failed"})
|
||||
failed_result = run(MemoryCompanionBridge(failed).record_bot_personal_archive(archive("failed")))
|
||||
self.assertEqual(("failed", "archive_failed"),
|
||||
(failed_result["state"], failed_result["error_code"]))
|
||||
|
||||
def test_profile_bridge_preserves_pending_degraded_and_filters_archive_payload(self):
|
||||
ready = run(MemoryCompanionBridge(_ProfileProvider()).read_bot_personal_profile())
|
||||
self.assertTrue(ready["read_only"])
|
||||
self.assertEqual("ready", ready["state"])
|
||||
self.assertEqual(["bot-1"], [item["record_id"] for item in ready["items"]])
|
||||
self.assertNotIn("payload", ready["items"][0])
|
||||
self.assertNotIn("content", ready["items"][0])
|
||||
|
||||
unavailable = run(MemoryCompanionBridge(object()).read_bot_personal_profile())
|
||||
self.assertEqual("degraded", unavailable["state"])
|
||||
self.assertTrue(unavailable["pending"])
|
||||
self.assertEqual("bridge_method_unavailable", unavailable["error_code"])
|
||||
|
||||
def test_capability_probe_failure_keeps_degraded_contract_fields(self):
|
||||
with patch.object(bot_personal_contract, "capability_descriptor", side_effect=RuntimeError("boom")):
|
||||
result = MemoryCompanionBridge(object()).probe_capability_snapshot()
|
||||
self.assertEqual("degraded", result["capability_state"])
|
||||
self.assertTrue(result["degraded"])
|
||||
self.assertFalse(result["available"])
|
||||
self.assertEqual("contract_descriptor_exception", result["error_code"])
|
||||
self.assertEqual(bot_personal_contract.BOT_PERSONAL_MEMORY_DOMAIN, result["domain"])
|
||||
self.assertIn("contract_descriptor_exception", result["warnings"])
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
正在加载…
添加表格
在新工单中引用