Self-evolving Context Database for AI Agents. Unify Agent Memory, Knowledge RAG and Skills.
Python agent-contextagent-memoryagent-pluginsagentic-ragcontext-databasedsh-pluginknowledge-basememorymemory-managementself-evolvingvector-database
# Copyright (c) 2026 Beijing Volcano Engine Technology Co., Ltd.
# SPDX-License-Identifier: Apache-2.0
"""Tests for SessionCommitProcessor observability identity binding.
Phase-2 memory extraction runs in this queue worker; its VLM/embedding token
events read identity from the root observability context. These tests assert the
worker binds the committing account/user (so tokens are not attributed to
"__unknown__") and resets the context afterwards.
"""
import json
from types import SimpleNamespace
from unittest.mock import AsyncMock, Mock
import pytest
from openviking.observability.context import get_root_observability_context
from openviking.server.identity import RequestContext, Role
from openviking.session.session import Session
from openviking.storage.queuefs.process_result import ProcessOutcome
from openviking.storage.queuefs.session_commit_msg import SessionCommitMsg
from openviking.storage.queuefs.session_commit_processor import SessionCommitProcessor
from openviking_cli.session.user_id import UserIdentifier
class _FakeSession:
def __init__(self, captured: dict, processed: bool = True) -> None:
self._captured = captured
self._processed = processed
async def exists(self) -> bool:
return True
async def resume_queued_commit(self, msg) -> bool:
root = get_root_observability_context()
self._captured["account_id"] = root.account_id if root else None
self._captured["user_id"] = root.user_id if root else None
return self._processed
class _MemoryVikingFS:
def __init__(self) -> None:
self.files: dict[str, str] = {}
async def stat(self, uri, ctx=None, skip_count=False):
return {"path": uri}
async def write_file(self, uri, content, ctx=None, lease_ref=None):
self.files[uri] = content
def _make_msg() -> SessionCommitMsg:
return SessionCommitMsg(
task_id="task-1",
session_id="sess-1",
session_uri="viking://user/alice/sessions/sess-1",
archive_uri="viking://user/alice/sessions/sess-1/history/archive_001",
user={"account_id": "acme", "user_id": "alice"},
)
async def test_process_binds_committing_identity_to_root_context(monkeypatch):
captured: dict = {}
session = _FakeSession(captured)
processor = SessionCommitProcessor(SimpleNamespace(session=Mock(return_value=session)))
tracker = SimpleNamespace(create=AsyncMock(side_effect=OSError("store unavailable")))
monkeypatch.setattr(
"openviking.storage.queuefs.session_commit_processor.get_task_tracker", lambda: tracker
)
message = {"data": _make_msg().to_dict()}
with pytest.raises(OSError, match="store unavailable"):
await processor.on_dequeue(message)
tracker.create.side_effect = None
original_resume = session.resume_queued_commit
session.resume_queued_commit = AsyncMock(side_effect=ValueError("invalid archive message"))
result = await processor.on_dequeue(message)
assert result.outcome is ProcessOutcome.FAILED
assert result.error == "invalid archive message"
session.resume_queued_commit = original_resume
assert (await processor.on_dequeue(message)).outcome is ProcessOutcome.SUCCESS
assert captured == {"account_id": "acme", "user_id": "alice"}
assert get_root_observability_context() is None
async def test_process_requeues_deferred_commit_and_resets_root_context(monkeypatch):
queued = []
class _QueueManager:
async def enqueue(self, queue_name, data):
queued.append((queue_name, data))
processor = SessionCommitProcessor(
SimpleNamespace(session=Mock(return_value=_FakeSession({}, processed=False))),
)
monkeypatch.setattr(
"openviking.storage.queuefs.get_queue_manager",
lambda: _QueueManager(),
)
ctx = RequestContext(user=UserIdentifier("acme", "alice"), role=Role.USER)
result = await processor._process(_make_msg(), ctx)
assert result is False
assert queued == [("SessionCommit", _make_msg().to_dict())]
assert get_root_observability_context() is None
async def test_cancelled_queued_commit_writes_terminal_marker_before_returning():
msg = _make_msg()
viking_fs = _MemoryVikingFS()
session = Session(
viking_fs=viking_fs,
session_id=msg.session_id,
session_uri=msg.session_uri,
)
processor = SessionCommitProcessor(
SimpleNamespace(session=Mock(return_value=session)),
)
marker_uri = f"{msg.archive_uri}/.failed.json"
result = await processor.on_cancelled({"data": json.dumps(msg.to_dict())})
assert result.outcome is ProcessOutcome.CANCELLED
marker = json.loads(viking_fs.files[marker_uri])
assert marker["stage"] == "cancelled"
assert marker["error"] == "session commit cancelled"