astrbot_plugin_memory_compa.../tests/test_security_cache.py

537 行
23 KiB
Python

2026-07-30 01:13:23 +08:00
from __future__ import annotations
import json
import sys
import tempfile
import time
import types
import unittest
from pathlib import Path
from types import SimpleNamespace
from unittest.mock import AsyncMock, patch
ROOT = Path(__file__).resolve().parents[1]
if str(ROOT.parent) not in sys.path:
sys.path.insert(0, str(ROOT.parent))
if "quart" not in sys.modules:
quart_stub = types.ModuleType("quart")
quart_stub.jsonify = lambda payload=None, **kwargs: payload or kwargs
quart_stub.request = SimpleNamespace(args={}, method="GET")
async def _send_file(path):
return path
quart_stub.send_file = _send_file
sys.modules["quart"] = quart_stub
import astrbot_plugin_remember_you.page_api as page_api_module
from astrbot_plugin_remember_you.core.models import EntityRef, MemoryRecord, SessionContext
from astrbot_plugin_remember_you.core.service import MemoryCompanionService
from astrbot_plugin_remember_you.page_api import PluginPageApi
class SecurityAndCacheTests(unittest.IsolatedAsyncioTestCase):
def make_service(self, config: dict | None = None) -> MemoryCompanionService:
temp_dir = tempfile.TemporaryDirectory()
self.addCleanup(temp_dir.cleanup)
service = MemoryCompanionService(
context=None,
config=config or {},
plugin_root=ROOT,
data_dir=Path(temp_dir.name),
)
self.addCleanup(service.close)
return service
async def page_search(self, payload: dict):
service = SimpleNamespace(
search_with_diagnostics=AsyncMock(return_value=([], [])),
)
api = PluginPageApi(SimpleNamespace(service=service))
fake_request = SimpleNamespace(get_json=AsyncMock(return_value=payload))
class JsonResponse(dict):
status_code = 200
with (
patch.object(page_api_module, "request", fake_request),
patch.object(page_api_module, "jsonify", side_effect=lambda body: JsonResponse(body)),
):
response = await api.search()
return response, service.search_with_diagnostics
@staticmethod
def group_memory(content: str = "唯一锚点蓝风铃") -> MemoryRecord:
return MemoryRecord(
memory_type="conversation_summary",
subject=EntityRef(kind="user", id="group-user", name="群成员"),
object=EntityRef(kind="group", id="g1", name="测试群"),
scope="group",
session_id="qq:GroupMessage:g1",
platform="qq",
group_id="g1",
visibility="group_public",
lifecycle="stable_memory",
content=content,
importance=0.9,
)
async def test_acl_revoke_invalidates_cached_search(self) -> None:
service = self.make_service(
{
"retrieval": {"mode": "basic"},
"visibility": {
"enable_acl_rules": True,
"allow_group_public_in_private": False,
},
}
)
memory_id = await service.store.insert_memory(self.group_memory())
rule = await service.store.upsert_acl_rule(
owner_scope="group",
owner_id="g1",
reader_scope="private",
reader_id="u1",
effect="allow",
)
ctx = SessionContext(
session_id="qq:FriendMessage:u1",
scope="private",
platform="qq",
user_id="u1",
bot_id="b1",
)
first = await service.search("蓝风铃", ctx)
second = await service.search("蓝风铃", ctx)
self.assertIn(memory_id, {item.memory.id for item in first})
self.assertIn(memory_id, {item.memory.id for item in second})
self.assertGreaterEqual(service._retrieval_result_cache_stats["hits"], 1)
await service.store.delete_acl_rule(rule["id"])
revoked = await service.search("蓝风铃", ctx)
self.assertNotIn(memory_id, {item.memory.id for item in revoked})
async def test_visibility_config_change_cannot_reuse_old_cache(self) -> None:
config = {
"retrieval": {"mode": "basic"},
"visibility": {
"enable_acl_rules": False,
"allow_group_public_in_private": True,
},
}
service = self.make_service(config)
memory_id = await service.store.insert_memory(self.group_memory("配置切换锚点绿松石"))
ctx = SessionContext(
session_id="qq:FriendMessage:u1",
scope="private",
platform="qq",
user_id="u1",
bot_id="b1",
)
visible = await service.search("绿松石", ctx)
self.assertIn(memory_id, {item.memory.id for item in visible})
config["visibility"]["allow_group_public_in_private"] = False
hidden = await service.search("绿松石", ctx)
self.assertNotIn(memory_id, {item.memory.id for item in hidden})
async def test_access_tracking_does_not_invalidate_retrieval_revision(self) -> None:
service = self.make_service()
memory_id = await service.store.insert_memory(self.group_memory("版本锚点"))
before = await service.store.memory_revision()
await service.store.mark_accessed([memory_id])
self.assertEqual(before, await service.store.memory_revision())
async def test_page_search_without_context_uses_authenticated_admin_scope(self) -> None:
response, search = await self.page_search({"query": "显微镜锚点", "scope": "unknown"})
self.assertTrue(search.await_args.kwargs["admin_read_all"])
context = search.await_args.args[1]
self.assertEqual("unknown", context.scope)
self.assertEqual("", context.session_id)
self.assertEqual("all", response["search_context"]["mode"])
response, search = await self.page_search(
{
"query": "显微镜锚点",
"context_mode": "all",
"bot_id": "不应进入管理检索上下文",
}
)
context = search.await_args.args[1]
self.assertEqual("", context.bot_id)
self.assertEqual("", response["search_context"]["bot_id"])
async def test_page_search_preserves_private_and_group_visibility_contexts(self) -> None:
cases = (
(
{
"query": "私聊锚点",
"scope": "private",
"session_id": "qq:FriendMessage:u1",
"user_id": "u1",
"bot_id": "bot-private",
"admin_read_all": True,
},
"private",
"u1",
"",
"bot-private",
),
(
{
"query": "群聊锚点",
"context_mode": "session",
"scope": "group",
"session_id": "qq:GroupMessage:g1",
"group_id": "g1",
"bot_id": "bot-group",
"admin_read_all": True,
},
"group",
"",
"g1",
"bot-group",
),
)
for payload, scope, user_id, group_id, bot_id in cases:
with self.subTest(scope=scope):
response, search = await self.page_search(payload)
self.assertFalse(search.await_args.kwargs["admin_read_all"])
context = search.await_args.args[1]
self.assertEqual(scope, context.scope)
self.assertEqual(user_id, context.user_id)
self.assertEqual(group_id, context.group_id)
self.assertEqual(bot_id, context.bot_id)
self.assertEqual("session", response["search_context"]["mode"])
self.assertEqual(bot_id, response["search_context"]["bot_id"])
async def test_page_search_rejects_incomplete_or_invalid_context_intent(self) -> None:
for payload in (
{"query": "锚点", "context_mode": "session", "scope": "private"},
{"query": "锚点", "scope": "group"},
{"query": "锚点", "bot_id": "bot-without-session"},
{
"query": "锚点",
"context_mode": "session",
"scope": "group",
"session_id": "qq:FriendMessage:u1",
"group_id": "g1",
},
{
"query": "锚点",
"context_mode": "session",
"scope": "private",
"session_id": "qq:FriendMessage:u1",
"user_id": "u2",
},
{"query": "锚点", "context_mode": "invalid"},
):
with self.subTest(payload=payload):
response, search = await self.page_search(payload)
self.assertEqual(400, response.status_code)
search.assert_not_awaited()
async def test_session_diagnostics_uses_bucket_bot_owner(self) -> None:
service = self.make_service({"retrieval": {"mode": "basic"}})
first = self.group_memory("多 Bot 甲号所有权锚点")
first.id = "multi-bot-a"
first.occurred_at = "2026-07-20T10:00:00+00:00"
first.metadata = {"owner_bot_id": "bot-a"}
first_id = await service.store.insert_memory(first)
second = self.group_memory("多 Bot 乙号所有权锚点")
second.id = "multi-bot-b"
second.occurred_at = "2026-07-21T10:00:00+00:00"
second.metadata = {"owner_bot_id": "bot-b"}
second_id = await service.store.insert_memory(second)
archived = self.group_memory("已归档 Bot 不得抢占样本")
archived.id = "multi-bot-archived"
archived.occurred_at = "2026-07-25T10:00:00+00:00"
archived.lifecycle = "archived"
archived.metadata = {"owner_bot_id": "bot-archived"}
await service.store.insert_memory(archived)
internal = self.group_memory("内部记录不得生成可检索上下文")
internal.id = "multi-bot-internal"
internal.occurred_at = "2026-07-26T10:00:00+00:00"
internal.visibility = "internal"
internal.metadata = {"owner_bot_id": "bot-internal"}
await service.store.insert_memory(internal)
raw_event = self.group_memory("默认关闭的原始事件不得生成可检索上下文")
raw_event.id = "multi-bot-raw-event"
raw_event.occurred_at = "2026-07-27T10:00:00+00:00"
raw_event.lifecycle = "raw_event"
raw_event.metadata = {"owner_bot_id": "bot-raw"}
await service.store.insert_memory(raw_event)
buckets = await service.store.list_memory_buckets()
bucket = next(item for item in buckets if item["target_id"] == "g1")
self.assertEqual("bot-b", bucket["sample_bot_id"])
contexts = {item["bot_id"]: item for item in bucket["sample_contexts"]}
self.assertEqual(
{"bot-a", "bot-b", "bot-archived", "bot-internal", "bot-raw"},
set(contexts),
)
self.assertEqual(2, bucket["searchable_count"])
self.assertEqual(1, contexts["bot-a"]["searchable_count"])
self.assertEqual(1, contexts["bot-b"]["searchable_count"])
self.assertEqual(0, contexts["bot-archived"]["searchable_count"])
self.assertEqual(0, contexts["bot-internal"]["searchable_count"])
self.assertEqual(0, contexts["bot-raw"]["searchable_count"])
raw_enabled_buckets = await service.store.list_memory_buckets(
include_raw_events=True,
)
raw_enabled_bucket = next(
item for item in raw_enabled_buckets if item["target_id"] == "g1"
)
raw_enabled_contexts = {
item["bot_id"]: item for item in raw_enabled_bucket["sample_contexts"]
}
self.assertEqual("bot-raw", raw_enabled_bucket["sample_bot_id"])
self.assertEqual(1, raw_enabled_contexts["bot-raw"]["searchable_count"])
first_context = SessionContext(
session_id="qq:GroupMessage:g1",
scope="group",
platform="qq",
group_id="g1",
bot_id="bot-a",
)
second_context = SessionContext(
session_id="qq:GroupMessage:g1",
scope="group",
platform="qq",
group_id="g1",
bot_id="bot-b",
)
other_context = SessionContext(
session_id="qq:GroupMessage:g1",
scope="group",
platform="qq",
group_id="g1",
bot_id="bot-other",
)
first_visible, _ = await service.search_with_diagnostics(
"多 Bot 甲号所有权锚点",
first_context,
8,
)
second_visible, _ = await service.search_with_diagnostics(
"多 Bot 乙号所有权锚点",
second_context,
8,
)
hidden, blocked = await service.search_with_diagnostics(
"多 Bot 甲号所有权锚点",
other_context,
8,
)
self.assertIn(first_id, {item.memory.id for item in first_visible})
self.assertIn(second_id, {item.memory.id for item in second_visible})
self.assertNotIn(first_id, {item.memory.id for item in hidden})
self.assertTrue(any("other_bot_owner" in item.get("reason", "") for item in blocked))
async def test_admin_diagnostics_can_retrieve_private_and_group_memories(self) -> None:
service = self.make_service({"retrieval": {"mode": "basic"}})
private_id = await service.store.insert_memory(
MemoryRecord(
memory_type="conversation_summary",
subject=EntityRef(kind="user", id="u1", name="测试用户"),
object=EntityRef(kind="bot", id="self", name="Bot"),
scope="private",
session_id="qq:FriendMessage:u1",
platform="qq",
visibility="private_pair",
lifecycle="stable_memory",
content="显微镜全库锚点来自私聊",
importance=0.9,
)
)
group_id = await service.store.insert_memory(
self.group_memory("显微镜全库锚点来自群聊")
)
internal_id = await service.store.insert_memory(
MemoryRecord(
memory_type="internal_note",
subject=EntityRef(kind="bot", id="self", name="Bot"),
object=EntityRef(kind="bot", id="self", name="Bot"),
scope="private",
session_id="qq:FriendMessage:u1",
visibility="internal",
lifecycle="stable_memory",
content="显微镜全库锚点内部记录",
importance=0.9,
)
)
archived_id = await service.store.insert_memory(
MemoryRecord(
memory_type="conversation_summary",
subject=EntityRef(kind="user", id="u2", name="归档用户"),
object=EntityRef(kind="bot", id="self", name="Bot"),
scope="private",
session_id="qq:FriendMessage:u2",
visibility="private_pair",
lifecycle="archived",
content="显微镜全库锚点归档记录",
importance=0.9,
)
)
context = SessionContext(session_id="", scope="unknown", message_text="显微镜全库锚点")
regular, _ = await service.search_with_diagnostics("显微镜全库锚点", context, 10)
admin, _ = await service.search_with_diagnostics(
"显微镜全库锚点",
context,
10,
admin_read_all=True,
)
self.assertFalse({private_id, group_id} & {item.memory.id for item in regular})
admin_ids = {item.memory.id for item in admin}
self.assertTrue({private_id, group_id}.issubset(admin_ids))
self.assertNotIn(internal_id, admin_ids)
self.assertNotIn(archived_id, admin_ids)
async def test_service_clear_resets_persisted_and_runtime_state(self) -> None:
service = self.make_service()
await service.store.insert_memory(self.group_memory("清空状态"))
ctx = SessionContext(
session_id="qq:FriendMessage:u1",
scope="private",
platform="qq",
user_id="u1",
bot_id="b1",
)
service._get_relationship_phase(ctx)["phase"] = "close"
service._save_relationship_phase_state()
service._emotional_event_queue[ctx.session_id] = [{"ts": 1.0}]
service._retrieval_result_cache["cached"] = {"payload": {}}
result = await service.clear_all_memory_data()
self.assertIn("backup", result)
self.assertEqual({}, service._relationship_phase_state)
self.assertEqual({}, service._emotional_event_queue)
self.assertEqual({}, service._retrieval_result_cache)
self.assertEqual({}, json.loads(service._RELATIONSHIP_PHASE_FILE.read_text(encoding="utf-8")))
async def test_cross_window_emotional_reads_are_opt_in(self) -> None:
config: dict = {"private_companion_bridge": {}}
service = self.make_service(config)
service._emotional_event_queue["qq:FriendMessage:u1"] = [
{
"id": "emotion-1",
"session_id": "qq:FriendMessage:u1",
"event_type": "warm_memory",
"ts": time.time(),
}
]
self.assertEqual([], service.bridge_get_emotional_events(session_id=""))
self.assertEqual(1, len(service._emotional_event_queue["qq:FriendMessage:u1"]))
config["private_companion_bridge"]["cross_window_emotional_continuity_enabled"] = True
events = service.bridge_get_emotional_events(session_id="")
self.assertEqual(["emotion-1"], [item["id"] for item in events])
async def test_note_tools_keep_read_and_delete_scoped_to_current_bot(self) -> None:
service = self.make_service({"retrieval": {"embedding_enabled": False}})
async def resolve_event_context(event):
return event
service.identity = SimpleNamespace(resolve_event_context=resolve_event_context)
current = SessionContext(session_id="qq:FriendMessage:u1", scope="private", bot_id="b1")
other = SessionContext(session_id="qq:FriendMessage:u2", scope="private", bot_id="b2")
own = await service.tool_note_create(current, "当前 Bot 的笔记", "只允许 b1 读取和删除")
foreign = await service.tool_note_create(other, "另一个 Bot 的笔记", "只允许 b2 读取和删除")
ordinary = await service.store.insert_memory(self.group_memory("普通长期记忆不能由笔记工具删除"))
visible = await service.tool_note_read(current, "", limit=20)
self.assertEqual([own["memory_id"]], [item["id"] for item in visible["notes"]])
denied = await service.tool_note_delete(current, foreign["memory_id"])
self.assertEqual({"ok": False, "error": "note not found"}, denied)
self.assertIsNotNone(await service.store.get_memory(foreign["memory_id"]))
wrong_type = await service.tool_note_delete(current, ordinary)
self.assertEqual({"ok": False, "error": "note not found"}, wrong_type)
self.assertIsNotNone(await service.store.get_memory(ordinary))
deleted = await service.tool_note_delete(current, own["memory_id"])
self.assertTrue(deleted["ok"])
self.assertTrue(deleted["deleted"])
self.assertIsNone(await service.store.get_memory(own["memory_id"]))
async def test_note_delete_requires_unique_exact_title_or_memory_id(self) -> None:
service = self.make_service({"retrieval": {"embedding_enabled": False}})
async def resolve_event_context(event):
return event
service.identity = SimpleNamespace(resolve_event_context=resolve_event_context)
ctx = SessionContext(session_id="qq:FriendMessage:u1", scope="private", bot_id="b1")
first = await service.tool_note_create(ctx, "周末计划", "第一版")
second = await service.tool_note_create(ctx, "周末计划", "第二版")
unique = await service.tool_note_create(ctx, "阅读清单", "读完测试文档")
ambiguous = await service.tool_note_delete(ctx, title="周末计划")
self.assertFalse(ambiguous["ok"])
self.assertEqual("ambiguous note title", ambiguous["error"])
self.assertEqual({first["memory_id"], second["memory_id"]}, {item["memory_id"] for item in ambiguous["matches"]})
fuzzy = await service.tool_note_delete(ctx, title="阅读")
self.assertFalse(fuzzy["ok"])
self.assertEqual("title match requires confirmation", fuzzy["error"])
self.assertEqual(unique["memory_id"], fuzzy["matches"][0]["memory_id"])
self.assertIsNotNone(await service.store.get_memory(unique["memory_id"]))
deleted = await service.tool_note_delete(ctx, title="阅读清单")
self.assertTrue(deleted["ok"])
self.assertIsNone(await service.store.get_memory(unique["memory_id"]))
def test_note_delete_llm_tool_is_registered_and_documented(self) -> None:
main = (ROOT / "main.py").read_text(encoding="utf-8")
readme = (ROOT / "README.md").read_text(encoding="utf-8")
schema = (ROOT / "_conf_schema.json").read_text(encoding="utf-8")
self.assertIn('@filter.llm_tool(name="memory_companion_note_delete")', main)
self.assertIn("memory_tools.enable_note_tools", main)
self.assertIn("memory_companion_note_delete", readme)
self.assertIn("创建、读取和删除当前 Bot", schema)
def test_photo_path_is_confined_and_local_path_is_not_exposed(self) -> None:
with tempfile.TemporaryDirectory() as temp:
base = Path(temp)
allowed = base / "companion-data"
own_data = base / "memory-data"
allowed.mkdir()
own_data.mkdir()
inside = allowed / "inside.jpg"
outside = base / "outside.jpg"
inside.write_bytes(b"jpeg-placeholder")
outside.write_bytes(b"jpeg-placeholder")
page_plugin = SimpleNamespace(service=SimpleNamespace(data_dir=own_data))
companion = SimpleNamespace(data_dir=allowed, data_file=allowed / "companions.json")
api = PluginPageApi(page_plugin)
self.assertEqual(inside.resolve(), api._safe_companion_photo_path(inside, companion))
self.assertEqual(inside.resolve(), api._safe_companion_photo_path("inside.jpg", companion))
self.assertIsNone(api._safe_companion_photo_path(outside, companion))
album = api._private_companion_album(
{"daily_outfit_photo": {"path": str(inside), "date": "2026-07-10"}},
"2026-07-10",
plugin=companion,
)
self.assertEqual(1, len(album))
self.assertNotIn("path", album[0])
self.assertNotIn("_local_path", album[0])
if __name__ == "__main__":
unittest.main()