The fastest, litest AI Gateway. Rust core with Python SDK. Call 100+ LLM APIs in OpenAI (or native) format with cost tracking, guardrails, load balancing, and logging [Bedrock, Azure, OpenAI, Anthropic, OpenAI, VertexAI, vLLM, Nvidia NIM]
Python ai-gatewayanthropicazure-openaibedrockgatewaylangchainlitellmllmllm-gatewayllmopsmcp-gatewayopenaiopenai-proxyrustrust-aivertex-ai
import json
import os
from typing import Final
import pytest
from fastapi.testclient import TestClient
from litellm.proxy._types import DefaultInternalUserParams, LitellmUserRoles
from litellm.proxy.proxy_server import app
from litellm.types.proxy.management_endpoints.ui_sso import (
DefaultTeamSSOParams,
SSOConfig,
)
client = TestClient(app)
@pytest.mark.asyncio
@pytest.mark.parametrize("config_value,stored_value,expected", [
(None, None, False), (None, False, False), (None, True, True),
(False, True, False), (True, False, True), ("false", True, False), ("true", False, True),
])
@pytest.mark.parametrize("encoded", [False, True])
@pytest.mark.parametrize("require_fresh", [False, True])
async def test_model_creation_policy_uses_refreshed_settings_with_config_precedence(
config_value: bool | str | None, stored_value: bool | None, expected: bool, encoded: bool,
require_fresh: bool,
) -> None:
from types import SimpleNamespace
from unittest.mock import AsyncMock, MagicMock
from litellm.proxy import proxy_server
from litellm.proxy.ui_crud_endpoints.proxy_setting_endpoints import (
model_creation_disabled_for_internal_users, sync_ui_settings_to_general_settings,
)
setting: Final = "disable_model_add_for_internal_users"
stored: Final = {} if stored_value is None else {setting: stored_value}
prisma: Final = MagicMock()
connection: Final = prisma.writer_db if require_fresh else prisma.db
unused_connection: Final = prisma.db if require_fresh else prisma.writer_db
connection.litellm_uisettings.find_unique = AsyncMock(return_value=SimpleNamespace(
ui_settings=json.dumps(stored) if encoded else stored,
))
proxy_server.proxy_config.settings.load_yaml({} if config_value is None else {setting: config_value})
await sync_ui_settings_to_general_settings(prisma, require_fresh=require_fresh)
assert model_creation_disabled_for_internal_users(proxy_server.general_settings) is expected
assert model_creation_disabled_for_internal_users(proxy_server.general_settings) is expected
connection.litellm_uisettings.find_unique.assert_awaited_once_with(where={"id": "ui_settings"})
unused_connection.litellm_uisettings.find_unique.assert_not_called()
@pytest.mark.asyncio
async def test_model_creation_policy_refresh_retains_last_value_on_failure_and_clears_deleted_flag() -> None:
from types import SimpleNamespace
from unittest.mock import AsyncMock, MagicMock
from litellm.proxy import proxy_server
from litellm.proxy.ui_crud_endpoints.proxy_setting_endpoints import (
model_creation_disabled_for_internal_users, sync_ui_settings_to_general_settings,
)
prisma: Final = MagicMock()
prisma.db.litellm_uisettings.find_unique = AsyncMock(side_effect=[
SimpleNamespace(ui_settings={"disable_model_add_for_internal_users": True}),
RuntimeError("database unavailable"),
SimpleNamespace(ui_settings={"disable_model_add_for_internal_users": False}),
SimpleNamespace(ui_settings={"disable_model_add_for_internal_users": True}),
None,
])
for expected in (True, True, False, True, False):
await sync_ui_settings_to_general_settings(prisma)
assert model_creation_disabled_for_internal_users(proxy_server.general_settings) is expected
@pytest.mark.asyncio
@pytest.mark.parametrize("disabled", [True, False])
async def test_model_creation_policy_patch_applies_after_successful_persistence(
monkeypatch: pytest.MonkeyPatch, disabled: bool,
) -> None:
from types import SimpleNamespace
from unittest.mock import AsyncMock, MagicMock
from litellm.proxy import proxy_server
from litellm.proxy._types import UserAPIKeyAuth
from litellm.proxy.ui_crud_endpoints.proxy_setting_endpoints import (
apply_runtime_general_settings_flags, model_creation_disabled_for_internal_users, update_ui_settings,
)
setting: Final = "disable_model_add_for_internal_users"
apply_runtime_general_settings_flags({setting: not disabled})
prisma: Final = MagicMock()
prisma.db.litellm_uisettings.find_unique = AsyncMock(return_value=SimpleNamespace(ui_settings={setting: not disabled}))
prisma.db.litellm_uisettings.upsert = AsyncMock(side_effect=[RuntimeError("write failed"), None])
monkeypatch.setattr(proxy_server, "prisma_client", prisma)
monkeypatch.setattr(proxy_server, "store_model_in_db", True)
actor: Final = UserAPIKeyAuth(user_id="admin", user_role=LitellmUserRoles.PROXY_ADMIN)
with pytest.raises(RuntimeError, match="write failed"):
await update_ui_settings({setting: disabled}, actor)
assert model_creation_disabled_for_internal_users(proxy_server.general_settings) is not disabled
await update_ui_settings({setting: disabled}, actor)
assert model_creation_disabled_for_internal_users(proxy_server.general_settings) is disabled
assert json.loads(prisma.db.litellm_uisettings.upsert.await_args.kwargs["data"]["update"]["ui_settings"]) == {
setting: disabled,
}
@pytest.fixture
def mock_proxy_config(monkeypatch):
"""Mock the proxy_config to avoid actual file operations during tests"""
mock_config = {
"litellm_settings": {
"default_internal_user_params": {
"user_role": LitellmUserRoles.INTERNAL_USER,
"max_budget": 100.0,
"budget_duration": "30d",
"models": ["gpt-3.5-turbo", "gpt-4"],
},
"default_team_params": {
"models": ["gpt-3.5-turbo"],
"max_budget": 50.0,
"budget_duration": "14d",
"tpm_limit": 100,
"rpm_limit": 10,
},
},
"general_settings": {"proxy_admin_email": "[email protected]"},
"environment_variables": {
"GOOGLE_CLIENT_ID": "test_google_client_id",
"GOOGLE_CLIENT_SECRET": "test_google_client_secret",
"MICROSOFT_CLIENT_ID": "test_microsoft_client_id",
"MICROSOFT_CLIENT_SECRET": "test_microsoft_client_secret",
"PROXY_BASE_URL": "https://example.com",
},
}
async def mock_get_config():
return mock_config
# Add a counter to track save_config calls
save_config_call_count = 0
saved_env_updates: list = []
async def mock_save_config(new_config=None):
nonlocal mock_config, save_config_call_count
save_config_call_count += 1
if new_config:
mock_config = new_config
return mock_config
async def mock_save_environment_variables(updates):
saved_env_updates.append(updates)
from litellm.proxy.proxy_server import proxy_config
monkeypatch.setattr(proxy_config, "get_config", mock_get_config)
monkeypatch.setattr(proxy_config, "save_config", mock_save_config)
monkeypatch.setattr(proxy_config, "save_environment_variables", mock_save_environment_variables)
# Return the config, the save_config call counter, and any env-var updates
# the endpoint routed through the dedicated save_environment_variables path
return {
"config": mock_config,
"save_call_count": lambda: save_config_call_count,
"env_updates": lambda: saved_env_updates,
}
@pytest.fixture
def mock_auth():
"""Mock the authentication to bypass auth checks using FastAPI dependency overrides"""
from litellm.proxy.auth.user_api_key_auth import user_api_key_auth
from litellm.proxy.proxy_server import app
async def mock_user_api_key_auth():
return {"user_id": "test_user"}
app.dependency_overrides[user_api_key_auth] = mock_user_api_key_auth
yield
app.dependency_overrides.pop(user_api_key_auth, None)
@pytest.fixture(autouse=True)
def fresh_settings_store(monkeypatch: pytest.MonkeyPatch) -> None:
from litellm.proxy import proxy_server
from litellm.proxy.config_resolvers.settings_store import SettingsStore
store: Final = SettingsStore("general_settings")
monkeypatch.setattr(proxy_server.proxy_config, "settings", store)
monkeypatch.setattr(proxy_server, "general_settings", store)
class TestProxySettingEndpoints:
def test_get_internal_user_settings(self, mock_proxy_config, mock_auth):
"""Test getting the internal user settings"""
response = client.get("/get/internal_user_settings")
assert response.status_code == 200
data = response.json()
# Check structure of response (updated to use field_schema)
assert "values" in data
assert "field_schema" in data
# Check values match our mock config
values = data["values"]
mock_params = mock_proxy_config["config"]["litellm_settings"][
"default_internal_user_params"
]
assert values["user_role"] == mock_params["user_role"]
assert values["max_budget"] == mock_params["max_budget"]
assert values["budget_duration"] == mock_params["budget_duration"]
assert values["models"] == mock_params["models"]
# Check field_schema contains descriptions (updated from schema to field_schema)
assert "properties" in data["field_schema"]
assert "user_role" in data["field_schema"]["properties"]
assert "description" in data["field_schema"]["properties"]["user_role"]
def test_get_internal_user_settings_fresh_db_defaults_to_viewer(
self, mock_auth, monkeypatch
):
"""
On a fresh DB with no saved settings, the GET endpoint should return
INTERNAL_USER_VIEW_ONLY as the default role — matching the runtime
fallback in SSO/SCIM/JWT provisioning paths.
"""
# Simulate fresh DB: no default_internal_user_params in config
empty_config = {
"litellm_settings": {},
"general_settings": {},
"environment_variables": {},
}
from litellm.proxy.proxy_server import proxy_config
async def mock_get_config():
return empty_config
monkeypatch.setattr(proxy_config, "get_config", mock_get_config)
response = client.get("/get/internal_user_settings")
assert response.status_code == 200
values = response.json()["values"]
assert values["user_role"] == LitellmUserRoles.INTERNAL_USER_VIEW_ONLY, (
f"Fresh DB should default to INTERNAL_USER_VIEW_ONLY, got {values['user_role']}. "
"The Pydantic default must match the runtime fallback."
)
def test_update_internal_user_settings(
self, mock_proxy_config, mock_auth, monkeypatch
):
"""Test updating the internal user settings"""
# Mock litellm.default_internal_user_params
import litellm
monkeypatch.setattr("litellm.proxy.proxy_server.store_model_in_db", True)
monkeypatch.setattr(litellm, "default_internal_user_params", {})
# New settings to update
new_settings = {
"user_role": LitellmUserRoles.PROXY_ADMIN,
"max_budget": 200.0,
"budget_duration": "7d",
"models": ["gpt-4", "claude-3"],
}
response = client.patch("/update/internal_user_settings", json=new_settings)
print(response.text)
assert response.status_code == 200
data = response.json()
# Check response structure
assert data["status"] == "success"
assert "settings" in data
# Verify settings were updated
settings = data["settings"]
assert settings["user_role"] == new_settings["user_role"]
assert settings["max_budget"] == new_settings["max_budget"]
assert settings["budget_duration"] == new_settings["budget_duration"]
assert settings["models"] == new_settings["models"]
# Verify the config was updated
updated_config = mock_proxy_config["config"]["litellm_settings"][
"default_internal_user_params"
]
assert updated_config["user_role"] == new_settings["user_role"]
assert updated_config["max_budget"] == new_settings["max_budget"]
# Verify save_config was called exactly once
assert mock_proxy_config["save_call_count"]() == 1
def test_get_default_team_settings(self, mock_proxy_config, mock_auth):
"""Test getting the default team settings"""
response = client.get("/get/default_team_settings")
assert response.status_code == 200
data = response.json()
# Check structure of response (updated to use field_schema)
assert "values" in data
assert "field_schema" in data
# Check values match our mock config
values = data["values"]
mock_params = mock_proxy_config["config"]["litellm_settings"][
"default_team_params"
]
assert values["models"] == mock_params["models"]
assert values["max_budget"] == mock_params["max_budget"]
assert values["budget_duration"] == mock_params["budget_duration"]
assert values["tpm_limit"] == mock_params["tpm_limit"]
assert values["rpm_limit"] == mock_params["rpm_limit"]
# Check field_schema contains descriptions (updated from schema to field_schema)
assert "properties" in data["field_schema"]
assert "models" in data["field_schema"]["properties"]
assert "description" in data["field_schema"]["properties"]["models"]
def test_update_default_team_settings(
self, mock_proxy_config, mock_auth, monkeypatch
):
"""Test updating the default team settings"""
# Mock litellm.default_team_params
import litellm
monkeypatch.setattr("litellm.proxy.proxy_server.store_model_in_db", True)
monkeypatch.setattr(litellm, "default_team_params", {})
# New settings to update
new_settings = {
"models": ["gpt-4", "claude-3"],
"max_budget": 150.0,
"budget_duration": "30d",
"tpm_limit": 200,
"rpm_limit": 20,
}
response = client.patch("/update/default_team_settings", json=new_settings)
assert response.status_code == 200
data = response.json()
# Check response structure
assert data["status"] == "success"
assert "settings" in data
# Verify settings were updated
settings = data["settings"]
assert settings["models"] == new_settings["models"]
assert settings["max_budget"] == new_settings["max_budget"]
assert settings["budget_duration"] == new_settings["budget_duration"]
assert settings["tpm_limit"] == new_settings["tpm_limit"]
assert settings["rpm_limit"] == new_settings["rpm_limit"]
# Verify the config was updated
updated_config = mock_proxy_config["config"]["litellm_settings"][
"default_team_params"
]
assert updated_config["models"] == new_settings["models"]
assert updated_config["max_budget"] == new_settings["max_budget"]
assert updated_config["tpm_limit"] == new_settings["tpm_limit"]
# Verify save_config was called exactly once
assert mock_proxy_config["save_call_count"]() == 1
def test_get_default_team_settings_includes_team_member_permissions_schema(
self, mock_proxy_config, mock_auth
):
"""Test that team_member_permissions field appears in schema with enum items"""
response = client.get("/get/default_team_settings")
assert response.status_code == 200
data = response.json()
# Check that team_member_permissions is in the schema
props = data["field_schema"]["properties"]
assert "team_member_permissions" in props
perm_schema = props["team_member_permissions"]
assert perm_schema["type"] == "array"
assert "items" in perm_schema
assert "enum" in perm_schema["items"]
# Verify some known enum values are present
enum_values = perm_schema["items"]["enum"]
assert "/key/generate" in enum_values
assert "/key/info" in enum_values
assert "/key/delete" in enum_values
def test_update_default_team_settings_with_permissions(
self, mock_proxy_config, mock_auth, monkeypatch
):
"""Test updating default team settings with team_member_permissions"""
import litellm
monkeypatch.setattr("litellm.proxy.proxy_server.store_model_in_db", True)
monkeypatch.setattr(litellm, "default_team_params", {})
new_settings = {
"models": ["gpt-4"],
"team_member_permissions": ["/key/generate", "/key/update", "/key/delete"],
}
response = client.patch("/update/default_team_settings", json=new_settings)
assert response.status_code == 200
data = response.json()
assert data["status"] == "success"
settings = data["settings"]
assert settings["team_member_permissions"] == [
"/key/generate",
"/key/update",
"/key/delete",
]
def test_get_sso_settings(self, mock_proxy_config, mock_auth, monkeypatch):
"""Test getting the SSO settings from the dedicated database table"""
from unittest.mock import AsyncMock, MagicMock
# Mock the prisma client with database record
# Note: Prisma returns Json fields as dicts (auto-parsed)
mock_prisma = MagicMock()
mock_db_record = MagicMock()
mock_db_record.sso_settings = {
"google_client_id": "test_google_client_id",
"google_client_secret": "test_google_client_secret",
"microsoft_client_id": "test_microsoft_client_id",
"microsoft_client_secret": "test_microsoft_client_secret",
"proxy_base_url": "https://example.com",
"user_email": "[email protected]",
}
mock_prisma.db.litellm_ssoconfig.find_unique = AsyncMock(
return_value=mock_db_record
)
monkeypatch.setattr("litellm.proxy.proxy_server.prisma_client", mock_prisma)
# Mock decryption to return the values as-is (simulating decryption)
from litellm.proxy.proxy_server import proxy_config
monkeypatch.setattr(
proxy_config,
"decrypt_and_set_db_env_variables",
lambda environment_variables: environment_variables,
)
response = client.get("/get/sso_settings")
assert response.status_code == 200
data = response.json()
# Check structure of response
assert "values" in data
assert "field_schema" in data
# Check values contain SSO configuration
values = data["values"]
assert "google_client_id" in values
assert "google_client_secret" in values
assert "microsoft_client_id" in values
assert "microsoft_client_secret" in values
assert "proxy_base_url" in values
assert "user_email" in values
# Verify non-secret values match our mock config. OAuth client
# secrets are masked on read so the GET response never carries
# plaintext credentials.
assert values["google_client_id"] == "test_google_client_id"
assert values["google_client_secret"] != "test_google_client_secret"
assert "*" in values["google_client_secret"]
assert values["microsoft_client_id"] == "test_microsoft_client_id"
assert values["microsoft_client_secret"] != "test_microsoft_client_secret"
assert "*" in values["microsoft_client_secret"]
assert values["proxy_base_url"] == "https://example.com"
assert values["user_email"] == "[email protected]"
# Check field_schema contains descriptions
assert "properties" in data["field_schema"]
assert "google_client_id" in data["field_schema"]["properties"]
assert "description" in data["field_schema"]["properties"]["google_client_id"]
# Verify role_mappings is present in response (can be None if not set)
assert "role_mappings" in values
assert values["role_mappings"] is None
# Verify find_unique was called with correct parameters
mock_prisma.db.litellm_ssoconfig.find_unique.assert_called_once()
call_args = mock_prisma.db.litellm_ssoconfig.find_unique.call_args
assert call_args.kwargs["where"]["id"] == "sso_config"
def _mock_sso_db_record(self, monkeypatch, sso_settings):
"""Point /get/sso_settings at a stored SSO row (or None for no row)."""
from unittest.mock import AsyncMock, MagicMock
mock_prisma = MagicMock()
if sso_settings is None:
mock_db_record = None
else:
mock_db_record = MagicMock()
mock_db_record.sso_settings = sso_settings
mock_prisma.db.litellm_ssoconfig.find_unique = AsyncMock(return_value=mock_db_record)
monkeypatch.setattr("litellm.proxy.proxy_server.prisma_client", mock_prisma)
# The resolver decrypts stored values via decrypt_value_helper; make it an
# identity so the plaintext fixtures round-trip.
monkeypatch.setattr(
"litellm.proxy.config_resolvers.sso.decrypt_value_helper",
lambda value, key, exception_type="error", return_original_value=False: value,
)
def test_get_sso_settings_falls_back_to_process_env(
self, mock_proxy_config, mock_auth, monkeypatch
):
"""
Regression for LIT-4165.
SSO configured purely as process env vars (helm/terraform, no UI writes)
logs users in successfully, because ui_sso.py resolves every setting from
os.environ. /get/sso_settings read only the sso_config table though, so
the Admin UI showed "not configured" for a working SSO deployment and hid
the Edit/Delete controls behind an empty-state placeholder.
"""
self._mock_sso_db_record(monkeypatch, None)
monkeypatch.setenv("GENERIC_CLIENT_ID", "env-client-id")
monkeypatch.setenv("GENERIC_CLIENT_SECRET", "env-client-secret-value")
monkeypatch.setenv("GENERIC_AUTHORIZATION_ENDPOINT", "https://idp.example.com/authorize")
monkeypatch.setenv("GENERIC_TOKEN_ENDPOINT", "https://idp.example.com/token")
monkeypatch.setenv("GENERIC_USERINFO_ENDPOINT", "https://idp.example.com/userinfo")
monkeypatch.setenv("GENERIC_SCOPE", "openid email profile groups")
monkeypatch.setenv("PROXY_BASE_URL", "https://gateway.example.com")
response = client.get("/get/sso_settings")
assert response.status_code == 200
values = response.json()["values"]
# Every one of these was None before the fix, despite SSO working.
assert values["generic_client_id"] == "env-client-id"
assert values["generic_authorization_endpoint"] == "https://idp.example.com/authorize"
assert values["generic_token_endpoint"] == "https://idp.example.com/token"
assert values["generic_userinfo_endpoint"] == "https://idp.example.com/userinfo"
assert values["generic_scope"] == "openid email profile groups"
assert values["proxy_base_url"] == "https://gateway.example.com"
# An env-sourced secret is masked exactly like a stored one.
assert values["generic_client_secret"] not in (None, "env-client-secret-value")
assert "*" in values["generic_client_secret"]
def test_get_sso_settings_does_not_mutate_os_environ(
self, mock_proxy_config, mock_auth, monkeypatch
):
"""A GET must not write os.environ. The legacy read path decrypted DB
values straight into the environment, so opening the settings page
repopulated env and masked any consumer that stopped reading it."""
self._mock_sso_db_record(monkeypatch, {"generic_client_id": "db-only-id"})
monkeypatch.delenv("GENERIC_CLIENT_ID", raising=False)
response = client.get("/get/sso_settings")
assert response.status_code == 200
assert response.json()["values"]["generic_client_id"] == "db-only-id"
# The DB value must NOT have leaked into the process environment.
assert "GENERIC_CLIENT_ID" not in os.environ
def test_get_sso_settings_prefers_stored_over_process_env(
self, mock_proxy_config, mock_auth, monkeypatch
):
"""A stored value wins; only fields absent from the row fall back to env."""
self._mock_sso_db_record(monkeypatch, {"generic_client_id": "stored-client-id"})
monkeypatch.setenv("GENERIC_CLIENT_ID", "env-client-id")
monkeypatch.setenv("GENERIC_TOKEN_ENDPOINT", "https://idp.example.com/token")
response = client.get("/get/sso_settings")
assert response.status_code == 200
values = response.json()["values"]
assert values["generic_client_id"] == "stored-client-id"
assert values["generic_token_endpoint"] == "https://idp.example.com/token"
def test_get_sso_settings_blank_stored_value_falls_back_to_process_env(
self, mock_proxy_config, mock_auth, monkeypatch
):
"""
Blank means absent. update_sso_settings clears the env var for a blank
field, so a blank row entry cannot describe a live setting; os.environ is
the effective config and is what the UI must report.
"""
self._mock_sso_db_record(monkeypatch, {"generic_client_id": " ", "generic_token_endpoint": ""})
monkeypatch.setenv("GENERIC_CLIENT_ID", "env-client-id")
monkeypatch.setenv("GENERIC_TOKEN_ENDPOINT", "https://idp.example.com/token")
response = client.get("/get/sso_settings")
assert response.status_code == 200
values = response.json()["values"]
assert values["generic_client_id"] == "env-client-id"
assert values["generic_token_endpoint"] == "https://idp.example.com/token"
def test_get_sso_settings_unset_everywhere_reports_source(
self, mock_proxy_config, mock_auth, monkeypatch
):
"""A field set in neither source is unset (or its effective default),
and provenance reports which."""
self._mock_sso_db_record(monkeypatch, None)
for env_var in (
"GENERIC_CLIENT_ID",
"GENERIC_CLIENT_SECRET",
"GENERIC_TOKEN_ENDPOINT",
"GENERIC_SCOPE",
"GOOGLE_CLIENT_ID",
"MICROSOFT_CLIENT_ID",
"PROXY_BASE_URL",
):
monkeypatch.delenv(env_var, raising=False)
response = client.get("/get/sso_settings")
assert response.status_code == 200
body = response.json()
values = body["values"]
provenance = body["provenance"]
assert values["generic_client_id"] is None
assert provenance["generic_client_id"] == "unset"
assert values["generic_client_secret"] is None
assert values["google_client_id"] is None
# generic_scope carries the same effective default the login path applies,
# so the settings page shows the scope logins would actually request.
assert values["generic_scope"] == "openid email profile"
assert provenance["generic_scope"] == "default"
def test_update_sso_settings(self, mock_proxy_config, mock_auth, monkeypatch):
"""Test updating the SSO settings to the dedicated database table"""
import json
from unittest.mock import AsyncMock, MagicMock
monkeypatch.setenv("LITELLM_SALT_KEY", "test_salt_key")
monkeypatch.setattr("litellm.proxy.proxy_server.store_model_in_db", True)
# Mock the prisma client
mock_prisma = MagicMock()
mock_prisma.db.litellm_ssoconfig.find_unique = AsyncMock(return_value=None)
mock_prisma.db.litellm_ssoconfig.upsert = AsyncMock()
mock_prisma.db.litellm_config = MagicMock()
mock_prisma.writer_db.litellm_config.find_unique = AsyncMock(return_value=None)
mock_prisma.db.litellm_config.update = AsyncMock()
monkeypatch.setattr("litellm.proxy.proxy_server.prisma_client", mock_prisma)
# Mock encryption to return values as-is
from litellm.proxy.proxy_server import proxy_config
monkeypatch.setattr(
proxy_config,
"encrypt_env_variables",
lambda environment_variables: environment_variables,
)
# New SSO settings to update
new_sso_settings = {
"google_client_id": "new_google_client_id",
"google_client_secret": "new_google_client_secret",
"microsoft_client_id": "new_microsoft_client_id",
"microsoft_client_secret": "new_microsoft_client_secret",
"proxy_base_url": "https://newexample.com",
"user_email": "[email protected]",
}
response = client.patch("/update/sso_settings", json=new_sso_settings)
assert response.status_code == 200
data = response.json()
# Check response structure
assert data["status"] == "success"
assert "settings" in data
# Verify settings were updated
settings = data["settings"]
assert settings["google_client_id"] == new_sso_settings["google_client_id"]
assert (
settings["google_client_secret"] == new_sso_settings["google_client_secret"]
)
assert (
settings["microsoft_client_id"] == new_sso_settings["microsoft_client_id"]
)
assert (
settings["microsoft_client_secret"]
== new_sso_settings["microsoft_client_secret"]
)
assert settings["proxy_base_url"] == new_sso_settings["proxy_base_url"]
assert settings["user_email"] == new_sso_settings["user_email"]
# Verify upsert was called with correct parameters
assert mock_prisma.db.litellm_ssoconfig.upsert.called
call_args = mock_prisma.db.litellm_ssoconfig.upsert.call_args
# Verify the upsert is using the correct ID
assert call_args.kwargs["where"]["id"] == "sso_config"
# Verify the data structure for create and update
create_data = call_args.kwargs["data"]["create"]
update_data = call_args.kwargs["data"]["update"]
assert create_data["id"] == "sso_config"
assert "sso_settings" in create_data
assert "sso_settings" in update_data
# Verify the data is stored as JSON string (as per implementation)
# The encryption mock returns data as-is, so we verify structure
create_sso_settings = json.loads(create_data["sso_settings"])
assert create_sso_settings["google_client_id"] == "new_google_client_id"
def test_update_sso_settings_maps_saml_fields_to_env_vars(
self, mock_proxy_config, mock_auth, monkeypatch
):
"""SAML settings entered in the admin UI must be applied as the SAML_* env
vars the SAML handler reads, and the allow-unsolicited toggle must map to
the 'true'/'false' string the handler expects."""
import json
import os
from unittest.mock import AsyncMock, MagicMock
monkeypatch.setenv("LITELLM_SALT_KEY", "test_salt_key")
monkeypatch.setattr("litellm.proxy.proxy_server.store_model_in_db", True)
mock_prisma = MagicMock()
mock_prisma.db.litellm_ssoconfig.find_unique = AsyncMock(return_value=None)
mock_prisma.db.litellm_ssoconfig.upsert = AsyncMock()
mock_prisma.db.litellm_config = MagicMock()
mock_prisma.writer_db.litellm_config.find_unique = AsyncMock(return_value=None)
mock_prisma.db.litellm_config.update = AsyncMock()
monkeypatch.setattr("litellm.proxy.proxy_server.prisma_client", mock_prisma)
from litellm.proxy.proxy_server import proxy_config
monkeypatch.setattr(
proxy_config,
"encrypt_env_variables",
lambda environment_variables: environment_variables,
)
for var in (
"SAML_IDP_METADATA_URL",
"SAML_IDP_METADATA_XML",
"SAML_SP_ENTITY_ID",
"SAML_ALLOW_UNSOLICITED",
):
monkeypatch.delenv(var, raising=False)
new_sso_settings = {
"saml_idp_metadata_url": "https://idp.example.com/metadata",
"saml_sp_entity_id": "https://proxy.example.com/sso/saml/metadata",
"saml_allow_unsolicited": "true",
"proxy_base_url": "https://proxy.example.com",
"user_email": "[email protected]",
}
try:
response = client.patch("/update/sso_settings", json=new_sso_settings)
assert response.status_code == 200
assert os.environ.get("SAML_IDP_METADATA_URL") == "https://idp.example.com/metadata"
assert os.environ.get("SAML_SP_ENTITY_ID") == "https://proxy.example.com/sso/saml/metadata"
assert os.environ.get("SAML_ALLOW_UNSOLICITED") == "true"
assert "SAML_IDP_METADATA_XML" not in os.environ
stored = json.loads(
mock_prisma.db.litellm_ssoconfig.upsert.call_args.kwargs["data"]["create"]["sso_settings"]
)
assert stored["saml_idp_metadata_url"] == "https://idp.example.com/metadata"
assert stored["saml_allow_unsolicited"] == "true"
finally:
for var in (
"SAML_IDP_METADATA_URL",
"SAML_IDP_METADATA_XML",
"SAML_SP_ENTITY_ID",
"SAML_ALLOW_UNSOLICITED",
):
os.environ.pop(var, None)
def test_update_sso_settings_audits_when_env_cleanup_fails(
self, mock_proxy_config, mock_auth, monkeypatch
):
import json
from unittest.mock import AsyncMock, MagicMock
monkeypatch.setenv("LITELLM_SALT_KEY", "test_salt_key")
monkeypatch.setattr("litellm.proxy.proxy_server.store_model_in_db", True)
mock_prisma = MagicMock()
mock_prisma.db.litellm_ssoconfig.find_unique = AsyncMock(return_value=None)
mock_prisma.db.litellm_ssoconfig.upsert = AsyncMock()
mock_prisma.db.litellm_config = MagicMock()
mock_prisma.db.litellm_config.find_unique = AsyncMock(
side_effect=ValueError("cleanup failed")
)
mock_prisma.db.litellm_config.update = AsyncMock()
monkeypatch.setattr("litellm.proxy.proxy_server.prisma_client", mock_prisma)
from litellm.proxy.proxy_server import proxy_config
monkeypatch.setattr(
proxy_config,
"encrypt_env_variables",
lambda environment_variables: environment_variables,
)
create_config_audit_log = AsyncMock()
monkeypatch.setattr(
"litellm.proxy.proxy_server.create_config_audit_log",
create_config_audit_log,
)
response = client.patch(
"/update/sso_settings",
json={"google_client_id": "new_google_client_id"},
)
assert response.status_code == 500
assert mock_prisma.db.litellm_ssoconfig.upsert.called
create_config_audit_log.assert_awaited_once()
audit_log_kwargs = create_config_audit_log.await_args.kwargs
assert audit_log_kwargs["param_name"] == "sso_config"
assert (
audit_log_kwargs["after_value"]["google_client_id"]
== "new_google_client_id"
)
assert (
json.loads(
mock_prisma.db.litellm_ssoconfig.upsert.call_args.kwargs["data"][
"create"
]["sso_settings"]
)["google_client_id"]
== "new_google_client_id"
)
def test_update_sso_settings_with_null_values_clears_env_vars(
self, mock_proxy_config, mock_auth, monkeypatch
):
"""Test that updating SSO settings with null values clears environment variables and updates database"""
import json
from unittest.mock import AsyncMock, MagicMock
monkeypatch.setenv("LITELLM_SALT_KEY", "test_salt_key")
monkeypatch.setattr("litellm.proxy.proxy_server.store_model_in_db", True)
# Mock the prisma client
mock_prisma = MagicMock()
mock_prisma.db.litellm_ssoconfig.find_unique = AsyncMock(return_value=None)
mock_prisma.db.litellm_ssoconfig.upsert = AsyncMock()
mock_prisma.db.litellm_config = MagicMock()
env_var_entry = MagicMock()
env_var_entry.param_value = json.dumps(
{
"GOOGLE_CLIENT_ID": "old_google_id",
"MICROSOFT_CLIENT_SECRET": "old_secret",
"PROXY_BASE_URL": "old_proxy_url",
}
)
mock_prisma.writer_db.litellm_config.find_unique = AsyncMock(
return_value=env_var_entry
)
mock_prisma.db.litellm_config.update = AsyncMock()
monkeypatch.setattr("litellm.proxy.proxy_server.prisma_client", mock_prisma)
# Mock encryption to return values as-is
from litellm.proxy.proxy_server import proxy_config
monkeypatch.setattr(
proxy_config,
"encrypt_env_variables",
lambda environment_variables: environment_variables,
)
# Set some initial environment variables for runtime testing
monkeypatch.setenv("GOOGLE_CLIENT_ID", "test_existing_google_id")
monkeypatch.setenv("MICROSOFT_CLIENT_ID", "test_existing_microsoft_id")
# Send SSO settings with null values to clear them
clear_sso_settings = {
"google_client_id": None,
"google_client_secret": None,
"microsoft_client_id": None,
"microsoft_client_secret": None,
"microsoft_tenant": None,
"generic_client_id": None,
"generic_client_secret": None,
"generic_authorization_endpoint": None,
"generic_token_endpoint": None,
"generic_userinfo_endpoint": None,
"proxy_base_url": None,
"user_email": None,
"sso_provider": None,
}
response = client.patch("/update/sso_settings", json=clear_sso_settings)
assert response.status_code == 200
data = response.json()
assert data["status"] == "success"
# Verify that runtime environment variables were cleared
assert "GOOGLE_CLIENT_ID" not in os.environ
assert "MICROSOFT_CLIENT_ID" not in os.environ
# Verify upsert was called with correct parameters
assert mock_prisma.db.litellm_ssoconfig.upsert.called
call_args = mock_prisma.db.litellm_ssoconfig.upsert.call_args
# Verify null values are stored in database
create_data = call_args.kwargs["data"]["create"]
create_sso_settings = json.loads(create_data["sso_settings"])
assert create_sso_settings["google_client_id"] is None
assert create_sso_settings["microsoft_client_id"] is None
def test_update_sso_settings_with_empty_strings_clears_env_vars(
self, mock_proxy_config, mock_auth, monkeypatch
):
"""Test that updating SSO settings with empty strings also clears environment variables and updates database"""
import json
from unittest.mock import AsyncMock, MagicMock
monkeypatch.setenv("LITELLM_SALT_KEY", "test_salt_key")
monkeypatch.setattr("litellm.proxy.proxy_server.store_model_in_db", True)
# Mock the prisma client
mock_prisma = MagicMock()
mock_prisma.db.litellm_ssoconfig.find_unique = AsyncMock(return_value=None)
mock_prisma.db.litellm_ssoconfig.upsert = AsyncMock()
mock_prisma.db.litellm_config = MagicMock()
env_var_entry = MagicMock()
env_var_entry.param_value = json.dumps(
{
"GOOGLE_CLIENT_ID": "old_google_id",
"MICROSOFT_CLIENT_SECRET": "old_secret",
"PROXY_BASE_URL": "old_proxy_url",
}
)
mock_prisma.writer_db.litellm_config.find_unique = AsyncMock(
return_value=env_var_entry
)
mock_prisma.db.litellm_config.update = AsyncMock()
monkeypatch.setattr("litellm.proxy.proxy_server.prisma_client", mock_prisma)
# Mock encryption to return values as-is
from litellm.proxy.proxy_server import proxy_config
monkeypatch.setattr(
proxy_config,
"encrypt_env_variables",
lambda environment_variables: environment_variables,
)
# Set some initial environment variables for runtime testing
monkeypatch.setenv("GOOGLE_CLIENT_ID", "test_existing_google_id")
monkeypatch.setenv("MICROSOFT_CLIENT_SECRET", "test_existing_microsoft_secret")
# Send SSO settings with empty strings to clear them
clear_sso_settings = {
"google_client_id": "",
"google_client_secret": "",
"microsoft_client_secret": "",
"proxy_base_url": "",
"user_email": "",
}
response = client.patch("/update/sso_settings", json=clear_sso_settings)
assert response.status_code == 200
data = response.json()
assert data["status"] == "success"
# Verify that runtime environment variables were cleared
assert "GOOGLE_CLIENT_ID" not in os.environ
assert "MICROSOFT_CLIENT_SECRET" not in os.environ
# Verify upsert was called with correct parameters
assert mock_prisma.db.litellm_ssoconfig.upsert.called
call_args = mock_prisma.db.litellm_ssoconfig.upsert.call_args
# Verify empty strings are stored in database
create_data = call_args.kwargs["data"]["create"]
create_sso_settings = json.loads(create_data["sso_settings"])
assert create_sso_settings["google_client_id"] == ""
assert create_sso_settings["microsoft_client_secret"] == ""
def test_update_sso_settings_mixed_null_and_valid_values(
self, mock_proxy_config, mock_auth, monkeypatch
):
"""Test updating SSO settings with mix of null and valid values - verifies both env vars and database"""
import json
from unittest.mock import AsyncMock, MagicMock
monkeypatch.setenv("LITELLM_SALT_KEY", "test_salt_key")
monkeypatch.setattr("litellm.proxy.proxy_server.store_model_in_db", True)
# Mock the prisma client
mock_prisma = MagicMock()
mock_prisma.db.litellm_ssoconfig.find_unique = AsyncMock(return_value=None)
mock_prisma.db.litellm_ssoconfig.upsert = AsyncMock()
mock_prisma.db.litellm_config = MagicMock()
env_var_entry = MagicMock()
env_var_entry.param_value = json.dumps(
{
"GOOGLE_CLIENT_ID": "test_existing_google_id",
"MICROSOFT_CLIENT_SECRET": "test_existing_microsoft_secret",
}
)
mock_prisma.writer_db.litellm_config.find_unique = AsyncMock(
return_value=env_var_entry
)
mock_prisma.db.litellm_config.update = AsyncMock()
monkeypatch.setattr("litellm.proxy.proxy_server.prisma_client", mock_prisma)
# Mock encryption to return values as-is
from litellm.proxy.proxy_server import proxy_config
monkeypatch.setattr(
proxy_config,
"encrypt_env_variables",
lambda environment_variables: environment_variables,
)
# Set some initial environment variables
monkeypatch.setenv("GOOGLE_CLIENT_ID", "old_google_id")
monkeypatch.setenv("MICROSOFT_CLIENT_ID", "old_microsoft_id")
monkeypatch.setenv("PROXY_BASE_URL", "old_proxy_url")
# Send mixed SSO settings - some null, some valid
mixed_sso_settings = {
"google_client_id": "new_google_client_id", # Valid value
"google_client_secret": None, # Null to clear
"microsoft_client_id": None, # Null to clear
"microsoft_client_secret": "new_microsoft_secret", # Valid value
"proxy_base_url": "https://newproxy.com", # Valid value
"user_email": None, # Null to clear
}
response = client.patch("/update/sso_settings", json=mixed_sso_settings)
assert response.status_code == 200
data = response.json()
assert data["status"] == "success"
# Verify runtime environment variables
assert os.environ.get("GOOGLE_CLIENT_ID") == "new_google_client_id"
assert os.environ.get("MICROSOFT_CLIENT_SECRET") == "new_microsoft_secret"
assert "GOOGLE_CLIENT_SECRET" not in os.environ
assert "MICROSOFT_CLIENT_ID" not in os.environ
# Verify upsert was called with correct parameters
assert mock_prisma.db.litellm_ssoconfig.upsert.called
call_args = mock_prisma.db.litellm_ssoconfig.upsert.call_args
# Verify the mixed values are stored correctly in database
create_data = call_args.kwargs["data"]["create"]
create_sso_settings = json.loads(create_data["sso_settings"])
assert create_sso_settings["google_client_id"] == "new_google_client_id"
assert create_sso_settings["google_client_secret"] is None
assert create_sso_settings["microsoft_client_id"] is None
assert create_sso_settings["microsoft_client_secret"] == "new_microsoft_secret"
assert create_sso_settings["proxy_base_url"] == "https://newproxy.com"
def test_update_sso_settings_ui_access_mode_handling(
self, mock_proxy_config, mock_auth, monkeypatch
):
"""Test that ui_access_mode is handled correctly and stored in database"""
import json
from unittest.mock import AsyncMock, MagicMock
monkeypatch.setenv("LITELLM_SALT_KEY", "test_salt_key")
monkeypatch.setattr("litellm.proxy.proxy_server.store_model_in_db", True)
# Mock the prisma client
mock_prisma = MagicMock()
mock_prisma.db.litellm_ssoconfig.find_unique = AsyncMock(return_value=None)
mock_prisma.db.litellm_ssoconfig.upsert = AsyncMock()
mock_prisma.db.litellm_config = MagicMock()
mock_prisma.writer_db.litellm_config.find_unique = AsyncMock(return_value=None)
mock_prisma.db.litellm_config.update = AsyncMock()
monkeypatch.setattr("litellm.proxy.proxy_server.prisma_client", mock_prisma)
# Mock encryption to return values as-is
from litellm.proxy.proxy_server import proxy_config
monkeypatch.setattr(
proxy_config,
"encrypt_env_variables",
lambda environment_variables: environment_variables,
)
# Test setting ui_access_mode
sso_settings_with_ui_mode = {
"ui_access_mode": "admin_only",
"user_email": "[email protected]",
}
response = client.patch("/update/sso_settings", json=sso_settings_with_ui_mode)
assert response.status_code == 200
data = response.json()
assert data["status"] == "success"
# Verify upsert was called with correct data
assert mock_prisma.db.litellm_ssoconfig.upsert.called
call_args = mock_prisma.db.litellm_ssoconfig.upsert.call_args
create_data = call_args.kwargs["data"]["create"]
create_sso_settings = json.loads(create_data["sso_settings"])
assert create_sso_settings["ui_access_mode"] == "admin_only"
assert create_sso_settings["user_email"] == "[email protected]"
# Test clearing ui_access_mode
clear_ui_mode = {"ui_access_mode": None, "user_email": None}
response = client.patch("/update/sso_settings", json=clear_ui_mode)
assert response.status_code == 200
# Verify upsert was called again with null values
assert mock_prisma.db.litellm_ssoconfig.upsert.call_count == 2
call_args = mock_prisma.db.litellm_ssoconfig.upsert.call_args
create_data = call_args.kwargs["data"]["create"]
create_sso_settings = json.loads(create_data["sso_settings"])
assert create_sso_settings["ui_access_mode"] is None
assert create_sso_settings["user_email"] is None
def test_get_ui_theme_settings(self, mock_proxy_config):
"""Test getting UI theme settings without authentication"""
response = client.get("/get/ui_theme_settings")
assert response.status_code == 200
data = response.json()
assert "values" in data
assert "field_schema" in data
def test_update_ui_theme_settings(self, mock_proxy_config, mock_auth, monkeypatch):
"""Test updating UI theme settings"""
monkeypatch.setenv("LITELLM_SALT_KEY", "test_salt_key")
monkeypatch.setattr("litellm.proxy.proxy_server.store_model_in_db", True)
new_theme = {"logo_url": "https://example.com/new-logo.png"}
response = client.patch("/update/ui_theme_settings", json=new_theme)
assert response.status_code == 200
data = response.json()
assert data["status"] == "success"
assert data["theme_config"]["logo_url"] == "https://example.com/new-logo.png"
# The logo path is applied to the live process immediately
assert os.environ["UI_LOGO_PATH"] == "https://example.com/new-logo.png"
assert mock_proxy_config["save_call_count"]() == 1
# env vars are persisted through the dedicated per-key path, and ONLY
# the keys this endpoint owns are touched. The unrelated SSO env
# vars in the merged config are never snapshotted.
env_updates = mock_proxy_config["env_updates"]()
assert env_updates == [
{
"UI_LOGO_PATH": "https://example.com/new-logo.png",
"UI_LOGO_PATH_DARK": None,
"LITELLM_FAVICON_URL": None,
}
]
def test_update_ui_theme_settings_with_favicon(
self, mock_proxy_config, mock_auth, monkeypatch
):
"""Test updating UI theme settings with favicon_url"""
monkeypatch.setenv("LITELLM_SALT_KEY", "test_salt_key")
monkeypatch.setattr("litellm.proxy.proxy_server.store_model_in_db", True)
new_theme = {
"logo_url": "https://example.com/new-logo.png",
"favicon_url": "https://example.com/custom-favicon.ico",
}
response = client.patch("/update/ui_theme_settings", json=new_theme)
assert response.status_code == 200
data = response.json()
assert data["status"] == "success"
assert data["theme_config"]["logo_url"] == "https://example.com/new-logo.png"
assert (
data["theme_config"]["favicon_url"]
== "https://example.com/custom-favicon.ico"
)
assert os.environ["UI_LOGO_PATH"] == "https://example.com/new-logo.png"
assert os.environ["LITELLM_FAVICON_URL"] == "https://example.com/custom-favicon.ico"
# Only the owned keys are persisted, each with its new value
assert mock_proxy_config["env_updates"]() == [
{
"UI_LOGO_PATH": "https://example.com/new-logo.png",
"UI_LOGO_PATH_DARK": None,
"LITELLM_FAVICON_URL": "https://example.com/custom-favicon.ico",
}
]
def test_update_ui_theme_settings_with_dark_logo(
self, mock_proxy_config, mock_auth, monkeypatch
):
"""A dark-mode logo is stored and applied to the live process like the light one."""
monkeypatch.setenv("LITELLM_SALT_KEY", "test_salt_key")
monkeypatch.setattr("litellm.proxy.proxy_server.store_model_in_db", True)
new_theme = {
"logo_url": "https://example.com/logo.png",
"logo_url_dark": "https://example.com/logo-dark.png",
}
response = client.patch("/update/ui_theme_settings", json=new_theme)
assert response.status_code == 200
assert response.json()["theme_config"]["logo_url_dark"] == "https://example.com/logo-dark.png"
assert os.environ["UI_LOGO_PATH_DARK"] == "https://example.com/logo-dark.png"
assert mock_proxy_config["env_updates"]() == [
{
"UI_LOGO_PATH": "https://example.com/logo.png",
"UI_LOGO_PATH_DARK": "https://example.com/logo-dark.png",
"LITELLM_FAVICON_URL": None,
}
]
def test_update_ui_theme_settings_rejects_local_path_dark_logo(
self, mock_proxy_config, mock_auth, monkeypatch
):
"""The dark logo is served by the unauthenticated /get_image, so a local
filesystem path must be refused exactly as it is for the light logo."""
monkeypatch.setenv("LITELLM_SALT_KEY", "test_salt_key")
monkeypatch.setattr("litellm.proxy.proxy_server.store_model_in_db", True)
response = client.patch(
"/update/ui_theme_settings",
json={"logo_url_dark": "/etc/passwd"},
)
assert response.status_code == 400
assert "logo_url_dark" in str(response.json())
def test_update_ui_theme_settings_persists_every_env_var_it_resolves(
self, mock_proxy_config, mock_auth, monkeypatch
):
"""Read and write must cover the same env vars.
/get/ui_theme_settings resolves each field through _UI_THEME_FIELD_ENV_VARS,
so a var missing from the update path would read back from an env value the
save never cleared, and the settings page would show a field it cannot unset.
"""
from litellm.proxy.ui_crud_endpoints.proxy_setting_endpoints import (
_UI_THEME_FIELD_ENV_VARS,
)
monkeypatch.setenv("LITELLM_SALT_KEY", "test_salt_key")
monkeypatch.setattr("litellm.proxy.proxy_server.store_model_in_db", True)
response = client.patch("/update/ui_theme_settings", json={})
assert response.status_code == 200
persisted = mock_proxy_config["env_updates"]()
assert len(persisted) == 1
assert set(persisted[0]) == set(_UI_THEME_FIELD_ENV_VARS.values())
def test_get_ui_theme_settings_surfaces_dark_logo_from_process_env(
self, mock_proxy_config, monkeypatch
):
"""A dark logo supplied only as a process env var must surface in the read."""
monkeypatch.setenv("UI_LOGO_PATH_DARK", "https://cdn.example.com/logo-dark.png")
response = client.get("/get/ui_theme_settings")
assert response.status_code == 200
assert response.json()["values"]["logo_url_dark"] == "https://cdn.example.com/logo-dark.png"
def test_update_ui_theme_settings_clear_favicon(
self, mock_proxy_config, mock_auth, monkeypatch
):
"""Test clearing favicon_url from UI theme settings"""
monkeypatch.setenv("LITELLM_SALT_KEY", "test_salt_key")
monkeypatch.setattr("litellm.proxy.proxy_server.store_model_in_db", True)
new_theme = {
"favicon_url": "https://example.com/custom-favicon.ico",
}
response = client.patch("/update/ui_theme_settings", json=new_theme)
assert response.status_code == 200
clear_theme = {"favicon_url": None}
response = client.patch("/update/ui_theme_settings", json=clear_theme)
assert response.status_code == 200
data = response.json()
assert data["status"] == "success"
assert "LITELLM_FAVICON_URL" not in os.environ
def test_get_ui_theme_settings_includes_favicon_schema(self, mock_proxy_config):
"""Test UI theme settings includes favicon_url in schema"""
response = client.get("/get/ui_theme_settings")
assert response.status_code == 200
data = response.json()
assert "values" in data
assert "field_schema" in data
assert "properties" in data["field_schema"]
assert "favicon_url" in data["field_schema"]["properties"]
assert "description" in data["field_schema"]["properties"]["favicon_url"]
def test_get_ui_theme_settings_with_favicon_configured(self, mock_proxy_config):
"""Test getting UI theme settings when favicon is configured"""
mock_proxy_config["config"]["litellm_settings"]["ui_theme_config"] = {
"logo_url": "https://example.com/logo.png",
"favicon_url": "https://example.com/favicon.ico",
}
response = client.get("/get/ui_theme_settings")
assert response.status_code == 200
data = response.json()
assert data["values"]["logo_url"] == "https://example.com/logo.png"
assert data["values"]["favicon_url"] == "https://example.com/favicon.ico"
def test_get_ui_theme_settings_falls_back_to_process_env(
self, mock_proxy_config, monkeypatch
):
"""Branding supplied only as process env vars must surface in the read.
A deployment that sets UI_LOGO_PATH / LITELLM_FAVICON_URL via IaC and
never touches the UI has no stored ui_theme_config, yet the branding is
live, so the settings page must reflect it rather than reading blank.
"""
monkeypatch.delenv("UI_LOGO_PATH", raising=False)
monkeypatch.delenv("LITELLM_FAVICON_URL", raising=False)
monkeypatch.setenv("UI_LOGO_PATH", "https://cdn.example.com/logo.png")
monkeypatch.setenv("LITELLM_FAVICON_URL", "https://cdn.example.com/favicon.ico")
response = client.get("/get/ui_theme_settings")
assert response.status_code == 200
values = response.json()["values"]
assert values["logo_url"] == "https://cdn.example.com/logo.png"
assert values["favicon_url"] == "https://cdn.example.com/favicon.ico"
def test_get_ui_theme_settings_stored_value_wins_over_env(
self, mock_auth, monkeypatch
):
"""A stored ui_theme_config field outranks the env var for that field.
The env fallback only fills fields the stored config leaves blank, so the
UI-driven flow is unchanged while an unstored field still resolves.
"""
from litellm.proxy.proxy_server import proxy_config
stored_config = {
"litellm_settings": {
"ui_theme_config": {"logo_url": "https://db.example.com/logo.png"}
}
}
async def mock_get_config():
return stored_config
monkeypatch.setattr(proxy_config, "get_config", mock_get_config)
monkeypatch.setenv("UI_LOGO_PATH", "https://env.example.com/logo.png")
monkeypatch.setenv("LITELLM_FAVICON_URL", "https://env.example.com/favicon.ico")
response = client.get("/get/ui_theme_settings")
assert response.status_code == 200
values = response.json()["values"]
assert values["logo_url"] == "https://db.example.com/logo.png"
assert values["favicon_url"] == "https://env.example.com/favicon.ico"
def test_get_ui_theme_settings_reports_unset_when_absent_everywhere(
self, mock_proxy_config, monkeypatch
):
"""A field set in neither the stored config nor the env stays null."""
monkeypatch.delenv("UI_LOGO_PATH", raising=False)
monkeypatch.delenv("LITELLM_FAVICON_URL", raising=False)
response = client.get("/get/ui_theme_settings")
assert response.status_code == 200
values = response.json()["values"]
assert values["logo_url"] is None
assert values["favicon_url"] is None
def test_get_ui_theme_settings_does_not_disclose_local_path_env_value(
self, mock_proxy_config, monkeypatch
):
"""This endpoint is public, so an env-configured local filesystem branding
path must never be surfaced to anonymous callers; only public http(s) URLs.
"""
monkeypatch.setenv("UI_LOGO_PATH", "/mnt/secret/internal/logo.png")
monkeypatch.setenv("LITELLM_FAVICON_URL", "file:///etc/favicon.ico")
response = client.get("/get/ui_theme_settings")
assert response.status_code == 200
values = response.json()["values"]
# the local path / file scheme is withheld rather than disclosed
assert values["logo_url"] is None
assert values["favicon_url"] is None
def test_get_ui_settings(self, mock_auth, monkeypatch):
"""Test retrieving UI settings with allowlist sanitization"""
from unittest.mock import AsyncMock, MagicMock
mock_prisma = MagicMock()
mock_db_record = MagicMock()
mock_db_record.ui_settings = {
"disable_model_add_for_internal_users": True,
"require_auth_for_public_ai_hub": True,
"unexpected_flag": True,
}
mock_prisma.db.litellm_uisettings.find_unique = AsyncMock(
return_value=mock_db_record
)
monkeypatch.setattr("litellm.proxy.proxy_server.prisma_client", mock_prisma)
response = client.get("/get/ui_settings")
assert response.status_code == 200
data = response.json()
assert data["values"]["disable_model_add_for_internal_users"] is True
assert data["values"]["require_auth_for_public_ai_hub"] is True
assert "unexpected_flag" not in data["values"]
assert (
"disable_model_add_for_internal_users" in data["field_schema"]["properties"]
)
assert "require_auth_for_public_ai_hub" in data["field_schema"]["properties"]
mock_prisma.db.litellm_uisettings.find_unique.assert_called_once_with(
where={"id": "ui_settings"}
)
def test_get_ui_settings_reports_sources(self, monkeypatch: pytest.MonkeyPatch) -> None:
from unittest.mock import AsyncMock, MagicMock
from litellm.proxy import proxy_server
from litellm.proxy.config_resolvers import SettingsStore
mock_prisma = MagicMock()
mock_db_record = MagicMock()
mock_db_record.ui_settings = {
"disable_model_add_for_internal_users": True,
"require_auth_for_public_ai_hub": True,
}
mock_prisma.db.litellm_uisettings.find_unique = AsyncMock(
return_value=mock_db_record
)
monkeypatch.setattr(proxy_server, "prisma_client", mock_prisma)
store = SettingsStore("general_settings")
store.load_yaml(
{
"disable_model_add_for_internal_users": False,
"forward_client_headers_to_llm_api": True,
}
)
store.apply_db_row(
"ui_settings",
{"disable_model_add_for_internal_users": True},
)
monkeypatch.setattr(proxy_server.proxy_config, "settings", store)
monkeypatch.setattr(proxy_server, "general_settings", store)
response = client.get("/get/ui_settings")
assert response.status_code == 200
data = response.json()
assert data["values"]["disable_model_add_for_internal_users"] is False
assert data["values"]["forward_client_headers_to_llm_api"] is True
assert data["values"]["require_auth_for_public_ai_hub"] is True
assert data["source"]["disable_model_add_for_internal_users"] == "config"
assert data["source"]["forward_client_headers_to_llm_api"] == "config"
assert data["source"]["require_auth_for_public_ai_hub"] == "db"
def test_get_ui_settings_schema_description_preserved_with_extensions(
self, mock_auth, monkeypatch
):
"""The UI renders ``schema.description`` as a header paragraph.
When an extension package registers extra fields, the effective
class is built via ``create_model`` — which drops the base
class docstring unless we pass ``__doc__`` explicitly."""
from unittest.mock import AsyncMock, MagicMock
from pydantic.fields import FieldInfo
from litellm.proxy.ui_crud_endpoints import proxy_setting_endpoints
from litellm.proxy.ui_crud_endpoints.proxy_setting_endpoints import (
_EXTRA_UI_SETTINGS_FIELDS,
ALLOWED_UI_SETTINGS_FIELDS,
register_extra_ui_setting,
)
# Snapshot + restore extension registry so the test doesn't leak.
original_fields = dict(_EXTRA_UI_SETTINGS_FIELDS)
original_allowed = set(ALLOWED_UI_SETTINGS_FIELDS)
monkeypatch.setattr(
proxy_setting_endpoints, "_EFFECTIVE_UI_SETTINGS_CLASS", None
)
try:
register_extra_ui_setting(
"test_extension_flag", bool, FieldInfo(default=False)
)
mock_prisma = MagicMock()
mock_prisma.db.litellm_uisettings.find_unique = AsyncMock(return_value=None)
monkeypatch.setattr("litellm.proxy.proxy_server.prisma_client", mock_prisma)
response = client.get("/get/ui_settings")
assert response.status_code == 200
data = response.json()
assert (
data["field_schema"]["description"]
== "Configuration for UI-specific flags"
)
finally:
_EXTRA_UI_SETTINGS_FIELDS.clear()
_EXTRA_UI_SETTINGS_FIELDS.update(original_fields)
ALLOWED_UI_SETTINGS_FIELDS.clear()
ALLOWED_UI_SETTINGS_FIELDS.update(original_allowed)
proxy_setting_endpoints._EFFECTIVE_UI_SETTINGS_CLASS = None
@pytest.mark.parametrize(
"user_role",
[
LitellmUserRoles.INTERNAL_USER,
LitellmUserRoles.INTERNAL_USER_VIEW_ONLY,
],
)
def test_get_ui_settings_allows_internal_roles(self, monkeypatch, user_role):
"""Ensure internal users and viewers can fetch UI settings"""
from unittest.mock import AsyncMock, MagicMock
from litellm.proxy.ui_crud_endpoints import proxy_setting_endpoints
mock_prisma = MagicMock()
mock_db_record = MagicMock()
mock_db_record.ui_settings = {"disable_model_add_for_internal_users": False}
mock_prisma.db.litellm_uisettings.find_unique = AsyncMock(
return_value=mock_db_record
)
monkeypatch.setattr("litellm.proxy.proxy_server.prisma_client", mock_prisma)
class MockUser:
def __init__(self, role):
self.user_role = role
self.team_id = "litellm-dashboard"
self.allowed_routes = []
async def mock_user_api_key_auth():
return MockUser(user_role)
app.dependency_overrides[proxy_setting_endpoints.user_api_key_auth] = (
mock_user_api_key_auth
)
try:
response = client.get("/get/ui_settings")
finally:
app.dependency_overrides.pop(
proxy_setting_endpoints.user_api_key_auth, None
)
assert response.status_code == 200
data = response.json()
assert data["values"]["disable_model_add_for_internal_users"] is False
mock_prisma.db.litellm_uisettings.find_unique.assert_called_once_with(
where={"id": "ui_settings"}
)
def test_update_ui_settings_allowlisted_value(self, mock_auth, monkeypatch):
"""Test updating UI settings with an allowlisted field"""
from unittest.mock import AsyncMock, MagicMock
from litellm.proxy._types import UserAPIKeyAuth
from litellm.proxy.auth.user_api_key_auth import user_api_key_auth
# Override the FastAPI dependency with a proper mock
mock_user_auth = UserAPIKeyAuth(
user_id="test-user-123",
user_role=LitellmUserRoles.PROXY_ADMIN,
)
app.dependency_overrides[user_api_key_auth] = lambda: mock_user_auth
monkeypatch.setattr("litellm.proxy.proxy_server.store_model_in_db", True)
mock_prisma = MagicMock()
mock_prisma.db.litellm_uisettings.upsert = AsyncMock()
mock_prisma.db.litellm_uisettings.find_unique = AsyncMock(return_value=None)
monkeypatch.setattr("litellm.proxy.proxy_server.prisma_client", mock_prisma)
payload = {"disable_model_add_for_internal_users": True}
try:
response = client.patch("/update/ui_settings", json=payload)
finally:
# Clean up the dependency override
app.dependency_overrides.clear()
assert response.status_code == 200
data = response.json()
assert data["status"] == "success"
assert data["settings"]["disable_model_add_for_internal_users"] is True
assert mock_prisma.db.litellm_uisettings.upsert.called
call_args = mock_prisma.db.litellm_uisettings.upsert.call_args
assert call_args.kwargs["where"]["id"] == "ui_settings"
create_data = call_args.kwargs["data"]["create"]
stored_settings = json.loads(create_data["ui_settings"])
assert stored_settings["disable_model_add_for_internal_users"] is True
def test_update_ui_settings_ignores_non_allowlisted_value(
self, mock_auth, monkeypatch
):
"""Test non-allowlisted UI settings are ignored on update"""
from unittest.mock import AsyncMock, MagicMock
from litellm.proxy._types import UserAPIKeyAuth
from litellm.proxy.auth.user_api_key_auth import user_api_key_auth
# Override the FastAPI dependency with a proper mock
mock_user_auth = UserAPIKeyAuth(
user_id="test-user-123",
user_role=LitellmUserRoles.PROXY_ADMIN,
)
app.dependency_overrides[user_api_key_auth] = lambda: mock_user_auth
monkeypatch.setattr("litellm.proxy.proxy_server.store_model_in_db", True)
mock_prisma = MagicMock()
mock_prisma.db.litellm_uisettings.upsert = AsyncMock()
mock_prisma.db.litellm_uisettings.find_unique = AsyncMock(return_value=None)
monkeypatch.setattr("litellm.proxy.proxy_server.prisma_client", mock_prisma)
payload = {
"disable_model_add_for_internal_users": False,
"unsupported_flag": True,
}
try:
response = client.patch("/update/ui_settings", json=payload)
finally:
# Clean up the dependency override
app.dependency_overrides.clear()
assert response.status_code == 200
data = response.json()
assert data["status"] == "success"
assert "unsupported_flag" not in data["settings"]
assert data["settings"]["disable_model_add_for_internal_users"] is False
assert mock_prisma.db.litellm_uisettings.upsert.called
call_args = mock_prisma.db.litellm_uisettings.upsert.call_args
stored_settings = json.loads(call_args.kwargs["data"]["create"]["ui_settings"])
assert "unsupported_flag" not in stored_settings
assert stored_settings["disable_model_add_for_internal_users"] is False
def test_update_ui_settings_preserves_public_ai_hub_auth_flag(
self, mock_auth, monkeypatch
):
"""Public AI Hub auth is an existing UI setting and must remain writable."""
from unittest.mock import AsyncMock, MagicMock
from litellm.proxy._types import UserAPIKeyAuth
from litellm.proxy.auth.user_api_key_auth import user_api_key_auth
mock_user_auth = UserAPIKeyAuth(
user_id="test-user-123",
user_role=LitellmUserRoles.PROXY_ADMIN,
)
app.dependency_overrides[user_api_key_auth] = lambda: mock_user_auth
monkeypatch.setattr("litellm.proxy.proxy_server.store_model_in_db", True)
mock_prisma = MagicMock()
mock_prisma.db.litellm_uisettings.upsert = AsyncMock()
mock_prisma.db.litellm_uisettings.find_unique = AsyncMock(return_value=None)
monkeypatch.setattr("litellm.proxy.proxy_server.prisma_client", mock_prisma)
payload = {"require_auth_for_public_ai_hub": True}
try:
response = client.patch("/update/ui_settings", json=payload)
finally:
app.dependency_overrides.clear()
assert response.status_code == 200
data = response.json()
assert data["status"] == "success"
assert data["settings"]["require_auth_for_public_ai_hub"] is True
call_args = mock_prisma.db.litellm_uisettings.upsert.call_args
stored_settings = json.loads(call_args.kwargs["data"]["create"]["ui_settings"])
assert stored_settings["require_auth_for_public_ai_hub"] is True
def test_update_ui_settings_persists_forward_llm_provider_auth_headers(
self, mock_auth, monkeypatch
):
"""BYOK flag must be allowlisted and persisted to litellm_uisettings."""
from unittest.mock import AsyncMock, MagicMock
from litellm.proxy._types import UserAPIKeyAuth
from litellm.proxy.auth.user_api_key_auth import user_api_key_auth
mock_user_auth = UserAPIKeyAuth(
user_id="test-user-123",
user_role=LitellmUserRoles.PROXY_ADMIN,
)
app.dependency_overrides[user_api_key_auth] = lambda: mock_user_auth
monkeypatch.setattr("litellm.proxy.proxy_server.store_model_in_db", True)
mock_prisma = MagicMock()
mock_prisma.db.litellm_uisettings.upsert = AsyncMock()
mock_prisma.db.litellm_uisettings.find_unique = AsyncMock(return_value=None)
monkeypatch.setattr("litellm.proxy.proxy_server.prisma_client", mock_prisma)
payload = {"forward_llm_provider_auth_headers": True}
try:
response = client.patch("/update/ui_settings", json=payload)
finally:
app.dependency_overrides.clear()
assert response.status_code == 200
data = response.json()
assert data["status"] == "success"
assert data["settings"]["forward_llm_provider_auth_headers"] is True
assert mock_prisma.db.litellm_uisettings.upsert.called
call_args = mock_prisma.db.litellm_uisettings.upsert.call_args
create_data = call_args.kwargs["data"]["create"]
stored_settings = json.loads(create_data["ui_settings"])
assert stored_settings["forward_llm_provider_auth_headers"] is True
def test_update_ui_settings_syncs_forward_llm_provider_auth_headers_to_general_settings(
self, mock_auth, monkeypatch
):
"""BYOK flag must be synced into general_settings dict so the request path sees it."""
from unittest.mock import AsyncMock, MagicMock
from litellm.proxy._types import UserAPIKeyAuth
from litellm.proxy.auth.user_api_key_auth import user_api_key_auth
mock_user_auth = UserAPIKeyAuth(
user_id="test-user-123",
user_role=LitellmUserRoles.PROXY_ADMIN,
)
app.dependency_overrides[user_api_key_auth] = lambda: mock_user_auth
monkeypatch.setattr("litellm.proxy.proxy_server.store_model_in_db", True)
# Reset general_settings so the test is hermetic
general_settings: dict = {}
monkeypatch.setattr(
"litellm.proxy.proxy_server.general_settings", general_settings
)
mock_prisma = MagicMock()
mock_prisma.db.litellm_uisettings.upsert = AsyncMock()
mock_prisma.db.litellm_uisettings.find_unique = AsyncMock(return_value=None)
monkeypatch.setattr("litellm.proxy.proxy_server.prisma_client", mock_prisma)
payload = {"forward_llm_provider_auth_headers": True}
try:
response = client.patch("/update/ui_settings", json=payload)
finally:
app.dependency_overrides.clear()
assert response.status_code == 200
assert general_settings.get("forward_llm_provider_auth_headers") is True
def test_update_ui_settings_syncs_public_health_readiness_details_to_general_settings(
self, mock_auth, monkeypatch
):
"""Public readiness details flag must be synced so the health route sees it."""
from unittest.mock import AsyncMock, MagicMock
from litellm.proxy._types import UserAPIKeyAuth
from litellm.proxy.auth.user_api_key_auth import user_api_key_auth
mock_user_auth = UserAPIKeyAuth(
user_id="test-user-123",
user_role=LitellmUserRoles.PROXY_ADMIN,
)
app.dependency_overrides[user_api_key_auth] = lambda: mock_user_auth
monkeypatch.setattr("litellm.proxy.proxy_server.store_model_in_db", True)
general_settings: dict = {}
monkeypatch.setattr(
"litellm.proxy.proxy_server.general_settings", general_settings
)
mock_prisma = MagicMock()
mock_prisma.db.litellm_uisettings.upsert = AsyncMock()
mock_prisma.db.litellm_uisettings.find_unique = AsyncMock(return_value=None)
monkeypatch.setattr("litellm.proxy.proxy_server.prisma_client", mock_prisma)
payload = {"allow_public_health_readiness_details": True}
try:
response = client.patch("/update/ui_settings", json=payload)
finally:
app.dependency_overrides.clear()
assert response.status_code == 200
assert general_settings.get("allow_public_health_readiness_details") is True
def test_update_ui_settings_persists_and_syncs_disable_key_generate_for_org_admin(
self, mock_auth, monkeypatch
):
"""disable_key_generate_for_org_admin must be allowlisted, persisted, and synced to general_settings."""
from unittest.mock import AsyncMock, MagicMock
from litellm.proxy._types import UserAPIKeyAuth
from litellm.proxy.auth.user_api_key_auth import user_api_key_auth
mock_user_auth = UserAPIKeyAuth(
user_id="test-user-123",
user_role=LitellmUserRoles.PROXY_ADMIN,
)
app.dependency_overrides[user_api_key_auth] = lambda: mock_user_auth
monkeypatch.setattr("litellm.proxy.proxy_server.store_model_in_db", True)
general_settings: dict = {}
monkeypatch.setattr(
"litellm.proxy.proxy_server.general_settings", general_settings
)
mock_prisma = MagicMock()
mock_prisma.db.litellm_uisettings.upsert = AsyncMock()
mock_prisma.db.litellm_uisettings.find_unique = AsyncMock(return_value=None)
monkeypatch.setattr("litellm.proxy.proxy_server.prisma_client", mock_prisma)
flag_name = "disable_key_generate_for_org_admin"
payload = {flag_name: True}
try:
response = client.patch("/update/ui_settings", json=payload)
finally:
app.dependency_overrides.clear()
assert response.status_code == 200
data = response.json()
assert data["settings"][flag_name] is True
# Persisted in DB
call_args = mock_prisma.db.litellm_uisettings.upsert.call_args
stored_settings = json.loads(call_args.kwargs["data"]["create"]["ui_settings"])
assert stored_settings[flag_name] is True
# Synced into general_settings so the enforcement helper sees it
assert general_settings.get(flag_name) is True
def test_get_sso_settings_from_database(
self, mock_proxy_config, mock_auth, monkeypatch
):
"""Test getting SSO settings from the dedicated database table"""
import json
from unittest.mock import AsyncMock, MagicMock
# Mock the prisma client
mock_prisma = MagicMock()
mock_db_record = MagicMock()
# Simulate encrypted data from database
mock_sso_settings = {
"google_client_id": "encrypted_google_id",
"google_client_secret": "encrypted_google_secret",
"microsoft_client_id": "encrypted_microsoft_id",
"proxy_base_url": "encrypted_proxy_url",
}
mock_db_record.sso_settings = mock_sso_settings
mock_prisma.db.litellm_ssoconfig.find_unique = AsyncMock(
return_value=mock_db_record
)
monkeypatch.setattr("litellm.proxy.proxy_server.prisma_client", mock_prisma)
# The resolver decrypts each stored value via decrypt_value_helper; map
# the ciphertext fixtures to their plaintext.
decrypted_by_ciphertext = {
"encrypted_google_id": "decrypted_google_id",
"encrypted_google_secret": "decrypted_google_secret",
"encrypted_microsoft_id": "decrypted_microsoft_id",
"encrypted_proxy_url": "https://decrypted.example.com",
}
def mock_decrypt(value, key, exception_type="error", return_original_value=False):
return decrypted_by_ciphertext.get(value, value)
monkeypatch.setattr(
"litellm.proxy.config_resolvers.sso.decrypt_value_helper", mock_decrypt
)
response = client.get("/get/sso_settings")
assert response.status_code == 200
data = response.json()
# Verify structure
assert "values" in data
assert "field_schema" in data
# Verify decrypted values are returned. OAuth client secrets are
# masked on read so plaintext is never sent to the UI.
values = data["values"]
assert values["google_client_id"] == "decrypted_google_id"
assert values["google_client_secret"] != "decrypted_google_secret"
assert "*" in values["google_client_secret"]
assert values["microsoft_client_id"] == "decrypted_microsoft_id"
assert values["proxy_base_url"] == "https://decrypted.example.com"
# Verify role_mappings is present in response (can be None if not set)
assert "role_mappings" in values
assert values["role_mappings"] is None
def test_update_sso_settings_to_database(
self, mock_proxy_config, mock_auth, monkeypatch
):
"""Test updating SSO settings saves to the dedicated database table"""
import json
from unittest.mock import AsyncMock, MagicMock
monkeypatch.setenv("LITELLM_SALT_KEY", "test_salt_key")
# Mock the prisma client
mock_prisma = MagicMock()
upsert_mock = AsyncMock()
mock_prisma.db.litellm_ssoconfig.find_unique = AsyncMock(return_value=None)
mock_prisma.db.litellm_ssoconfig.upsert = upsert_mock
mock_prisma.db.litellm_config = MagicMock()
mock_prisma.writer_db.litellm_config.find_unique = AsyncMock(return_value=None)
mock_prisma.db.litellm_config.update = AsyncMock()
monkeypatch.setattr("litellm.proxy.proxy_server.prisma_client", mock_prisma)
monkeypatch.setattr("litellm.proxy.proxy_server.store_model_in_db", True)
# Track what was encrypted
encrypted_data = {}
def mock_encrypt(environment_variables):
# Simulate encryption by adding prefix
encrypted = {
k: f"encrypted_{v}" if v else v
for k, v in environment_variables.items()
}
encrypted_data.update(encrypted)
return encrypted
from litellm.proxy.proxy_server import proxy_config
monkeypatch.setattr(proxy_config, "encrypt_env_variables", mock_encrypt)
# New SSO settings to save
new_sso_settings = {
"google_client_id": "new_google_id",
"google_client_secret": "new_google_secret",
"microsoft_client_id": "new_microsoft_id",
"proxy_base_url": "https://new.example.com",
}
response = client.patch("/update/sso_settings", json=new_sso_settings)
assert response.status_code == 200
data = response.json()
assert data["status"] == "success"
assert data["settings"]["google_client_id"] == "new_google_id"
# Verify upsert was called
assert upsert_mock.called
call_args = upsert_mock.call_args
# Verify it's using the correct ID
assert call_args.kwargs["where"]["id"] == "sso_config"
# Verify encrypted data was saved
create_data = call_args.kwargs["data"]["create"]
update_data = call_args.kwargs["data"]["update"]
assert create_data["id"] == "sso_config"
# The sso_settings should be JSON string of encrypted data
assert "sso_settings" in create_data
assert "sso_settings" in update_data
# Verify the encrypted data is correctly stored
create_sso_settings = json.loads(create_data["sso_settings"])
assert create_sso_settings["google_client_id"] == "encrypted_new_google_id"
assert (
create_sso_settings["google_client_secret"] == "encrypted_new_google_secret"
)
assert (
create_sso_settings["proxy_base_url"] == "encrypted_https://new.example.com"
)
def test_update_sso_settings_removes_sso_env_vars_from_config(
self, mock_proxy_config, mock_auth, monkeypatch
):
"""Ensure SSO-related env vars are deleted from stored config"""
import json
from unittest.mock import AsyncMock, MagicMock
monkeypatch.setenv("LITELLM_SALT_KEY", "test_salt_key")
monkeypatch.setattr("litellm.proxy.proxy_server.store_model_in_db", True)
mock_prisma = MagicMock()
mock_prisma.db = MagicMock()
mock_prisma.db.litellm_ssoconfig = MagicMock()
mock_prisma.db.litellm_ssoconfig.find_unique = AsyncMock(return_value=None)
mock_prisma.db.litellm_ssoconfig.upsert = AsyncMock()
env_var_entry = MagicMock()
env_var_entry.param_value = json.dumps(
{
"GOOGLE_CLIENT_ID": "old_google_id",
"GENERIC_TOKEN_ENDPOINT": "old_endpoint",
"UNCHANGED_ENV": "keep_me",
}
)
mock_prisma.db.litellm_config = MagicMock()
mock_prisma.writer_db.litellm_config.find_unique = AsyncMock(
return_value=env_var_entry
)
mock_prisma.db.litellm_config.update = AsyncMock()
monkeypatch.setattr("litellm.proxy.proxy_server.prisma_client", mock_prisma)
from litellm.proxy.proxy_server import proxy_config
monkeypatch.setattr(
proxy_config,
"encrypt_env_variables",
lambda environment_variables: environment_variables,
)
response = client.patch(
"/update/sso_settings", json={"google_client_id": "new_google_id"}
)
assert response.status_code == 200
mock_prisma.writer_db.litellm_config.find_unique.assert_called_once()
mock_prisma.db.litellm_config.update.assert_called_once()
update_call = mock_prisma.db.litellm_config.update.call_args
updated_env_vars = json.loads(update_call.kwargs["data"]["param_value"])
assert "GOOGLE_CLIENT_ID" not in updated_env_vars
assert "GENERIC_TOKEN_ENDPOINT" not in updated_env_vars
assert updated_env_vars["UNCHANGED_ENV"] == "keep_me"
def test_update_sso_settings_preserves_non_sso_env_vars(
self, mock_proxy_config, mock_auth, monkeypatch
):
"""Ensure env vars outside SSO mapping remain unchanged"""
import json
from unittest.mock import AsyncMock, MagicMock
monkeypatch.setenv("LITELLM_SALT_KEY", "test_salt_key")
monkeypatch.setattr("litellm.proxy.proxy_server.store_model_in_db", True)
mock_prisma = MagicMock()
mock_prisma.db = MagicMock()
mock_prisma.db.litellm_ssoconfig = MagicMock()
mock_prisma.db.litellm_ssoconfig.find_unique = AsyncMock(return_value=None)
mock_prisma.db.litellm_ssoconfig.upsert = AsyncMock()
env_var_entry = MagicMock()
env_var_entry.param_value = {
"UNRELATED_ENV": "keep_this",
"ANOTHER_ENV": "also_keep",
}
mock_prisma.db.litellm_config = MagicMock()
mock_prisma.writer_db.litellm_config.find_unique = AsyncMock(
return_value=env_var_entry
)
mock_prisma.db.litellm_config.update = AsyncMock()
monkeypatch.setattr("litellm.proxy.proxy_server.prisma_client", mock_prisma)
from litellm.proxy.proxy_server import proxy_config
monkeypatch.setattr(
proxy_config,
"encrypt_env_variables",
lambda environment_variables: environment_variables,
)
response = client.patch(
"/update/sso_settings", json={"microsoft_client_id": "new_microsoft_id"}
)
assert response.status_code == 200
mock_prisma.writer_db.litellm_config.find_unique.assert_called_once()
mock_prisma.db.litellm_config.update.assert_called_once()
update_call = mock_prisma.db.litellm_config.update.call_args
updated_env_vars = json.loads(update_call.kwargs["data"]["param_value"])
assert updated_env_vars == env_var_entry.param_value
def test_update_sso_settings_keeps_an_env_var_the_read_replica_has_not_caught_up_on(
self, mock_proxy_config, mock_auth, monkeypatch
):
import json
from types import SimpleNamespace
from unittest.mock import AsyncMock, MagicMock
monkeypatch.setenv("LITELLM_SALT_KEY", "test_salt_key")
monkeypatch.setattr("litellm.proxy.proxy_server.store_model_in_db", True)
mock_prisma = MagicMock()
mock_prisma.db.litellm_ssoconfig.find_unique = AsyncMock(return_value=None)
mock_prisma.db.litellm_ssoconfig.upsert = AsyncMock()
mock_prisma.writer_db.litellm_config.find_unique = AsyncMock(
return_value=SimpleNamespace(
param_value={"SAVED_A_MOMENT_AGO": "new", "MICROSOFT_CLIENT_ID": "old_microsoft_id"}
)
)
mock_prisma.db.litellm_config.find_unique = AsyncMock(
return_value=SimpleNamespace(param_value={"MICROSOFT_CLIENT_ID": "old_microsoft_id"})
)
mock_prisma.db.litellm_config.update = AsyncMock()
monkeypatch.setattr("litellm.proxy.proxy_server.prisma_client", mock_prisma)
response = client.patch(
"/update/sso_settings", json={"microsoft_client_id": "new_microsoft_id"}
)
assert response.status_code == 200
update_call = mock_prisma.db.litellm_config.update.call_args
assert json.loads(update_call.kwargs["data"]["param_value"]) == {"SAVED_A_MOMENT_AGO": "new"}
def test_get_sso_settings_empty_database(
self, mock_proxy_config, mock_auth, monkeypatch
):
"""Test getting SSO settings when database table is empty"""
from unittest.mock import AsyncMock, MagicMock
# Mock the prisma client to return None (no record found)
mock_prisma = MagicMock()
mock_prisma.db.litellm_ssoconfig.find_unique = AsyncMock(return_value=None)
monkeypatch.setattr("litellm.proxy.proxy_server.prisma_client", mock_prisma)
# Mock the decryption method
def mock_decrypt_and_set(environment_variables):
# Should receive empty dict
return environment_variables
from litellm.proxy.proxy_server import proxy_config
monkeypatch.setattr(
proxy_config, "decrypt_and_set_db_env_variables", mock_decrypt_and_set
)
response = client.get("/get/sso_settings")
assert response.status_code == 200
data = response.json()
# Verify structure is still correct with empty values
assert "values" in data
assert "field_schema" in data
# All values should be None
values = data["values"]
assert values.get("google_client_id") is None
assert values.get("google_client_secret") is None
assert values.get("microsoft_client_id") is None
assert values.get("role_mappings") is None
def test_update_sso_settings_no_database_connection(
self, mock_proxy_config, mock_auth, monkeypatch
):
"""Test updating SSO settings when database is not connected"""
monkeypatch.setattr("litellm.proxy.proxy_server.prisma_client", None)
new_sso_settings = {
"google_client_id": "new_google_id",
}
response = client.patch("/update/sso_settings", json=new_sso_settings)
assert response.status_code == 500
data = response.json()
assert "error" in data["detail"]
assert "Database not connected" in data["detail"]["error"]
def test_get_sso_settings_no_database_connection(
self, mock_proxy_config, mock_auth, monkeypatch
):
"""Test getting SSO settings when database is not connected"""
monkeypatch.setattr("litellm.proxy.proxy_server.prisma_client", None)
response = client.get("/get/sso_settings")
assert response.status_code == 500
data = response.json()
assert "error" in data["detail"]
assert "Database not connected" in data["detail"]["error"]
def test_get_sso_settings_with_role_mappings(
self, mock_proxy_config, mock_auth, monkeypatch
):
"""Test getting SSO settings when role_mappings is present in database"""
from unittest.mock import AsyncMock, MagicMock
from litellm.proxy._types import LitellmUserRoles
# Mock the prisma client with database record containing role_mappings
mock_prisma = MagicMock()
mock_db_record = MagicMock()
mock_db_record.sso_settings = {
"google_client_id": "test_google_client_id",
"role_mappings": {
"provider": "google",
"group_claim": "groups",
"default_role": LitellmUserRoles.INTERNAL_USER,
"roles": {
LitellmUserRoles.PROXY_ADMIN: ["admin-group"],
},
},
}
mock_prisma.db.litellm_ssoconfig.find_unique = AsyncMock(
return_value=mock_db_record
)
monkeypatch.setattr("litellm.proxy.proxy_server.prisma_client", mock_prisma)
# Mock decryption to return the values as-is (role_mappings should not be passed to decryption)
from litellm.proxy.proxy_server import proxy_config
def mock_decrypt(environment_variables):
# role_mappings should not be in environment_variables since it's extracted before decryption
assert "role_mappings" not in environment_variables
return environment_variables
monkeypatch.setattr(
proxy_config, "decrypt_and_set_db_env_variables", mock_decrypt
)
response = client.get("/get/sso_settings")
assert response.status_code == 200
data = response.json()
# Verify role_mappings is returned correctly
values = data["values"]
assert "role_mappings" in values
assert values["role_mappings"] is not None
assert values["role_mappings"]["provider"] == "google"
assert values["role_mappings"]["group_claim"] == "groups"
assert values["role_mappings"]["default_role"] == LitellmUserRoles.INTERNAL_USER
assert values["role_mappings"]["roles"][LitellmUserRoles.PROXY_ADMIN] == [
"admin-group"
]
def test_role_mappings_stored_and_retrieved(
self, mock_proxy_config, mock_auth, monkeypatch
):
"""Test that role_mappings is properly stored and retrieved from SSO settings"""
import json
from unittest.mock import AsyncMock, MagicMock
from litellm.proxy._types import LitellmUserRoles
monkeypatch.setenv("LITELLM_SALT_KEY", "test_salt_key")
monkeypatch.setattr("litellm.proxy.proxy_server.store_model_in_db", True)
# Mock the prisma client
mock_prisma = MagicMock()
mock_prisma.db.litellm_ssoconfig.find_unique = AsyncMock(return_value=None)
mock_prisma.db.litellm_ssoconfig.upsert = AsyncMock()
mock_prisma.db.litellm_config = MagicMock()
mock_prisma.writer_db.litellm_config.find_unique = AsyncMock(return_value=None)
mock_prisma.db.litellm_config.update = AsyncMock()
monkeypatch.setattr("litellm.proxy.proxy_server.prisma_client", mock_prisma)
# Mock encryption to return values as-is
from litellm.proxy.proxy_server import proxy_config
monkeypatch.setattr(
proxy_config,
"encrypt_env_variables",
lambda environment_variables: environment_variables,
)
# SSO settings with role_mappings
role_mappings_data = {
"provider": "google",
"group_claim": "groups",
"default_role": LitellmUserRoles.INTERNAL_USER,
"roles": {
LitellmUserRoles.PROXY_ADMIN: ["admin-group"],
LitellmUserRoles.INTERNAL_USER: ["user-group"],
},
}
new_sso_settings = {
"google_client_id": "test_google_id",
"role_mappings": role_mappings_data,
}
response = client.patch("/update/sso_settings", json=new_sso_settings)
assert response.status_code == 200
data = response.json()
assert data["status"] == "success"
assert "role_mappings" in data["settings"]
# Verify role_mappings structure in response
returned_role_mappings = data["settings"]["role_mappings"]
assert returned_role_mappings["provider"] == "google"
assert returned_role_mappings["group_claim"] == "groups"
assert returned_role_mappings["default_role"] == LitellmUserRoles.INTERNAL_USER
assert returned_role_mappings["roles"][LitellmUserRoles.PROXY_ADMIN] == [
"admin-group"
]
# Verify upsert was called with role_mappings in the data
assert mock_prisma.db.litellm_ssoconfig.upsert.called
call_args = mock_prisma.db.litellm_ssoconfig.upsert.call_args
create_data = call_args.kwargs["data"]["create"]
stored_sso_settings = json.loads(create_data["sso_settings"])
assert "role_mappings" in stored_sso_settings
assert stored_sso_settings["role_mappings"]["provider"] == "google"
# Now test retrieving role_mappings
mock_db_record = MagicMock()
mock_db_record.sso_settings = stored_sso_settings
mock_prisma.db.litellm_ssoconfig.find_unique = AsyncMock(
return_value=mock_db_record
)
monkeypatch.setattr(
proxy_config,
"decrypt_and_set_db_env_variables",
lambda environment_variables: environment_variables,
)
get_response = client.get("/get/sso_settings")
assert get_response.status_code == 200
get_data = get_response.json()
# Verify role_mappings is returned correctly
assert "role_mappings" in get_data["values"]
retrieved_role_mappings = get_data["values"]["role_mappings"]
assert retrieved_role_mappings is not None
assert retrieved_role_mappings["provider"] == "google"
assert retrieved_role_mappings["group_claim"] == "groups"
assert retrieved_role_mappings["default_role"] == LitellmUserRoles.INTERNAL_USER
def test_setup_role_mappings_custom_logic_with_env_vars(self, monkeypatch):
"""Test the _setup_role_mappings function directly with custom role mapping logic from environment variables"""
import asyncio
import os
from litellm.proxy._types import LitellmUserRoles
from litellm.proxy.management_endpoints.ui_sso import _setup_role_mappings
# Set up environment variables for custom role mappings using valid Python dict format
monkeypatch.setenv(
"GENERIC_ROLE_MAPPINGS_ROLES",
"{'proxy_admin': ['custom-admin-group'], 'internal_user': ['custom-user-group'], 'proxy_admin_viewer': ['custom-viewer-group']}",
)
monkeypatch.setenv("GENERIC_ROLE_MAPPINGS_GROUP_CLAIM", "custom-groups")
monkeypatch.setenv("GENERIC_ROLE_MAPPINGS_DEFAULT_ROLE", "internal_user_viewer")
# Debug: Print environment variables
print("GENERIC_ROLE_MAPPINGS_ROLES:", os.getenv("GENERIC_ROLE_MAPPINGS_ROLES"))
print(
"GENERIC_ROLE_MAPPINGS_GROUP_CLAIM:",
os.getenv("GENERIC_ROLE_MAPPINGS_GROUP_CLAIM"),
)
print(
"GENERIC_ROLE_MAPPINGS_DEFAULT_ROLE:",
os.getenv("GENERIC_ROLE_MAPPINGS_DEFAULT_ROLE"),
)
# Run the async function
role_mappings = asyncio.run(_setup_role_mappings())
# Debug: Print result
print("role_mappings result:", role_mappings)
# Verify role_mappings is returned correctly from environment variables
assert role_mappings is not None
assert role_mappings.provider == "generic"
assert role_mappings.group_claim == "custom-groups"
assert role_mappings.default_role == LitellmUserRoles.INTERNAL_USER_VIEW_ONLY
assert role_mappings.roles[LitellmUserRoles.PROXY_ADMIN] == [
"custom-admin-group"
]
assert role_mappings.roles[LitellmUserRoles.INTERNAL_USER] == [
"custom-user-group"
]
assert role_mappings.roles[LitellmUserRoles.PROXY_ADMIN_VIEW_ONLY] == [
"custom-viewer-group"
]
def test_setup_role_mappings_custom_logic_with_no_config(self, monkeypatch):
"""Test the _setup_role_mappings function returns None when no configuration is available"""
import asyncio
from unittest.mock import AsyncMock, MagicMock
from litellm.proxy.management_endpoints.ui_sso import _setup_role_mappings
# Ensure environment variables are not set
monkeypatch.delenv("GENERIC_ROLE_MAPPINGS_ROLES", raising=False)
monkeypatch.delenv("GENERIC_ROLE_MAPPINGS_GROUP_CLAIM", raising=False)
monkeypatch.delenv("GENERIC_ROLE_MAPPINGS_DEFAULT_ROLE", raising=False)
# Mock the prisma client to return None (no database record)
mock_prisma = MagicMock()
mock_prisma.db.litellm_ssoconfig.find_unique = AsyncMock(return_value=None)
# Run the async function
role_mappings = asyncio.run(_setup_role_mappings())
# Should return None when no configuration is available
assert role_mappings is None
def test_get_sso_settings_with_env_role_mappings(
self, mock_proxy_config, mock_auth, monkeypatch
):
import json
from unittest.mock import AsyncMock, MagicMock
from litellm.proxy._types import LitellmUserRoles
monkeypatch.setenv(
"GENERIC_ROLE_MAPPINGS_ROLES",
'{"proxy_admin": ["custom-admin-group"], "internal_user": ["custom-user-group"], "proxy_admin_viewer": ["custom-viewer-group"]}',
)
monkeypatch.setenv("GENERIC_ROLE_MAPPINGS_GROUP_CLAIM", "custom-groups")
monkeypatch.setenv("GENERIC_ROLE_MAPPINGS_DEFAULT_ROLE", "internal_user_viewer")
mock_prisma = MagicMock()
mock_db_record = MagicMock()
mock_db_record.sso_settings = {
"google_client_id": "test_google_client_id",
"role_mappings": {
"provider": "google",
"group_claim": "db-groups",
"default_role": "proxy_admin",
"roles": {
"proxy_admin": ["db-admin-group"],
},
},
}
mock_prisma.db.litellm_ssoconfig.find_unique = AsyncMock(
return_value=mock_db_record
)
monkeypatch.setattr("litellm.proxy.proxy_server.prisma_client", mock_prisma)
from litellm.proxy.proxy_server import proxy_config
monkeypatch.setattr(
proxy_config,
"decrypt_and_set_db_env_variables",
lambda environment_variables: environment_variables,
)
response = client.get("/get/sso_settings")
assert response.status_code == 200
data = response.json()
values = data["values"]
assert "role_mappings" in values
assert values["role_mappings"] is not None
# The database values shoeld override the environment variables
assert values["role_mappings"]["provider"] == "google"
assert values["role_mappings"]["group_claim"] == "db-groups"
assert values["role_mappings"]["default_role"] == LitellmUserRoles.PROXY_ADMIN
assert values["role_mappings"]["roles"][LitellmUserRoles.PROXY_ADMIN] == [
"db-admin-group"
]
# Verify that the database was checked but environment variables took priority
mock_prisma.db.litellm_ssoconfig.find_unique.assert_called_once_with(
where={"id": "sso_config"}
)
# Verify other SSO settings are still correctly returned
assert values["google_client_id"] == "test_google_client_id"
# Verify field_schema is still present
assert "field_schema" in data
assert "properties" in data["field_schema"]
assert "role_mappings" in data["field_schema"]["properties"]
def test_update_internal_user_settings_writes_audit_log(mock_proxy_config, monkeypatch):
"""Regression for the reported scenario: an admin changes Default User
Settings from the dashboard, which issues PATCH /update/internal_user_settings
(NOT /config/update). An audit row must record who changed it and what
changed."""
from unittest.mock import AsyncMock, MagicMock
import litellm
import litellm.proxy.proxy_server as proxy_server_module
from litellm.proxy._types import UserAPIKeyAuth
from litellm.proxy.auth.user_api_key_auth import user_api_key_auth
audit_create = AsyncMock()
fake_prisma = MagicMock()
fake_prisma.db.litellm_auditlog.create = audit_create
monkeypatch.setattr(proxy_server_module, "prisma_client", fake_prisma)
monkeypatch.setattr(proxy_server_module, "premium_user", True)
monkeypatch.setattr("litellm.proxy.proxy_server.store_model_in_db", True)
monkeypatch.setattr(litellm, "store_audit_logs", True)
monkeypatch.setattr(litellm, "default_internal_user_params", {})
async def _admin_auth():
return UserAPIKeyAuth(
user_id="audit-admin",
api_key="hashed-admin-key",
user_role=LitellmUserRoles.PROXY_ADMIN,
)
app.dependency_overrides[user_api_key_auth] = _admin_auth
try:
resp = client.patch(
"/update/internal_user_settings",
json={"max_budget": 999.0, "models": ["gpt-4"]},
)
assert resp.status_code == 200, resp.text
audit_create.assert_awaited_once()
written = audit_create.await_args.kwargs["data"]
assert written["object_id"] == "default_internal_user_params"
assert written["action"] == "updated"
assert written["table_name"] == "LiteLLM_Config"
assert written["changed_by"] == "audit-admin"
assert written["changed_by_api_key"] == "hashed-admin-key"
before = json.loads(written["before_value"])
after = json.loads(written["updated_values"])
assert before["max_budget"] == 100.0
assert after["max_budget"] == 999.0
finally:
app.dependency_overrides.pop(user_api_key_auth, None)
def test_update_internal_user_settings_returns_200_when_audit_write_raises(
mock_proxy_config, monkeypatch
):
"""The settings change is already committed by save_config, so an
audit-log failure must never surface as a 500. Scheduling via
asyncio.create_task keeps the audit call off the request path; this
test asserts that contract by making the audit helper raise."""
import litellm
import litellm.proxy.proxy_server as proxy_server_module
from litellm.proxy._types import UserAPIKeyAuth
from litellm.proxy.auth.user_api_key_auth import user_api_key_auth
monkeypatch.setattr("litellm.proxy.proxy_server.store_model_in_db", True)
monkeypatch.setattr(litellm, "default_internal_user_params", {})
async def _raise(**_kwargs):
raise RuntimeError("audit prisma blip")
monkeypatch.setattr(proxy_server_module, "create_config_audit_log", _raise)
async def _admin_auth():
return UserAPIKeyAuth(
user_id="audit-admin",
api_key="hashed-admin-key",
user_role=LitellmUserRoles.PROXY_ADMIN,
)
app.dependency_overrides[user_api_key_auth] = _admin_auth
try:
resp = client.patch(
"/update/internal_user_settings", json={"max_budget": 42.0}
)
assert resp.status_code == 200, resp.text
assert resp.json()["status"] == "success"
finally:
app.dependency_overrides.pop(user_api_key_auth, None)
def test_update_sso_settings_writes_redacted_audit_log(mock_proxy_config, monkeypatch):
"""Updating SSO settings must write an audit row to the SSO config table
with the client secret redacted."""
from unittest.mock import AsyncMock, MagicMock
import litellm
import litellm.proxy.proxy_server as proxy_server_module
from litellm.proxy._types import UserAPIKeyAuth
from litellm.proxy.auth.user_api_key_auth import user_api_key_auth
audit_create = AsyncMock()
fake_prisma = MagicMock()
fake_prisma.db.litellm_auditlog.create = audit_create
fake_prisma.db.litellm_ssoconfig.upsert = AsyncMock()
# No prior SSO row, so before_value resolves to None.
fake_prisma.db.litellm_ssoconfig.find_unique = AsyncMock(return_value=None)
fake_prisma.writer_db.litellm_config.find_unique = AsyncMock(return_value=None)
monkeypatch.setattr(proxy_server_module, "prisma_client", fake_prisma)
monkeypatch.setattr(proxy_server_module, "premium_user", True)
monkeypatch.setattr("litellm.proxy.proxy_server.store_model_in_db", True)
monkeypatch.setattr(litellm, "store_audit_logs", True)
monkeypatch.setattr(
proxy_server_module.proxy_config,
"encrypt_env_variables",
lambda environment_variables: environment_variables,
)
async def _admin_auth():
return UserAPIKeyAuth(
user_id="audit-admin",
api_key="hashed-admin-key",
user_role=LitellmUserRoles.PROXY_ADMIN,
)
app.dependency_overrides[user_api_key_auth] = _admin_auth
try:
resp = client.patch(
"/update/sso_settings",
json={
"google_client_id": "client-id-123",
"google_client_secret": "super-secret-xyz",
},
)
assert resp.status_code == 200, resp.text
audit_create.assert_awaited_once()
written = audit_create.await_args.kwargs["data"]
assert written["object_id"] == "sso_config"
assert written["table_name"] == "LiteLLM_SSOConfig"
assert written["changed_by"] == "audit-admin"
after = json.loads(written["updated_values"])
assert after["google_client_id"] == "client-id-123"
assert after["google_client_secret"] == "REDACTED"
assert "super-secret-xyz" not in written["updated_values"]
finally:
app.dependency_overrides.pop(user_api_key_auth, None)
def test_update_sso_settings_audit_captures_redacted_before_snapshot(
mock_proxy_config, monkeypatch
):
"""An auditor reviewing an SSO secret rotation needs to see a real
before/after diff in the audit row, not before_value=None. The endpoint
reads the existing (encrypted) SSO row, decrypts it, and lets the audit
helper redact the *_client_secret fields before persistence so neither
the old nor the new plaintext secret is recorded."""
from unittest.mock import AsyncMock, MagicMock
import litellm
import litellm.proxy.proxy_server as proxy_server_module
from litellm.proxy._types import UserAPIKeyAuth
from litellm.proxy.auth.user_api_key_auth import user_api_key_auth
audit_create = AsyncMock()
fake_prisma = MagicMock()
fake_prisma.db.litellm_auditlog.create = audit_create
fake_prisma.db.litellm_ssoconfig.upsert = AsyncMock()
# Pre-existing SSO row contains the *prior* secret (would be ciphertext in
# production; the test patches _decrypt_db_variables to pass through).
existing_record = MagicMock()
existing_record.sso_settings = {
"google_client_id": "old-client-id",
"google_client_secret": "OLD-SUPER-SECRET",
}
fake_prisma.db.litellm_ssoconfig.find_unique = AsyncMock(return_value=existing_record)
fake_prisma.writer_db.litellm_config.find_unique = AsyncMock(return_value=None)
monkeypatch.setattr(proxy_server_module, "prisma_client", fake_prisma)
monkeypatch.setattr(proxy_server_module, "premium_user", True)
monkeypatch.setattr("litellm.proxy.proxy_server.store_model_in_db", True)
monkeypatch.setattr(litellm, "store_audit_logs", True)
monkeypatch.setattr(
proxy_server_module.proxy_config,
"encrypt_env_variables",
lambda environment_variables: environment_variables,
)
# Pretend the stored value is already plaintext for the test (production
# decrypts via Fernet); the audit helper still has to redact it.
monkeypatch.setattr(
proxy_server_module.proxy_config,
"decrypt_db_variables",
lambda variables_dict: dict(variables_dict),
)
async def _admin_auth():
return UserAPIKeyAuth(
user_id="audit-admin",
api_key="hashed-admin-key",
user_role=LitellmUserRoles.PROXY_ADMIN,
)
app.dependency_overrides[user_api_key_auth] = _admin_auth
try:
resp = client.patch(
"/update/sso_settings",
json={
"google_client_id": "new-client-id",
"google_client_secret": "NEW-SUPER-SECRET",
},
)
assert resp.status_code == 200, resp.text
audit_create.assert_awaited_once()
written = audit_create.await_args.kwargs["data"]
before = json.loads(written["before_value"])
after = json.loads(written["updated_values"])
# Non-secret field shows the diff
assert before["google_client_id"] == "old-client-id"
assert after["google_client_id"] == "new-client-id"
# Secret field is redacted in BOTH snapshots — auditor sees the
# rotation event without ever seeing either plaintext secret.
assert before["google_client_secret"] == "REDACTED"
assert after["google_client_secret"] == "REDACTED"
assert "OLD-SUPER-SECRET" not in written["before_value"]
assert "NEW-SUPER-SECRET" not in written["updated_values"]
finally:
app.dependency_overrides.pop(user_api_key_auth, None)
def test_add_allowed_ip_writes_audit_log(mock_proxy_config, monkeypatch):
"""Adding an allowed IP is a system-wide security setting change and must
be audited with the before and after IP list."""
from unittest.mock import AsyncMock, MagicMock
import litellm
import litellm.proxy.proxy_server as proxy_server_module
from litellm.proxy._types import UserAPIKeyAuth
from litellm.proxy.auth.user_api_key_auth import user_api_key_auth
audit_create = AsyncMock()
fake_prisma = MagicMock()
fake_prisma.db.litellm_auditlog.create = audit_create
monkeypatch.setattr(proxy_server_module, "prisma_client", fake_prisma)
monkeypatch.setattr(proxy_server_module, "premium_user", True)
monkeypatch.setattr(proxy_server_module, "general_settings", {})
monkeypatch.setattr("litellm.proxy.proxy_server.store_model_in_db", True)
monkeypatch.setattr(litellm, "store_audit_logs", True)
async def _admin_auth():
return UserAPIKeyAuth(
user_id="audit-admin",
api_key="hashed-admin-key",
user_role=LitellmUserRoles.PROXY_ADMIN,
)
app.dependency_overrides[user_api_key_auth] = _admin_auth
try:
resp = client.post("/add/allowed_ip", json={"ip": "203.0.113.77"})
assert resp.status_code == 200, resp.text
audit_create.assert_awaited_once()
written = audit_create.await_args.kwargs["data"]
assert written["object_id"] == "general_settings"
assert written["action"] == "updated"
assert written["changed_by"] == "audit-admin"
before = json.loads(written["before_value"])
after = json.loads(written["updated_values"])
assert "203.0.113.77" not in before["allowed_ips"]
assert "203.0.113.77" in after["allowed_ips"]
finally:
app.dependency_overrides.pop(user_api_key_auth, None)
def test_add_allowed_ip_hands_save_config_only_the_changed_general_setting(monkeypatch):
"""An allowed-IP write must not drag the config file's own general_settings into
the database row. This covers the route end of that contract: what /add/allowed_ip
hands save_config differs from the loaded config in allowed_ips and nothing else.
save_config's end -- that the row it writes holds only those changed keys -- is
covered by test_ProxyConfig_save_config_merges_changed_keys_without_copying_file_settings.
This lives here rather than in the e2e suite because /add/allowed_ip mutates the
live general_settings["allowed_ips"] that auth_utils._check_valid_ip reads, so on a
shared proxy the first call locks every later request out, cleanup included.
"""
from types import MappingProxyType
from typing import Final
from unittest.mock import AsyncMock, MagicMock
import litellm.proxy.proxy_server as proxy_server_module
from litellm.proxy._types import UserAPIKeyAuth
from litellm.proxy.auth.user_api_key_auth import user_api_key_auth
from litellm.proxy.config_resolvers.changed_section_keys import changed_section_keys
from litellm.proxy.config_resolvers.settings_store import SettingsStore
file_settings: Final = MappingProxyType({"max_parallel_requests": 100, "proxy_config_reload_interval_seconds": 7})
store: Final = SettingsStore("general_settings")
store.load_yaml(file_settings)
fake_prisma: Final = MagicMock()
fake_prisma.db.litellm_auditlog.create = AsyncMock()
save_config: Final = AsyncMock(side_effect=lambda new_config: new_config)
async def _get_config():
return {"general_settings": dict(file_settings)}
monkeypatch.setattr(proxy_server_module, "prisma_client", fake_prisma)
monkeypatch.setattr(proxy_server_module, "store_model_in_db", True)
monkeypatch.setattr(proxy_server_module, "premium_user", True)
monkeypatch.setattr(proxy_server_module, "general_settings", store)
monkeypatch.setattr(proxy_server_module.proxy_config, "get_config", _get_config)
monkeypatch.setattr(proxy_server_module.proxy_config, "save_config", save_config)
async def _admin_auth():
return UserAPIKeyAuth(
user_id="config-admin",
api_key="hashed-admin-key",
user_role=LitellmUserRoles.PROXY_ADMIN,
)
app.dependency_overrides[user_api_key_auth] = _admin_auth
try:
resp: Final = client.post("/add/allowed_ip", json={"ip": "203.0.113.77"})
assert resp.status_code == 200, resp.text
save_config.assert_awaited_once()
persisted: Final = save_config.await_args.kwargs["new_config"]["general_settings"]
changed, removed = changed_section_keys(file_settings, persisted)
assert dict(changed) == {"allowed_ips": ["203.0.113.77"]}
assert removed == frozenset()
assert store["allowed_ips"] == ["203.0.113.77"]
finally:
app.dependency_overrides.pop(user_api_key_auth, None)
def test_delete_allowed_ip_writes_deleted_audit_log(monkeypatch):
"""Removing an allowed IP must be audited as a deletion, symmetric with the
add path."""
from unittest.mock import AsyncMock, MagicMock
import litellm
import litellm.proxy.proxy_server as proxy_server_module
from litellm.proxy._types import UserAPIKeyAuth
from litellm.proxy.auth.user_api_key_auth import user_api_key_auth
audit_create = AsyncMock()
fake_prisma = MagicMock()
fake_prisma.db.litellm_auditlog.create = audit_create
config = {"general_settings": {"allowed_ips": ["203.0.113.77", "198.51.100.1"]}}
async def _get_config():
return config
async def _save_config(new_config=None):
nonlocal config
if new_config is not None:
config = new_config
return config
monkeypatch.setattr(proxy_server_module, "prisma_client", fake_prisma)
monkeypatch.setattr(proxy_server_module, "premium_user", True)
monkeypatch.setattr(
proxy_server_module, "general_settings", {"allowed_ips": ["203.0.113.77"]}
)
monkeypatch.setattr(litellm, "store_audit_logs", True)
monkeypatch.setattr(proxy_server_module.proxy_config, "get_config", _get_config)
monkeypatch.setattr(proxy_server_module.proxy_config, "save_config", _save_config)
async def _admin_auth():
return UserAPIKeyAuth(
user_id="audit-admin",
api_key="hashed-admin-key",
user_role=LitellmUserRoles.PROXY_ADMIN,
)
app.dependency_overrides[user_api_key_auth] = _admin_auth
try:
resp = client.post("/delete/allowed_ip", json={"ip": "203.0.113.77"})
assert resp.status_code == 200, resp.text
audit_create.assert_awaited_once()
written = audit_create.await_args.kwargs["data"]
assert written["object_id"] == "general_settings"
assert written["action"] == "deleted"
before = json.loads(written["before_value"])
after = json.loads(written["updated_values"])
assert "203.0.113.77" in before["allowed_ips"]
assert "203.0.113.77" not in after["allowed_ips"]
finally:
app.dependency_overrides.pop(user_api_key_auth, None)
@pytest.mark.parametrize("route", ["/add/allowed_ip", "/delete/allowed_ip"])
def test_allowed_ip_routes_refuse_a_config_owned_list_with_a_clear_400(route, monkeypatch):
from unittest.mock import AsyncMock, MagicMock
import litellm.proxy.proxy_server as proxy_server_module
from litellm.proxy._types import UserAPIKeyAuth
from litellm.proxy.auth.user_api_key_auth import user_api_key_auth
from litellm.proxy.config_resolvers.settings_store import SettingsStore
store = SettingsStore("general_settings")
store.load_yaml({"allowed_ips": ["203.0.113.77"]})
saved = []
fake_prisma = MagicMock()
fake_prisma.db.litellm_auditlog.create = AsyncMock()
async def _get_config():
return {"general_settings": {"allowed_ips": ["203.0.113.77"]}}
async def _save_config(new_config=None):
saved.append(new_config)
return new_config
monkeypatch.setattr(proxy_server_module, "prisma_client", fake_prisma)
monkeypatch.setattr(proxy_server_module, "store_model_in_db", True)
monkeypatch.setattr(proxy_server_module, "general_settings", store)
monkeypatch.setattr(proxy_server_module.proxy_config, "get_config", _get_config)
monkeypatch.setattr(proxy_server_module.proxy_config, "save_config", _save_config)
async def _admin_auth():
return UserAPIKeyAuth(
user_id="config-admin",
api_key="hashed-admin-key",
user_role=LitellmUserRoles.PROXY_ADMIN,
)
app.dependency_overrides[user_api_key_auth] = _admin_auth
try:
ip = "198.51.100.9" if route == "/add/allowed_ip" else "203.0.113.77"
resp = client.post(route, json={"ip": ip})
assert resp.status_code == 400, resp.text
assert "allowed_ips" in resp.text
assert list(store["allowed_ips"]) == ["203.0.113.77"]
assert saved == []
finally:
app.dependency_overrides.pop(user_api_key_auth, None)
def test_update_ui_theme_settings_writes_audit_log(mock_proxy_config, monkeypatch):
"""Updating the UI theme must be audited under ui_theme_config."""
from unittest.mock import AsyncMock, MagicMock
import litellm
import litellm.proxy.proxy_server as proxy_server_module
from litellm.proxy._types import UserAPIKeyAuth
from litellm.proxy.auth.user_api_key_auth import user_api_key_auth
audit_create = AsyncMock()
fake_prisma = MagicMock()
fake_prisma.db.litellm_auditlog.create = audit_create
monkeypatch.setattr(proxy_server_module, "prisma_client", fake_prisma)
monkeypatch.setattr(proxy_server_module, "premium_user", True)
monkeypatch.setattr("litellm.proxy.proxy_server.store_model_in_db", True)
monkeypatch.setattr(litellm, "store_audit_logs", True)
monkeypatch.setattr(
proxy_server_module.proxy_config,
"encrypt_env_variables",
lambda environment_variables: environment_variables,
)
async def _admin_auth():
return UserAPIKeyAuth(
user_id="audit-admin",
api_key="hashed-admin-key",
user_role=LitellmUserRoles.PROXY_ADMIN,
)
app.dependency_overrides[user_api_key_auth] = _admin_auth
try:
resp = client.patch(
"/update/ui_theme_settings",
json={"logo_url": "https://example.com/logo.png"},
)
assert resp.status_code == 200, resp.text
audit_create.assert_awaited_once()
written = audit_create.await_args.kwargs["data"]
assert written["object_id"] == "ui_theme_config"
assert written["action"] == "updated"
assert written["changed_by"] == "audit-admin"
after = json.loads(written["updated_values"])
assert after["logo_url"] == "https://example.com/logo.png"
finally:
app.dependency_overrides.pop(user_api_key_auth, None)
def test_update_ui_settings_writes_audit_log(monkeypatch):
"""Updating UI settings must be audited under the UI settings table."""
from unittest.mock import AsyncMock, MagicMock
import litellm
import litellm.proxy.proxy_server as proxy_server_module
from litellm.proxy._types import UserAPIKeyAuth
from litellm.proxy.auth.user_api_key_auth import user_api_key_auth
audit_create = AsyncMock()
fake_prisma = MagicMock()
fake_prisma.db.litellm_auditlog.create = audit_create
fake_prisma.db.litellm_uisettings.find_unique = AsyncMock(return_value=None)
fake_prisma.db.litellm_uisettings.upsert = AsyncMock()
monkeypatch.setattr(proxy_server_module, "prisma_client", fake_prisma)
monkeypatch.setattr(proxy_server_module, "premium_user", True)
monkeypatch.setattr("litellm.proxy.proxy_server.store_model_in_db", True)
monkeypatch.setattr(litellm, "store_audit_logs", True)
async def _admin_auth():
return UserAPIKeyAuth(
user_id="audit-admin",
api_key="hashed-admin-key",
user_role=LitellmUserRoles.PROXY_ADMIN,
)
app.dependency_overrides[user_api_key_auth] = _admin_auth
try:
resp = client.patch(
"/update/ui_settings", json={"disable_custom_api_keys": True}
)
assert resp.status_code == 200, resp.text
audit_create.assert_awaited_once()
written = audit_create.await_args.kwargs["data"]
assert written["object_id"] == "ui_settings"
assert written["table_name"] == "LiteLLM_UISettings"
assert written["changed_by"] == "audit-admin"
after = json.loads(written["updated_values"])
assert after["disable_custom_api_keys"] is True
finally:
app.dependency_overrides.pop(user_api_key_auth, None)
@pytest.fixture
def mock_team_lookup(monkeypatch):
"""Back /update/internal_user_settings with a fake team table.
Yields the set of team ids that exist; the test mutates it before the call.
Also exposes the find_many mock so a test can assert the lookup was skipped.
"""
from unittest.mock import AsyncMock, MagicMock
import litellm
import litellm.proxy.proxy_server as proxy_server_module
existing_team_ids: set = set()
async def _find_many(where, **_):
requested = where["team_id"]["in"]
return [{"team_id": team_id} for team_id in requested if team_id in existing_team_ids]
find_many = AsyncMock(side_effect=_find_many)
fake_prisma = MagicMock()
fake_prisma.db.litellm_teamtable.find_many = find_many
member_budget_update = AsyncMock()
monkeypatch.setattr(proxy_server_module, "prisma_client", fake_prisma)
monkeypatch.setattr("litellm.proxy.proxy_server.store_model_in_db", True)
monkeypatch.setattr(litellm, "default_internal_user_params", {})
monkeypatch.setattr(
"litellm.proxy.ui_crud_endpoints.proxy_setting_endpoints.update_default_team_member_budget",
member_budget_update,
)
return {
"existing_team_ids": existing_team_ids,
"find_many": find_many,
"member_budget_update": member_budget_update,
}
def test_update_internal_user_settings_rejects_unknown_team_object(mock_proxy_config, mock_auth, mock_team_lookup):
"""Regression: saving a default team that doesn't exist used to return 200,
then silently fail for every SSO user because the membership write 404s."""
mock_team_lookup["existing_team_ids"].add("real-team")
resp = client.patch(
"/update/internal_user_settings",
json={
"max_budget": 10.0,
"teams": [
{"team_id": "real-team", "max_budget_in_team": 5.0},
{"team_id": "ghost-team"},
],
},
)
assert resp.status_code == 400, resp.text
assert "ghost-team" in resp.json()["detail"]["error"]
assert "real-team" not in resp.json()["detail"]["error"]
assert mock_proxy_config["save_call_count"]() == 0
assert mock_team_lookup["member_budget_update"].await_count == 0, (
"per-member budgets must not be written before the team ids are validated"
)
import litellm
assert litellm.default_internal_user_params == {}
def test_update_internal_user_settings_rejects_unknown_team_string(mock_proxy_config, mock_auth, mock_team_lookup):
"""The bare-string team shape must be validated too."""
resp = client.patch(
"/update/internal_user_settings",
json={"teams": ["ghost-team"]},
)
assert resp.status_code == 400, resp.text
assert "ghost-team" in resp.json()["detail"]["error"]
assert mock_proxy_config["save_call_count"]() == 0
def test_update_internal_user_settings_rejects_duplicate_team_ids(mock_proxy_config, mock_auth, mock_team_lookup):
"""Listing a team twice makes its per-member budget a race between the two
entries, so the payload is rejected rather than silently resolved."""
mock_team_lookup["existing_team_ids"].add("real-team")
resp = client.patch(
"/update/internal_user_settings",
json={
"teams": [
{"team_id": "real-team", "max_budget_in_team": 5.0},
{"team_id": "real-team", "max_budget_in_team": 50.0},
]
},
)
assert resp.status_code == 400, resp.text
assert "real-team" in resp.json()["detail"]["error"]
assert mock_proxy_config["save_call_count"]() == 0
def test_update_internal_user_settings_saves_when_all_teams_exist(mock_proxy_config, mock_auth, mock_team_lookup):
"""Valid team ids still save, and still reach the per-member budget update."""
mock_team_lookup["existing_team_ids"].update({"team-a", "team-b"})
resp = client.patch(
"/update/internal_user_settings",
json={
"max_budget": 10.0,
"teams": [
{"team_id": "team-a", "max_budget_in_team": 5.0},
{"team_id": "team-b"},
],
},
)
assert resp.status_code == 200, resp.text
assert [team["team_id"] for team in resp.json()["settings"]["teams"]] == [
"team-a",
"team-b",
]
assert mock_proxy_config["save_call_count"]() == 1
mock_team_lookup["member_budget_update"].assert_awaited_once()
def test_update_internal_user_settings_without_teams_skips_team_lookup(mock_proxy_config, mock_auth, mock_team_lookup):
"""Settings changes that don't touch teams must not pay for a DB round trip."""
resp = client.patch(
"/update/internal_user_settings",
json={"max_budget": 10.0},
)
assert resp.status_code == 200, resp.text
mock_team_lookup["find_many"].assert_not_awaited()
assert mock_proxy_config["save_call_count"]() == 1
@pytest.fixture
def mock_organization_lookup(monkeypatch):
"""Back /update/default_team_settings with a fake organization table.
Yields the set of organization ids that exist; the test mutates it before the call.
"""
from unittest.mock import AsyncMock, MagicMock
import litellm
import litellm.proxy.proxy_server as proxy_server_module
existing_organization_ids: set = set()
async def _find_unique(where):
organization_id = where["organization_id"]
if organization_id not in existing_organization_ids:
return None
return {"organization_id": organization_id}
find_unique = AsyncMock(side_effect=_find_unique)
fake_prisma = MagicMock()
fake_prisma.db.litellm_organizationtable.find_unique = find_unique
monkeypatch.setattr(proxy_server_module, "prisma_client", fake_prisma)
monkeypatch.setattr("litellm.proxy.proxy_server.store_model_in_db", True)
monkeypatch.setattr(litellm, "default_team_params", {})
return {
"existing_organization_ids": existing_organization_ids,
"find_unique": find_unique,
}
def test_update_default_team_settings_rejects_unknown_organization(
mock_proxy_config, mock_auth, mock_organization_lookup
):
"""Regression: an unknown default org saved fine here and then failed every
future team creation, far from the admin who typed it."""
mock_organization_lookup["existing_organization_ids"].add("real-org")
resp = client.patch(
"/update/default_team_settings",
json={"max_budget": 10.0, "organization_id": "ghost-org"},
)
assert resp.status_code == 400, resp.text
assert "ghost-org" in resp.json()["detail"]["error"]
assert mock_proxy_config["save_call_count"]() == 0
import litellm
assert litellm.default_team_params == {}
def test_update_default_team_settings_saves_when_organization_exists(
mock_proxy_config, mock_auth, mock_organization_lookup
):
"""A real organization id still saves and reaches the in-memory settings."""
mock_organization_lookup["existing_organization_ids"].add("real-org")
resp = client.patch(
"/update/default_team_settings",
json={"max_budget": 10.0, "organization_id": "real-org"},
)
assert resp.status_code == 200, resp.text
assert resp.json()["settings"]["organization_id"] == "real-org"
assert mock_proxy_config["save_call_count"]() == 1
import litellm
assert litellm.default_team_params["organization_id"] == "real-org"
def test_update_default_team_settings_without_organization_skips_lookup(
mock_proxy_config, mock_auth, mock_organization_lookup
):
"""Settings changes that don't set an organization must not pay for a DB round trip."""
resp = client.patch(
"/update/default_team_settings",
json={"max_budget": 10.0},
)
assert resp.status_code == 200, resp.text
mock_organization_lookup["find_unique"].assert_not_awaited()
assert mock_proxy_config["save_call_count"]() == 1
def test_update_mcp_semantic_filter_settings_requires_proxy_admin(monkeypatch):
"""Non-admin callers must not mutate global MCP semantic filter settings."""
from litellm.proxy._types import UserAPIKeyAuth
from litellm.proxy.auth.user_api_key_auth import user_api_key_auth
monkeypatch.setattr("litellm.proxy.proxy_server.store_model_in_db", True)
async def _internal_user_auth():
return UserAPIKeyAuth(
user_id="internal-user-1",
api_key="hashed-internal-key",
user_role=LitellmUserRoles.INTERNAL_USER,
)
app.dependency_overrides[user_api_key_auth] = _internal_user_auth
try:
resp = client.patch(
"/update/mcp_semantic_filter_settings",
json={"enabled": True, "top_k": 99, "similarity_threshold": 0.01},
)
assert resp.status_code == 403
assert "proxy admin" in resp.json()["detail"].lower()
finally:
app.dependency_overrides.pop(user_api_key_auth, None)
class TestMcpToolSearchSettingsEndpoints:
"""`litellm_settings.mcp_tool_search` drives the native `mcp_tool_search` virtual tool, so the UI must round-trip it."""
@staticmethod
def _override_auth(role: LitellmUserRoles):
from litellm.proxy._types import UserAPIKeyAuth
from litellm.proxy.auth.user_api_key_auth import user_api_key_auth
app.dependency_overrides[user_api_key_auth] = lambda: UserAPIKeyAuth(
user_id="u", api_key="hashed", user_role=role
)
def test_get_returns_stored_values_and_field_schema(self, mock_proxy_config, mock_auth, monkeypatch):
monkeypatch.setattr("litellm.proxy.proxy_server.prisma_client", object())
mock_proxy_config["config"]["litellm_settings"]["mcp_tool_search"] = {
"embedding_model": "text-embedding-3-small",
"core_tools": ["treasury-get_rates"],
}
resp = client.get("/get/mcp_tool_search_settings")
assert resp.status_code == 200, resp.text
assert resp.json()["values"] == {
"embedding_model": "text-embedding-3-small",
"top_k": 5,
"similarity_threshold": 0.0,
"core_tools": ["treasury-get_rates"],
}
assert resp.json()["field_schema"]["properties"]["core_tools"]["type"] == "array"
def test_update_requires_proxy_admin(self, monkeypatch):
monkeypatch.setattr("litellm.proxy.proxy_server.store_model_in_db", True)
self._override_auth(LitellmUserRoles.INTERNAL_USER)
try:
resp = client.patch("/update/mcp_tool_search_settings", json={"top_k": 3})
finally:
app.dependency_overrides.clear()
assert resp.status_code == 403
def test_update_persists_and_applies_in_memory(self, mock_proxy_config, monkeypatch):
import litellm
monkeypatch.setattr("litellm.proxy.proxy_server.store_model_in_db", True)
monkeypatch.setattr(litellm, "mcp_tool_search", None)
self._override_auth(LitellmUserRoles.PROXY_ADMIN)
payload = {
"embedding_model": "text-embedding-3-small",
"top_k": 3,
"similarity_threshold": 0.25,
"core_tools": ["treasury-get_rates"],
}
try:
resp = client.patch("/update/mcp_tool_search_settings", json=payload)
finally:
app.dependency_overrides.clear()
assert resp.status_code == 200, resp.text
assert mock_proxy_config["save_call_count"]() == 1
assert litellm.mcp_tool_search == payload
assert mock_proxy_config["config"]["litellm_settings"]["mcp_tool_search"] == payload
def test_update_rejects_out_of_range_top_k(self, mock_proxy_config, monkeypatch):
monkeypatch.setattr("litellm.proxy.proxy_server.store_model_in_db", True)
self._override_auth(LitellmUserRoles.PROXY_ADMIN)
try:
resp = client.patch("/update/mcp_tool_search_settings", json={"top_k": 0})
finally:
app.dependency_overrides.clear()
assert resp.status_code == 422
assert mock_proxy_config["save_call_count"]() == 0
class TestWebSearchInterceptionSettingsEndpoints:
@staticmethod
def _override_auth(role: LitellmUserRoles):
from litellm.proxy._types import UserAPIKeyAuth
from litellm.proxy.auth.user_api_key_auth import user_api_key_auth
app.dependency_overrides[user_api_key_auth] = lambda: UserAPIKeyAuth(
user_id="u", api_key="hashed", user_role=role
)
def test_get_returns_stored_values_and_field_schema(self, mock_proxy_config, mock_auth, monkeypatch):
import litellm
from litellm.integrations.websearch_interception.handler import (
WebSearchInterceptionLogger,
)
monkeypatch.setattr("litellm.proxy.proxy_server.prisma_client", object())
monkeypatch.setattr(litellm, "callbacks", [WebSearchInterceptionLogger(search_tool_name="running")])
mock_proxy_config["config"]["litellm_settings"]["websearch_interception_params"] = {
"enabled": True,
"enabled_providers": ["bedrock", "vertex_ai"],
"search_tool_name": "my-perplexity-search",
}
resp = client.get("/get/websearch_interception_settings")
assert resp.status_code == 200, resp.text
assert resp.json()["values"] == {
"enabled": True,
"enabled_providers": ["bedrock", "vertex_ai"],
"search_tool_name": "my-perplexity-search",
"max_agentic_loops": None,
}
assert resp.json()["field_schema"]["properties"]["enabled_providers"]["type"] == "array"
def test_update_requires_proxy_admin(self, monkeypatch):
monkeypatch.setattr("litellm.proxy.proxy_server.store_model_in_db", True)
self._override_auth(LitellmUserRoles.INTERNAL_USER)
try:
resp = client.patch("/update/websearch_interception_settings", json={"enabled": True})
finally:
app.dependency_overrides.clear()
assert resp.status_code == 403
assert "proxy admin" in resp.json()["detail"].lower()
def test_update_persists_settings(self, mock_proxy_config, monkeypatch):
monkeypatch.setattr("litellm.proxy.proxy_server.store_model_in_db", True)
self._override_auth(LitellmUserRoles.PROXY_ADMIN)
payload = {
"enabled": True,
"enabled_providers": ["bedrock"],
"search_tool_name": "my-perplexity-search",
"max_agentic_loops": 5,
}
try:
resp = client.patch("/update/websearch_interception_settings", json=payload)
finally:
app.dependency_overrides.clear()
assert resp.status_code == 200, resp.text
assert mock_proxy_config["save_call_count"]() == 1
assert mock_proxy_config["config"]["litellm_settings"]["websearch_interception_params"] == payload
def test_get_reports_enabled_while_the_callback_is_running_without_a_stored_flag(
self, mock_proxy_config, mock_auth, monkeypatch
):
import litellm
from litellm.integrations.websearch_interception.handler import (
WebSearchInterceptionLogger,
)
monkeypatch.setattr("litellm.proxy.proxy_server.prisma_client", object())
monkeypatch.setattr(litellm, "callbacks", [WebSearchInterceptionLogger(search_tool_name="from-config")])
mock_proxy_config["config"]["litellm_settings"]["websearch_interception_params"] = {
"enabled_providers": ["bedrock"],
"search_tool_name": "my-perplexity-search",
}
resp = client.get("/get/websearch_interception_settings")
assert resp.status_code == 200, resp.text
assert resp.json()["values"]["enabled"] is True
def test_get_reports_disabled_when_nothing_is_stored_and_nothing_is_running(
self, mock_proxy_config, mock_auth, monkeypatch
):
import litellm
monkeypatch.setattr("litellm.proxy.proxy_server.prisma_client", object())
monkeypatch.setattr(litellm, "callbacks", [])
mock_proxy_config["config"]["litellm_settings"]["websearch_interception_params"] = {
"enabled_providers": ["bedrock"],
}
resp = client.get("/get/websearch_interception_settings")
assert resp.status_code == 200, resp.text
assert resp.json()["values"]["enabled"] is False
assert resp.json()["values"]["enabled_providers"] == ["bedrock"]
def test_update_reapplies_settings_to_the_running_proxy(self, mock_proxy_config, monkeypatch):
from unittest.mock import AsyncMock
monkeypatch.setattr("litellm.proxy.proxy_server.store_model_in_db", True)
monkeypatch.setattr("litellm.proxy.proxy_server.prisma_client", object())
reapply = AsyncMock()
monkeypatch.setattr(
"litellm.proxy.proxy_server.proxy_config.init_websearch_interception_settings_in_db",
reapply,
)
self._override_auth(LitellmUserRoles.PROXY_ADMIN)
try:
resp = client.patch("/update/websearch_interception_settings", json={"enabled": True})
finally:
app.dependency_overrides.clear()
assert resp.status_code == 200, resp.text
reapply.assert_awaited_once()
def test_get_keeps_the_stored_flag_when_this_pod_has_not_reinitialized(
self, mock_proxy_config, mock_auth, monkeypatch
):
import litellm
monkeypatch.setattr("litellm.proxy.proxy_server.prisma_client", object())
monkeypatch.setattr(litellm, "callbacks", [])
mock_proxy_config["config"]["litellm_settings"]["websearch_interception_params"] = {
"enabled": True,
"search_tool_name": "cluster-search",
}
resp = client.get("/get/websearch_interception_settings")
assert resp.status_code == 200, resp.text
assert resp.json()["values"]["enabled"] is True
def test_get_flags_a_pod_that_has_not_applied_the_stored_setting(
self, mock_proxy_config, mock_auth, monkeypatch
):
import litellm
monkeypatch.setattr("litellm.proxy.proxy_server.prisma_client", object())
monkeypatch.setattr(litellm, "callbacks", [])
mock_proxy_config["config"]["litellm_settings"]["websearch_interception_params"] = {"enabled": True}
resp = client.get("/get/websearch_interception_settings")
assert resp.status_code == 200, resp.text
assert resp.json()["values"]["enabled"] is True
assert resp.json()["active_on_this_pod"] is False
def test_get_reports_the_pod_as_active_once_the_callback_is_registered(
self, mock_proxy_config, mock_auth, monkeypatch
):
import litellm
from litellm.integrations.websearch_interception.handler import (
WebSearchInterceptionLogger,
)
monkeypatch.setattr("litellm.proxy.proxy_server.prisma_client", object())
monkeypatch.setattr(litellm, "callbacks", [WebSearchInterceptionLogger(search_tool_name="running")])
mock_proxy_config["config"]["litellm_settings"]["websearch_interception_params"] = {"enabled": True}
resp = client.get("/get/websearch_interception_settings")
assert resp.status_code == 200, resp.text
assert resp.json()["active_on_this_pod"] is True
def test_get_reports_no_database_instead_of_empty_settings(self, mock_proxy_config, mock_auth, monkeypatch):
monkeypatch.setattr("litellm.proxy.proxy_server.prisma_client", None)
resp = client.get("/get/websearch_interception_settings")
assert resp.status_code == 500, resp.text
assert "Database not connected" in resp.json()["detail"]["error"]
def test_update_still_saves_when_the_live_reinit_fails(self, mock_proxy_config, monkeypatch):
from unittest.mock import AsyncMock
monkeypatch.setattr("litellm.proxy.proxy_server.store_model_in_db", True)
monkeypatch.setattr("litellm.proxy.proxy_server.prisma_client", object())
monkeypatch.setattr(
"litellm.proxy.proxy_server.proxy_config.init_websearch_interception_settings_in_db",
AsyncMock(side_effect=RuntimeError("callback blew up")),
)
self._override_auth(LitellmUserRoles.PROXY_ADMIN)
try:
resp = client.patch("/update/websearch_interception_settings", json={"enabled": True})
finally:
app.dependency_overrides.clear()
assert resp.status_code == 200, resp.text
assert mock_proxy_config["save_call_count"]() == 1
def test_update_rejects_zero_max_agentic_loops(self, mock_proxy_config, monkeypatch):
monkeypatch.setattr("litellm.proxy.proxy_server.store_model_in_db", True)
self._override_auth(LitellmUserRoles.PROXY_ADMIN)
try:
resp = client.patch(
"/update/websearch_interception_settings",
json={"enabled": True, "max_agentic_loops": 0},
)
finally:
app.dependency_overrides.clear()
assert resp.status_code == 422
assert mock_proxy_config["save_call_count"]() == 0
def test_upload_logo_requires_proxy_admin(monkeypatch):
"""Any authenticated key could previously write a file to the server's disk here."""
from litellm.proxy._types import UserAPIKeyAuth
from litellm.proxy.auth.user_api_key_auth import user_api_key_auth
async def _internal_user_auth():
return UserAPIKeyAuth(
user_id="internal-user-1",
api_key="hashed-internal-key",
user_role=LitellmUserRoles.INTERNAL_USER,
)
app.dependency_overrides[user_api_key_auth] = _internal_user_auth
try:
resp = client.post(
"/upload/logo",
files={"file": ("logo.png", b"\x89PNG\r\n\x1a\n" + b"x" * 32, "image/png")},
)
assert resp.status_code == 403
assert "proxy admin" in resp.json()["detail"].lower()
finally:
app.dependency_overrides.pop(user_api_key_auth, None)
def test_upload_logo_allows_proxy_admin(monkeypatch, tmp_path):
from litellm.proxy._types import UserAPIKeyAuth
from litellm.proxy.auth.user_api_key_auth import user_api_key_auth
async def _admin_auth():
return UserAPIKeyAuth(
user_id="admin-1",
api_key="hashed-admin-key",
user_role=LitellmUserRoles.PROXY_ADMIN,
)
app.dependency_overrides[user_api_key_auth] = _admin_auth
try:
resp = client.post(
"/upload/logo",
files={"file": ("logo.png", b"\x89PNG\r\n\x1a\n" + b"x" * 32, "image/png")},
)
assert resp.status_code == 200, resp.text
assert resp.json()["status"] == "success"
finally:
app.dependency_overrides.pop(user_api_key_auth, None)
uploaded_path = resp.json().get("file_path")
if uploaded_path and os.path.exists(uploaded_path):
os.remove(uploaded_path)
class TestPtuCostAttributionUISetting:
"""``enable_ptu_cost_attribution`` is derived from the environment on every GET.
It is deliberately not an allowlisted, persisted setting: the point of gating PTU
flat cost on an env var is that an admin cannot flip it at runtime from the UI.
"""
@staticmethod
def _mock_prisma(monkeypatch, stored=None):
from unittest.mock import AsyncMock, MagicMock
mock_prisma = MagicMock()
mock_record = None
if stored is not None:
mock_record = MagicMock()
mock_record.ui_settings = stored
mock_prisma.db.litellm_uisettings.find_unique = AsyncMock(return_value=mock_record)
mock_prisma.db.litellm_uisettings.upsert = AsyncMock()
monkeypatch.setattr("litellm.proxy.proxy_server.prisma_client", mock_prisma)
return mock_prisma
def test_reported_false_when_the_env_var_is_unset(self, mock_auth, monkeypatch):
from litellm.proxy.spend_tracking.ptu_feature_flag import PTU_COST_ATTRIBUTION_ENV_VAR
monkeypatch.delenv(PTU_COST_ATTRIBUTION_ENV_VAR, raising=False)
self._mock_prisma(monkeypatch)
response = client.get("/get/ui_settings")
assert response.status_code == 200
assert response.json()["values"]["enable_ptu_cost_attribution"] is False
assert response.json()["source"]["enable_ptu_cost_attribution"] == "default"
def test_reported_true_once_the_env_var_is_set(self, mock_auth, monkeypatch):
from litellm.proxy.spend_tracking.ptu_feature_flag import PTU_COST_ATTRIBUTION_ENV_VAR
monkeypatch.setenv(PTU_COST_ATTRIBUTION_ENV_VAR, "true")
self._mock_prisma(monkeypatch)
response = client.get("/get/ui_settings")
assert response.status_code == 200
assert response.json()["values"]["enable_ptu_cost_attribution"] is True
assert response.json()["source"]["enable_ptu_cost_attribution"] == "config"
def test_reported_config_when_secret_manager_enables_the_flag(
self, mock_auth: None, monkeypatch: pytest.MonkeyPatch
) -> None:
from litellm.proxy.spend_tracking.ptu_feature_flag import PTU_COST_ATTRIBUTION_ENV_VAR
monkeypatch.delenv(PTU_COST_ATTRIBUTION_ENV_VAR, raising=False)
monkeypatch.setattr(
"litellm.proxy.ui_crud_endpoints.proxy_setting_endpoints.is_ptu_cost_attribution_enabled",
lambda: True,
)
self._mock_prisma(monkeypatch)
response = client.get("/get/ui_settings")
assert response.status_code == 200
assert response.json()["values"]["enable_ptu_cost_attribution"] is True
assert response.json()["source"]["enable_ptu_cost_attribution"] == "config"
def test_reported_config_when_secret_manager_disables_the_flag(
self, mock_auth: None, monkeypatch: pytest.MonkeyPatch
) -> None:
from litellm.proxy.spend_tracking.ptu_feature_flag import PTU_COST_ATTRIBUTION_ENV_VAR
monkeypatch.delenv(PTU_COST_ATTRIBUTION_ENV_VAR, raising=False)
monkeypatch.setattr(
"litellm.proxy.ui_crud_endpoints.proxy_setting_endpoints.is_ptu_cost_attribution_enabled",
lambda: False,
)
monkeypatch.setattr(
"litellm.proxy.ui_crud_endpoints.proxy_setting_endpoints.get_secret",
lambda *_args: False,
)
self._mock_prisma(monkeypatch)
response = client.get("/get/ui_settings")
assert response.status_code == 200
assert response.json()["values"]["enable_ptu_cost_attribution"] is False
assert response.json()["source"]["enable_ptu_cost_attribution"] == "config"
def test_a_persisted_true_cannot_forge_the_derived_value(self, mock_auth, monkeypatch):
"""A row written before the allowlist existed must not be able to turn the feature on."""
from litellm.proxy.spend_tracking.ptu_feature_flag import PTU_COST_ATTRIBUTION_ENV_VAR
monkeypatch.delenv(PTU_COST_ATTRIBUTION_ENV_VAR, raising=False)
self._mock_prisma(monkeypatch, stored={"enable_ptu_cost_attribution": True})
response = client.get("/get/ui_settings")
assert response.status_code == 200
assert response.json()["values"]["enable_ptu_cost_attribution"] is False
def test_is_not_an_allowlisted_persisted_setting(self):
from litellm.proxy.ui_crud_endpoints.proxy_setting_endpoints import (
ALLOWED_UI_SETTINGS_FIELDS,
)
assert "enable_ptu_cost_attribution" not in ALLOWED_UI_SETTINGS_FIELDS
def test_the_body_get_returns_is_a_valid_patch_body(self, mock_auth, monkeypatch):
"""Read-modify-write is how a client edits one setting. GET injects the derived key,
so rejecting it on presence made GET's own output an invalid PATCH body: the caller
got a 400 and silently lost the edit it actually wanted."""
from litellm.proxy._types import UserAPIKeyAuth
from litellm.proxy.auth.user_api_key_auth import user_api_key_auth
from litellm.proxy.spend_tracking.ptu_feature_flag import PTU_COST_ATTRIBUTION_ENV_VAR
app.dependency_overrides[user_api_key_auth] = lambda: UserAPIKeyAuth(
user_id="test-user-123",
user_role=LitellmUserRoles.PROXY_ADMIN,
)
monkeypatch.setattr("litellm.proxy.proxy_server.store_model_in_db", True)
monkeypatch.delenv(PTU_COST_ATTRIBUTION_ENV_VAR, raising=False)
mock_prisma = self._mock_prisma(monkeypatch)
try:
round_tripped = client.get("/get/ui_settings").json()["values"]
assert "enable_ptu_cost_attribution" in round_tripped
response = client.patch("/update/ui_settings", json=round_tripped)
finally:
app.dependency_overrides.clear()
assert response.status_code == 200
assert mock_prisma.db.litellm_uisettings.upsert.called
def test_a_co_submitted_setting_still_applies_alongside_the_derived_key(self, mock_auth, monkeypatch):
"""The derived key riding along must not discard the caller's real edit."""
from litellm.proxy._types import UserAPIKeyAuth
from litellm.proxy.auth.user_api_key_auth import user_api_key_auth
from litellm.proxy.spend_tracking.ptu_feature_flag import PTU_COST_ATTRIBUTION_ENV_VAR
app.dependency_overrides[user_api_key_auth] = lambda: UserAPIKeyAuth(
user_id="test-user-123",
user_role=LitellmUserRoles.PROXY_ADMIN,
)
monkeypatch.setattr("litellm.proxy.proxy_server.store_model_in_db", True)
monkeypatch.delenv(PTU_COST_ATTRIBUTION_ENV_VAR, raising=False)
mock_prisma = self._mock_prisma(monkeypatch)
try:
response = client.patch(
"/update/ui_settings",
json={"enable_ptu_cost_attribution": False, "enable_chat_ui": True},
)
finally:
app.dependency_overrides.clear()
assert response.status_code == 200
upsert_data = mock_prisma.db.litellm_uisettings.upsert.call_args.kwargs["data"]
persisted = json.loads(upsert_data["create"]["ui_settings"])
assert persisted["enable_chat_ui"] is True
assert "enable_ptu_cost_attribution" not in persisted
def test_patch_rejects_the_derived_setting(self, mock_auth, monkeypatch):
from litellm.proxy._types import UserAPIKeyAuth
from litellm.proxy.auth.user_api_key_auth import user_api_key_auth
app.dependency_overrides[user_api_key_auth] = lambda: UserAPIKeyAuth(
user_id="test-user-123",
user_role=LitellmUserRoles.PROXY_ADMIN,
)
monkeypatch.setattr("litellm.proxy.proxy_server.store_model_in_db", True)
mock_prisma = self._mock_prisma(monkeypatch)
try:
response = client.patch(
"/update/ui_settings",
json={"enable_ptu_cost_attribution": True},
)
finally:
app.dependency_overrides.clear()
assert response.status_code == 400
assert "enable_ptu_cost_attribution" in str(response.json()["detail"])
assert not mock_prisma.db.litellm_uisettings.upsert.called
class TestEnableChatUISetting:
def test_chat_ui_is_on_when_nothing_is_stored(self, mock_auth, monkeypatch):
TestPtuCostAttributionUISetting._mock_prisma(monkeypatch)
response = client.get("/get/ui_settings")
assert response.status_code == 200
assert response.json()["values"]["enable_chat_ui"] is True
def test_admin_can_still_turn_chat_ui_off(self, mock_auth, monkeypatch):
TestPtuCostAttributionUISetting._mock_prisma(monkeypatch, stored={"enable_chat_ui": False})
response = client.get("/get/ui_settings")
assert response.status_code == 200
assert response.json()["values"]["enable_chat_ui"] is False
class TestApplyUserBudgetToTeamKeysUISetting:
"""``apply_user_budget_to_team_keys`` mirrors general_settings on every GET.
The proxy enforces the key owner's user budget on team keys only when
``general_settings.apply_user_budget_to_team_keys`` is on, so the dashboard
shows the owner's budget gate on a team key iff this derived value is true.
Like the other derived settings it is read-only and never persisted.
"""
@staticmethod
def _mock_prisma(monkeypatch, stored=None):
from unittest.mock import AsyncMock, MagicMock
mock_prisma = MagicMock()
mock_record = None
if stored is not None:
mock_record = MagicMock()
mock_record.ui_settings = stored
mock_prisma.db.litellm_uisettings.find_unique = AsyncMock(return_value=mock_record)
mock_prisma.db.litellm_uisettings.upsert = AsyncMock()
monkeypatch.setattr("litellm.proxy.proxy_server.prisma_client", mock_prisma)
return mock_prisma
def test_reported_false_when_general_settings_lacks_the_flag(self, mock_auth, monkeypatch):
monkeypatch.setattr("litellm.proxy.proxy_server.general_settings", {})
self._mock_prisma(monkeypatch)
response = client.get("/get/ui_settings")
assert response.status_code == 200
assert response.json()["values"]["apply_user_budget_to_team_keys"] is False
def test_reported_true_when_general_settings_enables_the_flag(self, mock_auth, monkeypatch):
monkeypatch.setattr(
"litellm.proxy.proxy_server.general_settings",
{"apply_user_budget_to_team_keys": True},
)
self._mock_prisma(monkeypatch)
response = client.get("/get/ui_settings")
assert response.status_code == 200
assert response.json()["values"]["apply_user_budget_to_team_keys"] is True
def test_non_json_values_elsewhere_in_general_settings_do_not_break_get(self, mock_auth, monkeypatch):
"""general_settings holds non-JSON values at runtime (e.g. RoleBasedPermissions
instances under "role_permissions"); only the flag itself may be inspected."""
monkeypatch.setattr(
"litellm.proxy.proxy_server.general_settings",
{"role_permissions": [object()], "apply_user_budget_to_team_keys": True},
)
self._mock_prisma(monkeypatch)
response = client.get("/get/ui_settings")
assert response.status_code == 200
assert response.json()["values"]["apply_user_budget_to_team_keys"] is True
def test_reads_only_the_flag_key(self):
from litellm.proxy.ui_crud_endpoints.proxy_setting_endpoints import (
_apply_user_budget_to_team_keys_enabled,
)
assert _apply_user_budget_to_team_keys_enabled({"apply_user_budget_to_team_keys": True}) is True
assert _apply_user_budget_to_team_keys_enabled({}) is False
assert _apply_user_budget_to_team_keys_enabled({"apply_user_budget_to_team_keys": "true"}) is False
def test_a_persisted_true_cannot_forge_the_derived_value(self, mock_auth, monkeypatch):
"""A row written before the allowlist existed must not be able to turn the feature on."""
monkeypatch.setattr("litellm.proxy.proxy_server.general_settings", {})
self._mock_prisma(monkeypatch, stored={"apply_user_budget_to_team_keys": True})
response = client.get("/get/ui_settings")
assert response.status_code == 200
assert response.json()["values"]["apply_user_budget_to_team_keys"] is False
def test_is_not_an_allowlisted_persisted_setting(self):
from litellm.proxy.ui_crud_endpoints.proxy_setting_endpoints import (
ALLOWED_UI_SETTINGS_FIELDS,
)
assert "apply_user_budget_to_team_keys" not in ALLOWED_UI_SETTINGS_FIELDS
class TestTeamAdminEditableTeamFieldsSetting:
"""team_admin_editable_team_fields: the proxy-wide allow-list update_team applies to team admins."""
def _as_proxy_admin(self, monkeypatch):
from unittest.mock import AsyncMock, MagicMock
from litellm.proxy._types import UserAPIKeyAuth
from litellm.proxy.auth.user_api_key_auth import user_api_key_auth
app.dependency_overrides[user_api_key_auth] = lambda: UserAPIKeyAuth(
user_id="test-user-123",
user_role=LitellmUserRoles.PROXY_ADMIN,
)
monkeypatch.setattr("litellm.proxy.proxy_server.store_model_in_db", True)
mock_prisma = MagicMock()
mock_prisma.db.litellm_uisettings.upsert = AsyncMock()
mock_prisma.db.litellm_uisettings.find_unique = AsyncMock(return_value=None)
monkeypatch.setattr("litellm.proxy.proxy_server.prisma_client", mock_prisma)
return mock_prisma
def test_patch_rejects_field_names_the_proxy_does_not_support(self, monkeypatch):
mock_prisma = self._as_proxy_admin(monkeypatch)
monkeypatch.setattr(
"litellm.proxy.ui_crud_endpoints.proxy_setting_endpoints.SUPPORTED_TEAM_ADMIN_PERMISSIONS",
frozenset({"tpm_limit"}),
)
try:
response = client.patch(
"/update/ui_settings",
json={"team_admin_editable_team_fields": ["tpm_limit", "blocked", "organization_id"]},
)
finally:
app.dependency_overrides.clear()
assert response.status_code == 400
detail = response.json()["detail"]["error"]
assert "['blocked', 'organization_id']" in detail
assert "['tpm_limit']" in detail
assert not mock_prisma.db.litellm_uisettings.upsert.called
def test_patch_rejects_a_non_list_value(self, monkeypatch):
self._as_proxy_admin(monkeypatch)
try:
response = client.patch("/update/ui_settings", json={"team_admin_editable_team_fields": "tpm_limit"})
finally:
app.dependency_overrides.clear()
assert response.status_code == 422
def test_patch_422_never_echoes_the_submitted_value(self, monkeypatch):
self._as_proxy_admin(monkeypatch)
submitted = "hunter2-Sup3rSecret!"
try:
response = client.patch("/update/ui_settings", json={"team_admin_editable_team_fields": submitted})
finally:
app.dependency_overrides.clear()
assert response.status_code == 422
assert submitted.encode() not in response.content
detail = response.json()["detail"]
assert detail[0]["loc"] == ["team_admin_editable_team_fields"]
assert detail[0]["msg"]
assert set(detail[0]) == {"type", "loc", "msg"}
def test_patch_persists_and_syncs_the_list_to_general_settings(self, monkeypatch):
mock_prisma = self._as_proxy_admin(monkeypatch)
general_settings: dict = {"team_admin_editable_team_fields": []}
monkeypatch.setattr("litellm.proxy.proxy_server.general_settings", general_settings)
enabled = ["tpm_limit", "rpm_limit", "max_budget"]
try:
response = client.patch("/update/ui_settings", json={"team_admin_editable_team_fields": enabled})
finally:
app.dependency_overrides.clear()
assert response.status_code == 200
stored = json.loads(mock_prisma.db.litellm_uisettings.upsert.call_args.kwargs["data"]["create"]["ui_settings"])
assert stored["team_admin_editable_team_fields"] == enabled
assert general_settings["team_admin_editable_team_fields"] == enabled
def test_patch_rejects_raise_max_budget_without_max_budget(self, monkeypatch: pytest.MonkeyPatch):
mock_prisma = self._as_proxy_admin(monkeypatch)
try:
response = client.patch(
"/update/ui_settings", json={"team_admin_editable_team_fields": ["tpm_limit", "raise_max_budget"]}
)
finally:
app.dependency_overrides.clear()
assert response.status_code == 400
detail = response.json()["detail"]["error"]
assert "'raise_max_budget'" in detail
assert "'max_budget'" in detail
assert not mock_prisma.db.litellm_uisettings.upsert.called
def test_patch_accepts_raise_max_budget_with_max_budget_and_update_team_sees_it(
self, monkeypatch: pytest.MonkeyPatch
):
from litellm.proxy.management_endpoints.team_admin_field_permissions import (
team_admin_may_raise_max_budget,
)
mock_prisma = self._as_proxy_admin(monkeypatch)
general_settings: dict[str, object] = {"team_admin_editable_team_fields": ["max_budget"]}
monkeypatch.setattr("litellm.proxy.proxy_server.general_settings", general_settings)
assert team_admin_may_raise_max_budget(general_settings) is False
try:
response = client.patch(
"/update/ui_settings", json={"team_admin_editable_team_fields": ["max_budget", "raise_max_budget"]}
)
finally:
app.dependency_overrides.clear()
assert response.status_code == 200
stored = json.loads(mock_prisma.db.litellm_uisettings.upsert.call_args.kwargs["data"]["create"]["ui_settings"])
assert stored["team_admin_editable_team_fields"] == ["max_budget", "raise_max_budget"]
assert team_admin_may_raise_max_budget(general_settings) is True
def test_patch_accepts_the_projects_permission_and_project_endpoints_see_it(self, monkeypatch):
from litellm.proxy.management_endpoints.team_admin_field_permissions import (
team_admin_may_manage_projects,
)
mock_prisma = self._as_proxy_admin(monkeypatch)
general_settings: dict = {}
monkeypatch.setattr("litellm.proxy.proxy_server.general_settings", general_settings)
assert team_admin_may_manage_projects(general_settings) is False
try:
response = client.patch("/update/ui_settings", json={"team_admin_editable_team_fields": ["projects"]})
finally:
app.dependency_overrides.clear()
assert response.status_code == 200
stored = json.loads(mock_prisma.db.litellm_uisettings.upsert.call_args.kwargs["data"]["create"]["ui_settings"])
assert stored["team_admin_editable_team_fields"] == ["projects"]
assert team_admin_may_manage_projects(general_settings) is True
def test_patch_accepts_the_member_key_budgets_permission(self, monkeypatch):
from litellm.proxy.management_endpoints.team_admin_field_permissions import (
team_admin_may_edit_member_key_budgets,
)
mock_prisma = self._as_proxy_admin(monkeypatch)
general_settings: dict = {}
monkeypatch.setattr("litellm.proxy.proxy_server.general_settings", general_settings)
assert team_admin_may_edit_member_key_budgets(general_settings) is False
try:
response = client.patch(
"/update/ui_settings", json={"team_admin_editable_team_fields": ["member_key_budgets"]}
)
finally:
app.dependency_overrides.clear()
assert response.status_code == 200
stored = json.loads(mock_prisma.db.litellm_uisettings.upsert.call_args.kwargs["data"]["create"]["ui_settings"])
assert stored["team_admin_editable_team_fields"] == ["member_key_budgets"]
assert team_admin_may_edit_member_key_budgets(general_settings) is True
def test_patch_accepts_the_create_member_keys_permission(self, monkeypatch):
from litellm.proxy.management_endpoints.team_admin_field_permissions import (
team_admin_may_create_member_keys,
)
mock_prisma = self._as_proxy_admin(monkeypatch)
general_settings: dict = {}
monkeypatch.setattr("litellm.proxy.proxy_server.general_settings", general_settings)
assert team_admin_may_create_member_keys(general_settings) is False
try:
response = client.patch(
"/update/ui_settings", json={"team_admin_editable_team_fields": ["create_member_keys"]}
)
finally:
app.dependency_overrides.clear()
assert response.status_code == 200
stored = json.loads(mock_prisma.db.litellm_uisettings.upsert.call_args.kwargs["data"]["create"]["ui_settings"])
assert stored["team_admin_editable_team_fields"] == ["create_member_keys"]
assert team_admin_may_create_member_keys(general_settings) is True
def test_patch_with_an_empty_list_turns_team_admin_editing_off_again(self, monkeypatch):
mock_prisma = self._as_proxy_admin(monkeypatch)
general_settings: dict = {"team_admin_editable_team_fields": ["tpm_limit"]}
monkeypatch.setattr("litellm.proxy.proxy_server.general_settings", general_settings)
try:
response = client.patch("/update/ui_settings", json={"team_admin_editable_team_fields": []})
finally:
app.dependency_overrides.clear()
assert response.status_code == 200
stored = json.loads(mock_prisma.db.litellm_uisettings.upsert.call_args.kwargs["data"]["create"]["ui_settings"])
assert stored["team_admin_editable_team_fields"] == []
assert general_settings["team_admin_editable_team_fields"] == []
def test_get_reports_the_stored_list_and_advertises_supported_fields(self, mock_auth, monkeypatch):
from unittest.mock import AsyncMock, MagicMock
mock_prisma = MagicMock()
mock_db_record = MagicMock()
mock_db_record.ui_settings = {"team_admin_editable_team_fields": ["tpm_limit"]}
mock_prisma.db.litellm_uisettings.find_unique = AsyncMock(return_value=mock_db_record)
monkeypatch.setattr("litellm.proxy.proxy_server.prisma_client", mock_prisma)
general_settings: dict = {}
monkeypatch.setattr("litellm.proxy.proxy_server.general_settings", general_settings)
response = client.get("/get/ui_settings")
assert response.status_code == 200
data = response.json()
assert data["values"]["team_admin_editable_team_fields"] == ["tpm_limit"]
assert general_settings["team_admin_editable_team_fields"] == ["tpm_limit"]
field_schema = data["field_schema"]["properties"]["team_admin_editable_team_fields"]
assert field_schema["type"] == "array"
assert field_schema["items"]["type"] == "string"
assert "tpm_limit" in field_schema["items"]["enum"]
assert "projects" in field_schema["items"]["enum"]
@pytest.mark.parametrize(("stored", "patched"), [(["tpm_limit"], []), (["rpm_limit"], ["max_budget"])])
def test_get_reports_its_own_db_row_whatever_an_earlier_test_patched(self, monkeypatch, stored, patched):
"""A booted proxy keeps its runtime settings in one shared store. Each case PATCHes a list into
that store, so whichever case ran second used to read the other's list instead of its own DB row."""
from unittest.mock import AsyncMock, MagicMock
from litellm.proxy import proxy_server
mock_prisma = self._as_proxy_admin(monkeypatch)
mock_db_record = MagicMock()
mock_db_record.ui_settings = {"team_admin_editable_team_fields": stored}
mock_prisma.db.litellm_uisettings.find_unique = AsyncMock(return_value=mock_db_record)
monkeypatch.setattr("litellm.proxy.proxy_server.general_settings", {})
try:
fetched = client.get("/get/ui_settings")
proxy_server._bind_general_settings_store(proxy_server.proxy_config.settings)
response = client.patch("/update/ui_settings", json={"team_admin_editable_team_fields": patched})
finally:
app.dependency_overrides.clear()
assert fetched.json()["values"]["team_admin_editable_team_fields"] == stored
assert response.status_code == 200
assert proxy_server.general_settings["team_admin_editable_team_fields"] == patched
class TestSyncUiSettingsToGeneralSettings:
"""The DB re-read each pod runs on startup and on every config reload."""
def _sync(self):
from litellm.proxy.ui_crud_endpoints.proxy_setting_endpoints import (
sync_ui_settings_to_general_settings,
)
return sync_ui_settings_to_general_settings
@pytest.mark.asyncio
async def test_applies_runtime_flags_and_leaves_other_ui_settings_alone(self, monkeypatch):
from unittest.mock import AsyncMock, MagicMock
general_settings: dict = {"allow_agents_for_team_admins": False}
monkeypatch.setattr("litellm.proxy.proxy_server.general_settings", general_settings)
mock_prisma = MagicMock()
record = MagicMock()
record.ui_settings = json.dumps(
{
"allow_agents_for_team_admins": True,
"team_admin_editable_team_fields": ["tpm_limit"],
"enable_chat_ui": False,
}
)
mock_prisma.db.litellm_uisettings.find_unique = AsyncMock(return_value=record)
applied = await self._sync()(mock_prisma)
assert dict(applied) == {
"allow_agents_for_team_admins": True,
"team_admin_editable_team_fields": ["tpm_limit"],
}
assert general_settings["allow_agents_for_team_admins"] is True
assert general_settings["team_admin_editable_team_fields"] == ["tpm_limit"]
assert "enable_chat_ui" not in general_settings
@pytest.mark.asyncio
async def test_reads_a_row_the_prisma_client_already_deserialized(self, monkeypatch):
from unittest.mock import AsyncMock, MagicMock
general_settings: dict = {}
monkeypatch.setattr("litellm.proxy.proxy_server.general_settings", general_settings)
mock_prisma = MagicMock()
record = MagicMock()
record.ui_settings = {"team_admin_editable_team_fields": ["rpm_limit"]}
mock_prisma.db.litellm_uisettings.find_unique = AsyncMock(return_value=record)
await self._sync()(mock_prisma)
assert general_settings["team_admin_editable_team_fields"] == ["rpm_limit"]
@pytest.mark.asyncio
async def test_without_a_stored_row_general_settings_is_left_untouched(self, monkeypatch):
from unittest.mock import AsyncMock, MagicMock
general_settings: dict = {"allow_agents_for_team_admins": True}
monkeypatch.setattr("litellm.proxy.proxy_server.general_settings", general_settings)
mock_prisma = MagicMock()
mock_prisma.db.litellm_uisettings.find_unique = AsyncMock(return_value=None)
applied = await self._sync()(mock_prisma)
assert dict(applied) == {}
assert general_settings == {"allow_agents_for_team_admins": True}
def test_applied_runtime_flags_keep_the_ui_row_as_the_source(self, monkeypatch):
from litellm.proxy import proxy_server
from litellm.proxy.config_resolvers import SettingsStore
from litellm.proxy.ui_crud_endpoints.proxy_setting_endpoints import apply_runtime_general_settings_flags
general_settings = SettingsStore("general_settings")
general_settings.load_yaml({})
monkeypatch.setattr(proxy_server, "general_settings", general_settings)
apply_runtime_general_settings_flags({"forward_client_headers_to_llm_api": True})
assert general_settings["forward_client_headers_to_llm_api"] is True
assert general_settings.source("forward_client_headers_to_llm_api") == "db"
def test_every_runtime_flag_reaches_a_reader_once_applied(self, monkeypatch):
"""A flag the settings rules do not route to the ui_settings row is stored but never read back."""
from litellm.proxy import proxy_server
from litellm.proxy.config_resolvers import SettingsStore
from litellm.proxy.ui_crud_endpoints.proxy_setting_endpoints import (
TEAM_ADMIN_EDITABLE_TEAM_FIELDS_SETTING,
_RUNTIME_GENERAL_SETTINGS_FLAGS,
apply_runtime_general_settings_flags,
)
general_settings = SettingsStore("general_settings")
general_settings.load_yaml({})
monkeypatch.setattr(proxy_server, "general_settings", general_settings)
stored = {
key: (["tpm_limit"] if key == TEAM_ADMIN_EDITABLE_TEAM_FIELDS_SETTING else True)
for key in _RUNTIME_GENERAL_SETTINGS_FLAGS
}
assert stored
apply_runtime_general_settings_flags(stored)
read_back = {key: general_settings.get(key) for key in stored}
assert read_back == stored
def test_applied_runtime_flags_cannot_override_the_config_file(self, monkeypatch):
from litellm.proxy import proxy_server
from litellm.proxy.config_resolvers import SettingsStore
from litellm.proxy.ui_crud_endpoints.proxy_setting_endpoints import apply_runtime_general_settings_flags
general_settings = SettingsStore("general_settings")
general_settings.load_yaml({"forward_client_headers_to_llm_api": False})
monkeypatch.setattr(proxy_server, "general_settings", general_settings)
apply_runtime_general_settings_flags({"forward_client_headers_to_llm_api": True})
assert general_settings["forward_client_headers_to_llm_api"] is False
assert general_settings.source("forward_client_headers_to_llm_api") == "config"
class TestMoyaiUrlSetting:
@pytest.mark.parametrize(
"value,expected",
[
(None, None),
("", None),
("https://moyai.example.com", "https://moyai.example.com"),
("https://moyai.example.com/", "https://moyai.example.com"),
("http://localhost:8787/", "http://localhost:8787"),
],
)
def test_moyai_url_validator_accepts_and_normalizes(self, value, expected):
from litellm.proxy.ui_crud_endpoints.proxy_setting_endpoints import UISettings
assert UISettings(moyai_url=value).moyai_url == expected
@pytest.mark.parametrize(
"value",
[
"javascript:alert(1)",
"ftp://moyai.example.com",
"https://user:[email protected]",
"https://[email protected]",
"not-a-url",
"https://",
],
)
def test_moyai_url_validator_rejects(self, value):
from pydantic import ValidationError
from litellm.proxy.ui_crud_endpoints.proxy_setting_endpoints import UISettings
with pytest.raises(ValidationError):
UISettings(moyai_url=value)
def test_moyai_url_is_in_allowed_ui_settings_fields(self):
from litellm.proxy.ui_crud_endpoints.proxy_setting_endpoints import ALLOWED_UI_SETTINGS_FIELDS
assert "moyai_url" in ALLOWED_UI_SETTINGS_FIELDS
@pytest.mark.asyncio
async def test_moyai_url_patch_sets_and_clears(self, monkeypatch):
from types import SimpleNamespace
from unittest.mock import AsyncMock, MagicMock
from litellm.proxy import proxy_server
from litellm.proxy._types import UserAPIKeyAuth
from litellm.proxy.ui_crud_endpoints.proxy_setting_endpoints import update_ui_settings
prisma = MagicMock()
prisma.db.litellm_uisettings.find_unique = AsyncMock(
return_value=SimpleNamespace(ui_settings={"moyai_url": "https://old.example.com"})
)
persisted: dict = {}
async def _upsert(where, data):
persisted.update(json.loads(data["update"]["ui_settings"]))
prisma.db.litellm_uisettings.upsert = AsyncMock(side_effect=_upsert)
monkeypatch.setattr(proxy_server, "prisma_client", prisma)
monkeypatch.setattr(proxy_server, "store_model_in_db", True)
actor = UserAPIKeyAuth(user_id="admin", user_role=LitellmUserRoles.PROXY_ADMIN)
await update_ui_settings({"moyai_url": "https://new.example.com/"}, actor)
assert persisted["moyai_url"] == "https://new.example.com"
await update_ui_settings({"moyai_url": None}, actor)
assert persisted["moyai_url"] is None