Refactor OpenVikingMemorySystemClient to use OpenVikingCredential and update session handling; increase EverOS timeout to 180 seconds; enhance tests for credential handling and vector removal in search results.

tests/test_memory_system_clients.py

@@ -1,4 +1,96 @@
-from memory_system_api.clients import EverOSMemorySystemClient
+import asyncio
+
+from memory_system_api.clients import EverOSMemorySystemClient, OpenVikingMemorySystemClient
+
+
+class FakeStore:
+    def __init__(self):
+        self.saved = {}
+
+    def get_user_key(self, user_id: str) -> str | None:
+        return self.saved.get(user_id)
+
+    def save_user_key(self, user_id: str, user_key: str) -> None:
+        self.saved[user_id] = user_key
+
+
+class FakeResponse:
+    def __init__(self, status_code: int, data: dict):
+        self.status_code = status_code
+        self._data = data
+
+    def json(self) -> dict:
+        return self._data
+
+    def raise_for_status(self) -> None:
+        if self.status_code >= 400:
+            raise AssertionError(f"unexpected status {self.status_code}")
+
+
+class FakeAsyncClient:
+    def __init__(self, calls: list, responses: list[FakeResponse], api_key: str, headers: dict):
+        self.calls = calls
+        self.responses = responses
+        self.api_key = api_key
+        self.headers = headers
+
+    async def __aenter__(self):
+        return self
+
+    async def __aexit__(self, exc_type, exc, tb):
+        return False
+
+    async def post(self, path: str, json: dict | None = None) -> FakeResponse:
+        self.calls.append(("post", self.api_key, self.headers, path, json))
+        return self.responses.pop(0)
+
+
+def test_openviking_uses_root_identity_when_account_already_exists():
+    store = FakeStore()
+    client = OpenVikingMemorySystemClient(store=store)
+    client.root_key = "root-key"
+    calls = []
+    responses = [FakeResponse(409, {"status": "error", "error": {"code": "CONFLICT"}})]
+    client._client = lambda api_key, extra_headers=None: FakeAsyncClient(  # type: ignore[method-assign]
+        calls,
+        responses,
+        api_key,
+        extra_headers or {},
+    )
+
+    credential = asyncio.run(client.ensure_user("tom"))
+
+    assert credential.api_key == "root-key"
+    assert credential.account_id == "tom"
+    assert credential.user_id == "tom"
+    assert store.saved == {}
+
+
+def test_openviking_root_identity_headers_are_sent_for_session_create():
+    client = OpenVikingMemorySystemClient(store=FakeStore())
+    client.root_key = "root-key"
+    calls = []
+    responses = [FakeResponse(200, {"status": "ok", "result": {"session_id": "sess-2"}})]
+    client._client = lambda api_key, extra_headers=None: FakeAsyncClient(  # type: ignore[method-assign]
+        calls,
+        responses,
+        api_key,
+        extra_headers or {},
+    )
+    credential = client.root_credential("tom")
+
+    result = asyncio.run(client.ensure_session(credential, "sess-2"))
+
+    assert result == {"status": "ok", "result": {"session_id": "sess-2"}}
+    assert calls == [
+        (
+            "post",
+            "root-key",
+            {"X-OpenViking-Account": "tom", "X-OpenViking-User": "tom"},
+            "/api/v1/sessions",
+            {"session_id": "sess-2"},
+        )
+    ]
 
 
 def test_everos_assistant_payload_does_not_use_user_id_as_sender():

tests/test_memory_system_service.py

@@ -51,6 +51,62 @@ class FakeEverOS:
         return {"items": [{"source": f"everos-{method}"}]}
 
 
+class FakeEverOSWithVector(FakeEverOS):
+    async def search(self, user_id: str, session_id: str | None, query: str, method: str, limit: int) -> dict:
+        self.calls.append(("search", user_id, session_id, query, method, limit))
+        return {
+            "data": {
+                "episodes": [{"id": "episode-1", "vector": [0.1, 0.2]}],
+                "original_data": {
+                    "episodes": {
+                        "episode-1": {
+                            "summary": "喜欢拿铁",
+                            "vector": [0.1, 0.2],
+                            "nested": {"vector": [0.3]},
+                        }
+                    }
+                },
+            }
+        }
+
+
+def test_capture_includes_exception_type_when_message_is_empty():
+    service = MemorySystemService(openviking=FakeOpenViking(), everos=FakeEverOS())
+
+    class EmptyError(Exception):
+        pass
+
+    async def fail():
+        raise EmptyError()
+
+    response = asyncio.run(service._capture(fail))
+
+    assert response.status == "failed"
+    assert response.error == "EmptyError"
+
+
+def test_search_removes_vectors_from_items_and_backend_results():
+    service = MemorySystemService(openviking=FakeOpenViking(), everos=FakeEverOSWithVector())
+
+    response = asyncio.run(service.search(
+        SearchRequest(user_id="tom", session_id="sess-1", query="咖啡偏好", use_llm=False, limit=5)
+    ))
+
+    assert response.items == [
+        {"source_backend": "openviking", "source": "openviking-find"},
+        {"source_backend": "everos", "id": "episode-1"},
+    ]
+    assert not _has_key(response.backends["everos"].result, "vector")
+
+
+def _has_key(value, key: str) -> bool:
+    if isinstance(value, dict):
+        return key in value or any(_has_key(item, key) for item in value.values())
+    if isinstance(value, list):
+        return any(_has_key(item, key) for item in value)
+    return False
+
+
 def test_ingest_splits_user_and_assistant_messages():
     openviking = FakeOpenViking()
     everos = FakeEverOS()