claude-proxy / tests /config /test_model_fallbacks.py
dheraingoud's picture
Copilot App
Sync upstream v6.19.35 and preserve custom addons
a9e27c0
Raw History Blame Contribute Delete
7.01 kB
"""Fallback model/effort configuration and persistence contracts."""
import json
from pathlib import Path
import pytest
from pydantic import ValidationError
from free_claude_code.config.admin.persistence import prepare_admin_update
from free_claude_code.config.admin.values import load_config_response
from free_claude_code.config.loader import (
ConfigSource,
ManagedConfigSnapshot,
compose_settings_snapshot,
)
from free_claude_code.config.model_refs import configured_chat_model_refs
from free_claude_code.config.reasoning import ReasoningPreference
from free_claude_code.config.settings import Settings
def _snapshot(managed=None, process=None):
managed, process = managed or {}, process or {}
result = compose_settings_snapshot(managed, process)
return ManagedConfigSnapshot(
result.settings, result.sources, managed, process, Path("unused.env")
)
def _fallback_field(state):
fields = load_config_response(state, revision_key=b"test-revision-key")["fields"]
assert isinstance(fields, list)
for field in fields:
assert isinstance(field, dict)
if field["key"] == "MODEL_FALLBACKS":
return field
raise AssertionError("Fallback field is missing")
@pytest.mark.parametrize(
"effort", ["inherit", "off", "client", "low", "medium", "high", "xhigh", "max"]
)
@pytest.mark.parametrize("as_json", [False, True])
def test_fallback_records_preserve_model_and_effort(effort, as_json):
value = [
{"model": " groq/vendor/Model-A ", "reasoning": effort},
{"model": "open_router/vendor/model-b"},
]
settings = Settings.model_validate(
{"MODEL_FALLBACKS": json.dumps(value) if as_json else value}
)
assert settings.model_fallbacks is not None
assert [
(entry.model, entry.reasoning.value) for entry in settings.model_fallbacks
] == [
("groq/vendor/Model-A", effort),
("open_router/vendor/model-b", "inherit"),
]
with pytest.raises(ValidationError):
settings.model_fallbacks[0].__setattr__("reasoning", ReasoningPreference.OFF)
@pytest.mark.parametrize(
"value",
[
"groq/one, open_router/vendor/two ",
["groq/one", "open_router/vendor/two"],
("groq/one", "open_router/vendor/two"),
],
)
def test_legacy_fallbacks_are_inherit_records(value):
settings = Settings.model_validate({"MODEL_FALLBACKS": value})
assert settings.model_fallbacks is not None
assert [
(entry.model, entry.reasoning.value) for entry in settings.model_fallbacks
] == [("groq/one", "inherit"), ("open_router/vendor/two", "inherit")]
@pytest.mark.parametrize(
"value",
[
[{"model": "groq/one", "reasoning": "minimal"}],
[{"model": "groq/one", "reasoning": True}],
[{"model": "groq/one", "reasoning": "low", "unknown": 1}],
[{"model": "groq/"}],
[{"model": "unknown/one"}],
[
{"model": "groq/one", "reasoning": "low"},
{"model": "groq/one", "reasoning": "high"},
],
'[{"model":"groq/one"}',
],
)
def test_invalid_fallback_records_are_rejected(value):
with pytest.raises(ValidationError):
Settings.model_validate({"MODEL_FALLBACKS": value})
def test_fallback_records_retain_primary_overlap_and_discovery_identity():
settings = Settings(
MODEL="groq/one",
MODEL_OPUS="groq/one",
MODEL_FALLBACKS=[
{"model": "groq/one", "reasoning": "off"},
{"model": "open_router/vendor/two", "reasoning": "max"},
],
)
assert [entry.model_ref for entry in configured_chat_model_refs(settings)] == [
"groq/one",
"open_router/vendor/two",
]
@pytest.mark.parametrize("as_json", [False, True])
def test_admin_fallback_records_round_trip_without_restart_or_false_changes(as_json):
entries = [
{"model": "groq/one", "reasoning": "low"},
{"model": "open_router/vendor/two", "reasoning": "inherit"},
]
canonical = [
{"model": "groq/one", "reasoning": "low", "api_key_number": 1},
{
"model": "open_router/vendor/two",
"reasoning": "inherit",
"api_key_number": 1,
},
]
original = _snapshot()
saved = prepare_admin_update(
{"MODEL_FALLBACKS": json.dumps(entries) if as_json else entries},
original,
original.settings,
revision_key=b"test-revision-key",
)
assert saved.valid, saved.errors
assert saved.pending_fields == ()
assert json.loads(saved.target_values["MODEL_FALLBACKS"]) == canonical
loaded = _snapshot(saved.target_values)
field = _fallback_field(loaded)
value = field["value"]
assert isinstance(value, str) and json.loads(value) == canonical
assert field["source"] == ConfigSource.MANAGED.value
options = field["options"]
assert isinstance(options, list)
values = []
for option in options:
assert isinstance(option, dict)
values.append(option["value"])
assert values == [
"inherit",
"off",
"client",
"low",
"medium",
"high",
"xhigh",
"max",
]
unchanged = prepare_admin_update(
{"MODEL_FALLBACKS": field["value"]},
loaded,
loaded.settings,
revision_key=b"test-revision-key",
)
assert unchanged.valid and unchanged.changed_keys == ()
@pytest.mark.parametrize("empty", ["", "[]", []])
def test_empty_process_fallbacks_override_managed_records_and_remain_locked(empty):
managed = {"MODEL_FALLBACKS": '[{"model":"groq/one","reasoning":"max"}]'}
state = _snapshot(
managed,
{"MODEL_FALLBACKS": json.dumps(empty) if isinstance(empty, list) else empty},
)
assert state.settings.model_fallbacks is None
field = _fallback_field(state)
assert field["locked"] is True and field["value"] is None
result = prepare_admin_update(
{"MODEL_FALLBACKS": [{"model": "groq/two", "reasoning": "off"}]},
state,
state.settings,
revision_key=b"test-revision-key",
)
assert result.valid and result.settings is not None
assert result.settings.model_fallbacks is None
assert json.loads(result.target_values["MODEL_FALLBACKS"]) == [
{"model": "groq/one", "reasoning": "max", "api_key_number": 1}
]
def test_retired_provider_normalization_preserves_surviving_efforts():
state = _snapshot(
{
"MODEL_FALLBACKS": json.dumps(
[
{"model": "groq/one", "reasoning": "low"},
{"model": "github_models/retired", "reasoning": "high"},
{"model": "deepseek/two", "reasoning": "max"},
]
)
}
)
assert state.settings.model_fallbacks is not None
assert [
(entry.model, entry.reasoning.value) for entry in state.settings.model_fallbacks
] == [("groq/one", "low"), ("deepseek/two", "max")]