wehub-resource-sync
475 lines
15 KiB
Python
475 lines
15 KiB
Python
"""Regression tests for review findings on the headless onboard CLI.
|
|
|
|
Covers: keep-current --router on re-saves (S1), EOFError cancellation
|
|
productization (S4), restart guidance at the bare-onboard boundary (F17),
|
|
wizard-phase OSError diagnosis (F27), validation-error redaction (F29), and
|
|
the single-preflight-load contract of the --provider path (F41).
|
|
All tests are offline and use synthetic dummy data only.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import errno
|
|
import re
|
|
import tomllib
|
|
|
|
import pytest
|
|
from typer.testing import CliRunner
|
|
|
|
from opensquilla.cli.main import app
|
|
from opensquilla.onboarding.config_store import load_config
|
|
|
|
runner = CliRunner()
|
|
_ANSI_RE = re.compile(r"\x1b\[[0-?]*[ -/]*[@-~]")
|
|
|
|
|
|
def _plain(value: str) -> str:
|
|
return " ".join(_ANSI_RE.sub("", value).split())
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# S1: bare `onboard --provider` re-saves keep the stored router state when
|
|
# --router is omitted; explicit --router and first-run behavior are unchanged.
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
def test_onboard_provider_key_rotation_keeps_router_disabled_and_model(
|
|
tmp_path, monkeypatch
|
|
):
|
|
target = tmp_path / "c.toml"
|
|
target.write_text(
|
|
"[llm]\n"
|
|
'provider = "openrouter"\n'
|
|
'model = "custom/model-x"\n'
|
|
'api_key = "sk-old"\n'
|
|
"\n"
|
|
"[squilla_router]\n"
|
|
"enabled = false\n",
|
|
encoding="utf-8",
|
|
)
|
|
monkeypatch.setenv("OPENSQUILLA_GATEWAY_CONFIG_PATH", str(target))
|
|
|
|
result = runner.invoke(
|
|
app,
|
|
["onboard", "--provider", "openrouter", "--api-key", "sk-new", "--minimal"],
|
|
)
|
|
|
|
assert result.exit_code == 0, result.output
|
|
cfg = load_config(target)
|
|
assert cfg.squilla_router.enabled is False
|
|
assert cfg.llm.model == "custom/model-x"
|
|
assert cfg.llm.api_key == "sk-new"
|
|
data = tomllib.loads(target.read_text(encoding="utf-8"))
|
|
assert data["squilla_router"]["enabled"] is False
|
|
|
|
|
|
def test_onboard_provider_key_rotation_keeps_hand_customized_tiers(
|
|
tmp_path, monkeypatch
|
|
):
|
|
target = tmp_path / "c.toml"
|
|
target.write_text(
|
|
"[llm]\n"
|
|
'provider = "openrouter"\n'
|
|
'model = "custom/model-x"\n'
|
|
'api_key = "sk-old"\n'
|
|
"\n"
|
|
"[squilla_router.tiers.c0]\n"
|
|
'provider = "openrouter"\n'
|
|
'model = "my-org/custom-c0"\n'
|
|
"[squilla_router.tiers.c1]\n"
|
|
'provider = "openrouter"\n'
|
|
'model = "my-org/custom-c1"\n'
|
|
"[squilla_router.tiers.c2]\n"
|
|
'provider = "openrouter"\n'
|
|
'model = "my-org/custom-c2"\n'
|
|
"[squilla_router.tiers.c3]\n"
|
|
'provider = "openrouter"\n'
|
|
'model = "my-org/custom-c3"\n',
|
|
encoding="utf-8",
|
|
)
|
|
monkeypatch.setenv("OPENSQUILLA_GATEWAY_CONFIG_PATH", str(target))
|
|
|
|
result = runner.invoke(
|
|
app,
|
|
["onboard", "--provider", "openrouter", "--api-key", "sk-new", "--minimal"],
|
|
)
|
|
|
|
assert result.exit_code == 0, result.output
|
|
cfg = load_config(target)
|
|
for tier in ("c0", "c1", "c2", "c3"):
|
|
assert cfg.squilla_router.tiers[tier]["model"] == f"my-org/custom-{tier}"
|
|
assert cfg.llm.api_key == "sk-new"
|
|
|
|
|
|
def test_onboard_provider_explicit_router_flag_still_applies_on_resave(
|
|
tmp_path, monkeypatch
|
|
):
|
|
target = tmp_path / "c.toml"
|
|
target.write_text(
|
|
"[llm]\n"
|
|
'provider = "openrouter"\n'
|
|
'model = "custom/model-x"\n'
|
|
'api_key = "sk-old"\n'
|
|
"\n"
|
|
"[squilla_router]\n"
|
|
"enabled = false\n",
|
|
encoding="utf-8",
|
|
)
|
|
monkeypatch.setenv("OPENSQUILLA_GATEWAY_CONFIG_PATH", str(target))
|
|
|
|
result = runner.invoke(
|
|
app,
|
|
[
|
|
"onboard",
|
|
"--provider",
|
|
"openrouter",
|
|
"--api-key",
|
|
"sk-new",
|
|
"--router",
|
|
"recommended",
|
|
"--minimal",
|
|
],
|
|
)
|
|
|
|
assert result.exit_code == 0, result.output
|
|
cfg = load_config(target)
|
|
assert cfg.squilla_router.enabled is True
|
|
assert cfg.squilla_router.tier_profile == "openrouter"
|
|
|
|
|
|
def test_onboard_provider_first_run_still_applies_recommended_router(
|
|
tmp_path, monkeypatch
|
|
):
|
|
# Fresh/unconfigured install: an omitted --router keeps today's first-run
|
|
# behavior and applies the recommended profile.
|
|
target = tmp_path / "c.toml"
|
|
monkeypatch.setenv("OPENSQUILLA_GATEWAY_CONFIG_PATH", str(target))
|
|
monkeypatch.delenv("OPENSQUILLA_LLM_API_KEY", raising=False)
|
|
|
|
result = runner.invoke(
|
|
app,
|
|
["onboard", "--provider", "openrouter", "--api-key", "sk", "--minimal"],
|
|
)
|
|
|
|
assert result.exit_code == 0, result.output
|
|
data = tomllib.loads(target.read_text(encoding="utf-8"))
|
|
assert data["squilla_router"]["tier_profile"] == "openrouter"
|
|
cfg = load_config(target)
|
|
assert cfg.squilla_router.enabled is True
|
|
|
|
|
|
def test_onboard_provider_first_run_with_env_key_still_applies_router(
|
|
tmp_path, monkeypatch
|
|
):
|
|
# An env-absorbed credential must not make a fresh install look
|
|
# configured: the recommended profile still applies on first setup.
|
|
target = tmp_path / "c.toml"
|
|
monkeypatch.setenv("OPENSQUILLA_GATEWAY_CONFIG_PATH", str(target))
|
|
monkeypatch.setenv("OPENSQUILLA_LLM_API_KEY", "sk-from-env")
|
|
|
|
result = runner.invoke(
|
|
app,
|
|
["onboard", "--provider", "openrouter", "--api-key", "sk", "--minimal"],
|
|
)
|
|
|
|
assert result.exit_code == 0, result.output
|
|
data = tomllib.loads(target.read_text(encoding="utf-8"))
|
|
assert data["squilla_router"]["tier_profile"] == "openrouter"
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# S4: EOFError (Ctrl+D / exhausted piped stdin) must be productized exactly
|
|
# like Esc/Ctrl+C — one short "Setup cancelled" line, exit 130.
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
def test_onboard_wizard_eof_is_productized_as_cancellation(tmp_path, monkeypatch):
|
|
from opensquilla.cli import onboard_cmd
|
|
|
|
target = tmp_path / "c.toml"
|
|
monkeypatch.setenv("OPENSQUILLA_GATEWAY_CONFIG_PATH", str(target))
|
|
|
|
def eof(_options):
|
|
raise EOFError
|
|
|
|
monkeypatch.setattr(onboard_cmd, "run_interactive_onboard", eof)
|
|
|
|
result = runner.invoke(app, ["onboard"])
|
|
|
|
assert result.exit_code == 130
|
|
assert "Setup cancelled" in _plain(result.stderr)
|
|
assert "Aborted" not in result.output + result.stderr
|
|
assert "Traceback" not in result.output + result.stderr
|
|
assert not target.exists()
|
|
|
|
|
|
def test_configure_wizard_eof_is_productized_as_cancellation(tmp_path, monkeypatch):
|
|
from opensquilla.cli import onboard_cmd
|
|
|
|
target = tmp_path / "c.toml"
|
|
monkeypatch.setenv("OPENSQUILLA_GATEWAY_CONFIG_PATH", str(target))
|
|
|
|
def eof(_section, *, config_path=None):
|
|
raise EOFError
|
|
|
|
monkeypatch.setattr(onboard_cmd, "run_interactive_configure", eof)
|
|
|
|
result = runner.invoke(app, ["onboard", "configure", "router"])
|
|
|
|
assert result.exit_code == 130
|
|
assert "Setup cancelled" in _plain(result.stderr)
|
|
assert "Aborted" not in result.output + result.stderr
|
|
assert "Traceback" not in result.output + result.stderr
|
|
assert not target.exists()
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# F17: bare `onboard` must surface PersistResult.restart_required with the
|
|
# same structured guidance `onboard configure` prints.
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
def test_bare_onboard_prints_restart_guidance_when_result_requires_it(
|
|
tmp_path, monkeypatch
|
|
):
|
|
from opensquilla.cli import onboard_cmd
|
|
from opensquilla.onboarding.config_store import PersistResult
|
|
|
|
target = tmp_path / "c.toml"
|
|
target.write_text(
|
|
'[llm]\nprovider = "openrouter"\nmodel = "m"\napi_key = "sk"\n',
|
|
encoding="utf-8",
|
|
)
|
|
monkeypatch.setenv("OPENSQUILLA_GATEWAY_CONFIG_PATH", str(target))
|
|
|
|
def hub_edit(_options):
|
|
# Simulates onboard -> "Change specific sections" -> a channel edit:
|
|
# the aggregated result carries the sticky restart flag.
|
|
return PersistResult(
|
|
path=target,
|
|
backup_path=None,
|
|
restart_required=True,
|
|
warnings=[],
|
|
)
|
|
|
|
monkeypatch.setattr(onboard_cmd, "run_interactive_onboard", hub_edit)
|
|
|
|
result = runner.invoke(app, ["onboard"])
|
|
|
|
assert result.exit_code == 0, result.output
|
|
plain = _plain(result.stdout)
|
|
assert "restart required" in plain
|
|
assert "opensquilla gateway restart" in plain
|
|
|
|
|
|
def test_bare_onboard_prints_no_restart_guidance_without_flag(tmp_path, monkeypatch):
|
|
from opensquilla.cli import onboard_cmd
|
|
from opensquilla.onboarding.config_store import PersistResult
|
|
|
|
target = tmp_path / "c.toml"
|
|
target.write_text(
|
|
'[llm]\nprovider = "openrouter"\nmodel = "m"\napi_key = "sk"\n',
|
|
encoding="utf-8",
|
|
)
|
|
monkeypatch.setenv("OPENSQUILLA_GATEWAY_CONFIG_PATH", str(target))
|
|
|
|
monkeypatch.setattr(
|
|
onboard_cmd,
|
|
"run_interactive_onboard",
|
|
lambda _options: PersistResult(
|
|
path=target,
|
|
backup_path=None,
|
|
restart_required=False,
|
|
warnings=[],
|
|
),
|
|
)
|
|
|
|
result = runner.invoke(app, ["onboard"])
|
|
|
|
assert result.exit_code == 0, result.output
|
|
assert "restart required" not in _plain(result.stdout)
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# F27: an OSError raised INSIDE the wizard (e.g. disk full during the final
|
|
# persist) is a write failure, not a config-load error — the CLI must not
|
|
# claim the config failed to load or suggest editing/moving it.
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
def test_onboard_wizard_write_oserror_is_not_misdiagnosed_as_load_error(
|
|
tmp_path, monkeypatch
|
|
):
|
|
from opensquilla.cli import onboard_cmd
|
|
|
|
target = tmp_path / "c.toml"
|
|
target.write_text(
|
|
'[llm]\nprovider = "openrouter"\nmodel = "m"\napi_key = "sk"\n',
|
|
encoding="utf-8",
|
|
)
|
|
monkeypatch.setenv("OPENSQUILLA_GATEWAY_CONFIG_PATH", str(target))
|
|
|
|
def disk_full(_options):
|
|
raise OSError(errno.ENOSPC, "No space left on device")
|
|
|
|
monkeypatch.setattr(onboard_cmd, "run_interactive_onboard", disk_full)
|
|
|
|
result = runner.invoke(app, ["onboard"])
|
|
|
|
assert result.exit_code == 2
|
|
plain = _plain(result.stderr)
|
|
assert "No space left on device" in plain
|
|
assert "OpenSquilla config error" not in plain
|
|
assert "edit or move this config" not in plain
|
|
assert "Traceback" not in result.output + result.stderr
|
|
|
|
|
|
def test_onboard_prevalidates_config_before_entering_wizard(tmp_path, monkeypatch):
|
|
from opensquilla.cli import onboard_cmd
|
|
|
|
target = tmp_path / "c.toml"
|
|
target.write_text("not toml :::", encoding="utf-8")
|
|
monkeypatch.setenv("OPENSQUILLA_GATEWAY_CONFIG_PATH", str(target))
|
|
|
|
def must_not_run(_options): # pragma: no cover - the pre-check exits first
|
|
raise AssertionError("the wizard must not start over a corrupt config")
|
|
|
|
monkeypatch.setattr(onboard_cmd, "run_interactive_onboard", must_not_run)
|
|
|
|
result = runner.invoke(app, ["onboard"])
|
|
|
|
assert result.exit_code == 2
|
|
assert "OpenSquilla config error" in result.stderr
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# F29: a validator message that interpolates the offending input must be
|
|
# masked by the free-text redactor before it reaches stderr.
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
def test_onboard_provider_validation_error_redacts_secret_shaped_values(
|
|
tmp_path, monkeypatch
|
|
):
|
|
from pydantic import BaseModel, ValidationError, field_validator
|
|
|
|
from opensquilla.cli import onboard_cmd
|
|
|
|
secret = "sk-live-SECRETSECRETSECRETSECRET123456"
|
|
|
|
class _Probe(BaseModel):
|
|
api_key: str
|
|
|
|
@field_validator("api_key")
|
|
@classmethod
|
|
def _reject(cls, value: str) -> str:
|
|
raise ValueError(f"key {value!r} looks malformed")
|
|
|
|
try:
|
|
_Probe(api_key=secret)
|
|
except ValidationError as exc:
|
|
captured = exc
|
|
else: # pragma: no cover - the construction above always fails
|
|
raise AssertionError("expected a ValidationError")
|
|
|
|
target = tmp_path / "c.toml"
|
|
monkeypatch.setenv("OPENSQUILLA_GATEWAY_CONFIG_PATH", str(target))
|
|
|
|
class _RaisingEngine:
|
|
def __init__(self, *_a, **_kw):
|
|
pass
|
|
|
|
def apply(self, *_a, **_kw):
|
|
raise captured
|
|
|
|
def persist(self, *_a, **_kw): # pragma: no cover - apply raises first
|
|
raise AssertionError("persist must not run after a failed apply")
|
|
|
|
monkeypatch.setattr(onboard_cmd, "SetupEngine", _RaisingEngine)
|
|
|
|
result = runner.invoke(
|
|
app,
|
|
["onboard", "--provider", "openrouter", "--api-key", secret, "--minimal"],
|
|
)
|
|
|
|
assert result.exit_code == 2
|
|
combined = result.output + result.stderr
|
|
assert secret not in combined
|
|
assert "***" in _plain(result.stderr)
|
|
assert "api_key" in _plain(result.stderr)
|
|
assert not target.exists()
|
|
|
|
|
|
def test_format_validation_error_masks_interpolated_secret_unit():
|
|
from pydantic import BaseModel, ValidationError, field_validator
|
|
|
|
from opensquilla.cli.onboard_cmd import _format_validation_error
|
|
|
|
secret = "sk-live-UNITSECRETUNITSECRET987654"
|
|
|
|
class _Probe(BaseModel):
|
|
api_key: str
|
|
|
|
@field_validator("api_key")
|
|
@classmethod
|
|
def _reject(cls, value: str) -> str:
|
|
raise ValueError(f"key {value!r} looks malformed")
|
|
|
|
with pytest.raises(ValidationError) as excinfo:
|
|
_Probe(api_key=secret)
|
|
|
|
rendered = _format_validation_error(excinfo.value)
|
|
assert secret not in rendered
|
|
assert "***" in rendered
|
|
assert "api_key" in rendered
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# F41: the `onboard --provider` path must reuse its preflight load for the
|
|
# save instead of loading the config again inside the engine.
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
def test_onboard_provider_reuses_preflight_load_for_the_save(tmp_path, monkeypatch):
|
|
from opensquilla.cli import onboard_cmd
|
|
from opensquilla.onboarding import setup_engine
|
|
|
|
target = tmp_path / "c.toml"
|
|
monkeypatch.setenv("OPENSQUILLA_GATEWAY_CONFIG_PATH", str(target))
|
|
|
|
def engine_must_not_load(*_a, **_kw): # pragma: no cover - regression guard
|
|
raise AssertionError(
|
|
"SetupEngine must receive the preflight-loaded config, not reload it"
|
|
)
|
|
|
|
monkeypatch.setattr(setup_engine, "load_config", engine_must_not_load)
|
|
|
|
load_calls: list[object] = []
|
|
real_load = onboard_cmd.load_config
|
|
|
|
def counting_load(path=None):
|
|
load_calls.append(path)
|
|
return real_load(path)
|
|
|
|
monkeypatch.setattr(onboard_cmd, "load_config", counting_load)
|
|
|
|
result = runner.invoke(
|
|
app,
|
|
[
|
|
"onboard",
|
|
"--provider",
|
|
"openrouter",
|
|
"--model",
|
|
"deepseek/deepseek-v4-flash",
|
|
"--api-key",
|
|
"sk",
|
|
"--minimal",
|
|
],
|
|
)
|
|
|
|
assert result.exit_code == 0, result.output
|
|
# One preflight load feeding the engine + one post-save load for the
|
|
# handoff summary; the previous shape performed three full loads.
|
|
assert len(load_calls) == 2
|
|
assert "openrouter" in target.read_text(encoding="utf-8")
|