Skip to content

Self-hosted AI workspace.

Python
3.5 KB
Raw Blame
"""Retired settings stay stored but cannot leak through generic interfaces."""

import asyncio
import json
from types import SimpleNamespace

import pytest

import core.database as database
import routes.auth_routes as auth_routes
import src.settings as settings_mod
from src.agent_tools.admin_tools import do_manage_settings


LEGACY_VALUE = [
    {"endpoint_id": "private-endpoint-id", "model": "private-model-name"},
]


class _AuthManager:
    def get_username_for_token(self, token):
        return "admin" if token == "admin-session" else None

    def is_admin(self, username):
        return username == "admin"


class _Request(SimpleNamespace):
    def __init__(self, body=None, *, admin=False):
        super().__init__(
            cookies={
                auth_routes.SESSION_COOKIE: "admin-session"
            } if admin else {},
            _body=body,
        )

    async def json(self):
        return self._body


def _route(router, path, method):
    return next(
        route.endpoint
        for route in router.routes
        if route.path == path and method in route.methods
    )


@pytest.mark.asyncio
async def test_generic_settings_hide_and_preserve_retired_fallbacks(monkeypatch):
    store = {
        **settings_mod.DEFAULT_SETTINGS,
        "default_model_fallbacks": list(LEGACY_VALUE),
        "tts_enabled": True,
    }

    monkeypatch.setattr(auth_routes, "migrate_from_settings", lambda: None)
    monkeypatch.setattr(auth_routes, "_load_settings", lambda: dict(store))

    def save_settings(updated):
        store.clear()
        store.update(updated)

    monkeypatch.setattr(auth_routes, "_save_settings", save_settings)
    router = auth_routes.setup_auth_routes(_AuthManager())
    get_settings = _route(router, "/api/auth/settings", "GET")
    set_settings = _route(router, "/api/auth/settings", "POST")

    anonymous = await get_settings(_Request())
    admin = await get_settings(_Request(admin=True))

    assert "default_model_fallbacks" not in anonymous
    assert "default_model_fallbacks" not in admin
    assert store["default_model_fallbacks"] == LEGACY_VALUE

    response = await set_settings(_Request({
        "default_model_fallbacks": [],
        "tts_enabled": False,
    }, admin=True))

    assert "default_model_fallbacks" not in response
    assert store["default_model_fallbacks"] == LEGACY_VALUE
    assert store["tts_enabled"] is False


def test_manage_settings_tombstones_legacy_fallback_key(monkeypatch):
    store = {
        **settings_mod.DEFAULT_SETTINGS,
        "default_model_fallbacks": list(LEGACY_VALUE),
    }
    save_calls = []

    class _Db:
        def close(self):
            return None

    monkeypatch.setattr(database, "SessionLocal", lambda: _Db())
    monkeypatch.setattr(settings_mod, "load_settings", lambda: dict(store))

    def save_settings(updated):
        save_calls.append(dict(updated))
        store.clear()
        store.update(updated)

    monkeypatch.setattr(settings_mod, "save_settings", save_settings)

    listed = asyncio.run(do_manage_settings(json.dumps({"action": "list"})))
    assert "default_model_fallbacks" not in listed["settings"]

    for action in ("get", "set", "reset", "delete"):
        payload = {"action": action, "key": "default_model_fallbacks"}
        if action == "set":
            payload["value"] = []
        result = asyncio.run(do_manage_settings(json.dumps(payload)))
        assert result["exit_code"] == 1
        assert "Unknown setting" in result["error"]

    assert save_calls == []
    assert store["default_model_fallbacks"] == LEGACY_VALUE