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
"""Tests for the openviking-server init setup wizard."""
from __future__ import annotations
import json
import os
from unittest.mock import MagicMock, patch
import pytest
from openviking_cli.setup_wizard import (
_CUSTOM_SETUP,
_DEFAULT_KIMI_MODEL,
_GO_BACK,
_SKIP_VLM,
BYTEPLUS_PLANS,
CLOUD_PROVIDERS,
EMBEDDING_PRESETS,
LOCAL_GGUF_PRESETS,
QUERY_PLANNER_PRESETS,
VLM_PRESETS,
VOLCENGINE_PLANS,
_build_ollama_config,
_build_query_planner_config,
_config_path,
_get_recommended_indices,
_is_llamacpp_installed,
_mask_secret,
_masked_input,
_next_backup_path,
_parse_size_gb,
_prompt_api_key,
_prompt_api_key_with_env,
_prompt_required_input,
_prompt_required_int,
_update_existing_config,
_wizard_ollama,
_wizard_query_planner,
_wizard_server,
_wizard_two_step,
_workspace_path,
_write_config,
run_init,
)
from openviking_cli.utils.ollama import (
check_ollama_running,
get_ollama_models,
is_model_available,
)
# ---------------------------------------------------------------------------
# Ollama detection
# ---------------------------------------------------------------------------
class TestOllamaDetection:
def test_ollama_running(self):
mock_resp = MagicMock()
mock_resp.__enter__ = MagicMock(return_value=mock_resp)
mock_resp.__exit__ = MagicMock(return_value=False)
with patch("openviking_cli.utils.ollama.urllib.request.urlopen", return_value=mock_resp):
assert check_ollama_running() is True
def test_ollama_not_running(self):
import urllib.error
with patch(
"openviking_cli.utils.ollama.urllib.request.urlopen",
side_effect=urllib.error.URLError("refused"),
):
assert check_ollama_running() is False
def test_get_models(self):
mock_data = json.dumps(
{
"models": [
{"name": "qwen3-embedding:0.6b", "size": 639000000},
{"name": "gemma4:e4b", "size": 9600000000},
]
}
).encode()
mock_resp = MagicMock()
mock_resp.read.return_value = mock_data
mock_resp.__enter__ = MagicMock(return_value=mock_resp)
mock_resp.__exit__ = MagicMock(return_value=False)
with patch("openviking_cli.utils.ollama.urllib.request.urlopen", return_value=mock_resp):
models = get_ollama_models()
assert "qwen3-embedding:0.6b" in models
assert "gemma4:e4b" in models
def test_get_models_error(self):
import urllib.error
with patch(
"openviking_cli.utils.ollama.urllib.request.urlopen",
side_effect=urllib.error.URLError("refused"),
):
assert get_ollama_models() == []
# ---------------------------------------------------------------------------
# Model availability
# ---------------------------------------------------------------------------
class TestModelAvailability:
def test_exact_match(self):
available = ["qwen3-embedding:0.6b", "gemma4:e4b"]
assert is_model_available("qwen3-embedding:0.6b", available) is True
def test_no_match(self):
available = ["qwen3-embedding:0.6b"]
assert is_model_available("nomic-embed-text", available) is False
def test_tagless_matches_latest(self):
available = ["gemma:300m"]
assert is_model_available("gemma", available) is True
def test_prefix_variant(self):
available = ["qwen3-embedding:0.6b-fp16"]
assert is_model_available("qwen3-embedding:0.6b", available) is True
# ---------------------------------------------------------------------------
# Config building
# ---------------------------------------------------------------------------
class TestConfigBuilding:
def test_ollama_config_structure(self):
embedding = EMBEDDING_PRESETS[0] # qwen3-embedding:0.6b
vlm = VLM_PRESETS[0] # qwen3.5:4b
config = _build_ollama_config(embedding, vlm, "/tmp/ov_test")
assert config["storage"]["workspace"] == "/tmp/ov_test"
dense = config["embedding"]["dense"]
assert dense["provider"] == "ollama"
assert dense["model"] == "qwen3-embedding:0.6b"
assert dense["dimension"] == 1024
assert dense["api_base"] == "http://localhost:11434/v1"
vlm_cfg = config["vlm"]
assert vlm_cfg["provider"] == "litellm"
assert vlm_cfg["model"] == "ollama/qwen3.5:4b"
assert vlm_cfg["api_key"] == "no-key"
assert vlm_cfg["api_base"] == "http://localhost:11434"
# Ollama needs a larger context window (default 4096 truncates OV's
# ~5k-token extraction prompt) and thinking disabled.
assert vlm_cfg["extra_request_body"] == {"num_ctx": 16384, "think": False}
def test_prompt_required_input_uses_default_on_empty(self):
with patch("builtins.input", return_value=""):
value = _prompt_required_input("Model", default=_DEFAULT_KIMI_MODEL)
assert value == _DEFAULT_KIMI_MODEL
def test_prompt_required_int_uses_default_on_empty(self):
with patch("builtins.input", return_value=""):
value = _prompt_required_int("Dimension", default=1024)
assert value == 1024
def test_all_presets_valid(self):
"""Every preset should produce a config with required fields."""
for emb in EMBEDDING_PRESETS:
for vlm in VLM_PRESETS:
config = _build_ollama_config(emb, vlm, "/tmp/test")
assert "embedding" in config
assert "vlm" in config
assert config["embedding"]["dense"]["dimension"] > 0
# ---------------------------------------------------------------------------
# Query planner
# ---------------------------------------------------------------------------
class TestQueryPlanner:
def test_build_query_planner_config_structure(self):
preset = QUERY_PLANNER_PRESETS[0] # v4_q8
config = _build_query_planner_config(preset)
assert config["provider"] == "litellm"
assert config["model"] == preset.litellm_model
assert config["model"].startswith("ollama/")
# litellm Ollama base URL must not carry the /v1 suffix
assert config["api_base"] == "http://localhost:11434"
assert config["temperature"] == 0.0
assert config["extra_request_body"] == {"think": False}
def test_presets_have_litellm_models(self):
assert all(p.litellm_model.startswith("ollama/") for p in QUERY_PLANNER_PRESETS)
def test_wizard_enables_v4_sets_planner_without_prompt_override(self, tmp_path):
# Prompt selection happens at retrieval time from the configured model;
# the wizard must not write a prompt override or prompts.templates_dir.
config_dict: dict = {"embedding": {}, "vlm": {}}
config_path = tmp_path / "ov.conf"
with (
patch.dict(os.environ, {"OPENVIKING_CONFIG_FILE": str(config_path)}, clear=False),
patch("openviking_cli.setup_wizard._prompt_confirm", return_value=True),
patch("openviking_cli.setup_wizard.get_ollama_models", return_value=[]),
patch("openviking_cli.setup_wizard._prompt_choice", return_value=1), # v4_q8
patch("openviking_cli.setup_wizard.is_model_available", return_value=True),
patch("builtins.print"),
):
_wizard_query_planner(config_dict, ollama_running=True)
assert config_dict["query_planner"]["model"] == QUERY_PLANNER_PRESETS[0].litellm_model
assert config_dict["query_planner"]["api_base"] == "http://localhost:11434"
assert "prompts" not in config_dict
assert not (config_path.parent / "prompts").exists()
def test_wizard_v4_sets_planner_and_returns_none(self, tmp_path):
config_dict: dict = {"embedding": {}, "vlm": {}}
config_path = tmp_path / "ov.conf"
with (
patch.dict(os.environ, {"OPENVIKING_CONFIG_FILE": str(config_path)}, clear=False),
patch("openviking_cli.setup_wizard._prompt_confirm", return_value=True),
patch("openviking_cli.setup_wizard.get_ollama_models", return_value=[]),
patch("openviking_cli.setup_wizard._prompt_choice", return_value=2), # v4_q8
patch("openviking_cli.setup_wizard.is_model_available", return_value=True),
patch("builtins.print"),
):
_wizard_query_planner(config_dict, ollama_running=True)
assert config_dict["query_planner"]["model"] == QUERY_PLANNER_PRESETS[1].litellm_model
assert "prompts" not in config_dict
def test_wizard_declined_leaves_config_untouched(self, tmp_path):
# With an Ollama VLM present, the planner is offered; declining the
# enable prompt must leave the config untouched.
config_dict: dict = {"embedding": {}, "vlm": {}}
with (
patch("openviking_cli.setup_wizard._prompt_confirm", return_value=False),
patch("builtins.print"),
):
_wizard_query_planner(config_dict, ollama_running=True)
assert "query_planner" not in config_dict
assert "prompts" not in config_dict
def test_wizard_no_ollama_vlm_defaults_to_no_without_recommend(self, tmp_path):
# Cloud / non-Ollama-VLM setups (ollama_running is None) are still offered
# the planner, but off by default and without the recommendation tag.
config_dict: dict = {"embedding": {}, "vlm": {}}
with (
patch(
"openviking_cli.setup_wizard._prompt_confirm", return_value=False
) as mock_confirm,
patch("openviking_cli.setup_wizard._ensure_ollama") as mock_ensure,
patch("builtins.print"),
):
_wizard_query_planner(config_dict, ollama_running=None)
enable_call = mock_confirm.call_args_list[0]
assert enable_call.kwargs.get("default") is False
assert "(recommended)" not in enable_call.args[0]
mock_ensure.assert_not_called() # declined before reaching install
assert "query_planner" not in config_dict
def test_wizard_no_ollama_vlm_opt_in_runs_install(self, tmp_path):
# Opting in without an Ollama VLM runs the Ollama install flow.
config_dict: dict = {"embedding": {}, "vlm": {}}
with (
patch("openviking_cli.setup_wizard._prompt_confirm", return_value=True),
patch("openviking_cli.setup_wizard._ensure_ollama", return_value=True) as mock_ensure,
patch("openviking_cli.setup_wizard.get_ollama_models", return_value=[]),
patch("openviking_cli.setup_wizard._prompt_choice", return_value=1),
patch("openviking_cli.setup_wizard.is_model_available", return_value=True),
patch("builtins.print"),
):
_wizard_query_planner(config_dict, ollama_running=None)
mock_ensure.assert_called_once()
assert config_dict["query_planner"]["model"] == QUERY_PLANNER_PRESETS[0].litellm_model
def test_wizard_ollama_vlm_defaults_to_yes_with_recommend(self, tmp_path):
# With an Ollama VLM present (ollama_running is not None) the planner is
# recommended, so the enable prompt is tagged and defaults to Yes.
config_dict: dict = {"embedding": {}, "vlm": {}}
with (
patch("openviking_cli.setup_wizard._prompt_confirm", return_value=True) as mock_confirm,
patch("openviking_cli.setup_wizard.get_ollama_models", return_value=[]),
patch("openviking_cli.setup_wizard._prompt_choice", return_value=1),
patch("openviking_cli.setup_wizard.is_model_available", return_value=True),
patch("builtins.print"),
):
_wizard_query_planner(config_dict, ollama_running=True)
enable_call = mock_confirm.call_args_list[0]
assert enable_call.kwargs.get("default") is True
assert "(recommended)" in enable_call.args[0]
assert config_dict["query_planner"]["model"] == QUERY_PLANNER_PRESETS[0].litellm_model
# ---------------------------------------------------------------------------
# RAM-based recommendations
# ---------------------------------------------------------------------------
class TestRAMRecommendations:
def test_low_ram(self):
emb_idx, vlm_idx = _get_recommended_indices(4)
assert EMBEDDING_PRESETS[emb_idx].model == "qwen3-embedding:0.6b"
assert VLM_PRESETS[vlm_idx].ollama_model == "qwen3.5:4b"
def test_medium_ram(self):
emb_idx, vlm_idx = _get_recommended_indices(16)
assert EMBEDDING_PRESETS[emb_idx].model == "qwen3-embedding:0.6b"
assert VLM_PRESETS[vlm_idx].ollama_model == "qwen3.5:4b"
def test_high_ram(self):
emb_idx, vlm_idx = _get_recommended_indices(32)
assert EMBEDDING_PRESETS[emb_idx].model == "qwen3-embedding:8b"
def test_very_high_ram(self):
emb_idx, vlm_idx = _get_recommended_indices(128)
assert EMBEDDING_PRESETS[emb_idx].model == "qwen3-embedding:8b"
# ---------------------------------------------------------------------------
# Config writing
# ---------------------------------------------------------------------------
class TestConfigWriting:
def test_write_new_config(self, tmp_path):
config_path = tmp_path / "ov.conf"
config = _build_ollama_config(EMBEDDING_PRESETS[0], VLM_PRESETS[0], str(tmp_path / "data"))
assert _write_config(config, config_path) is True
assert config_path.exists()
assert config_path.stat().st_mode & 0o777 == 0o600
loaded = json.loads(config_path.read_text(encoding="utf-8"))
assert loaded["embedding"]["dense"]["provider"] == "ollama"
def test_backup_existing(self, tmp_path):
config_path = tmp_path / "ov.conf"
config_path.write_text('{"old": true}', encoding="utf-8")
config = _build_ollama_config(EMBEDDING_PRESETS[0], VLM_PRESETS[0], str(tmp_path / "data"))
assert _write_config(config, config_path) is True
backup = tmp_path / "ov.conf.bak"
assert backup.exists()
assert backup.stat().st_mode & 0o777 == 0o600
assert json.loads(backup.read_text())["old"] is True
def test_creates_parent_dirs(self, tmp_path):
config_path = tmp_path / "subdir" / "ov.conf"
config = _build_ollama_config(EMBEDDING_PRESETS[0], VLM_PRESETS[0], "/tmp/data")
assert _write_config(config, config_path) is True
assert config_path.exists()
def test_replace_failure_preserves_existing_config(self, tmp_path):
config_path = tmp_path / "ov.conf"
config_path.write_text('{"old": true}', encoding="utf-8")
with patch("openviking_cli.setup_wizard.os.replace", side_effect=OSError("replace")):
assert _write_config({"new": True}, config_path) is False
assert json.loads(config_path.read_text()) == {"old": True}
assert not list(tmp_path.glob(".ov.conf.*"))
def test_backup_copy_failure_leaves_no_public_backup(self, tmp_path):
config_path = tmp_path / "ov.conf"
config_path.write_text('{"secret": true}', encoding="utf-8")
def fail_after_partial_copy(source, target):
target.write(source.read(1))
raise OSError("copy")
with patch("openviking_cli.setup_wizard.shutil.copyfileobj", fail_after_partial_copy):
assert _write_config({"new": True}, config_path) is False
assert json.loads(config_path.read_text()) == {"secret": True}
assert not (tmp_path / "ov.conf.bak").exists()
assert not list(tmp_path.glob(".ov.conf*.*"))
def test_run_init_redacts_summary_output(self, tmp_path):
config_path = tmp_path / "ov.conf"
config = {
"embedding": {
"dense": {
"provider": "local",
"model": "secret-model",
"dimension": 1024,
"model_path": "/very/secret/model.gguf",
}
},
"vlm": {
"provider": "openai",
"model": "secret-vlm",
},
"storage": {
"workspace": "/very/secret/workspace",
},
}
with (
patch.dict(os.environ, {"OPENVIKING_CONFIG_FILE": str(config_path)}, clear=False),
patch("openviking_cli.setup_wizard._prompt_choice", return_value=2),
patch("openviking_cli.setup_wizard._wizard_ollama", return_value=(config, True)),
patch("openviking_cli.setup_wizard._wizard_query_planner", return_value=None),
patch(
"openviking_cli.setup_wizard._wizard_server",
return_value={"host": "127.0.0.1"},
),
patch("openviking_cli.setup_wizard._prompt_confirm", return_value=True),
patch("openviking_cli.setup_wizard._write_config", return_value=True),
patch("openviking_cli.setup_wizard._post_save_actions", return_value=None),
patch("builtins.print") as mock_print,
):
assert run_init() == 0
output = "\n".join(
" ".join(str(arg) for arg in call.args) for call in mock_print.call_args_list
)
assert "/very/secret/model.gguf" not in output
assert "/very/secret/workspace" not in output
assert str(config_path) not in output
assert "custom local model (hidden)" in output
assert "default config location" in output
def test_env_overrides_config_path_and_derives_workspace(self, tmp_path):
config_path = tmp_path / "runtime" / "ov.conf"
with patch.dict(os.environ, {"OPENVIKING_CONFIG_FILE": str(config_path)}, clear=False):
assert _config_path() == config_path
assert _workspace_path() == str(config_path.parent / "data")
def test_run_init_writes_to_env_config_path(self, tmp_path):
config_path = tmp_path / "runtime" / "ov.conf"
config = {
"embedding": {"dense": {"provider": "ollama", "model": "qwen", "dimension": 1024}},
"storage": {"workspace": str(config_path.parent / "data")},
}
with (
patch.dict(os.environ, {"OPENVIKING_CONFIG_FILE": str(config_path)}, clear=False),
patch("openviking_cli.setup_wizard._prompt_choice", return_value=2),
patch("openviking_cli.setup_wizard._wizard_ollama", return_value=(config, True)),
patch("openviking_cli.setup_wizard._wizard_query_planner", return_value=None),
patch(
"openviking_cli.setup_wizard._wizard_server",
return_value={"host": "127.0.0.1"},
),
patch("openviking_cli.setup_wizard._prompt_confirm", return_value=True),
patch("openviking_cli.setup_wizard._write_config", return_value=True) as mock_write,
patch("openviking_cli.setup_wizard._post_save_actions", return_value=None),
patch("builtins.print"),
):
assert run_init() == 0
expected = dict(config)
expected["server"] = {"host": "127.0.0.1"}
mock_write.assert_called_once_with(expected, config_path)
# ---------------------------------------------------------------------------
# llama.cpp local embedding config
# ---------------------------------------------------------------------------
class TestLlamaCppDetection:
def test_llamacpp_installed(self):
with patch.dict("sys.modules", {"llama_cpp": MagicMock()}):
assert _is_llamacpp_installed() is True
def test_llamacpp_not_installed(self):
import importlib
with patch.object(importlib, "import_module", side_effect=ImportError("no module")):
assert _is_llamacpp_installed() is False
class TestLocalGGUFPresets:
def test_presets_have_valid_dimensions(self):
for preset in LOCAL_GGUF_PRESETS:
assert preset.dimension > 0
assert preset.model_name
assert preset.label
class TestCloudProviderOrdering:
def test_volcengine_is_first_and_default(self):
assert CLOUD_PROVIDERS[0].label == "VolcEngine (火山引擎)"
assert CLOUD_PROVIDERS[0].provider == "volcengine"
def test_byteplus_is_second(self):
assert CLOUD_PROVIDERS[1].label == "BytePlus"
assert CLOUD_PROVIDERS[1].default_api_base == (
"https://ark.ap-southeast.bytepluses.com/api/v3"
)
def test_openai_is_third(self):
assert CLOUD_PROVIDERS[2].label == "OpenAI"
assert CLOUD_PROVIDERS[2].provider == "openai"
class TestVolcenginePlans:
def test_plan_endpoints_and_defaults(self):
agent, coding, payg = VOLCENGINE_PLANS
assert agent.api_base == "https://ark.cn-beijing.volces.com/api/plan/v3"
assert coding.api_base == "https://ark.cn-beijing.volces.com/api/coding/v3"
assert payg.api_base == "https://ark.cn-beijing.volces.com/api/v3"
for plan in (agent, coding):
assert plan.default_vlm_model == "doubao-seed-2.1-lite"
assert plan.default_embedding_model == "doubao-embedding-vision"
assert plan.default_embedding_dim == 1024
assert payg.default_vlm_model == "doubao-seed-2-1-lite-260915"
def test_plan_menu_defaults_to_current_endpoint(self):
from openviking_cli.setup_wizard import _select_access_plan
with patch("openviking_cli.setup_wizard._prompt_choice", return_value=2) as mock_choice:
plan = _select_access_plan(
"VolcEngine (火山引擎)", VOLCENGINE_PLANS, VOLCENGINE_PLANS[1].api_base
)
assert plan is VOLCENGINE_PLANS[1]
assert mock_choice.call_args.kwargs.get("default") == 2
def test_plan_menu_offers_keep_for_custom_endpoint(self):
from openviking_cli.setup_wizard import _select_access_plan
custom = "https://proxy.volces.com/custom/v3"
with patch("openviking_cli.setup_wizard._prompt_choice", return_value=4) as mock_choice:
plan = _select_access_plan("VolcEngine (火山引擎)", VOLCENGINE_PLANS, custom)
assert plan.api_base == custom
options = mock_choice.call_args.args[1]
assert len(options) == len(VOLCENGINE_PLANS) + 1
assert mock_choice.call_args.kwargs.get("default") == len(options)
def test_plan_menu_back_returns_sentinel(self):
from openviking_cli.setup_wizard import _select_access_plan
with patch("openviking_cli.setup_wizard._prompt_choice", return_value=0):
assert (
_select_access_plan("VolcEngine (火山引擎)", VOLCENGINE_PLANS, allow_back=True)
is _GO_BACK
)
def test_byteplus_plan_endpoints_and_defaults(self):
coding, payg = BYTEPLUS_PLANS
assert coding.label == "ModelArk Coding Plan"
assert coding.api_base == "https://ark.ap-southeast.bytepluses.com/api/coding/v3"
assert coding.default_vlm_model == "dola-seed-2.0-lite"
assert coding.default_embedding_model == "skylark-embedding-vision"
assert coding.default_embedding_dim == 1024
assert payg.api_base == "https://ark.ap-southeast.bytepluses.com/api/v3"
assert payg.default_vlm_model == "seed-2-0-lite-260428"
def test_vlm_flow_byteplus_coding_plan(self):
from openviking_cli.setup_wizard import _prompt_cloud_vlm
with (
# VLM provider -> BytePlus, plan menu -> ModelArk Coding Plan
patch("openviking_cli.setup_wizard._prompt_choice", side_effect=[2, 1]),
patch("openviking_cli.setup_wizard._prompt_api_key_with_env", return_value="bp-key"),
patch(
"openviking_cli.setup_wizard._prompt_required_input",
side_effect=lambda prompt, default=None, **kw: default,
),
patch("builtins.print"),
):
vlm_config, _ = _prompt_cloud_vlm()
assert vlm_config["provider"] == "volcengine"
assert vlm_config["model"] == "dola-seed-2.0-lite"
assert vlm_config["api_base"] == "https://ark.ap-southeast.bytepluses.com/api/coding/v3"
def test_embedding_flow_byteplus_coding_plan(self):
from openviking_cli.setup_wizard import _prompt_cloud_embedding
with (
# Provider menu -> BytePlus, plan menu -> ModelArk Coding Plan
patch("openviking_cli.setup_wizard._prompt_choice", side_effect=[2, 1]),
patch("openviking_cli.setup_wizard._prompt_api_key_with_env", return_value="bp-key"),
patch(
"openviking_cli.setup_wizard._prompt_required_input",
side_effect=lambda prompt, default=None, **kw: default,
),
patch("builtins.print"),
):
dense = _prompt_cloud_embedding()
assert dense["provider"] == "volcengine"
assert dense["model"] == "skylark-embedding-vision"
assert dense["api_base"] == "https://ark.ap-southeast.bytepluses.com/api/coding/v3"
assert dense["dimension"] == 1024
def test_provider_index_distinguishes_byteplus_plan_endpoint(self):
from openviking_cli.setup_wizard import _cloud_provider_index_for
byteplus_plan = {
"provider": "volcengine",
"api_base": "https://ark.ap-southeast.bytepluses.com/api/coding/v3",
}
volc_plan = {
"provider": "volcengine",
"api_base": "https://ark.cn-beijing.volces.com/api/plan/v3",
}
assert _cloud_provider_index_for(byteplus_plan) == 2
assert _cloud_provider_index_for(volc_plan) == 1
def test_embedding_flow_uses_selected_plan(self):
from openviking_cli.setup_wizard import _prompt_cloud_embedding
with (
# Provider menu -> VolcEngine, plan menu -> Agent Plan
patch("openviking_cli.setup_wizard._prompt_choice", side_effect=[1, 1]),
patch("openviking_cli.setup_wizard._prompt_api_key_with_env", return_value="ark-key"),
patch(
"openviking_cli.setup_wizard._prompt_required_input",
side_effect=lambda prompt, default=None, **kw: default,
),
patch("builtins.print"),
):
dense = _prompt_cloud_embedding()
assert dense == {
"provider": "volcengine",
"model": "doubao-embedding-vision",
"api_key": "ark-key",
"api_base": "https://ark.cn-beijing.volces.com/api/plan/v3",
"dimension": 1024,
}
def test_embedding_flow_plan_back_returns_to_provider_menu(self):
from openviking_cli.setup_wizard import _prompt_cloud_embedding
with (
# VolcEngine -> plan menu back -> provider menu -> OpenAI
patch("openviking_cli.setup_wizard._prompt_choice", side_effect=[1, 0, 3]),
patch("openviking_cli.setup_wizard._prompt_api_key_with_env", return_value="sk-x"),
patch(
"openviking_cli.setup_wizard._prompt_required_input",
side_effect=lambda prompt, default=None, **kw: default,
),
patch("builtins.print"),
):
dense = _prompt_cloud_embedding()
assert dense["provider"] == "openai"
assert dense["api_base"] == "https://api.openai.com/v1"
def test_vlm_flow_uses_selected_plan(self):
from openviking_cli.setup_wizard import _prompt_cloud_vlm
with (
# VLM provider -> VolcEngine, plan menu -> Coding Plan
patch("openviking_cli.setup_wizard._prompt_choice", side_effect=[1, 2]),
patch("openviking_cli.setup_wizard._prompt_api_key_with_env", return_value="ark-key"),
patch(
"openviking_cli.setup_wizard._prompt_required_input",
side_effect=lambda prompt, default=None, **kw: default,
),
patch("builtins.print"),
):
vlm_config, _ = _prompt_cloud_vlm()
assert vlm_config["provider"] == "volcengine"
assert vlm_config["model"] == "doubao-seed-2.1-lite"
assert vlm_config["api_base"] == "https://ark.cn-beijing.volces.com/api/coding/v3"
assert vlm_config["api_key"] == "ark-key"
def test_vlm_flow_plan_back_returns_to_provider_menu(self):
from openviking_cli.setup_wizard import _prompt_cloud_vlm
with (
# VolcEngine -> plan menu back -> provider menu -> GLM
patch("openviking_cli.setup_wizard._prompt_choice", side_effect=[1, 0, 6]),
patch("openviking_cli.setup_wizard._prompt_api_key_with_env", return_value="glm-key"),
patch(
"openviking_cli.setup_wizard._prompt_required_input",
side_effect=lambda prompt, default=None, **kw: default,
),
patch("builtins.print"),
):
vlm_config, _ = _prompt_cloud_vlm()
assert vlm_config["provider"] == "glm"
def test_two_step_seeds_vlm_plan_from_embedding(self):
dense = {
"provider": "volcengine",
"model": "doubao-embedding-vision",
"api_key": "ark-key",
"api_base": "https://ark.cn-beijing.volces.com/api/coding/v3",
"dimension": 1024,
}
with (
patch(
"openviking_cli.setup_wizard._prompt_embedding_flow",
return_value=(dense, None),
),
patch(
"openviking_cli.setup_wizard._prompt_cloud_vlm",
return_value=(_SKIP_VLM, None),
) as mock_vlm,
patch("builtins.print"),
):
config, _ = _wizard_two_step()
assert "vlm" not in config
assert (
mock_vlm.call_args.kwargs.get("plan_seed")
== "https://ark.cn-beijing.volces.com/api/coding/v3"
)
class TestCustomEmbedding:
def test_interactive_openai_compatible(self):
from openviking_cli.setup_wizard import _prompt_cloud_embedding
answers = {"API Base URL": "https://my.proxy/v1", "Model": "text-embedding-3-large"}
with (
# Provider menu -> Custom / manual, custom menu -> interactive
patch("openviking_cli.setup_wizard._prompt_choice", side_effect=[4, 1]),
patch(
"openviking_cli.setup_wizard._prompt_required_input",
side_effect=lambda prompt, default=None, **kw: answers.get(prompt, default),
),
patch(
"openviking_cli.setup_wizard._prompt_api_key_with_env",
return_value="sk-proxy",
),
patch("openviking_cli.setup_wizard._prompt_required_int", return_value=3072),
patch("builtins.print"),
):
dense = _prompt_cloud_embedding()
assert dense == {
"provider": "openai",
"model": "text-embedding-3-large",
"api_key": "sk-proxy",
"api_base": "https://my.proxy/v1",
"dimension": 3072,
}
def test_manual_edit_returns_custom_sentinel(self):
from openviking_cli.setup_wizard import _prompt_cloud_embedding
with (
patch("openviking_cli.setup_wizard._prompt_choice", side_effect=[4, 2]),
patch("openviking_cli.setup_wizard._wizard_custom") as mock_custom,
patch("builtins.print"),
):
assert _prompt_cloud_embedding() is _CUSTOM_SETUP
mock_custom.assert_called_once()
def test_custom_back_returns_to_provider_menu(self):
from openviking_cli.setup_wizard import _prompt_cloud_embedding
with (
# Custom / manual -> back -> provider menu -> back
patch("openviking_cli.setup_wizard._prompt_choice", side_effect=[4, 0, 0]),
patch("builtins.print"),
):
assert _prompt_cloud_embedding(allow_back=True) is _GO_BACK
def test_back_token_at_dimension_returns_to_provider_menu(self):
from openviking_cli.setup_wizard import _prompt_cloud_embedding
with (
# Custom / manual -> interactive, then !back at the dimension prompt,
# provider menu -> back
patch("openviking_cli.setup_wizard._prompt_choice", side_effect=[4, 1, 0]),
patch(
"openviking_cli.setup_wizard._prompt_required_input",
side_effect=lambda prompt, default=None, **kw: default or "value",
),
patch("openviking_cli.setup_wizard._prompt_api_key_with_env", return_value="sk-x"),
patch("openviking_cli.setup_wizard._prompt_required_int", return_value=_GO_BACK),
patch("builtins.print"),
):
assert _prompt_cloud_embedding(allow_back=True) is _GO_BACK
class TestCustomVlm:
def test_interactive_custom_vlm(self):
from openviking_cli.setup_wizard import _prompt_cloud_vlm
answers = {"API Base URL": "https://my.proxy/v1", "Model": "my-vlm"}
with (
patch("openviking_cli.setup_wizard._prompt_choice", return_value=7),
patch(
"openviking_cli.setup_wizard._prompt_required_input",
side_effect=lambda prompt, default=None, **kw: answers.get(prompt, default),
),
patch(
"openviking_cli.setup_wizard._prompt_api_key_with_env",
return_value="sk-proxy",
),
patch("builtins.print"),
):
vlm_config, _ = _prompt_cloud_vlm()
assert vlm_config["provider"] == "openai"
assert vlm_config["model"] == "my-vlm"
assert vlm_config["api_base"] == "https://my.proxy/v1"
assert vlm_config["api_key"] == "sk-proxy"
def test_back_token_in_custom_vlm_returns_to_provider_menu(self):
from openviking_cli.setup_wizard import _prompt_cloud_vlm
with (
# Custom -> !back at the URL prompt -> provider menu -> GLM
patch("openviking_cli.setup_wizard._prompt_choice", side_effect=[7, 6]),
patch(
"openviking_cli.setup_wizard._prompt_required_input",
side_effect=lambda prompt, default=None, **kw: (
_GO_BACK if prompt == "API Base URL" else default
),
),
patch("openviking_cli.setup_wizard._prompt_api_key_with_env", return_value="glm-key"),
patch("builtins.print"),
):
vlm_config, _ = _prompt_cloud_vlm()
assert vlm_config["provider"] == "glm"
def test_required_input_back_token(self):
with patch("builtins.input", return_value="!back"):
assert _prompt_required_input("Model", allow_back=True) is _GO_BACK
with patch("builtins.input", return_value="!back"):
assert _prompt_required_input("Model") == "!back" # literal without allow_back
def test_required_int_back_token(self):
with patch("builtins.input", return_value="!back"):
assert _prompt_required_int("Dimension", allow_back=True) is _GO_BACK
class TestBackupRotation:
def test_first_backup_uses_bak_suffix(self, tmp_path):
config_path = tmp_path / "ov.conf"
assert _next_backup_path(config_path) == tmp_path / "ov.conf.bak"
def test_rotates_when_bak_exists(self, tmp_path):
config_path = tmp_path / "ov.conf"
(tmp_path / "ov.conf.bak").write_text("old", encoding="utf-8")
assert _next_backup_path(config_path) == tmp_path / "ov.conf.bak.1"
def test_skips_existing_numbered_backups(self, tmp_path):
config_path = tmp_path / "ov.conf"
(tmp_path / "ov.conf.bak").write_text("0", encoding="utf-8")
(tmp_path / "ov.conf.bak.1").write_text("1", encoding="utf-8")
(tmp_path / "ov.conf.bak.2").write_text("2", encoding="utf-8")
assert _next_backup_path(config_path) == tmp_path / "ov.conf.bak.3"
def test_write_config_rotates_existing_backup(self, tmp_path):
config_path = tmp_path / "ov.conf"
config_path.write_text('{"v":1}', encoding="utf-8")
(tmp_path / "ov.conf.bak").write_text('{"old":true}', encoding="utf-8")
config = _build_ollama_config(EMBEDDING_PRESETS[0], VLM_PRESETS[0], str(tmp_path / "data"))
assert _write_config(config, config_path) is True
# Original backup preserved, new one rotated to .bak.1
assert (tmp_path / "ov.conf.bak").read_text() == '{"old":true}'
assert (tmp_path / "ov.conf.bak.1").read_text() == '{"v":1}'
class TestApiKeyMasking:
def test_mask_short_secret_is_fully_starred(self):
assert _mask_secret("abc") == "***"
assert _mask_secret("a" * 11) == "*" * 11
def test_mask_long_secret_keeps_prefix_and_suffix(self):
value = "sk-proj-1234567890ABCDEF"
masked = _mask_secret(value)
assert masked.startswith("sk-proj")
assert masked.endswith("CDEF")
assert "1234567890AB" not in masked
assert len(masked) == len(value)
def test_mask_empty(self):
assert _mask_secret("") == ""
def test_prompt_api_key_uses_masked_input(self):
with patch(
"openviking_cli.setup_wizard._masked_input",
return_value="sk-proj-1234567890ABCDEF",
) as masked:
value = _prompt_api_key("API Key")
assert value == "sk-proj-1234567890ABCDEF"
masked.assert_called_once()
def test_prompt_api_key_does_not_print_extra_preview_line(self, capsys):
with patch(
"openviking_cli.setup_wizard._masked_input",
return_value="sk-proj-1234567890ABCDEF",
):
_prompt_api_key("API Key")
# No extra "Using ..." confirmation line — the inline rewrite in
# _masked_input is the only place the masked preview should appear.
assert "Using API Key" not in capsys.readouterr().out
def test_masked_input_falls_back_to_input_for_non_tty(self):
with patch("builtins.input", return_value="paste-me") as plain:
assert _masked_input("API Key: ") == "paste-me"
plain.assert_called_once_with("API Key: ")
def test_prompt_required_input_with_mask_routes_through_masked_input(self):
with patch(
"openviking_cli.setup_wizard._masked_input",
return_value="hunter2",
) as masked:
value = _prompt_required_input("API Key", mask=True)
assert value == "hunter2"
masked.assert_called_once()
class TestServerWizard:
def test_local_mode_returns_loopback_host_and_port(self):
with (
patch("openviking_cli.setup_wizard._prompt_choice", return_value=1),
patch("openviking_cli.setup_wizard._prompt_required_int", return_value=1933),
patch("builtins.print"),
):
assert _wizard_server() == {"host": "127.0.0.1", "port": 1933}
def test_local_mode_custom_port(self):
with (
patch("openviking_cli.setup_wizard._prompt_choice", return_value=1),
patch("openviking_cli.setup_wizard._prompt_required_int", return_value=8080),
patch("builtins.print"),
):
assert _wizard_server() == {"host": "127.0.0.1", "port": 8080}
def test_remote_mode_manual_root_api_key(self):
with (
# bind=Remote, key source=Enter my own
patch("openviking_cli.setup_wizard._prompt_choice", side_effect=[2, 2]),
patch("openviking_cli.setup_wizard._prompt_required_int", return_value=1933),
patch(
"openviking_cli.setup_wizard._prompt_required_input",
return_value="my-secret-key",
),
patch("builtins.print"),
):
assert _wizard_server() == {
"host": "0.0.0.0",
"port": 1933,
"root_api_key": "my-secret-key",
}
def test_remote_mode_generates_and_displays_root_api_key(self):
with (
# bind=Remote, key source=Generate one for me
patch("openviking_cli.setup_wizard._prompt_choice", side_effect=[2, 1]),
patch("openviking_cli.setup_wizard._prompt_required_int", return_value=1933),
patch("builtins.print") as mock_print,
):
result = _wizard_server()
assert result is not None
key = result["root_api_key"]
# 64-char hex, matching the repo's root-key convention (token_hex(32)).
assert len(key) == 64
int(key, 16) # raises if not hex
assert result == {"host": "0.0.0.0", "port": 1933, "root_api_key": key}
# The full key must be displayed to the user exactly once.
output = "\n".join(
" ".join(str(arg) for arg in call.args) for call in mock_print.call_args_list
)
assert key in output
def test_remote_mode_empty_manual_key_cancels(self):
with (
patch("openviking_cli.setup_wizard._prompt_choice", side_effect=[2, 2]),
patch("openviking_cli.setup_wizard._prompt_required_int", return_value=1933),
patch("openviking_cli.setup_wizard._prompt_required_input", return_value=""),
patch("builtins.print"),
):
assert _wizard_server() is None
class TestServerWizardCurrentDefaults:
CURRENT = {"host": "0.0.0.0", "port": 2044, "root_api_key": "k" * 64}
def test_current_port_seeds_default(self):
with (
patch("openviking_cli.setup_wizard._prompt_choice", side_effect=[1]),
patch(
"openviking_cli.setup_wizard._prompt_required_int", return_value=2044
) as mock_int,
patch("builtins.print"),
):
result = _wizard_server(current={"host": "127.0.0.1", "port": 2044})
assert result == {"host": "127.0.0.1", "port": 2044}
mock_int.assert_called_once_with("Port", default=2044)
def test_remote_current_defaults_to_remote_and_keeps_key(self):
with (
# bind menu (defaults to Remote), key menu option 1 = Keep existing
patch("openviking_cli.setup_wizard._prompt_choice", side_effect=[2, 1]) as mock_choice,
patch("openviking_cli.setup_wizard._prompt_required_int", return_value=2044),
patch("builtins.print"),
):
result = _wizard_server(current=self.CURRENT)
assert result == self.CURRENT
# Bind menu default seeded to Remote (2) because current host is 0.0.0.0.
bind_call = mock_choice.call_args_list[0]
assert bind_call.kwargs.get("default") == 2
# Key menu offers "Keep existing key" as the first, default option.
key_call = mock_choice.call_args_list[1]
assert key_call.args[1][0][0] == "Keep existing key"
def test_remote_current_can_rotate_key(self):
with (
# bind=Remote, key menu option 2 = Generate one for me (after Keep)
patch("openviking_cli.setup_wizard._prompt_choice", side_effect=[2, 2]),
patch("openviking_cli.setup_wizard._prompt_required_int", return_value=2044),
patch("builtins.print"),
):
result = _wizard_server(current=self.CURRENT)
assert result is not None
assert result["root_api_key"] != self.CURRENT["root_api_key"]
assert len(result["root_api_key"]) == 64
class TestGatewayWizard:
def test_local_enable_needs_no_management_key(self):
from openviking_cli.setup_wizard import _wizard_gateway
with patch("openviking_cli.setup_wizard._prompt_confirm", return_value=True) as prompt:
assert _wizard_gateway({"host": "127.0.0.1"}) == {"enabled": True}
assert prompt.call_count == 1
def test_remote_restricted_generates_key_and_preserves_it_on_update(self):
from openviking_cli.setup_wizard import _wizard_gateway
server = {"root_api_key": "root-secret"}
with (
patch("openviking_cli.setup_wizard._prompt_confirm", side_effect=[True, False]),
patch("builtins.print"),
):
gateway = _wizard_gateway(server)
assert gateway["management_key"].startswith("ovgm_")
assert len(gateway["management_key"]) >= 32
with (
patch("openviking_cli.setup_wizard._prompt_confirm", side_effect=[True, False]),
patch("builtins.print") as output,
):
assert _wizard_gateway(server, gateway) == gateway
assert gateway["management_key"] not in str(output.call_args_list)
def test_open_configuration_removes_management_key(self):
from openviking_cli.setup_wizard import _wizard_gateway
with patch("openviking_cli.setup_wizard._prompt_confirm", side_effect=[True, True]):
assert _wizard_gateway(
{"auth_mode": "api_key"},
{"enabled": True, "management_key": "old-secret", "storage_path": "/gateway"},
) == {"enabled": True, "storage_path": "/gateway"}
def test_gateway_update_preserves_other_sections_and_redacts_summary(self, tmp_path):
config_path = tmp_path / "ov.conf"
original = _existing_config()
original["gateway"] = {"enabled": False, "management_key": "ovgm_saved-secret"}
config_path.write_text(json.dumps(original))
with (
patch("openviking_cli.setup_wizard._prompt_confirm", return_value=True),
patch("openviking_cli.setup_wizard._post_save_actions"),
patch("builtins.print") as output,
):
assert _update_existing_config(config_path, "gateway") == 0
updated = json.loads(config_path.read_text())
assert updated == {**original, "gateway": {**original["gateway"], "enabled": True}}
assert "ovgm_saved-secret" not in str(output.call_args_list)
def test_update_drops_legacy_fields_and_stale_public_url(self):
from openviking_cli.setup_wizard import _wizard_gateway
legacy = {
"enabled": True,
"host": "0.0.0.0",
"port": 1935,
"workers": 2,
"url": "http://127.0.0.1:1935",
"openviking_url": "http://127.0.0.1:1933",
"admin_token_env": "OPENVIKING_GATEWAY_ADMIN_TOKEN",
"encryption_key_env": "OPENVIKING_GATEWAY_ENCRYPTION_KEY",
"public_url": "http://127.0.0.1:1935",
"storage_path": "/gateway",
}
with (
patch(
"openviking_cli.setup_wizard._prompt_confirm", side_effect=[True, True]
) as prompt,
patch("builtins.print"),
):
gateway = _wizard_gateway({"host": "127.0.0.1", "port": 1933}, legacy)
assert gateway == {"enabled": True, "storage_path": "/gateway"}
assert prompt.call_args_list[1].kwargs["default"] is True
def test_public_url_on_server_port_is_kept_without_asking(self):
from openviking_cli.setup_wizard import _wizard_gateway
current = {"enabled": True, "public_url": "https://ov.example.com"}
with patch("openviking_cli.setup_wizard._prompt_confirm", return_value=True) as prompt:
assert _wizard_gateway({"host": "127.0.0.1"}, current) == current
assert prompt.call_count == 1
def test_server_switch_to_local_drops_management_key(self, tmp_path):
config_path = tmp_path / "ov.conf"
original = _existing_config()
original["server"] = {"host": "0.0.0.0", "port": 1933, "root_api_key": "rk"}
original["gateway"] = {"enabled": True, "management_key": "ovgm_saved-secret"}
config_path.write_text(json.dumps(original))
with (
patch(
"openviking_cli.setup_wizard._wizard_server",
return_value={"host": "127.0.0.1", "port": 1933},
),
patch("openviking_cli.setup_wizard._prompt_confirm", return_value=True),
patch("openviking_cli.setup_wizard._post_save_actions"),
patch("builtins.print"),
):
assert _update_existing_config(config_path, "server") == 0
assert json.loads(config_path.read_text())["gateway"] == {"enabled": True}
def test_server_switch_to_remote_asks_who_may_configure(self, tmp_path):
config_path = tmp_path / "ov.conf"
original = _existing_config()
original["gateway"] = {"enabled": True}
config_path.write_text(json.dumps(original))
with (
patch(
"openviking_cli.setup_wizard._wizard_server",
return_value={"host": "0.0.0.0", "port": 1933, "root_api_key": "rk"},
),
patch("openviking_cli.setup_wizard._prompt_confirm", side_effect=[False, True]),
patch("openviking_cli.setup_wizard._post_save_actions"),
patch("builtins.print"),
):
assert _update_existing_config(config_path, "server") == 0
gateway = json.loads(config_path.read_text())["gateway"]
assert gateway["enabled"] is True
assert gateway["management_key"].startswith("ovgm_")
def test_new_config_writes_gateway_and_summary_hides_management_key(self, tmp_path):
config_path = tmp_path / "ov.conf"
config = {
"embedding": {"dense": {"provider": "ollama", "model": "qwen", "dimension": 1024}}
}
with (
patch.dict(os.environ, {"OPENVIKING_CONFIG_FILE": str(config_path)}, clear=False),
patch("openviking_cli.setup_wizard._prompt_choice", return_value=2),
patch("openviking_cli.setup_wizard._wizard_ollama", return_value=(config, True)),
patch("openviking_cli.setup_wizard._wizard_query_planner", return_value=None),
patch(
"openviking_cli.setup_wizard._wizard_server",
return_value={"host": "0.0.0.0", "port": 1933, "root_api_key": "root-secret"},
),
patch(
"openviking_cli.setup_wizard._prompt_confirm",
side_effect=lambda prompt, default=True: "Allow users" not in prompt,
),
patch("openviking_cli.setup_wizard._write_config", return_value=True) as mock_write,
patch("openviking_cli.setup_wizard._post_save_actions", return_value=None),
patch("builtins.print") as mock_print,
):
assert run_init() == 0
written = mock_write.call_args.args[0]
key = written["gateway"]["management_key"]
assert written["gateway"] == {"enabled": True, "management_key": key}
output = "\n".join(
" ".join(str(arg) for arg in call.args) for call in mock_print.call_args_list
)
# Shown once when generated; never in the summary.
assert output.count(key) == 1
assert "root-secret" not in output
assert "Gateway: enabled on server port · management key required" in output
class TestCurrentConfigSeeding:
def test_cloud_embedding_keeps_existing_key_and_model(self):
from openviking_cli.setup_wizard import _prompt_cloud_embedding
current = {
"provider": "volcengine",
"model": "doubao-embedding-vision-240000",
"api_key": "old-key-1234567890",
"api_base": CLOUD_PROVIDERS[0].default_api_base,
"dimension": 2048,
}
with (
# Provider menu -> VolcEngine, plan menu -> pay-as-you-go (matches current api_base)
patch("openviking_cli.setup_wizard._prompt_choice", side_effect=[1, 3]) as mock_choice,
# Keep the existing API key? -> yes
patch("openviking_cli.setup_wizard._prompt_confirm", return_value=True),
# Model prompt returns its default (the current model)
patch(
"openviking_cli.setup_wizard._prompt_required_input",
side_effect=lambda prompt, default=None, **kw: default,
),
patch("openviking_cli.setup_wizard._prompt_api_key_with_env") as mock_env_key,
patch("builtins.print"),
):
dense = _prompt_cloud_embedding(current=current)
assert dense == current
mock_env_key.assert_not_called() # key kept, never re-prompted
# Provider menu default seeded to the current provider, plan menu to
# the plan matching the current endpoint.
assert mock_choice.call_args_list[0].kwargs.get("default") == 1
assert mock_choice.call_args_list[1].kwargs.get("default") == 3
def test_vlm_option_index_mapping(self):
from openviking_cli.setup_wizard import _vlm_option_index_for
assert _vlm_option_index_for({"provider": "volcengine", "api_base": "https://ark.cn"}) == 1
assert (
_vlm_option_index_for(
{"provider": "volcengine", "api_base": "https://ark.ap-southeast.bytepluses.com"}
)
== 2
)
assert (
_vlm_option_index_for({"provider": "openai", "api_base": "https://api.openai.com/v1"})
== 3
)
assert _vlm_option_index_for({"provider": "openai-codex"}) == 4
assert _vlm_option_index_for({"provider": "kimi"}) == 5
assert _vlm_option_index_for({"provider": "glm"}) == 6
assert _vlm_option_index_for({"provider": "openai", "api_base": "https://my.proxy"}) == 7
assert _vlm_option_index_for({"provider": "litellm", "model": "ollama/qwen3.6:27b"}) == 8
def test_run_init_menu_shows_current_values(self, tmp_path):
config_path = tmp_path / "ov.conf"
config_path.write_text(json.dumps(_existing_config()), encoding="utf-8")
with (
patch.dict(os.environ, {"OPENVIKING_CONFIG_FILE": str(config_path)}, clear=False),
patch("openviking_cli.setup_wizard._prompt_choice", return_value=6) as mock_choice,
patch("builtins.print") as mock_print,
):
assert run_init() == 0
# Action menu descriptions carry the current values.
options = mock_choice.call_args.args[1]
labels = dict(options)
assert "openai · old-vlm" in labels["Update VLM"]
assert "ollama · qwen" in labels["Update embedding"]
assert "127.0.0.1" in labels["Update server & auth"]
# And the current-configuration block is printed above the menu.
output = "\n".join(
" ".join(str(arg) for arg in call.args) for call in mock_print.call_args_list
)
assert "Current configuration" in output
def test_update_section_shows_change_diff(self, tmp_path):
config_path = tmp_path / "ov.conf"
config_path.write_text(json.dumps(_existing_config()), encoding="utf-8")
new_vlm = {"provider": "kimi", "model": "kimi-code", "api_base": "https://new"}
with (
patch("openviking_cli.setup_wizard._prompt_cloud_vlm", return_value=(new_vlm, None)),
patch("openviking_cli.setup_wizard._prompt_confirm", return_value=True),
patch("openviking_cli.setup_wizard._post_save_actions", return_value=None),
patch("builtins.print") as mock_print,
):
assert _update_existing_config(config_path, "vlm") == 0
output = "\n".join(
" ".join(str(arg) for arg in call.args) for call in mock_print.call_args_list
)
assert "Change:" in output
assert "openai · old-vlm" in output
assert "kimi · kimi-code" in output
# ---------------------------------------------------------------------------
# VLM presets (qwen3.6 replaces qwen3.5 27B/35B)
# ---------------------------------------------------------------------------
class TestVLMPresets:
def test_qwen36_replaces_qwen35_large_tiers(self):
models = [p.ollama_model for p in VLM_PRESETS]
assert "qwen3.6:27b" in models
assert "qwen3.6:35b" in models
assert "qwen3.5:27b" not in models
assert "qwen3.5:35b" not in models
def test_qwen36_litellm_models(self):
by_ollama = {p.ollama_model: p for p in VLM_PRESETS}
assert by_ollama["qwen3.6:27b"].litellm_model == "ollama/qwen3.6:27b"
assert by_ollama["qwen3.6:35b"].litellm_model == "ollama/qwen3.6:35b"
def test_very_high_ram_recommends_qwen36_27b(self):
_, vlm_idx = _get_recommended_indices(128)
assert VLM_PRESETS[vlm_idx].ollama_model == "qwen3.6:27b"
# ---------------------------------------------------------------------------
# Size-hint parsing
# ---------------------------------------------------------------------------
class TestSizeParsing:
def test_parses_gb(self):
assert _parse_size_gb("~4.7 GB") == 4.7
assert _parse_size_gb("~17 GB, 256K ctx") == 17.0
def test_parses_mb(self):
assert abs(_parse_size_gb("~639 MB") - 639 / 1024) < 1e-9
def test_unparseable_returns_zero(self):
assert _parse_size_gb("~0.8B, recommended") == 0.0
assert _parse_size_gb("") == 0.0
# ---------------------------------------------------------------------------
# Recommended all-Ollama fast path
# ---------------------------------------------------------------------------
class TestRecommendedOllamaSetup:
def test_fast_path_builds_full_config_with_planner(self):
with (
patch("openviking_cli.setup_wizard._ensure_ollama", return_value=True),
patch("openviking_cli.setup_wizard.get_ollama_models", return_value=[]),
patch("openviking_cli.setup_wizard._get_system_ram_gb", return_value=16),
patch("openviking_cli.setup_wizard._prompt_confirm", return_value=True),
patch("openviking_cli.setup_wizard._check_disk_before_pull", return_value=True),
patch("openviking_cli.setup_wizard.ollama_pull_model", return_value=True),
patch("builtins.print"),
):
config, ollama_running = _wizard_ollama()
assert ollama_running is True
assert config is not None
# 16 GB RAM tier: qwen3-embedding:0.6b + qwen3.5:4b
assert config["embedding"]["dense"]["model"] == "qwen3-embedding:0.6b"
assert config["vlm"]["model"] == "ollama/qwen3.5:4b"
assert config["query_planner"]["model"] == QUERY_PLANNER_PRESETS[0].litellm_model
def test_decline_falls_back_to_per_model_selection(self):
with (
patch("openviking_cli.setup_wizard._ensure_ollama", return_value=True),
patch("openviking_cli.setup_wizard.get_ollama_models", return_value=[]),
patch("openviking_cli.setup_wizard._get_system_ram_gb", return_value=16),
patch("openviking_cli.setup_wizard._prompt_confirm", return_value=False),
patch("openviking_cli.setup_wizard._prompt_choice", return_value=1),
patch("openviking_cli.setup_wizard.is_model_available", return_value=True),
patch("builtins.print"),
):
config, _ = _wizard_ollama()
assert config is not None
assert config["embedding"]["dense"]["model"] == EMBEDDING_PRESETS[0].model
assert config["vlm"]["model"] == VLM_PRESETS[0].litellm_model
assert "query_planner" not in config
# ---------------------------------------------------------------------------
# Query planner: skip when already configured
# ---------------------------------------------------------------------------
class TestQueryPlannerAlreadyConfigured:
def test_early_return_leaves_config_untouched(self):
planner = _build_query_planner_config(QUERY_PLANNER_PRESETS[0])
config_dict = {"embedding": {}, "vlm": {}, "query_planner": dict(planner)}
with patch("openviking_cli.setup_wizard._prompt_confirm") as mock_confirm:
_wizard_query_planner(config_dict, ollama_running=True)
mock_confirm.assert_not_called()
assert config_dict["query_planner"] == planner
# ---------------------------------------------------------------------------
# Cloud "Other (manual)" routes to custom instead of cancelling
# ---------------------------------------------------------------------------
class TestCloudOtherRoutesToCustom:
def test_run_init_exits_cleanly_on_custom_sentinel(self, tmp_path):
config_path = tmp_path / "ov.conf"
with (
patch.dict(os.environ, {"OPENVIKING_CONFIG_FILE": str(config_path)}, clear=False),
patch("openviking_cli.setup_wizard._prompt_choice", return_value=1),
patch(
"openviking_cli.setup_wizard._wizard_two_step",
return_value=(_CUSTOM_SETUP, None),
),
patch("openviking_cli.setup_wizard._write_config") as mock_write,
patch("builtins.print"),
):
assert run_init() == 0
mock_write.assert_not_called()
# ---------------------------------------------------------------------------
# API key from environment variables
# ---------------------------------------------------------------------------
class TestEnvApiKey:
def test_uses_env_var_when_confirmed_on_tty(self):
with (
patch.dict(os.environ, {"ARK_API_KEY": "env-key-1234567890"}, clear=False),
patch("openviking_cli.setup_wizard._stdin_stdout_tty", return_value=True),
patch("openviking_cli.setup_wizard._prompt_confirm", return_value=True),
patch("openviking_cli.setup_wizard._prompt_api_key") as mock_prompt,
):
value = _prompt_api_key_with_env(["ARK_API_KEY"])
assert value == "env-key-1234567890"
mock_prompt.assert_not_called()
def test_falls_back_to_prompt_when_declined(self):
with (
patch.dict(os.environ, {"ARK_API_KEY": "env-key-1234567890"}, clear=False),
patch("openviking_cli.setup_wizard._stdin_stdout_tty", return_value=True),
patch("openviking_cli.setup_wizard._prompt_confirm", return_value=False),
patch("openviking_cli.setup_wizard._prompt_api_key", return_value="typed-key"),
):
assert _prompt_api_key_with_env(["ARK_API_KEY"]) == "typed-key"
def test_skips_env_shortcut_when_not_tty(self):
with (
patch.dict(os.environ, {"ARK_API_KEY": "env-key-1234567890"}, clear=False),
patch("openviking_cli.setup_wizard._stdin_stdout_tty", return_value=False),
patch("openviking_cli.setup_wizard._prompt_confirm") as mock_confirm,
patch("openviking_cli.setup_wizard._prompt_api_key", return_value="typed-key"),
):
assert _prompt_api_key_with_env(["ARK_API_KEY"]) == "typed-key"
mock_confirm.assert_not_called()
# ---------------------------------------------------------------------------
# Partial reconfiguration of an existing config
# ---------------------------------------------------------------------------
def _existing_config() -> dict:
return {
"storage": {"workspace": "/tmp/ov"},
"embedding": {"dense": {"provider": "ollama", "model": "qwen", "dimension": 1024}},
"vlm": {"provider": "openai", "model": "old-vlm", "api_base": "https://old"},
"server": {"host": "127.0.0.1"},
}
class TestPartialUpdate:
def test_update_vlm_only(self, tmp_path):
config_path = tmp_path / "ov.conf"
config_path.write_text(json.dumps(_existing_config()), encoding="utf-8")
new_vlm = {"provider": "kimi", "model": "kimi-code", "api_base": "https://new"}
with (
patch("openviking_cli.setup_wizard._prompt_cloud_vlm", return_value=(new_vlm, None)),
patch("openviking_cli.setup_wizard._prompt_confirm", return_value=True),
patch("openviking_cli.setup_wizard._post_save_actions", return_value=None),
patch("builtins.print"),
):
assert _update_existing_config(config_path, "vlm") == 0
data = json.loads(config_path.read_text(encoding="utf-8"))
assert data["vlm"] == new_vlm
assert data["embedding"] == _existing_config()["embedding"] # untouched
assert (tmp_path / "ov.conf.bak").exists() # old config backed up
def test_update_server_only(self, tmp_path):
config_path = tmp_path / "ov.conf"
original = _existing_config()
original["server"].update(
{"auth_mode": "trusted", "workers": 4, "temp_upload": {"default_mode": "shared"}}
)
config_path.write_text(json.dumps(original), encoding="utf-8")
with (
patch(
"openviking_cli.setup_wizard._wizard_server",
return_value={"host": "0.0.0.0", "root_api_key": "rk"},
),
patch("openviking_cli.setup_wizard._prompt_confirm", return_value=True),
patch("openviking_cli.setup_wizard._post_save_actions", return_value=None),
patch("builtins.print"),
):
assert _update_existing_config(config_path, "server") == 0
data = json.loads(config_path.read_text(encoding="utf-8"))
assert data["server"] == {
"host": "0.0.0.0",
"root_api_key": "rk",
"auth_mode": "trusted",
"workers": 4,
"temp_upload": {"default_mode": "shared"},
}
assert data["vlm"] == _existing_config()["vlm"]
def test_update_server_local_removes_root_key_only(self, tmp_path):
config_path = tmp_path / "ov.conf"
original = _existing_config()
original["server"].update({"auth_mode": "api_key", "root_api_key": "rk", "workers": 4})
config_path.write_text(json.dumps(original), encoding="utf-8")
with (
patch(
"openviking_cli.setup_wizard._wizard_server",
return_value={"host": "127.0.0.1", "port": 1933},
),
patch("openviking_cli.setup_wizard._prompt_confirm", return_value=True),
patch("openviking_cli.setup_wizard._post_save_actions", return_value=None),
patch("builtins.print"),
):
assert _update_existing_config(config_path, "server") == 0
assert json.loads(config_path.read_text())["server"] == {
"host": "127.0.0.1",
"port": 1933,
"workers": 4,
}
def test_embedding_dimension_change_requires_confirmation(self, tmp_path):
config_path = tmp_path / "ov.conf"
original = _existing_config()
config_path.write_text(json.dumps(original), encoding="utf-8")
new_dense = {"provider": "local", "model": "bge-small-zh-v1.5-f16", "dimension": 512}
with (
patch(
"openviking_cli.setup_wizard._prompt_embedding_flow",
return_value=(new_dense, None),
),
# Decline the dimension-change warning → nothing written.
patch("openviking_cli.setup_wizard._prompt_confirm", return_value=False),
patch("builtins.print"),
):
assert _update_existing_config(config_path, "embedding") == 0
assert json.loads(config_path.read_text(encoding="utf-8")) == original
def test_unreadable_config_returns_error(self, tmp_path):
config_path = tmp_path / "ov.conf"
config_path.write_text("{not json", encoding="utf-8")
with patch("builtins.print"):
assert _update_existing_config(config_path, "vlm") == 1
class TestRunInitExistingConfigMenu:
@pytest.mark.parametrize("choice,section", [(2, "vlm"), (5, "gateway")])
def test_dispatches_partial_update(self, tmp_path, choice, section):
config_path = tmp_path / "ov.conf"
config_path.write_text(json.dumps(_existing_config()), encoding="utf-8")
with (
patch.dict(os.environ, {"OPENVIKING_CONFIG_FILE": str(config_path)}, clear=False),
patch("openviking_cli.setup_wizard._prompt_choice", return_value=choice),
patch(
"openviking_cli.setup_wizard._update_existing_config", return_value=0
) as mock_update,
patch("builtins.print"),
):
assert run_init() == 0
mock_update.assert_called_once_with(config_path, section)
def test_cancel_leaves_config_untouched(self, tmp_path):
config_path = tmp_path / "ov.conf"
original = json.dumps(_existing_config())
config_path.write_text(original, encoding="utf-8")
with (
patch.dict(os.environ, {"OPENVIKING_CONFIG_FILE": str(config_path)}, clear=False),
patch("openviking_cli.setup_wizard._prompt_choice", return_value=6),
patch("builtins.print"),
):
assert run_init() == 0
assert config_path.read_text(encoding="utf-8") == original
# ---------------------------------------------------------------------------
# Two-step setup: embedding and VLM chosen independently
# ---------------------------------------------------------------------------
class TestTwoStepWizard:
def test_mixed_local_embedding_codex_vlm(self):
dense = {"provider": "ollama", "model": "qwen3-embedding:0.6b", "dimension": 1024}
with (
patch(
"openviking_cli.setup_wizard._prompt_embedding_flow",
return_value=(dense, True),
),
patch("openviking_cli.setup_wizard._prompt_choice", return_value=4),
patch("openviking_cli.setup_wizard._ensure_codex_auth", return_value=True),
patch("builtins.input", return_value=""),
patch("builtins.print"),
):
config, ollama_running = _wizard_two_step()
assert config is not None
assert config["embedding"]["dense"] == dense
assert config["vlm"] == {
"provider": "openai-codex",
"model": "gpt-5.6-terra",
"api_base": "https://chatgpt.com/backend-api/codex",
"temperature": 0.0,
"max_retries": 2,
}
assert config["storage"]["workspace"] == _workspace_path()
# Ollama state from the embedding step survives a non-Ollama VLM step.
assert ollama_running is True
def test_skip_vlm_produces_embedding_only_config(self):
dense = {"provider": "local", "model": "bge-small-zh-v1.5-f16", "dimension": 512}
with (
patch(
"openviking_cli.setup_wizard._prompt_embedding_flow",
return_value=(dense, None),
),
patch(
"openviking_cli.setup_wizard._prompt_cloud_vlm",
return_value=(_SKIP_VLM, None),
),
patch("builtins.print"),
):
config, _ = _wizard_two_step()
assert config is not None
assert config["embedding"]["dense"] == dense
assert "vlm" not in config
def test_embedding_key_offered_for_vlm_reuse(self):
dense = {
"provider": "volcengine",
"model": "doubao-embedding-vision-251215",
"api_key": "ve-key",
"dimension": 1024,
}
with (
patch(
"openviking_cli.setup_wizard._prompt_embedding_flow",
return_value=(dense, None),
),
patch(
"openviking_cli.setup_wizard._prompt_cloud_vlm",
return_value=({"provider": "volcengine", "model": "m"}, None),
) as mock_vlm,
patch("builtins.print"),
):
_wizard_two_step()
mock_vlm.assert_called_once_with(
allow_skip=True, reuse_key=("volcengine", "ve-key"), allow_back=True, plan_seed=None
)
def test_cancel_in_vlm_step_cancels_setup(self):
dense = {"provider": "openai", "model": "text-embedding-3-small", "dimension": 1536}
with (
patch(
"openviking_cli.setup_wizard._prompt_embedding_flow",
return_value=(dense, None),
),
patch("openviking_cli.setup_wizard._prompt_cloud_vlm", return_value=(None, None)),
patch("builtins.print"),
):
config, _ = _wizard_two_step()
assert config is None
class TestVLMKeyReuse:
def test_reuse_accepted_skips_key_prompt(self):
from openviking_cli.setup_wizard import _prompt_cloud_vlm
with (
patch("openviking_cli.setup_wizard._prompt_choice", return_value=3), # OpenAI
patch("openviking_cli.setup_wizard._prompt_confirm", return_value=True),
patch(
"openviking_cli.setup_wizard._prompt_required_input",
return_value="gpt-5.4",
),
patch("openviking_cli.setup_wizard._prompt_api_key_with_env") as mock_key,
patch("builtins.print"),
):
vlm_config, _ = _prompt_cloud_vlm(reuse_key=("openai", "shared-key"))
assert vlm_config["api_key"] == "shared-key"
mock_key.assert_not_called()
def test_different_provider_prompts_normally(self):
from openviking_cli.setup_wizard import _prompt_cloud_vlm
with (
patch("openviking_cli.setup_wizard._prompt_choice", return_value=3), # OpenAI
patch("openviking_cli.setup_wizard._prompt_confirm") as mock_confirm,
patch(
"openviking_cli.setup_wizard._prompt_required_input",
return_value="gpt-5.4",
),
patch(
"openviking_cli.setup_wizard._prompt_api_key_with_env",
return_value="typed-key",
),
patch("builtins.print"),
):
vlm_config, _ = _prompt_cloud_vlm(reuse_key=("volcengine", "other-key"))
assert vlm_config["api_key"] == "typed-key"
mock_confirm.assert_not_called()
# ---------------------------------------------------------------------------
# Back navigation (← / [0] Back)
# ---------------------------------------------------------------------------
class TestBackNavigation:
def test_numbered_fallback_accepts_zero_as_back(self):
from openviking_cli.setup_wizard import _prompt_choice_numbered
with patch("builtins.input", return_value="0"), patch("builtins.print"):
assert _prompt_choice_numbered("Q:", [("A", ""), ("B", "")], allow_back=True) == 0
def test_numbered_fallback_rejects_zero_without_back(self):
with patch("builtins.input", side_effect=["0", "2"]), patch("builtins.print"):
from openviking_cli.setup_wizard import _prompt_choice_numbered
assert _prompt_choice_numbered("Q:", [("A", ""), ("B", "")]) == 2
def test_embedding_flow_backs_out_of_backend_menu(self):
with (
patch("openviking_cli.setup_wizard._prompt_choice", return_value=0),
patch("builtins.print"),
):
from openviking_cli.setup_wizard import _prompt_embedding_flow
dense, _ = _prompt_embedding_flow(allow_back=True)
assert dense is _GO_BACK
def test_vlm_menu_backs_out(self):
from openviking_cli.setup_wizard import _prompt_cloud_vlm
with (
patch("openviking_cli.setup_wizard._prompt_choice", return_value=0),
patch("builtins.print"),
):
vlm_config, _ = _prompt_cloud_vlm(allow_back=True)
assert vlm_config is _GO_BACK
def test_two_step_back_from_vlm_reruns_embedding(self):
dense1 = {"provider": "ollama", "model": "first", "dimension": 1024}
dense2 = {"provider": "ollama", "model": "second", "dimension": 1024}
with (
patch(
"openviking_cli.setup_wizard._prompt_embedding_flow",
side_effect=[(dense1, None), (dense2, None)],
),
patch(
"openviking_cli.setup_wizard._prompt_cloud_vlm",
side_effect=[(_GO_BACK, None), (_SKIP_VLM, None)],
),
patch("builtins.print"),
):
config, _ = _wizard_two_step()
assert config is not None
assert config["embedding"]["dense"] == dense2
def test_run_init_back_from_two_step_reshows_mode_menu(self, tmp_path):
config_path = tmp_path / "ov.conf"
ollama_config = {
"embedding": {"dense": {"provider": "ollama", "model": "q", "dimension": 1024}},
"storage": {"workspace": str(tmp_path / "data")},
}
with (
patch.dict(os.environ, {"OPENVIKING_CONFIG_FILE": str(config_path)}, clear=False),
# First pass picks step-by-step, which backs out; second pass picks
# the recommended Ollama mode.
patch("openviking_cli.setup_wizard._prompt_choice", side_effect=[1, 2]),
patch(
"openviking_cli.setup_wizard._wizard_two_step",
return_value=(_GO_BACK, None),
),
patch(
"openviking_cli.setup_wizard._wizard_ollama",
return_value=(ollama_config, True),
),
patch("openviking_cli.setup_wizard._wizard_query_planner", return_value=None),
patch(
"openviking_cli.setup_wizard._wizard_server",
return_value={"host": "127.0.0.1"},
),
patch("openviking_cli.setup_wizard._prompt_confirm", return_value=True),
patch("openviking_cli.setup_wizard._write_config", return_value=True) as mock_write,
patch("openviking_cli.setup_wizard._post_save_actions", return_value=None),
patch("builtins.print"),
):
assert run_init() == 0
mock_write.assert_called_once()