free-claude-code/tests/config/test_model_fallbacks.py

"""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")]