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 memory semantic queue stall fix (issue #864).
Ensures that _process_memory_directory() error paths propagate exceptions
so that on_dequeue() returns an explicit processing outcome.
"""
import asyncio
from types import SimpleNamespace
from unittest.mock import AsyncMock, MagicMock, patch
from uuid import uuid4
import pytest
from openviking.storage.queuefs.process_result import ProcessOutcome
from openviking.storage.queuefs.semantic_msg import SemanticMsg
from openviking.storage.queuefs.semantic_processor import SemanticProcessor
from openviking.utils.circuit_breaker import CircuitBreakerOpen
def _processor():
resolver = SimpleNamespace(get_vlm=AsyncMock(return_value=SimpleNamespace()))
return SemanticProcessor(vlm_resolver=resolver)
def _make_msg(uri="viking://user/usr1/memories", context_type="memory", **kwargs):
"""Build a minimal SemanticMsg for testing."""
defaults = {
"id": "test-msg-1",
"uri": uri,
"context_type": context_type,
"recursive": False,
"role": "root",
"account_id": "acc1",
"user_id": "usr1",
"peer_id": "test-peer",
"telemetry_id": "",
"target_uri": "",
"changes": None,
"is_code_repo": False,
}
defaults.update(kwargs)
return SemanticMsg.from_dict(defaults)
def _build_data(msg: SemanticMsg) -> dict:
"""Wrap a SemanticMsg into the dict format on_dequeue expects."""
return msg.to_dict()
@pytest.mark.parametrize("context_type", ["resource", "memory", "skill"])
async def test_retry_cancellation_keeps_skill_wait_isolated(monkeypatch, context_type):
from openviking.service.task_store import PersistentTaskStore
from openviking.service.task_tracker import TaskTracker
from tests.test_task_tracker import _FakeAgfs
monkeypatch.setattr(
"openviking.service.task_tracker._instance", TaskTracker(PersistentTaskStore(_FakeAgfs()))
)
processor = _processor()
processor._circuit_breakers["acc1"] = SimpleNamespace(
check=MagicMock(side_effect=CircuitBreakerOpen), retry_after=0
)
entered, release = asyncio.Event(), asyncio.Event()
written = []
async def enqueue(msg, *, deduplicate_memory=True):
entered.set()
await release.wait()
written.append(msg.id)
queue = SimpleNamespace(enqueue=enqueue)
monkeypatch.setattr(
"openviking.storage.queuefs.get_queue_manager",
lambda: SimpleNamespace(SEMANTIC="Semantic", get_queue=lambda _: queue),
)
msg = _make_msg(context_type=context_type, telemetry_id=str(uuid4()))
processor._circuit_breakers[msg.account_id] = SimpleNamespace(
check=MagicMock(side_effect=CircuitBreakerOpen), retry_after=0
)
worker = asyncio.create_task(processor.on_dequeue(msg.to_dict()))
try:
await asyncio.wait_for(entered.wait(), 1)
worker.cancel()
if context_type == "skill":
await asyncio.sleep(0)
assert not worker.done()
assert not written
release.set()
with pytest.raises(asyncio.CancelledError):
await asyncio.wait_for(worker, 1)
assert written == ([msg.id] if context_type == "skill" else [])
finally:
release.set()
if not worker.done():
worker.cancel()
await asyncio.gather(worker, return_exceptions=True)
@pytest.mark.asyncio
async def test_root_semantic_message_is_acknowledged_without_processing():
processor = _processor()
result = await processor.on_dequeue(
_build_data(_make_msg(uri="viking://", context_type="resource"))
)
assert result.outcome is ProcessOutcome.SUCCESS
assert result.value is None
assert result.error is None
@pytest.mark.asyncio
async def test_memory_empty_dir_still_returns_success():
"""An empty memory directory must return a successful processing result."""
processor = _processor()
fake_fs = MagicMock()
fake_fs.exists = AsyncMock(return_value=True)
fake_fs.ls = AsyncMock(return_value=[])
msg = _make_msg()
data = _build_data(msg)
with (
patch(
"openviking.storage.queuefs.semantic_processor.get_viking_fs",
return_value=fake_fs,
),
patch(
"openviking.storage.queuefs.semantic_work.resolve_telemetry",
return_value=None,
),
):
result = await processor.on_dequeue(data)
assert result.outcome is ProcessOutcome.SUCCESS
assert result.value is None
assert result.error is None
@pytest.mark.asyncio
async def test_memory_ls_error_returns_failed():
"""A permanent filesystem error must return a failed processing result.
Uses a real classify_api_error (no mock): FileNotFoundError is classified
as permanent by the real classifier, so the processor returns FAILED.
"""
processor = _processor()
fake_fs = MagicMock()
fake_fs.exists = AsyncMock(return_value=True)
fake_fs.ls = AsyncMock(side_effect=FileNotFoundError("/memories not found"))
msg = _make_msg()
data = _build_data(msg)
with (
patch(
"openviking.storage.queuefs.semantic_processor.get_viking_fs",
return_value=fake_fs,
),
patch(
"openviking.storage.queuefs.semantic_work.resolve_telemetry",
return_value=None,
),
):
result = await processor.on_dequeue(data)
assert result.outcome is ProcessOutcome.FAILED
assert result.value is None
assert result.error == (f"Failed to list memory directory {msg.uri}: /memories not found")
@pytest.mark.asyncio
async def test_memory_ls_transient_error_returns_failed():
"""Queue processing does not retry an error after the owning layer exhausts it."""
processor = _processor()
fake_fs = MagicMock()
fake_fs.exists = AsyncMock(return_value=True)
fake_fs.ls = AsyncMock(side_effect=RuntimeError("500 Internal Server Error"))
msg = _make_msg(telemetry_id="tel-1")
data = _build_data(msg)
with (
patch(
"openviking.storage.queuefs.semantic_processor.get_viking_fs",
return_value=fake_fs,
),
patch(
"openviking.storage.queuefs.semantic_work.resolve_telemetry",
return_value=None,
),
):
result = await processor.on_dequeue(data)
assert result.outcome is ProcessOutcome.FAILED
assert result.value is None
assert result.error == (
f"Failed to list memory directory {msg.uri}: 500 Internal Server Error"
)
@pytest.mark.asyncio
async def test_memory_write_error_returns_failed():
"""An abstract/overview PermissionError must return a failed processing result.
Exercises the write failure path with real classify_api_error: PermissionError
is classified as permanent, so the processor returns FAILED.
"""
processor = _processor()
fake_fs = MagicMock()
fake_fs.exists = AsyncMock(return_value=True)
fake_fs.ls = AsyncMock(return_value=[{"name": "file1.md", "isDir": False}])
fake_fs.read_file = AsyncMock(return_value="some content")
fake_fs.write_file = AsyncMock(side_effect=PermissionError("Permission denied"))
fake_fs._async_agfs.pathlock_acquire_exact_batch = AsyncMock(return_value={"lease_ref": "test"})
fake_fs._async_agfs.pathlock_release = AsyncMock()
fake_fs._uri_to_path = MagicMock(
side_effect=lambda uri, ctx=None: f"/local/acc1/{uri.removeprefix('viking://')}"
)
msg = _make_msg(skip_vectorization=True)
data = _build_data(msg)
with (
patch(
"openviking.storage.queuefs.semantic_processor.get_viking_fs",
return_value=fake_fs,
),
patch(
"openviking.storage.queuefs.semantic_work.resolve_telemetry",
return_value=None,
),
patch(
"openviking.storage.queuefs.semantic_processor.get_openviking_config",
return_value=SimpleNamespace(
semantic=SimpleNamespace(
overview_max_chars=100_000,
abstract_max_chars=10_000,
)
),
),
patch.object(
processor,
"_generate_single_file_summary",
new=AsyncMock(return_value={"name": "file1.md", "summary": "test summary"}),
),
patch.object(
processor,
"_generate_overview",
new=AsyncMock(return_value="# Overview\ntest overview"),
),
):
result = await processor.on_dequeue(data)
assert result.outcome is ProcessOutcome.FAILED
assert result.value is None
assert result.error == (f"Failed to write abstract/overview for {msg.uri}: Permission denied")