Skip to content

Self-evolving Context Database for AI Agents. Unify Agent Memory, Knowledge RAG and Skills.

6.4 KB
Raw Blame
# Copyright (c) 2026 Beijing Volcano Engine Technology Co., Ltd.
# SPDX-License-Identifier: Apache-2.0
"""Focused tests for core service behavior."""

from types import SimpleNamespace
from unittest.mock import AsyncMock, patch

import pytest

from openviking.server.identity import RequestContext, Role
from openviking.service.core import OpenVikingService
from openviking.storage.index_consistency import IndexConsistencyReport
from openviking_cli.exceptions import InvalidArgumentError
from openviking_cli.session.user_id import UserIdentifier
from openviking_cli.utils.config.vlm_config import VLMConfig


def test_service_passes_queue_worker_concurrency_to_storage(monkeypatch) -> None:
    storage_calls = []
    embedder = SimpleNamespace(is_sparse=False)
    config = SimpleNamespace(
        default_account="default",
        default_user="default",
        storage=object(),
        embedding=SimpleNamespace(
            max_concurrent=10,
            dimension=1024,
            get_embedder=lambda: embedder,
        ),
        vlm=SimpleNamespace(max_concurrent=32),
        parser_api=SimpleNamespace(),
        compile_api=SimpleNamespace(base_url=""),
        queue_workers=SimpleNamespace(
            external_parse=SimpleNamespace(max_concurrent=9),
            add_resource=SimpleNamespace(max_concurrent=7),
            session_commit=SimpleNamespace(max_concurrent=5),
            external_task=SimpleNamespace(max_concurrent=6),
        ),
        git=object(),
    )

    monkeypatch.setattr(
        "openviking.service.core.initialize_openviking_config",
        lambda **_kwargs: config,
    )
    monkeypatch.setattr(OpenVikingService, "_ensure_data_dir_lock_acquired", lambda self: None)
    monkeypatch.setattr(
        OpenVikingService,
        "_build_ragfs_binding_config",
        lambda self: object(),
    )

    def _capture_storage_init(self, *args, **kwargs) -> None:
        storage_calls.append((args, kwargs))

    monkeypatch.setattr(OpenVikingService, "_init_storage", _capture_storage_init)

    OpenVikingService()

    assert storage_calls[0][1]["max_concurrent_external_parse"] == 9
    assert storage_calls[0][1]["max_concurrent_add_resource"] == 7
    assert storage_calls[0][1]["max_concurrent_session_commit"] == 5
    assert storage_calls[0][1]["max_concurrent_external_task"] == 6


def _service_with_fs(stat_result: dict) -> tuple[OpenVikingService, AsyncMock]:
    service = OpenVikingService.__new__(OpenVikingService)
    service._initialized = True
    service._user = UserIdentifier.the_default_user()
    service._vikingdb_manager = AsyncMock()
    service._viking_fs = AsyncMock()
    service._viking_fs.stat.return_value = stat_result
    return service, service._viking_fs


@pytest.mark.asyncio
async def test_check_consistency_rejects_file_uri() -> None:
    service, viking_fs = _service_with_fs({"isDir": False})
    ctx = RequestContext(user=service.user, role=Role.ROOT)

    with pytest.raises(
        InvalidArgumentError,
        match="Consistency check only supports directory URIs",
    ):
        await service.check_consistency(
            uri="viking://resources/consistency-file.md",
            ctx=ctx,
        )

    viking_fs.tree.assert_not_awaited()


@pytest.mark.asyncio
async def test_check_consistency_preserves_directory_behavior() -> None:
    service, viking_fs = _service_with_fs({"isDir": True})
    viking_fs.tree.return_value = []
    ctx = RequestContext(user=service.user, role=Role.ROOT)
    report = IndexConsistencyReport(expected=(), missing_records=())

    with patch(
        "openviking.service.core.check_index_consistency",
        new=AsyncMock(return_value=report),
    ) as check:
        result = await service.check_consistency(uri="viking://resources", ctx=ctx)

    assert result == report.to_dict()
    viking_fs.stat.assert_awaited_once_with(
        "viking://resources",
        ctx=ctx,
        skip_count=True,
    )
    viking_fs.tree.assert_awaited_once()
    check.assert_awaited_once()


@pytest.mark.asyncio
async def test_close_stops_queue_manager_before_ragfs_binding(monkeypatch) -> None:
    from openviking.ttl import wiring

    events: list[str] = []

    async def close_ttl():
        events.append("ttl")

    adapter = SimpleNamespace(aclose=close_ttl)
    monkeypatch.setattr(wiring, "_adapter", adapter)
    monkeypatch.setattr(
        "openviking.service.core.get_task_tracker", lambda: SimpleNamespace(close=AsyncMock())
    )

    class ResourceService:
        async def close_background_tasks(self) -> None:
            events.append("resource_tasks")

    class QueueManager:
        def stop(self) -> None:
            assert wiring.get_ttl_adapter() is adapter
            events.append("queue_manager")

    class RagfsClient:
        def close(self) -> None:
            events.append("ragfs_binding")

    service = OpenVikingService.__new__(OpenVikingService)
    service._resource_service = ResourceService()
    service._config = SimpleNamespace(vlm=VLMConfig())
    service._compile_scheduler = None
    service._ttl_adapter = adapter
    service._expiry_runtime = SimpleNamespace(
        stop_roles=AsyncMock(side_effect=lambda **_: events.append("expiry_roles")),
        close=AsyncMock(side_effect=lambda: events.append("expiry_storage")),
    )
    service._session_service = SimpleNamespace(set_session_expiry_adapter=lambda _: None)
    service._runtime_config_manager = None
    service._watch_scheduler = None
    service._session_auto_commit_scheduler = None
    service._queue_manager = QueueManager()
    service._vikingdb_manager = None
    service._agfs_client = RagfsClient()
    service._viking_fs = object()
    service._resource_processor = object()
    service._skill_processor = object()
    service._session_compressor = object()
    service._directory_initializer = object()
    service._privacy_config_service = object()
    service._initialized = True
    monkeypatch.setattr(
        OpenVikingService,
        "_release_data_dir_lock",
        lambda self: events.append("data_dir_lock"),
    )

    await service.close()

    assert events.index("queue_manager") < events.index("ragfs_binding")
    assert wiring.get_ttl_adapter() is None
    assert events.index("expiry_roles") < events.index("queue_manager")
    assert events.index("queue_manager") < events.index("ttl") < events.index("expiry_storage")
    assert events.index("expiry_storage") < events.index("ragfs_binding")
    assert events[-1] == "data_dir_lock"