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: AGPL-3.0
from __future__ import annotations
import os
from pathlib import Path
from types import SimpleNamespace
import pytest
import openviking.server.app as app_module
import openviking.server.bootstrap as bootstrap
from openviking.scheduling.expiry.config import ExpiryConfig
from openviking.server.config import ServerConfig
from openviking.utils.agfs_utils import resolve_queuefs_mount_point
from openviking_cli.utils.config.memory_config import SessionAutoCommitConfig
from openviking_cli.utils.config.open_viking_config import OpenVikingConfigSingleton
from openviking_cli.utils.config.storage_config import StorageConfig
def test_main_keeps_config_host_when_cli_host_is_omitted(monkeypatch):
config = ServerConfig(host="127.0.0.1", port=1933)
captured: dict[str, object] = {}
monkeypatch.setattr(
bootstrap,
"load_server_config",
lambda config_path: config,
)
monkeypatch.setattr(
bootstrap,
"create_app",
lambda config, **kwargs: "app",
)
monkeypatch.setattr(
bootstrap,
"configure_uvicorn_logging",
lambda: None,
)
monkeypatch.setattr(
OpenVikingConfigSingleton,
"initialize",
classmethod(lambda cls, config_path: None),
)
monkeypatch.setattr(
bootstrap.argparse.ArgumentParser,
"parse_args",
lambda self: SimpleNamespace(
host=None,
port=None,
config=None,
workers=None,
bot=False,
with_bot=False,
bot_url="http://localhost:18790",
enable_bot_logging=None,
bot_log_dir="/tmp/bot-logs",
),
)
monkeypatch.setattr(
bootstrap,
"_run_restartable_server",
lambda app, host, port, log_config=None, **kwargs: captured.update(
{"app": app, "host": host, "port": port, "log_config": log_config, **kwargs}
),
)
bootstrap.main()
assert captured["host"] == "127.0.0.1"
assert captured["port"] == 1933
def test_main_coerces_cli_host_all_to_none(monkeypatch):
config = ServerConfig(host="127.0.0.1", port=1933)
captured: dict[str, object] = {}
monkeypatch.setattr(
bootstrap,
"load_server_config",
lambda config_path: config,
)
monkeypatch.setattr(
bootstrap,
"create_app",
lambda config, **kwargs: "app",
)
monkeypatch.setattr(
bootstrap,
"configure_uvicorn_logging",
lambda: None,
)
monkeypatch.setattr(
OpenVikingConfigSingleton,
"initialize",
classmethod(lambda cls, config_path: None),
)
monkeypatch.setattr(
bootstrap.argparse.ArgumentParser,
"parse_args",
lambda self: SimpleNamespace(
host="all",
port=None,
config=None,
workers=None,
bot=False,
with_bot=False,
bot_url="http://localhost:18790",
enable_bot_logging=None,
bot_log_dir="/tmp/bot-logs",
),
)
monkeypatch.setattr(
bootstrap,
"_run_restartable_server",
lambda app, host, port, log_config=None, **kwargs: captured.update(
{"app": app, "host": host, "port": port, "log_config": log_config, **kwargs}
),
)
bootstrap.main()
assert captured["host"] is None
assert captured["port"] == 1933
def test_main_enables_bot_logging_when_with_bot_comes_from_config(monkeypatch):
config = ServerConfig(host="127.0.0.1", port=1933, with_bot=True)
captured: dict[str, object] = {}
bot_process = object()
monkeypatch.setattr(bootstrap, "load_server_config", lambda config_path: config)
monkeypatch.setattr(bootstrap, "create_app", lambda config, **kwargs: "app")
monkeypatch.setattr(bootstrap, "configure_uvicorn_logging", lambda: None)
monkeypatch.setattr(
OpenVikingConfigSingleton,
"initialize",
classmethod(lambda cls, config_path: None),
)
monkeypatch.setattr(
bootstrap.argparse.ArgumentParser,
"parse_args",
lambda self: SimpleNamespace(
host=None,
port=None,
config=None,
workers=None,
bot=False,
with_bot=False,
bot_port=bootstrap.VIKINGBOT_DEFAULT_PORT,
enable_bot_logging=None,
bot_log_dir="/tmp/bot-logs",
),
)
monkeypatch.setattr(bootstrap, "_abort_if_port_in_use", lambda port, label: None)
def _fake_start(enable_logging, log_dir, port, **kwargs):
captured.update(
{
"enable_logging": enable_logging,
"log_dir": log_dir,
"port": port,
}
)
return bot_process
monkeypatch.setattr(bootstrap, "_start_vikingbot_gateway", _fake_start)
monkeypatch.setattr(bootstrap, "_stop_vikingbot_gateway", lambda process: None)
monkeypatch.setattr(bootstrap, "_run_restartable_server", lambda *args, **kwargs: False)
bootstrap.main()
assert captured == {
"enable_logging": True,
"log_dir": "/tmp/bot-logs",
"port": bootstrap.VIKINGBOT_DEFAULT_PORT,
}
def test_bot_alias_propagates_resolved_config_to_workers(monkeypatch):
config = ServerConfig(host="127.0.0.1", port=1933)
captured = {}
original_parse_args = bootstrap.argparse.ArgumentParser.parse_args
def parse_bot_alias(parser):
args = original_parse_args(parser, ["--bot", "--workers", "2", "--bot-port", "19000"])
captured["with_bot"] = args.with_bot
return args
monkeypatch.setattr(bootstrap.argparse.ArgumentParser, "parse_args", parse_bot_alias)
monkeypatch.setattr(bootstrap, "load_server_config", lambda config_path: config)
monkeypatch.setattr(bootstrap, "create_app", lambda config, **kwargs: "parent-app")
monkeypatch.setattr(bootstrap, "configure_uvicorn_logging", lambda: None)
monkeypatch.setattr(bootstrap, "_abort_if_port_in_use", lambda port, label: None)
monkeypatch.setattr(bootstrap, "_start_vikingbot_gateway", lambda *args, **kwargs: object())
monkeypatch.setattr(bootstrap, "_stop_vikingbot_gateway", lambda process: None)
monkeypatch.setattr(
OpenVikingConfigSingleton,
"initialize",
classmethod(lambda cls, config_path: None),
)
monkeypatch.setattr(
"openviking_cli.utils.ollama.detect_ollama_in_config",
lambda config: (False, "127.0.0.1", 11434),
)
monkeypatch.setattr(
bootstrap.uvicorn,
"run",
lambda app, **kwargs: captured.update({"app": app, **kwargs}),
)
with monkeypatch.context() as worker_env:
worker_env.delenv(app_module.WORKER_HOST_ENV, raising=False)
worker_env.delenv(app_module.WORKER_PORT_ENV, raising=False)
worker_env.delenv(app_module.WORKER_WITH_BOT_ENV, raising=False)
worker_env.delenv(app_module.WORKER_BOT_API_URL_ENV, raising=False)
bootstrap.main()
assert captured["with_bot"] is True
assert captured["app"] == "openviking.server.app:create_worker_app"
assert os.environ[app_module.WORKER_HOST_ENV] == config.host
assert os.environ[app_module.WORKER_PORT_ENV] == str(config.port)
assert os.environ[app_module.WORKER_WITH_BOT_ENV] == "1"
assert os.environ[app_module.WORKER_BOT_API_URL_ENV] == "http://127.0.0.1:19000"
def test_main_prints_config_diagnostics_on_validation_error(monkeypatch, capsys):
"""An unknown top-level config field must exit 1 with actionable diagnostics."""
config = ServerConfig(host="127.0.0.1", port=1933)
monkeypatch.setattr(bootstrap, "resolve_config_path", lambda *a, **k: Path("/tmp/ov.conf"))
monkeypatch.setattr(bootstrap, "load_server_config", lambda *a, **k: config)
def failing_initialize(cls, config_path):
raise ValueError("Unknown config field 'claude_code' in OpenVikingConfig")
monkeypatch.setattr(
OpenVikingConfigSingleton,
"initialize",
classmethod(failing_initialize),
)
monkeypatch.setattr(
bootstrap.argparse.ArgumentParser,
"parse_args",
lambda self: SimpleNamespace(
host=None,
port=None,
config="/tmp/ov.conf",
workers=None,
bot=False,
with_bot=False,
bot_url="http://localhost:18790",
enable_bot_logging=None,
bot_log_dir="/tmp/bot-logs",
),
)
with pytest.raises(SystemExit) as exc:
bootstrap.main()
assert exc.value.code == 1
err = capsys.readouterr().err
assert "/tmp/ov.conf" in err
assert "Unknown config field 'claude_code'" in err
assert "openviking-server doctor" in err
assert "examples/ov.conf.example" in err
def test_worker_factory_replays_bot_overrides(monkeypatch):
config = ServerConfig(with_bot=False, bot_api_url="http://from-config")
captured = {}
monkeypatch.setenv(app_module.WORKER_HOST_ENV, "::")
monkeypatch.setenv(app_module.WORKER_PORT_ENV, "1999")
monkeypatch.setenv(app_module.WORKER_WITH_BOT_ENV, "1")
monkeypatch.setenv(app_module.WORKER_BOT_API_URL_ENV, "http://127.0.0.1:19000")
monkeypatch.setattr(
app_module,
"resolve_config_path",
lambda config_path, env_var, default_name: "/tmp/worker-ov.conf",
)
monkeypatch.setattr(
app_module,
"load_server_config",
lambda config_path: captured.update({"load_path": config_path}) or config,
)
monkeypatch.setattr(
app_module,
"create_app",
lambda worker_config, config_path: captured.update(
{
"app_config": worker_config,
"app_config_path": config_path,
}
)
or worker_config,
)
worker_config = app_module.create_worker_app()
assert worker_config.host == "::"
assert worker_config.port == 1999
assert worker_config.with_bot is True
assert worker_config.bot_api_url == "http://127.0.0.1:19000"
assert captured == {
"load_path": "/tmp/worker-ov.conf",
"app_config": config,
"app_config_path": "/tmp/worker-ov.conf",
}
def test_resolve_queuefs_mount_point_defaults_to_shared():
config = StorageConfig()
assert resolve_queuefs_mount_point(config) == "/queue"
def test_resolve_queuefs_mount_point_worker_mode_uses_process_index(monkeypatch):
monkeypatch.setattr(
"openviking.utils.agfs_utils.multiprocessing.current_process",
lambda: SimpleNamespace(_identity=(3,)),
)
config = StorageConfig(agfs={"queuefs": {"mode": "worker"}})
assert resolve_queuefs_mount_point(config) == "/queue/worker-2"
def test_resolve_queuefs_mount_point_worker_mode_falls_back_to_pid(monkeypatch):
monkeypatch.setattr(
"openviking.utils.agfs_utils.multiprocessing.current_process",
lambda: SimpleNamespace(_identity=()),
)
monkeypatch.setattr(os, "getpid", lambda: 43210)
config = StorageConfig(agfs={"queuefs": {"mode": "worker"}})
assert resolve_queuefs_mount_point(config) == "/queue/worker-43210"
def test_configure_default_executor_uses_configured_size(monkeypatch):
created: dict[str, object] = {}
class _Executor:
def __init__(self, *, max_workers, thread_name_prefix):
created["max_workers"] = max_workers
created["thread_name_prefix"] = thread_name_prefix
class _Loop:
def set_default_executor(self, executor):
created["executor"] = executor
monkeypatch.setattr(app_module, "ThreadPoolExecutor", _Executor)
monkeypatch.setattr(app_module.asyncio, "get_running_loop", lambda: _Loop())
app_module._configure_default_executor(ServerConfig(executor_threads=48))
assert created["max_workers"] == 48
assert created["thread_name_prefix"] == "openviking-asyncio"
assert created["executor"].__class__ is _Executor
def test_configure_default_executor_keeps_python_default_when_zero(monkeypatch):
monkeypatch.setattr(
app_module.asyncio,
"get_running_loop",
lambda: pytest.fail("event loop should not be touched when the setting is zero"),
)
app_module._configure_default_executor(ServerConfig())
def test_restartable_server_drains_uvicorn_before_returning(monkeypatch):
from fastapi import FastAPI
app = FastAPI()
server = SimpleNamespace(should_exit=False)
def run():
assert app.state.restart_controller.status()["supported"]
app.state.restart_controller.request()
app.state.restart_controller.stop()
assert server.should_exit
server.run = run
monkeypatch.setattr(bootstrap.uvicorn, "Server", lambda config: server)
assert bootstrap._run_restartable_server(app, host="127.0.0.1", port=1933)
@pytest.mark.parametrize("app_startup_fails", [False, True])
def test_main_restart_cleans_up_managed_children_and_preserves_launch_command(
monkeypatch, app_startup_fails
):
import sys
config = ServerConfig(
host="127.0.0.1",
port=1933,
with_bot=True,
ttl_adapter={"enabled": True},
)
steps = []
monkeypatch.setattr(sys, "argv", ["openviking-server", "--with-bot", "--bot-port", "19000"])
original_argv = [sys.executable, "/venv/bin/openviking-server", *sys.argv[1:]]
monkeypatch.setattr(sys, "orig_argv", original_argv)
monkeypatch.setattr(bootstrap, "load_server_config", lambda path: config)
monkeypatch.setattr(bootstrap, "resolve_config_path", lambda *a: Path("/tmp/explicit.conf"))
monkeypatch.setattr(
OpenVikingConfigSingleton,
"initialize",
classmethod(
lambda cls, **kw: SimpleNamespace(
memory=SimpleNamespace(
session_auto_commit=SessionAutoCommitConfig(enabled=False, idle_backend="redis")
),
expiry=ExpiryConfig(),
)
),
)
monkeypatch.setattr(
"openviking_cli.utils.ollama.detect_ollama_in_config", lambda c: (False, "", 0)
)
monkeypatch.setattr(bootstrap, "configure_uvicorn_logging", lambda: None)
def create_app(*args, **kwargs):
assert steps == [("start", Path("/tmp/explicit.conf"))]
if app_startup_fails:
raise RuntimeError("application initialization failed")
return "app"
monkeypatch.setattr(bootstrap, "create_app", create_app)
monkeypatch.setattr(bootstrap, "_abort_if_port_in_use", lambda *a: None)
monkeypatch.setattr(bootstrap, "_start_vikingbot_gateway", lambda *a, **kw: "bot")
monkeypatch.setattr(bootstrap, "_start_expiry_publisher", lambda *a, **kw: None)
monkeypatch.setattr(
bootstrap, "_stop_vikingbot_gateway", lambda bot: steps.append(("stop", bot))
)
monkeypatch.setattr(
bootstrap,
"_start_expiry_publisher",
lambda path: steps.append(("start", path)) or "publisher",
)
monkeypatch.setattr(
bootstrap, "_stop_expiry_publisher", lambda child: steps.append(("stop", child))
)
monkeypatch.setattr(bootstrap, "_run_restartable_server", lambda *a, **kw: True)
monkeypatch.setattr(
os, "execv", lambda executable, args: steps.append(("exec", executable, args))
)
monkeypatch.setenv("OPENVIKING_CONFIG_FILE", "/tmp/explicit.conf")
lifecycle = [
("start", Path("/tmp/explicit.conf")),
("stop", "publisher"),
("stop", "bot"),
]
if app_startup_fails:
with pytest.raises(RuntimeError, match="application initialization failed"):
bootstrap.main()
assert steps == lifecycle
return
bootstrap.main()
assert steps == [*lifecycle, ("exec", sys.executable, original_argv)]
assert os.environ["OPENVIKING_CONFIG_FILE"] == "/tmp/explicit.conf"
@pytest.mark.parametrize("failure", ["bind", "lifespan", "bootstrap", "success", "retry_failure"])
def test_restart_recovery_through_real_exec(tmp_path, monkeypatch, failure):
"""Exercise socket/lifespan failures and a single recovery with real execv."""
import hashlib
import json
import socket
import subprocess
import sys
import textwrap
from openviking.server.restart import RestartRecovery
path = tmp_path / "ov.conf"
original = b'{"port":0,"stage":"original"}\n'
monkeypatch.setattr(OpenVikingConfigSingleton, "_config_file", path)
monkeypatch.setattr(OpenVikingConfigSingleton, "_config_file_content", original)
monkeypatch.delenv("OPENVIKING_RESTART_RECOVERY", raising=False)
monkeypatch.delenv("OPENVIKING_RESTART_ROLLED_BACK", raising=False)
with socket.socket() as occupied:
occupied.bind(("127.0.0.1", 0))
occupied.listen()
path.write_text(json.dumps({"port": occupied.getsockname()[1], "stage": failure}))
# A normal save backup may contain an intermediate, never-started draft.
path.with_name("ov.conf.studio.bak").write_bytes(b'{"stage":"intermediate"}')
RestartRecovery().prepare(hashlib.sha256(path.read_bytes()).hexdigest())
backup = Path(json.loads(os.environ["OPENVIKING_RESTART_RECOVERY"])["backup"])
assert backup.read_bytes() == original
if os.name != "nt":
assert backup.stat().st_mode & 0o777 == 0o600
script = tmp_path / "restart_probe.py"
script.write_text(
textwrap.dedent("""\
import asyncio, json, sys
from contextlib import asynccontextmanager
from pathlib import Path
from fastapi import FastAPI
import openviking.server.bootstrap as bootstrap
def run(recovery):
path = Path(sys.argv[1])
config = json.loads(path.read_text())
if config['stage'] in ('bootstrap', 'retry_failure') or (sys.argv[2] == 'retry_failure' and recovery.rolled_back):
raise SystemExit(1)
@asynccontextmanager
async def lifespan(app):
if config['stage'] == 'lifespan':
raise RuntimeError('startup failed')
asyncio.get_running_loop().call_later(0.2, lambda: setattr(app.state.restart_controller, 'requested', True))
asyncio.get_running_loop().call_later(0.3, lambda: app.state.restart_controller.stop())
yield
app = FastAPI(lifespan=lifespan)
bootstrap._run_restartable_server(app, recovery=recovery, host='127.0.0.1',
port=config['port'] if config['stage'] == 'bind' else 0, log_config=None)
print('RECOVERED' if recovery.rolled_back else 'APPLIED')
bootstrap._main = run
bootstrap.main()
""")
)
result = subprocess.run(
[sys.executable, str(script), str(path), failure],
env=os.environ.copy(),
capture_output=True,
text=True,
timeout=40,
)
if failure == "retry_failure":
assert result.returncode != 0
assert result.stderr.count("retrying once") == 1
assert path.read_bytes() == original
else:
assert result.returncode == 0, result.stderr
assert ("APPLIED" if failure == "success" else "RECOVERED") in result.stdout
assert (path.read_bytes() == original) == (failure != "success")
assert not backup.exists()
def test_restart_recovery_does_not_overwrite_external_changes(tmp_path, monkeypatch):
import hashlib
from openviking.server.restart import RestartRecovery
path = tmp_path / "ov.conf"
path.write_bytes(b"new configuration")
monkeypatch.setattr(OpenVikingConfigSingleton, "_config_file", path)
monkeypatch.setattr(OpenVikingConfigSingleton, "_config_file_content", b"startup configuration")
monkeypatch.delenv("OPENVIKING_RESTART_RECOVERY", raising=False)
RestartRecovery().prepare(hashlib.sha256(path.read_bytes()).hexdigest())
recovery = RestartRecovery()
path.write_bytes(b"external edit")
with pytest.raises(RuntimeError, match="refusing to overwrite"):
recovery.rollback()
assert path.read_bytes() == b"external edit"