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 asyncio
import hashlib
import json
import logging
from collections.abc import AsyncIterator, Mapping, Sequence
from contextlib import asynccontextmanager
from datetime import datetime, timezone
from types import SimpleNamespace
from typing import TYPE_CHECKING, Final, cast
from unittest.mock import AsyncMock, MagicMock
import httpx
import pytest
from fastapi import HTTPException
from fastapi.testclient import TestClient
from pytest_mock import MockerFixture
from litellm.llms.custom_httpx.http_handler import AsyncHTTPHandler
from litellm.proxy._types import (
LiteLLM_UserTable,
LiteLLM_UserTableFiltered,
LitellmUserRoles,
NewUserRequest,
NewUserResponse,
ProxyErrorTypes,
ProxyException,
UpdateUserRequest,
UserAPIKeyAuth,
)
from litellm.proxy.auth import auth_checks
from litellm.proxy.common_utils.user_api_key_cache import UserApiKeyCache
from litellm.proxy.management_endpoints.internal_user_endpoints import (
_authorize_user_list_request,
_resolve_org_filter_for_user_search,
_resolve_user_email_metadata,
_update_internal_user_params,
get_users,
new_user,
ui_view_users,
)
from litellm.proxy.proxy_server import app
from litellm.types.proxy.auth.auth_checks import UserNotFoundError
from litellm.types.proxy.management_endpoints.internal_user_endpoints import InsensitiveContains
from tests.unit.proxy.management_endpoints.jwt_key_mapping_doubles import (
CascadingJWTMappingTable,
JWTMappingRow,
)
client = TestClient(app)
if TYPE_CHECKING:
from litellm.caching.redis_cache import RedisCache
from litellm.proxy.utils import PrismaClient
@pytest.mark.asyncio
async def test_ui_view_users_with_null_email(mocker, caplog):
"""
Test that /user/filter/ui endpoint returns users even when they have null email fields.
Uses proxy admin so no org filtering is applied.
"""
# Mock the prisma client
mock_prisma_client = mocker.MagicMock()
# Create mock user data with null email
mock_user = mocker.MagicMock()
mock_user.model_dump.return_value = {
"user_id": "test-user-null-email",
"user_email": None,
"user_role": "proxy_admin",
"created_at": "2024-01-01T00:00:00Z",
}
async def mock_find_many(*args, **kwargs):
return [mock_user]
mock_prisma_client.db.litellm_usertable.find_many = mock_find_many
# Flag OFF by default
mocker.patch(
"litellm.proxy.ui_crud_endpoints.proxy_setting_endpoints.get_ui_settings_cached",
return_value={},
)
mocker.patch("litellm.proxy.proxy_server.prisma_client", mock_prisma_client)
# Proxy admin: no org filter, no get_user_object call
response = await ui_view_users(
user_api_key_dict=UserAPIKeyAuth(user_id="test_user", user_role=LitellmUserRoles.PROXY_ADMIN),
user_id="test_user",
user_email=None,
team_id=None,
page=1,
page_size=50,
)
assert response == [LiteLLM_UserTableFiltered(user_id="test-user-null-email", user_email=None)]
@pytest.mark.asyncio
async def test_ui_view_users_proxy_admin_no_org_filter(mocker):
"""
Proxy admin: find_many is called without organization_memberships in where.
"""
mock_prisma_client = mocker.MagicMock()
async def mock_find_many(*args, **kwargs):
assert "organization_memberships" not in (kwargs.get("where") or {})
return []
mock_prisma_client.db.litellm_usertable.find_many = mock_find_many
# Flag OFF by default
mocker.patch(
"litellm.proxy.ui_crud_endpoints.proxy_setting_endpoints.get_ui_settings_cached",
return_value={},
)
mocker.patch("litellm.proxy.proxy_server.prisma_client", mock_prisma_client)
await ui_view_users(
user_api_key_dict=UserAPIKeyAuth(user_id="admin", user_role=LitellmUserRoles.PROXY_ADMIN),
user_id=None,
user_email="foo",
team_id=None,
page=1,
page_size=50,
)
UserWhereCondition = InsensitiveContains | Sequence[Mapping[str, InsensitiveContains]]
def _matches_user_where(row: LiteLLM_UserTableFiltered, where: Mapping[str, UserWhereCondition]) -> bool:
def matches(field: str, condition: UserWhereCondition) -> bool:
if not isinstance(condition, Mapping):
return any(_matches_user_where(row, branch) for branch in condition)
value: Final = {"user_id": row.user_id, "user_email": row.user_email}[field]
return value is not None and condition["contains"].lower() in value.lower()
return all(matches(field, condition) for field, condition in where.items())
@pytest.mark.parametrize(
"params, expected_user_ids",
[
({"search": "SVC"}, ["svc-bot"]),
({"search": "ali"}, ["alice-admin"]),
({"search": "example.com"}, ["alice-admin"]),
({"search": "admin"}, ["alice-admin"]),
({"user_email": "svc"}, []),
({"user_id": "svc"}, ["svc-bot"]),
({"search": "ali", "user_id": "svc"}, []),
],
)
def test_ui_view_users_search_matches_user_id_or_email(
mocker: MockerFixture, params: Mapping[str, str], expected_user_ids: list[str]
):
"""
search= returns users whose user_id or user_email contains the value (case-insensitive),
including users with no email; user_id=/user_email= keep filtering a single field and AND with search.
"""
from litellm.proxy.auth.user_api_key_auth import user_api_key_auth
users = (
LiteLLM_UserTableFiltered(user_id="alice-admin", user_email="[email protected]"),
LiteLLM_UserTableFiltered(user_id="svc-bot", user_email=None),
LiteLLM_UserTableFiltered(user_id="bob", user_email="[email protected]"),
)
async def mock_find_many(*, where: Mapping[str, UserWhereCondition], **_: object):
return [user for user in users if _matches_user_where(user, where)]
mock_prisma_client = mocker.MagicMock()
mock_prisma_client.db.litellm_usertable.find_many = mock_find_many
mocker.patch( # test-quality-ok: endpoint reads settings via module global; same seam as sibling tests
"litellm.proxy.ui_crud_endpoints.proxy_setting_endpoints.get_ui_settings_cached",
return_value={},
)
mocker.patch( # test-quality-ok: endpoint reads prisma_client via module global; same seam as sibling tests
"litellm.proxy.proxy_server.prisma_client", mock_prisma_client
)
app.dependency_overrides[user_api_key_auth] = lambda: UserAPIKeyAuth(
user_id="admin", user_role=LitellmUserRoles.PROXY_ADMIN
)
try:
response = client.get("/user/filter/ui", params=params)
finally:
app.dependency_overrides.pop(user_api_key_auth, None)
assert response.status_code == 200, response.text
assert [user["user_id"] for user in response.json()] == expected_user_ids
@pytest.mark.asyncio
async def test_ui_view_users_org_admin_filtered_by_org(mocker):
"""
Org admin with scope_user_search_to_org ON: find_many is called with
organization_memberships filter so only users in the caller's org(s) are returned.
"""
from litellm.proxy._types import LiteLLM_OrganizationMembershipTable
mock_prisma_client = mocker.MagicMock()
org_id = "org-123"
async def mock_find_many(*args, **kwargs):
where = kwargs.get("where") or {}
assert "organization_memberships" in where
assert where["organization_memberships"] == {"some": {"organization_id": {"in": [org_id]}}}
return []
mock_prisma_client.db.litellm_usertable.find_many = mock_find_many
# Flag ON
mocker.patch(
"litellm.proxy.ui_crud_endpoints.proxy_setting_endpoints.get_ui_settings_cached",
return_value={"scope_user_search_to_org": True},
)
mocker.patch("litellm.proxy.proxy_server.prisma_client", mock_prisma_client)
mocker.patch("litellm.proxy.proxy_server.user_api_key_cache", mocker.MagicMock())
mocker.patch("litellm.proxy.proxy_server.proxy_logging_obj", mocker.MagicMock())
caller_user = mocker.MagicMock()
caller_user.organization_memberships = [
LiteLLM_OrganizationMembershipTable(
user_id="org-admin",
organization_id=org_id,
user_role=LitellmUserRoles.ORG_ADMIN.value,
created_at=datetime.now(timezone.utc),
updated_at=datetime.now(timezone.utc),
)
]
async def mock_get_user_object(*args, **kwargs):
return caller_user
mocker.patch(
"litellm.proxy.management_endpoints.internal_user_endpoints.get_user_object",
side_effect=mock_get_user_object,
)
response = await ui_view_users(
user_api_key_dict=UserAPIKeyAuth(user_id="org-admin", user_role=None),
user_id=None,
user_email="u",
team_id=None,
page=1,
page_size=50,
)
assert response == []
@pytest.mark.asyncio
async def test_ui_view_users_non_org_admin_returns_403(mocker):
"""
Flag ON, caller is not proxy admin and not org admin, no team_id: endpoint returns 403.
"""
from fastapi import HTTPException
mock_prisma_client = mocker.MagicMock()
# Flag ON
mocker.patch(
"litellm.proxy.ui_crud_endpoints.proxy_setting_endpoints.get_ui_settings_cached",
return_value={"scope_user_search_to_org": True},
)
mocker.patch("litellm.proxy.proxy_server.prisma_client", mock_prisma_client)
mocker.patch("litellm.proxy.proxy_server.user_api_key_cache", mocker.MagicMock())
mocker.patch("litellm.proxy.proxy_server.proxy_logging_obj", mocker.MagicMock())
# Caller has no org admin membership
caller_user = mocker.MagicMock()
caller_user.organization_memberships = [] # not an org admin
async def mock_get_user_object(*args, **kwargs):
return caller_user
mocker.patch(
"litellm.proxy.management_endpoints.internal_user_endpoints.get_user_object",
side_effect=mock_get_user_object,
)
with pytest.raises(HTTPException) as exc_info:
await ui_view_users(
user_api_key_dict=UserAPIKeyAuth(user_id="internal_user", user_role=None),
user_id=None,
user_email="u",
team_id=None,
page=1,
page_size=50,
)
assert exc_info.value.status_code == 403
assert "scope_user_search_to_org is enabled" in str(exc_info.value.detail)
@pytest.mark.asyncio
async def test_ui_view_users_flag_off_internal_user_can_search(mocker):
"""
Flag OFF (default): any authenticated user can search all users without org filtering.
"""
mock_prisma_client = mocker.MagicMock()
async def mock_find_many(*args, **kwargs):
where = kwargs.get("where") or {}
assert "organization_memberships" not in where
return []
mock_prisma_client.db.litellm_usertable.find_many = mock_find_many
# Flag OFF
mocker.patch(
"litellm.proxy.ui_crud_endpoints.proxy_setting_endpoints.get_ui_settings_cached",
return_value={},
)
mocker.patch("litellm.proxy.proxy_server.prisma_client", mock_prisma_client)
response = await ui_view_users(
user_api_key_dict=UserAPIKeyAuth(user_id="internal_user", user_role=None),
user_id=None,
user_email="foo",
team_id=None,
page=1,
page_size=50,
)
assert response == []
@pytest.mark.asyncio
async def test_ui_view_users_flag_on_team_admin_org_team(mocker):
"""
Flag ON, team admin for org-bound team: org filter is applied using team's org.
"""
from litellm.proxy._types import LiteLLM_TeamTableCachedObj
mock_prisma_client = mocker.MagicMock()
org_id = "org-456"
tid = "team-789"
async def mock_find_many(*args, **kwargs):
where = kwargs.get("where") or {}
assert "organization_memberships" in where
assert where["organization_memberships"] == {"some": {"organization_id": {"in": [org_id]}}}
return []
mock_prisma_client.db.litellm_usertable.find_many = mock_find_many
# Flag ON
mocker.patch(
"litellm.proxy.ui_crud_endpoints.proxy_setting_endpoints.get_ui_settings_cached",
return_value={"scope_user_search_to_org": True},
)
# Mock get_team_object
team_obj = LiteLLM_TeamTableCachedObj(
team_id=tid,
team_alias="test-team",
organization_id=org_id,
members_with_roles=[{"user_id": "team-admin-user", "role": "admin"}],
)
async def mock_get_team_object(*args, **kwargs):
return team_obj
mocker.patch(
"litellm.proxy.management_endpoints.internal_user_endpoints.get_team_object",
side_effect=mock_get_team_object,
)
mocker.patch("litellm.proxy.proxy_server.prisma_client", mock_prisma_client)
mocker.patch("litellm.proxy.proxy_server.user_api_key_cache", mocker.MagicMock())
mocker.patch("litellm.proxy.proxy_server.proxy_logging_obj", mocker.MagicMock())
# Caller is not org admin
caller_user = mocker.MagicMock()
caller_user.organization_memberships = []
async def mock_get_user_object(*args, **kwargs):
return caller_user
mocker.patch(
"litellm.proxy.management_endpoints.internal_user_endpoints.get_user_object",
side_effect=mock_get_user_object,
)
response = await ui_view_users(
user_api_key_dict=UserAPIKeyAuth(user_id="team-admin-user", user_role=None),
user_id=None,
user_email="u",
team_id=tid,
page=1,
page_size=50,
)
assert response == []
@pytest.mark.asyncio
async def test_ui_view_users_flag_on_team_admin_non_org_team_403(mocker):
"""
Flag ON, team admin for non-org team: returns 403.
"""
from fastapi import HTTPException
from litellm.proxy._types import LiteLLM_TeamTableCachedObj
mock_prisma_client = mocker.MagicMock()
tid = "team-no-org"
# Flag ON
mocker.patch(
"litellm.proxy.ui_crud_endpoints.proxy_setting_endpoints.get_ui_settings_cached",
return_value={"scope_user_search_to_org": True},
)
# Mock get_team_object — team has no organization_id
team_obj = LiteLLM_TeamTableCachedObj(
team_id=tid,
team_alias="no-org-team",
organization_id=None,
members_with_roles=[{"user_id": "team-admin-user", "role": "admin"}],
)
async def mock_get_team_object(*args, **kwargs):
return team_obj
mocker.patch(
"litellm.proxy.management_endpoints.internal_user_endpoints.get_team_object",
side_effect=mock_get_team_object,
)
mocker.patch("litellm.proxy.proxy_server.prisma_client", mock_prisma_client)
mocker.patch("litellm.proxy.proxy_server.user_api_key_cache", mocker.MagicMock())
mocker.patch("litellm.proxy.proxy_server.proxy_logging_obj", mocker.MagicMock())
# Caller is not org admin
caller_user = mocker.MagicMock()
caller_user.organization_memberships = []
async def mock_get_user_object(*args, **kwargs):
return caller_user
mocker.patch(
"litellm.proxy.management_endpoints.internal_user_endpoints.get_user_object",
side_effect=mock_get_user_object,
)
with pytest.raises(HTTPException) as exc_info:
await ui_view_users(
user_api_key_dict=UserAPIKeyAuth(user_id="team-admin-user", user_role=None),
user_id=None,
user_email="u",
team_id=tid,
page=1,
page_size=50,
)
assert exc_info.value.status_code == 403
assert "not part of an organization" in str(exc_info.value.detail)
@pytest.mark.asyncio
async def test_ui_view_users_flag_on_team_admin_org_member_no_team_id(mocker):
"""
Flag ON, team admin who is an org member (not org admin), no team_id param:
should succeed and filter by the user's org membership.
"""
mock_prisma_client = mocker.MagicMock()
org_id = "org-member-org"
async def mock_find_many(*args, **kwargs):
where = kwargs.get("where") or {}
assert "organization_memberships" in where
assert where["organization_memberships"] == {"some": {"organization_id": {"in": [org_id]}}}
return []
mock_prisma_client.db.litellm_usertable.find_many = mock_find_many
mocker.patch(
"litellm.proxy.ui_crud_endpoints.proxy_setting_endpoints.get_ui_settings_cached",
return_value={"scope_user_search_to_org": True},
)
mocker.patch("litellm.proxy.proxy_server.prisma_client", mock_prisma_client)
mocker.patch("litellm.proxy.proxy_server.user_api_key_cache", mocker.MagicMock())
mocker.patch("litellm.proxy.proxy_server.proxy_logging_obj", mocker.MagicMock())
# Caller is org member (internal_user role, not org admin)
membership = mocker.MagicMock()
membership.organization_id = org_id
membership.user_role = "internal_user"
caller_user = mocker.MagicMock()
caller_user.organization_memberships = [membership]
async def mock_get_user_object(*args, **kwargs):
return caller_user
mocker.patch(
"litellm.proxy.management_endpoints.internal_user_endpoints.get_user_object",
side_effect=mock_get_user_object,
)
response = await ui_view_users(
user_api_key_dict=UserAPIKeyAuth(user_id="team-admin-in-org", user_role=None),
user_id=None,
user_email="u",
team_id=None,
page=1,
page_size=50,
)
assert response == []
@pytest.mark.asyncio
async def test_ui_view_users_flag_on_team_admin_not_in_org_resolves_via_key_team(
mocker,
):
"""
Flag ON, team admin NOT in any org, no team_id query param but
user_api_key_dict.team_id is set: resolves org via the key's team.
"""
from litellm.proxy._types import LiteLLM_TeamTableCachedObj
mock_prisma_client = mocker.MagicMock()
org_id = "org-from-team"
tid = "key-team-id"
async def mock_find_many(*args, **kwargs):
where = kwargs.get("where") or {}
assert "organization_memberships" in where
assert where["organization_memberships"] == {"some": {"organization_id": {"in": [org_id]}}}
return []
mock_prisma_client.db.litellm_usertable.find_many = mock_find_many
mocker.patch(
"litellm.proxy.ui_crud_endpoints.proxy_setting_endpoints.get_ui_settings_cached",
return_value={"scope_user_search_to_org": True},
)
team_obj = LiteLLM_TeamTableCachedObj(
team_id=tid,
team_alias="key-team",
organization_id=org_id,
members_with_roles=[{"user_id": "team-admin-no-org", "role": "admin"}],
)
async def mock_get_team_object(*args, **kwargs):
return team_obj
mocker.patch(
"litellm.proxy.management_endpoints.internal_user_endpoints.get_team_object",
side_effect=mock_get_team_object,
)
mocker.patch("litellm.proxy.proxy_server.prisma_client", mock_prisma_client)
mocker.patch("litellm.proxy.proxy_server.user_api_key_cache", mocker.MagicMock())
mocker.patch("litellm.proxy.proxy_server.proxy_logging_obj", mocker.MagicMock())
# Caller has no org memberships
caller_user = mocker.MagicMock()
caller_user.organization_memberships = []
async def mock_get_user_object(*args, **kwargs):
return caller_user
mocker.patch(
"litellm.proxy.management_endpoints.internal_user_endpoints.get_user_object",
side_effect=mock_get_user_object,
)
# No team_id query param, but team_id on the API key
response = await ui_view_users(
user_api_key_dict=UserAPIKeyAuth(user_id="team-admin-no-org", user_role=None, team_id=tid),
user_id=None,
user_email="u",
team_id=None,
page=1,
page_size=50,
)
assert response == []
def test_user_daily_activity_types():
"""
Assert all fiels in SpendMetrics are reported in DailySpendMetadata as "total_"
"""
from litellm.proxy.management_endpoints.common_daily_activity import (
DailySpendMetadata,
SpendMetrics,
)
# Create a SpendMetrics instance
spend_metrics = SpendMetrics()
# Create a DailySpendMetadata instance
daily_spend_metadata = DailySpendMetadata()
# Assert all fields in SpendMetrics are reported in DailySpendMetadata as "total_"
for field in spend_metrics.__dict__:
if field.startswith("total_"):
assert hasattr(daily_spend_metadata, field), f"Field {field} is not reported in DailySpendMetadata"
else:
assert not hasattr(daily_spend_metadata, field), f"Field {field} is reported in DailySpendMetadata"
@pytest.mark.asyncio
async def test_get_users_includes_timestamps(mocker):
"""
Test that /user/list endpoint returns users with created_at and updated_at fields.
"""
# Mock the prisma client
mock_prisma_client = mocker.MagicMock()
# Create mock user data with timestamps
mock_user_data = {
"user_id": "test-user-timestamps",
"user_email": "[email protected]",
"user_role": "internal_user",
"created_at": datetime.now(timezone.utc),
"updated_at": datetime.now(timezone.utc),
}
mock_user_row = mocker.MagicMock()
mock_user_row.model_dump.return_value = mock_user_data
# Setup the mock find_many response as an async function
async def mock_find_many(*args, **kwargs):
return [mock_user_row]
# Setup the mock count response as an async function
async def mock_count(*args, **kwargs):
return 1
mock_prisma_client.db.litellm_usertable.find_many = mock_find_many
mock_prisma_client.db.litellm_usertable.count = mock_count
# Patch the prisma client import in the endpoint
mocker.patch("litellm.proxy.proxy_server.prisma_client", mock_prisma_client)
# Mock the helper function get_user_key_counts
async def mock_get_user_key_counts(*args, **kwargs):
return {"test-user-timestamps": 0}
mocker.patch(
"litellm.proxy.management_endpoints.internal_user_endpoints.get_user_key_counts",
mock_get_user_key_counts,
)
# Call get_users function directly with proxy admin auth
admin_key = UserAPIKeyAuth(user_id="admin", user_role=LitellmUserRoles.PROXY_ADMIN)
response = await get_users(page=1, page_size=1, user_api_key_dict=admin_key, organization_ids=None)
print("user /list response: ", response)
# Assertions
assert response is not None
assert "users" in response
assert "total" in response
assert response["total"] == 1
assert len(response["users"]) == 1
user_response = response["users"][0]
assert user_response.user_id == "test-user-timestamps"
assert user_response.created_at is not None
assert isinstance(user_response.created_at, datetime)
assert user_response.updated_at is not None
assert isinstance(user_response.updated_at, datetime)
assert user_response.created_at == mock_user_data["created_at"]
assert user_response.updated_at == mock_user_data["updated_at"]
assert user_response.key_count == 0
@pytest.mark.asyncio
async def test_get_users_redacts_scim_enterprise_metadata(mocker):
"""
/user/list must strip scim_enterprise from each user's metadata while leaving
the rest of the metadata intact, matching the user-info endpoints.
"""
mock_prisma_client = mocker.MagicMock()
mock_user_row = mocker.MagicMock()
mock_user_row.user_id = "listed-user"
mock_user_row.model_dump.return_value = {
"user_id": "listed-user",
"user_email": "[email protected]",
"user_role": "internal_user",
"metadata": {
"scim_metadata": {"givenName": "Jane", "familyName": "Doe"},
"scim_enterprise": {"costCenter": "CC-42", "department": "Platform"},
},
}
async def mock_find_many(*args, **kwargs):
return [mock_user_row]
async def mock_count(*args, **kwargs):
return 1
mock_prisma_client.db.litellm_usertable.find_many = mock_find_many
mock_prisma_client.db.litellm_usertable.count = mock_count
mocker.patch("litellm.proxy.proxy_server.prisma_client", mock_prisma_client)
async def mock_get_user_key_counts(*args, **kwargs):
return {"listed-user": 0}
mocker.patch(
"litellm.proxy.management_endpoints.internal_user_endpoints.get_user_key_counts",
mock_get_user_key_counts,
)
admin_key = UserAPIKeyAuth(user_id="admin", user_role=LitellmUserRoles.PROXY_ADMIN)
response = await get_users(page=1, page_size=1, user_api_key_dict=admin_key, organization_ids=None)
listed = response["users"][0]
assert listed.metadata == {"scim_metadata": {"givenName": "Jane", "familyName": "Doe"}}
assert "scim_enterprise" not in (listed.metadata or {})
def test_validate_sort_params():
"""
Test that validate_sort_params returns None if sort_by is None
"""
from fastapi import HTTPException
from litellm.proxy.management_endpoints.internal_user_endpoints import (
_validate_sort_params,
)
assert _validate_sort_params(None, "asc") is None
assert _validate_sort_params(None, "desc") is None
assert _validate_sort_params("user_id", "asc") == {"user_id": "asc"}
assert _validate_sort_params("user_id", "desc") == {"user_id": "desc"}
with pytest.raises(HTTPException):
_validate_sort_params("user_id", "invalid")
def test_update_user_request_pydantic_object():
"""
Test that _update_internal_user_params correctly processes an email-only update
"""
data = UpdateUserRequest(user_email="[email protected]")
data_json = data.model_dump(exclude_unset=True)
assert data_json == {"user_email": "[email protected]"}
def test_update_internal_user_params_email():
"""
Test that _update_internal_user_params correctly processes an email-only update
"""
from litellm.proxy._types import UpdateUserRequest
from litellm.proxy.management_endpoints.internal_user_endpoints import (
_update_internal_user_params,
)
# Create test data with only email update
data_json = {"user_email": "[email protected]"}
data = UpdateUserRequest(user_email="[email protected]")
# Call the function
non_default_values = _update_internal_user_params(data_json=data_json, data=data)
# Assertions
assert len(non_default_values) == 1 # Should only contain email
assert "user_email" in non_default_values
assert non_default_values["user_email"] == "[email protected]"
assert "user_id" not in non_default_values # Should not add user_id if not provided
assert "max_budget" not in non_default_values # Should not add default values
assert "budget_duration" not in non_default_values # Should not add default values
def test_update_internal_user_params_reset_spend_and_max_budget():
"""
Relevant Issue: https://github.com/BerriAI/litellm/issues/10495
"""
from litellm.proxy._types import UpdateUserRequest
from litellm.proxy.management_endpoints.internal_user_endpoints import (
_update_internal_user_params,
)
# Create test data with only email update
data = UpdateUserRequest(spend=0, max_budget=0, user_id="test_user_id")
data_json = data.model_dump(exclude_unset=True)
# Call the function
non_default_values = _update_internal_user_params(data_json=data_json, data=data)
# Assertions
assert len(non_default_values) == 3 # Should only contain email
assert "spend" in non_default_values
assert non_default_values["spend"] == 0
assert "max_budget" in non_default_values
assert non_default_values["max_budget"] == 0
assert "user_id" in non_default_values # Should not add user_id if not provided
assert non_default_values["user_id"] == "test_user_id"
assert "budget_duration" not in non_default_values # Should not add default values
@pytest.mark.parametrize("bad_duration", ["0s", "-5m"])
def test_update_internal_user_params_rejects_a_duration_that_never_advances(bad_duration):
"""A zero-length window resets to "now", so the user row is due again the
moment it is written and the reset job re-reads it on every tick. Enough of
them fill each batch and starve other tenants' resets.
"""
from fastapi import HTTPException
from litellm.proxy._types import UpdateUserRequest
from litellm.proxy.management_endpoints.internal_user_endpoints import (
_update_internal_user_params,
)
data = UpdateUserRequest(user_id="test_user_id", budget_duration=bad_duration)
with pytest.raises(HTTPException) as exc_info:
_update_internal_user_params(data_json=data.model_dump(exclude_unset=True), data=data)
assert exc_info.value.status_code == 400
assert "Invalid budget_duration" in str(exc_info.value.detail)
def test_update_internal_user_params_accepts_a_normal_duration():
from litellm.proxy._types import UpdateUserRequest
from litellm.proxy.management_endpoints.internal_user_endpoints import (
_update_internal_user_params,
)
data = UpdateUserRequest(user_id="test_user_id", budget_duration="30d")
non_default_values = _update_internal_user_params(data_json=data.model_dump(exclude_unset=True), data=data)
assert non_default_values["budget_duration"] == "30d"
assert non_default_values["budget_reset_at"] is not None
@pytest.mark.asyncio
@pytest.mark.parametrize("bad_duration", ["0s", "-5m"])
async def test_new_user_rejects_a_duration_that_never_advances(mocker, bad_duration):
"""/user/new must reject the same never-advancing durations /user/update does."""
from unittest.mock import AsyncMock, MagicMock
from litellm.proxy.management_endpoints.internal_user_endpoints import new_user
mocker.patch("litellm.proxy.proxy_server.prisma_client", MagicMock())
duplicate_check = mocker.patch(
"litellm.proxy.management_endpoints.internal_user_endpoints._check_duplicate_user_id",
new=AsyncMock(),
)
admin = UserAPIKeyAuth(user_id="admin", user_role=LitellmUserRoles.PROXY_ADMIN)
with pytest.raises(ProxyException) as exc_info:
await new_user(
data=NewUserRequest(budget_duration=bad_duration),
user_api_key_dict=admin,
)
assert str(exc_info.value.code) == "400"
assert "Invalid budget_duration" in str(exc_info.value.message)
duplicate_check.assert_not_awaited()
@pytest.mark.asyncio
async def test_new_user_license_over_limit(mocker):
"""
Test that /user/new endpoint raises an error when license is over the user limit
"""
from fastapi import HTTPException
from litellm.proxy._types import NewUserRequest, UserAPIKeyAuth
from litellm.proxy.management_endpoints.internal_user_endpoints import new_user
# Mock the prisma client
mock_prisma_client = mocker.MagicMock()
# 1000 billable users (no SCIM-deactivated rows): the filtered count used
# for "deactivated" returns 0, so billable == total == 1000
async def mock_count(*args, where=None, **kwargs):
return 0 if where is not None else 1000
mock_prisma_client.db.litellm_usertable.count = mock_count
# Mock duplicate checks to pass
async def mock_check_duplicate_user_email(*args, **kwargs):
return None # No duplicate found
async def mock_check_duplicate_user_id(*args, **kwargs):
return None # No duplicate found
mocker.patch(
"litellm.proxy.management_endpoints.internal_user_endpoints._check_duplicate_user_email",
mock_check_duplicate_user_email,
)
mocker.patch(
"litellm.proxy.management_endpoints.internal_user_endpoints._check_duplicate_user_id",
mock_check_duplicate_user_id,
)
# Mock the license check to return True (over limit)
mock_license_check = mocker.MagicMock()
mock_license_check.is_over_limit.return_value = True
# Patch the imports in the endpoint
mocker.patch("litellm.proxy.proxy_server.prisma_client", mock_prisma_client)
mocker.patch("litellm.proxy.proxy_server._license_check", mock_license_check)
# Create test request data
user_request = NewUserRequest(user_email="[email protected]", user_role="internal_user")
# Mock user_api_key_dict
mock_user_api_key_dict = UserAPIKeyAuth(user_id="test_admin")
# Call new_user function and expect HTTPException
with pytest.raises(ProxyException) as exc_info:
await new_user(data=user_request, user_api_key_dict=mock_user_api_key_dict)
# Verify the exception details
assert exc_info.value.code == 403 or exc_info.value.code == "403"
assert "License is over limit" in str(exc_info.value.message)
assert "[email protected]" in str(exc_info.value.message)
# Verify that the license check was called with the correct user count
mock_license_check.is_over_limit.assert_called_once_with(total_users=1000)
@pytest.mark.asyncio
async def test_new_user_license_gate_counts_only_billable_users(mocker):
"""
The /user/new license gate must count billable users only (excluding
SCIM-deactivated rows). Deactivated users that push the raw total over
max_users must not block creation, while active users over the limit must.
"""
from litellm.proxy.auth.litellm_license import LicenseCheck
async def _noop(*args, **kwargs):
return None
mocker.patch(
"litellm.proxy.management_endpoints.internal_user_endpoints._check_duplicate_user_email",
_noop,
)
mocker.patch(
"litellm.proxy.management_endpoints.internal_user_endpoints._check_duplicate_user_id",
_noop,
)
license_check = LicenseCheck()
license_check.airgapped_license_data = {"max_users": 2} # type: ignore
mocker.patch("litellm.proxy.proxy_server._license_check", license_check)
key_gen = mocker.patch(
"litellm.proxy.management_endpoints.internal_user_endpoints.generate_key_helper_fn",
new=mocker.AsyncMock(side_effect=RuntimeError("reached key generation")),
)
def _prisma(total, deactivated):
client = mocker.MagicMock()
async def _count(*args, where=None, **kwargs):
return deactivated if where is not None else total
client.db.litellm_usertable.count = _count
return client
admin = UserAPIKeyAuth(user_id="admin", user_role=LitellmUserRoles.PROXY_ADMIN)
request = NewUserRequest(user_role="internal_user")
# 2 active + 3 deactivated -> billable 2, not over max_users 2: gate passes
mocker.patch("litellm.proxy.proxy_server.prisma_client", _prisma(total=5, deactivated=3))
with pytest.raises(ProxyException) as passed:
await new_user(data=request, user_api_key_dict=admin)
assert key_gen.call_count == 1
assert "License is over limit" not in str(passed.value.message)
# 3 active, 0 deactivated -> billable 3, over max_users 2: gate blocks
key_gen.reset_mock()
mocker.patch("litellm.proxy.proxy_server.prisma_client", _prisma(total=3, deactivated=0))
with pytest.raises(ProxyException) as blocked:
await new_user(data=request, user_api_key_dict=admin)
assert blocked.value.code == 403 or blocked.value.code == "403"
assert "License is over limit" in str(blocked.value.message)
assert key_gen.call_count == 0
@pytest.mark.asyncio
async def test_new_user_non_admin_cannot_create_admin(mocker):
"""
Test that non-admin users cannot create administrative users (PROXY_ADMIN or PROXY_ADMIN_VIEW_ONLY).
This prevents privilege escalation vulnerabilities.
"""
from litellm.proxy.management_endpoints.internal_user_endpoints import new_user
# Mock the prisma client
mock_prisma_client = mocker.MagicMock()
# Setup the mock count response (under license limit)
async def mock_count(*args, **kwargs):
return 5 # Low user count, under limit
mock_prisma_client.db.litellm_usertable.count = mock_count
# Mock duplicate checks to pass
async def mock_check_duplicate_user_email(*args, **kwargs):
return None # No duplicate found
async def mock_check_duplicate_user_id(*args, **kwargs):
return None # No duplicate found
mocker.patch(
"litellm.proxy.management_endpoints.internal_user_endpoints._check_duplicate_user_email",
mock_check_duplicate_user_email,
)
mocker.patch(
"litellm.proxy.management_endpoints.internal_user_endpoints._check_duplicate_user_id",
mock_check_duplicate_user_id,
)
# Mock the license check to return False (under limit)
mock_license_check = mocker.MagicMock()
mock_license_check.is_over_limit.return_value = False
# Patch the imports in the endpoint
mocker.patch("litellm.proxy.proxy_server.prisma_client", mock_prisma_client)
mocker.patch("litellm.proxy.proxy_server._license_check", mock_license_check)
# Test Case 1: INTERNAL_USER trying to create PROXY_ADMIN
user_request = NewUserRequest(user_email="[email protected]", user_role=LitellmUserRoles.PROXY_ADMIN)
# Mock user_api_key_dict with non-admin role
mock_user_api_key_dict = UserAPIKeyAuth(user_id="test_internal_user", user_role=LitellmUserRoles.INTERNAL_USER)
# Call new_user function and expect ProxyException
with pytest.raises(ProxyException) as exc_info:
await new_user(data=user_request, user_api_key_dict=mock_user_api_key_dict)
# Verify the exception details
assert exc_info.value.code == 403 or exc_info.value.code == "403"
assert "Only proxy admins can create administrative users" in str(exc_info.value.message)
assert "proxy_admin" in str(exc_info.value.message)
assert "proxy_admin_viewer" in str(exc_info.value.message)
assert str(LitellmUserRoles.PROXY_ADMIN) in str(exc_info.value.message)
assert str(LitellmUserRoles.INTERNAL_USER) in str(exc_info.value.message)
# Test Case 2: INTERNAL_USER trying to create PROXY_ADMIN_VIEW_ONLY
user_request_viewer = NewUserRequest(
user_email="[email protected]",
user_role=LitellmUserRoles.PROXY_ADMIN_VIEW_ONLY,
)
with pytest.raises(ProxyException) as exc_info2:
await new_user(data=user_request_viewer, user_api_key_dict=mock_user_api_key_dict)
# Verify the exception details
assert exc_info2.value.code == 403 or exc_info2.value.code == "403"
assert "Only proxy admins can create administrative users" in str(exc_info2.value.message)
assert str(LitellmUserRoles.PROXY_ADMIN_VIEW_ONLY) in str(exc_info2.value.message)
@pytest.mark.asyncio
async def test_new_user_non_admin_permissions_non_empty_rejected(mocker):
"""`new_user` rejects a non-admin when `permissions` is present in the
request body. `/user/new` propagates the value into the auto-created
key via `generate_key_helper_fn`."""
from litellm.proxy.management_endpoints.internal_user_endpoints import new_user
mock_prisma_client = mocker.MagicMock()
async def mock_count(*args, **kwargs):
return 5
mock_prisma_client.db.litellm_usertable.count = mock_count
async def mock_check(*_args, **_kwargs):
return None
mocker.patch(
"litellm.proxy.management_endpoints.internal_user_endpoints._check_duplicate_user_email",
mock_check,
)
mocker.patch(
"litellm.proxy.management_endpoints.internal_user_endpoints._check_duplicate_user_id",
mock_check,
)
mock_license_check = mocker.MagicMock()
mock_license_check.is_over_limit.return_value = False
mocker.patch("litellm.proxy.proxy_server.prisma_client", mock_prisma_client)
mocker.patch("litellm.proxy.proxy_server._license_check", mock_license_check)
data = NewUserRequest(
user_email="[email protected]",
user_role=LitellmUserRoles.INTERNAL_USER,
permissions={"get_spend_routes": True},
)
caller = UserAPIKeyAuth(user_id="org-admin", user_role=LitellmUserRoles.ORG_ADMIN)
with pytest.raises(ProxyException) as exc_info:
await new_user(data=data, user_api_key_dict=caller)
assert str(exc_info.value.code) == "403"
assert "permissions" in str(exc_info.value.message)
@pytest.mark.asyncio
async def test_new_user_non_admin_permissions_explicit_empty_rejected(mocker):
"""`new_user` rejects a non-admin when `permissions` is present as
`{}` in the request body. The value matches the model default but
`model_fields_set` distinguishes the two."""
from litellm.proxy.management_endpoints.internal_user_endpoints import new_user
mock_prisma_client = mocker.MagicMock()
async def mock_count(*args, **kwargs):
return 5
mock_prisma_client.db.litellm_usertable.count = mock_count
async def mock_check(*_args, **_kwargs):
return None
mocker.patch(
"litellm.proxy.management_endpoints.internal_user_endpoints._check_duplicate_user_email",
mock_check,
)
mocker.patch(
"litellm.proxy.management_endpoints.internal_user_endpoints._check_duplicate_user_id",
mock_check,
)
mock_license_check = mocker.MagicMock()
mock_license_check.is_over_limit.return_value = False
mocker.patch("litellm.proxy.proxy_server.prisma_client", mock_prisma_client)
mocker.patch("litellm.proxy.proxy_server._license_check", mock_license_check)
data = NewUserRequest(
user_email="[email protected]",
user_role=LitellmUserRoles.INTERNAL_USER,
permissions={},
)
assert "permissions" in data.model_fields_set
caller = UserAPIKeyAuth(user_id="org-admin", user_role=LitellmUserRoles.ORG_ADMIN)
with pytest.raises(ProxyException) as exc_info:
await new_user(data=data, user_api_key_dict=caller)
assert str(exc_info.value.code) == "403"
assert "permissions" in str(exc_info.value.message)
@pytest.mark.asyncio
async def test_new_user_non_admin_omits_permissions_succeeds(mocker):
"""`new_user` does not fire the permissions gate when `permissions`
is absent from the request body. The model-level default `{}` is not
in `model_fields_set`."""
from litellm.proxy.management_endpoints.internal_user_endpoints import new_user
mock_prisma_client = mocker.MagicMock()
async def mock_count(*args, **kwargs):
return 5
mock_prisma_client.db.litellm_usertable.count = mock_count
async def mock_check(*_args, **_kwargs):
return None
mocker.patch(
"litellm.proxy.management_endpoints.internal_user_endpoints._check_duplicate_user_email",
mock_check,
)
mocker.patch(
"litellm.proxy.management_endpoints.internal_user_endpoints._check_duplicate_user_id",
mock_check,
)
mock_license_check = mocker.MagicMock()
mock_license_check.is_over_limit.return_value = False
mocker.patch("litellm.proxy.proxy_server.prisma_client", mock_prisma_client)
mocker.patch("litellm.proxy.proxy_server._license_check", mock_license_check)
stub_response = {"user_id": "alice", "key": "sk-alice", "expires": None}
async def stub_helper(**_kwargs):
return stub_response
mocker.patch(
"litellm.proxy.management_endpoints.internal_user_endpoints.generate_key_helper_fn",
stub_helper,
)
data = NewUserRequest(
user_email="[email protected]",
user_role=LitellmUserRoles.INTERNAL_USER,
)
assert "permissions" not in data.model_fields_set
caller = UserAPIKeyAuth(user_id="org-admin", user_role=LitellmUserRoles.ORG_ADMIN)
result = await new_user(data=data, user_api_key_dict=caller)
assert result is not None
@pytest.mark.asyncio
async def test_new_user_admin_can_set_permissions(mocker):
"""`new_user` accepts a PROXY_ADMIN caller for any shape of
`permissions` in the request body."""
from litellm.proxy.management_endpoints.internal_user_endpoints import new_user
mock_prisma_client = mocker.MagicMock()
async def mock_count(*args, **kwargs):
return 5
mock_prisma_client.db.litellm_usertable.count = mock_count
async def mock_check(*_args, **_kwargs):
return None
mocker.patch(
"litellm.proxy.management_endpoints.internal_user_endpoints._check_duplicate_user_email",
mock_check,
)
mocker.patch(
"litellm.proxy.management_endpoints.internal_user_endpoints._check_duplicate_user_id",
mock_check,
)
mock_license_check = mocker.MagicMock()
mock_license_check.is_over_limit.return_value = False
mocker.patch("litellm.proxy.proxy_server.prisma_client", mock_prisma_client)
mocker.patch("litellm.proxy.proxy_server._license_check", mock_license_check)
async def stub_helper(**_kwargs):
return {"user_id": "alice", "key": "sk-alice", "expires": None}
mocker.patch(
"litellm.proxy.management_endpoints.internal_user_endpoints.generate_key_helper_fn",
stub_helper,
)
admin = UserAPIKeyAuth(user_id="admin", user_role=LitellmUserRoles.PROXY_ADMIN)
for permissions_value in ({"get_spend_routes": True}, {}, None):
data = NewUserRequest(
user_email=f"alice-{permissions_value}@example.com",
user_role=LitellmUserRoles.INTERNAL_USER,
permissions=permissions_value,
)
result = await new_user(data=data, user_api_key_dict=admin)
assert result is not None
@pytest.mark.asyncio
@pytest.mark.parametrize(
"limit_key",
["max_batch_file_records", "max_batch_file_uploads_per_day", "max_file_downloads_per_minute"],
)
async def test_new_user_only_proxy_admin_sets_batch_limits_on_the_created_key(mocker, limit_key):
from litellm.proxy.management_endpoints.internal_user_endpoints import new_user
mock_prisma_client = mocker.MagicMock()
async def mock_count(*args, **kwargs):
return 5
mock_prisma_client.db.litellm_usertable.count = mock_count
async def mock_check(*_args, **_kwargs):
return None
mocker.patch(
"litellm.proxy.management_endpoints.internal_user_endpoints._check_duplicate_user_email",
mock_check,
)
mocker.patch(
"litellm.proxy.management_endpoints.internal_user_endpoints._check_duplicate_user_id",
mock_check,
)
mock_license_check = mocker.MagicMock()
mock_license_check.is_over_limit.return_value = False
mocker.patch("litellm.proxy.proxy_server.prisma_client", mock_prisma_client)
mocker.patch("litellm.proxy.proxy_server._license_check", mock_license_check)
created_with: list[dict[str, object]] = []
async def stub_helper(**kwargs):
created_with.append(kwargs)
return {"user_id": "alice", "key": "sk-alice", "expires": None}
mocker.patch(
"litellm.proxy.management_endpoints.internal_user_endpoints.generate_key_helper_fn",
stub_helper,
)
org_admin = UserAPIKeyAuth(user_id="org-admin", user_role=LitellmUserRoles.ORG_ADMIN)
admin = UserAPIKeyAuth(user_id="admin", user_role=LitellmUserRoles.PROXY_ADMIN)
def request(auto_create_key: bool) -> NewUserRequest:
return NewUserRequest(
user_email="[email protected]",
user_role=LitellmUserRoles.INTERNAL_USER,
metadata={limit_key: 1000},
auto_create_key=auto_create_key,
)
with pytest.raises(ProxyException) as exc_info:
await new_user(data=request(auto_create_key=True), user_api_key_dict=org_admin)
assert str(exc_info.value.code) == "403"
assert f"Only proxy admins can set {limit_key} on a key" in str(exc_info.value.message)
assert created_with == []
await new_user(data=request(auto_create_key=False), user_api_key_dict=org_admin)
await new_user(data=request(auto_create_key=True), user_api_key_dict=admin)
assert [call["metadata"] for call in created_with] == [{limit_key: 1000}, {limit_key: 1000}]
@pytest.mark.asyncio
async def test_update_single_user_non_admin_permissions_rejected(mocker):
"""`_update_single_user_helper` rejects a non-admin when `permissions`
is present in the request body. Covers both `/user/update` and
`/user/bulk_update`, which share this helper."""
from fastapi import HTTPException
from litellm.proxy._types import UpdateUserRequest
from litellm.proxy.management_endpoints.internal_user_endpoints import (
_update_single_user_helper,
)
mock_prisma_client = mocker.MagicMock()
mocker.patch("litellm.proxy.proxy_server.prisma_client", mock_prisma_client)
mocker.patch("litellm.proxy.proxy_server.litellm_proxy_admin_name", "admin")
data = UpdateUserRequest(
user_id="alice",
permissions={"get_spend_routes": True},
)
caller = UserAPIKeyAuth(user_id="org-admin", user_role=LitellmUserRoles.ORG_ADMIN)
with pytest.raises(HTTPException) as exc_info:
await _update_single_user_helper(user_request=data, user_api_key_dict=caller)
assert exc_info.value.status_code == 403
assert "permissions" in str(exc_info.value.detail)
@pytest.mark.asyncio
async def test_update_single_user_non_admin_permissions_explicit_empty_rejected(mocker):
"""`_update_single_user_helper` rejects a non-admin when `permissions`
is present as `{}` in the request body."""
from fastapi import HTTPException
from litellm.proxy._types import UpdateUserRequest
from litellm.proxy.management_endpoints.internal_user_endpoints import (
_update_single_user_helper,
)
mock_prisma_client = mocker.MagicMock()
mocker.patch("litellm.proxy.proxy_server.prisma_client", mock_prisma_client)
mocker.patch("litellm.proxy.proxy_server.litellm_proxy_admin_name", "admin")
data = UpdateUserRequest(user_id="alice", permissions={})
assert "permissions" in data.model_fields_set
caller = UserAPIKeyAuth(user_id="org-admin", user_role=LitellmUserRoles.ORG_ADMIN)
with pytest.raises(HTTPException) as exc_info:
await _update_single_user_helper(user_request=data, user_api_key_dict=caller)
assert exc_info.value.status_code == 403
assert "permissions" in str(exc_info.value.detail)
@pytest.mark.asyncio
async def test_user_info_url_encoding_plus_character(mocker):
"""
Test that /user/info endpoint properly handles email addresses with + characters
when passed in the URL query parameters.
Issue: + characters in emails get converted to spaces due to URL encoding
Solution: Parse the raw query string to preserve + characters
"""
from fastapi import Request
from litellm.proxy._types import LiteLLM_UserTable, UserAPIKeyAuth
from litellm.proxy.management_endpoints.internal_user_endpoints import user_info
# Mock the prisma client
mock_prisma_client = mocker.MagicMock()
# Create a real LiteLLM_UserTable instance (BaseModel) so isinstance check passes
mock_user = LiteLLM_UserTable(
user_id="[email protected]",
user_email="[email protected]",
teams=[],
)
# Mock get_data to return user when called with user_id, empty list for keys
async def mock_get_data(*args, **kwargs):
if kwargs.get("table_name") == "key":
return []
elif kwargs.get("table_name") == "team":
return []
elif kwargs.get("user_id") is not None:
return mock_user
return None
mock_prisma_client.get_data = mocker.AsyncMock(side_effect=mock_get_data)
# Mock list_team to return None (patch it from where it's imported)
mock_list_team = mocker.AsyncMock(return_value=None)
mocker.patch(
"litellm.proxy.management_endpoints.team_endpoints.list_team",
mock_list_team,
)
# Patch the prisma client import in the endpoint
mocker.patch("litellm.proxy.proxy_server.prisma_client", mock_prisma_client)
# Create a mock request with the raw query string containing +
mock_request = mocker.MagicMock(spec=Request)
mock_request.url.query = "[email protected]"
# Mock user_api_key_dict
mock_user_api_key_dict = UserAPIKeyAuth(user_id="test_admin", user_role="proxy_admin")
# Call user_info function with the URL-decoded user_id (as FastAPI would pass it)
# FastAPI would normally convert + to space, but our fix should handle this
decoded_user_id = "machine-user [email protected]" # What FastAPI gives us
expected_user_id = "[email protected]"
response = await user_info(
user_id=decoded_user_id,
user_api_key_dict=mock_user_api_key_dict,
request=mock_request,
)
# Verify that the response contains the correct user data
# Check that get_data was called with the correct user_id (first call should be for user)
user_call = None
for call in mock_prisma_client.get_data.call_args_list:
if call.kwargs.get("user_id") and not call.kwargs.get("table_name"):
user_call = call
break
assert user_call is not None, "get_data should be called with user_id"
assert user_call.kwargs["user_id"] == expected_user_id
@pytest.mark.asyncio
async def test_user_info_nonexistent_user(mocker):
"""
Test that /user/info endpoint returns 404 when a non-existent user_id is provided.
"""
from fastapi import Request
from litellm.proxy._types import ProxyException, UserAPIKeyAuth
from litellm.proxy.management_endpoints.internal_user_endpoints import user_info
# Mock the prisma client
mock_prisma_client = mocker.MagicMock()
# Mock get_data to return None (user doesn't exist)
async def mock_get_data(*args, **kwargs):
if kwargs.get("table_name") == "key":
return []
elif kwargs.get("user_id") is not None:
return None # User not found
return None
mock_prisma_client.get_data = mocker.AsyncMock(side_effect=mock_get_data)
# Patch the prisma client import in the endpoint
mocker.patch("litellm.proxy.proxy_server.prisma_client", mock_prisma_client)
# Create a mock request
mock_request = mocker.MagicMock(spec=Request)
# Mock user_api_key_dict
mock_user_api_key_dict = UserAPIKeyAuth(user_id="test_admin", user_role="proxy_admin")
# Call user_info function with a non-existent user_id
nonexistent_user_id = "[email protected]"
# Should raise ProxyException with 404 status code (HTTPException is converted by decorator)
with pytest.raises(ProxyException) as exc_info:
await user_info(
user_id=nonexistent_user_id,
user_api_key_dict=mock_user_api_key_dict,
request=mock_request,
)
# Verify the exception details
assert exc_info.value.code == "404" # ProxyException.code is a string
assert f"User {nonexistent_user_id} not found" in str(exc_info.value.message)
@pytest.mark.asyncio
async def test_user_info_no_user_id_view_only_admin_gets_proxy_admin_payload(mocker):
"""PROXY_ADMIN_VIEW_ONLY must take the proxy-admin branch; otherwise /user/info
silently narrows to the viewer's own row instead of the whole tenant."""
from fastapi import Request
from litellm.proxy._types import LitellmUserRoles, UserAPIKeyAuth, UserInfoResponse
from litellm.proxy.management_endpoints.internal_user_endpoints import user_info
mock_prisma_client = mocker.MagicMock()
mock_prisma_client.get_data = mocker.AsyncMock(return_value=None)
mocker.patch("litellm.proxy.proxy_server.prisma_client", mock_prisma_client)
admin_payload = UserInfoResponse(user_id=None, user_info=None, keys=[], teams=[])
mock_get_user_info_for_proxy_admin = mocker.AsyncMock(return_value=admin_payload)
mocker.patch(
"litellm.proxy.management_endpoints.internal_user_endpoints._get_user_info_for_proxy_admin",
mock_get_user_info_for_proxy_admin,
)
viewer = UserAPIKeyAuth(user_id="viewer", user_role=LitellmUserRoles.PROXY_ADMIN_VIEW_ONLY.value)
mock_request = mocker.MagicMock(spec=Request)
response = await user_info(user_id=None, user_api_key_dict=viewer, request=mock_request)
mock_get_user_info_for_proxy_admin.assert_awaited_once_with(user_api_key_dict=viewer)
assert response is admin_payload
@pytest.mark.asyncio
async def test_new_user_default_teams_flow(mocker):
"""
Test that when teams are set via default_internal_user_params:
- Teams are NOT sent to generate_key_helper_fn
- Teams ARE sent to _add_user_to_team
"""
import litellm
from litellm.proxy._types import NewUserRequest, NewUserRequestTeam, UserAPIKeyAuth
from litellm.proxy.management_endpoints.internal_user_endpoints import new_user
# Mock the prisma client
mock_prisma_client = mocker.MagicMock()
# Setup the mock count response (under license limit)
async def mock_count(*args, **kwargs):
return 5 # Low user count, under limit
mock_prisma_client.db.litellm_usertable.count = mock_count
persisted_user_row = mocker.MagicMock()
persisted_user_row.teams = ["96fed65b-0182-4ff4-8429-2721cd7d42af"]
mock_prisma_client.db.litellm_usertable.find_unique = mocker.AsyncMock(return_value=persisted_user_row)
# Mock duplicate checks to pass
async def mock_check_duplicate_user_email(*args, **kwargs):
return None # No duplicate found
async def mock_check_duplicate_user_id(*args, **kwargs):
return None # No duplicate found
mocker.patch(
"litellm.proxy.management_endpoints.internal_user_endpoints._check_duplicate_user_email",
mock_check_duplicate_user_email,
)
mocker.patch(
"litellm.proxy.management_endpoints.internal_user_endpoints._check_duplicate_user_id",
mock_check_duplicate_user_id,
)
# Mock the license check to return False (under limit)
mock_license_check = mocker.MagicMock()
mock_license_check.is_over_limit.return_value = False
# Mock generate_key_helper_fn
mock_generate_key_helper_fn = mocker.AsyncMock()
mock_generate_key_helper_fn.return_value = {
"user_id": "test-user-123",
"token": "sk-test-token-123",
"expires": None,
"max_budget": 100,
"teams": [],
}
# Mock _add_user_to_team
mock_add_user_to_team = mocker.AsyncMock()
# Mock UserManagementEventHooks.async_user_created_hook
mock_user_created_hook = mocker.AsyncMock()
# Setup default_internal_user_params with teams
original_default_params = getattr(litellm, "default_internal_user_params", None)
litellm.default_internal_user_params = {
"teams": [
{
"team_id": "96fed65b-0182-4ff4-8429-2721cd7d42af",
"max_budget_in_team": 100,
"user_role": "user",
}
]
}
try:
# Patch all the imports
mocker.patch("litellm.proxy.proxy_server.prisma_client", mock_prisma_client)
mocker.patch("litellm.proxy.proxy_server._license_check", mock_license_check)
mocker.patch(
"litellm.proxy.management_endpoints.internal_user_endpoints.generate_key_helper_fn",
mock_generate_key_helper_fn,
)
mocker.patch(
"litellm.proxy.management_endpoints.internal_user_endpoints._add_user_to_team",
mock_add_user_to_team,
)
mocker.patch(
"litellm.proxy.management_endpoints.internal_user_endpoints.UserManagementEventHooks.async_user_created_hook",
mock_user_created_hook,
)
# Create test request data WITHOUT teams (teams should come from defaults)
user_request = NewUserRequest(user_email="[email protected]", user_role="internal_user")
# Mock user_api_key_dict
mock_user_api_key_dict = UserAPIKeyAuth(user_id="test_admin")
# Call new_user function
response = await new_user(data=user_request, user_api_key_dict=mock_user_api_key_dict)
# Verify generate_key_helper_fn was called WITHOUT teams
mock_generate_key_helper_fn.assert_called_once()
call_kwargs = mock_generate_key_helper_fn.call_args.kwargs
# Teams should be removed from the data passed to generate_key_helper_fn
assert "teams" not in call_kwargs, "Teams should not be passed to generate_key_helper_fn"
assert call_kwargs["request_type"] == "user"
assert call_kwargs["user_email"] == "[email protected]"
assert call_kwargs["user_role"] == "internal_user"
# Verify _add_user_to_team was called with the default team
mock_add_user_to_team.assert_called_once()
team_call_kwargs = mock_add_user_to_team.call_args.kwargs
assert team_call_kwargs["user_id"] == "test-user-123"
assert team_call_kwargs["team_id"] == "96fed65b-0182-4ff4-8429-2721cd7d42af"
assert team_call_kwargs["user_email"] == "[email protected]"
assert team_call_kwargs["user_role"] == "user"
# Verify response structure
assert response.user_id == "test-user-123"
assert response.key == "sk-test-token-123"
assert response.teams == ["96fed65b-0182-4ff4-8429-2721cd7d42af"]
finally:
# Restore original default params (always assign, never delattr — the attribute
# is defined in litellm/__init__.py and delattr-ing it breaks parallel tests)
litellm.default_internal_user_params = original_default_params
@pytest.mark.asyncio
async def test_new_user_clears_recent_missing_user_lookup(mocker: MockerFixture) -> None:
user_id: Final = "sso-created-user"
db_access_time_key: Final = f"user_id:{user_id}"
auth_checks.last_db_access_time.pop(db_access_time_key, None)
mocker.patch.object(auth_checks, "db_cache_expiry", 3600)
prisma_client: Final = mocker.MagicMock()
prisma_client.db.litellm_usertable.count = mocker.AsyncMock(return_value=1)
prisma_client.db.litellm_usertable.find_unique = mocker.AsyncMock(return_value=None)
prisma_client.db.litellm_usertable.find_first = mocker.AsyncMock(return_value=None)
user_api_key_cache: Final = UserApiKeyCache()
mocker.patch("litellm.proxy.proxy_server.prisma_client", prisma_client)
license_check: Final = mocker.MagicMock()
license_check.is_over_limit.return_value = False
mocker.patch("litellm.proxy.proxy_server._license_check", license_check)
mocker.patch(
"litellm.proxy.management_endpoints.internal_user_endpoints._check_duplicate_user_email",
new=mocker.AsyncMock(return_value=None),
)
mocker.patch(
"litellm.proxy.management_endpoints.internal_user_endpoints._check_duplicate_user_id",
new=mocker.AsyncMock(return_value=None),
)
mocker.patch(
"litellm.proxy.management_endpoints.internal_user_endpoints.check_if_default_team_set",
return_value=None,
)
mocker.patch(
"litellm.proxy.management_endpoints.internal_user_endpoints.generate_key_helper_fn",
new=mocker.AsyncMock(
return_value={"user_id": user_id, "token": "sk-sso-created-user", "expires": None}
),
)
try:
with pytest.raises(UserNotFoundError):
await auth_checks.get_user_object(
user_id=user_id,
prisma_client=prisma_client,
user_api_key_cache=user_api_key_cache,
user_id_upsert=False,
sso_user_id="sso-user-id",
user_email="[email protected]",
)
created_user: Final[NewUserResponse] = await new_user(
data=NewUserRequest(
user_id=user_id,
user_email="[email protected]",
user_role=LitellmUserRoles.INTERNAL_USER,
),
user_api_key_dict=UserAPIKeyAuth(user_id="admin", user_role=LitellmUserRoles.PROXY_ADMIN),
)
assert created_user.user_id == user_id
prisma_client.db.litellm_usertable.find_unique.return_value = LiteLLM_UserTable(
user_id=user_id,
user_email="[email protected]",
user_role=LitellmUserRoles.INTERNAL_USER,
)
user: Final = await auth_checks.get_user_object(
user_id=user_id,
prisma_client=prisma_client,
user_api_key_cache=user_api_key_cache,
user_id_upsert=False,
)
assert user is not None
assert user.user_id == user_id
finally:
auth_checks.last_db_access_time.pop(db_access_time_key, None)
def test_update_internal_new_user_params_proxy_admin_role():
"""
Test that default_internal_user_params are NOT applied when user_role is PROXY_ADMIN
"""
import litellm
from litellm.proxy._types import LitellmUserRoles, NewUserRequest
from litellm.proxy.management_endpoints.internal_user_endpoints import (
_update_internal_new_user_params,
)
# Set up default_internal_user_params
original_default_params = getattr(litellm, "default_internal_user_params", None)
litellm.default_internal_user_params = {
"max_budget": 1000,
"models": ["gpt-3.5-turbo", "gpt-4"],
"tpm_limit": 5000,
}
try:
# Create test data with PROXY_ADMIN role
data = NewUserRequest(user_email="[email protected]", user_role=LitellmUserRoles.PROXY_ADMIN.value)
data_json = data.model_dump(exclude_unset=True)
# Call the function
result = _update_internal_new_user_params(data_json=data_json, data=data)
# Assertions - default params should NOT be applied for PROXY_ADMIN
assert "max_budget" not in result, "Default max_budget should NOT be applied to PROXY_ADMIN"
assert "models" not in result, "Default models should NOT be applied to PROXY_ADMIN"
assert "tpm_limit" not in result, "Default tpm_limit should NOT be applied to PROXY_ADMIN"
# These should still work
assert result["user_email"] == "[email protected]"
assert result["user_role"] == LitellmUserRoles.PROXY_ADMIN.value
finally:
litellm.default_internal_user_params = original_default_params
def test_update_internal_new_user_params_no_role_specified():
"""
Test that default_internal_user_params ARE applied when user_role is not set
"""
import litellm
from litellm.proxy._types import NewUserRequest
from litellm.proxy.management_endpoints.internal_user_endpoints import (
_update_internal_new_user_params,
)
# Set up default_internal_user_params
original_default_params = getattr(litellm, "default_internal_user_params", None)
litellm.default_internal_user_params = {
"max_budget": 1000,
"models": ["gpt-3.5-turbo", "gpt-4"],
"tpm_limit": 5000,
}
try:
# Create test data without specifying user_role
data = NewUserRequest(user_email="[email protected]") # No user_role specified
data_json = data.model_dump(exclude_unset=True)
# Call the function
result = _update_internal_new_user_params(data_json=data_json, data=data)
# Assertions - default params should be applied when no role is specified
assert result.get("max_budget") == 1000
assert result.get("models") == ["gpt-3.5-turbo", "gpt-4"]
assert result.get("tpm_limit") == 5000
assert result["user_email"] == "[email protected]"
finally:
litellm.default_internal_user_params = original_default_params
def test_update_internal_new_user_params_internal_user_role():
"""
Test that default_internal_user_params ARE applied when user_role is INTERNAL_USER
"""
import litellm
from litellm.proxy._types import LitellmUserRoles, NewUserRequest
from litellm.proxy.management_endpoints.internal_user_endpoints import (
_update_internal_new_user_params,
)
# Set up default_internal_user_params
original_default_params = getattr(litellm, "default_internal_user_params", None)
litellm.default_internal_user_params = {
"max_budget": 1000,
"models": ["gpt-3.5-turbo", "gpt-4"],
"tpm_limit": 5000,
}
try:
# Create test data with INTERNAL_USER role
data = NewUserRequest(
user_email="[email protected]",
user_role=LitellmUserRoles.INTERNAL_USER.value,
)
data_json = data.model_dump(exclude_unset=True)
# Call the function
result = _update_internal_new_user_params(data_json=data_json, data=data)
# Assertions - default params should be applied for INTERNAL_USER
assert result.get("max_budget") == 1000
assert result.get("models") == ["gpt-3.5-turbo", "gpt-4"]
assert result.get("tpm_limit") == 5000
assert result["user_email"] == "[email protected]"
assert result["user_role"] == LitellmUserRoles.INTERNAL_USER.value
finally:
litellm.default_internal_user_params = original_default_params
@pytest.mark.asyncio
async def test_check_duplicate_user_email_case_insensitive(mocker):
"""
Test that _check_duplicate_user_email performs case insensitive email matching.
This ensures that emails like '[email protected]' and '[email protected]'
are treated as the same user, preventing duplicate accounts.
"""
from fastapi import HTTPException
from litellm.proxy.management_endpoints.internal_user_endpoints import (
_check_duplicate_user_email,
)
# Mock the prisma client
mock_prisma_client = mocker.MagicMock()
# Test Case 1: Duplicate found with different case
# Mock existing user with uppercase email
mock_existing_user = mocker.MagicMock()
mock_existing_user.user_email = "[email protected]"
async def mock_find_first_duplicate(*args, **kwargs):
# Verify that the query uses case insensitive matching
where_clause = kwargs.get("where", {})
user_email_clause = where_clause.get("user_email", {})
# Check that the query structure is correct for case insensitive search
assert "equals" in user_email_clause, "Query should use 'equals' for case insensitive search"
assert user_email_clause.get("mode") == "insensitive", "Query should use 'insensitive' mode"
assert user_email_clause.get("equals") == "[email protected]", "Query should search for the provided email"
return mock_existing_user # Return existing user to simulate duplicate
mock_prisma_client.db.litellm_usertable.find_first = mock_find_first_duplicate
# Should raise HTTPException when duplicate is found
with pytest.raises(HTTPException) as exc_info:
await _check_duplicate_user_email("[email protected]", mock_prisma_client)
assert exc_info.value.status_code == 409
assert "User with email [email protected] already exists" in str(exc_info.value.detail)
# Test Case 2: No duplicate found
async def mock_find_first_no_duplicate(*args, **kwargs):
# Verify the query structure again
where_clause = kwargs.get("where", {})
user_email_clause = where_clause.get("user_email", {})
assert "equals" in user_email_clause
assert user_email_clause.get("mode") == "insensitive"
assert user_email_clause.get("equals") == "[email protected]"
return None # No existing user found
mock_prisma_client.db.litellm_usertable.find_first = mock_find_first_no_duplicate
# Should not raise any exception when no duplicate is found
try:
await _check_duplicate_user_email("[email protected]", mock_prisma_client)
# If we reach here, no exception was raised (which is expected)
assert True
except Exception as e:
pytest.fail(f"Should not raise exception when no duplicate found, but got: {e}")
# Test Case 3: None email should not cause issues
await _check_duplicate_user_email(None, mock_prisma_client) # Should not raise exception
@pytest.mark.asyncio
async def test_check_duplicate_user_id(mocker):
"""
Test that _check_duplicate_user_id detects duplicates and does not use case insensitive matching.
"""
from fastapi import HTTPException
from litellm.proxy.management_endpoints.internal_user_endpoints import (
_check_duplicate_user_id,
)
mock_prisma_client = mocker.MagicMock()
# Duplicate user_id should raise
mock_existing_user = mocker.MagicMock()
mock_existing_user.user_id = "existing-user-id"
async def mock_find_first_duplicate(*args, **kwargs):
where_clause = kwargs.get("where", {})
user_id_clause = where_clause.get("user_id", {})
assert user_id_clause.get("equals") == "existing-user-id"
assert "mode" not in user_id_clause
return mock_existing_user
mock_prisma_client.db.litellm_usertable.find_first = mock_find_first_duplicate
with pytest.raises(HTTPException) as exc_info:
await _check_duplicate_user_id("existing-user-id", mock_prisma_client)
assert exc_info.value.status_code == 409
assert "User with id existing-user-id already exists" in str(exc_info.value.detail)
# No duplicate should pass
async def mock_find_first_no_duplicate(*args, **kwargs):
where_clause = kwargs.get("where", {})
user_id_clause = where_clause.get("user_id", {})
assert user_id_clause.get("equals") == "new-user-id"
assert "mode" not in user_id_clause
return None
mock_prisma_client.db.litellm_usertable.find_first = mock_find_first_no_duplicate
await _check_duplicate_user_id("new-user-id", mock_prisma_client)
# None user_id should no-op
await _check_duplicate_user_id(None, mock_prisma_client)
def test_process_keys_for_user_info_filters_dashboard_keys(monkeypatch):
"""
Test that _process_keys_for_user_info filters out keys with team_id='litellm-dashboard'
UI session tokens (team_id='litellm-dashboard') should be excluded from user info responses
to prevent confusion, as these are automatically created during dashboard login.
"""
from unittest.mock import MagicMock
from litellm.constants import UI_SESSION_TOKEN_TEAM_ID
from litellm.proxy.management_endpoints.internal_user_endpoints import (
_process_keys_for_user_info,
)
# Create mock keys with different team_ids
mock_key_dashboard = MagicMock()
mock_key_dashboard.model_dump.return_value = {
"token": "sk-dashboard-token",
"team_id": UI_SESSION_TOKEN_TEAM_ID,
"user_id": "test-user",
"key_alias": "dashboard-session-key",
}
mock_key_regular = MagicMock()
mock_key_regular.model_dump.return_value = {
"token": "sk-regular-token",
"team_id": "regular-team",
"user_id": "test-user",
"key_alias": "regular-key",
}
mock_key_no_team = MagicMock()
mock_key_no_team.model_dump.return_value = {
"token": "sk-no-team-token",
"team_id": None,
"user_id": "test-user",
"key_alias": "no-team-key",
}
keys = [mock_key_dashboard, mock_key_regular, mock_key_no_team]
# Mock general_settings and litellm_master_key_hash (they're imported from proxy_server)
monkeypatch.setattr(
"litellm.proxy.proxy_server.general_settings",
{},
)
monkeypatch.setattr(
"litellm.proxy.proxy_server.litellm_master_key_hash",
"different-hash",
)
# Call the function
result = _process_keys_for_user_info(keys=keys, all_teams=None)
# Verify that dashboard key is filtered out
assert len(result) == 2, "Should return 2 keys (dashboard key filtered out)"
# Verify dashboard key is not in results
result_team_ids = [key.get("team_id") for key in result]
assert UI_SESSION_TOKEN_TEAM_ID not in result_team_ids, "Dashboard key should be filtered out"
# Verify regular keys are included
assert "regular-team" in result_team_ids, "Regular team key should be included"
assert None in result_team_ids, "No-team key should be included"
# Verify the correct keys are returned
result_tokens = [key.get("token") for key in result]
assert "sk-regular-token" in result_tokens, "Regular key should be included"
assert "sk-no-team-token" in result_tokens, "No-team key should be included"
assert "sk-dashboard-token" not in result_tokens, "Dashboard key should not be included"
def test_process_keys_for_user_info_handles_none_keys(monkeypatch):
"""
Test that _process_keys_for_user_info handles None keys gracefully
"""
from litellm.proxy.management_endpoints.internal_user_endpoints import (
_process_keys_for_user_info,
)
# Mock general_settings and litellm_master_key_hash (they're imported from proxy_server)
monkeypatch.setattr(
"litellm.proxy.proxy_server.general_settings",
{},
)
monkeypatch.setattr(
"litellm.proxy.proxy_server.litellm_master_key_hash",
"different-hash",
)
# Call with None keys
result = _process_keys_for_user_info(keys=None, all_teams=None)
# Should return empty list
assert result == [], "Should return empty list when keys is None"
def test_process_keys_for_user_info_handles_empty_keys(monkeypatch):
"""
Test that _process_keys_for_user_info handles empty keys list
"""
from litellm.proxy.management_endpoints.internal_user_endpoints import (
_process_keys_for_user_info,
)
# Mock general_settings and litellm_master_key_hash (they're imported from proxy_server)
monkeypatch.setattr(
"litellm.proxy.proxy_server.general_settings",
{},
)
monkeypatch.setattr(
"litellm.proxy.proxy_server.litellm_master_key_hash",
"different-hash",
)
# Call with empty list
result = _process_keys_for_user_info(keys=[], all_teams=None)
# Should return empty list
assert result == [], "Should return empty list when keys is empty"
@pytest.mark.asyncio
async def test_get_users_user_id_partial_match(mocker):
"""
Test that /user/list endpoint uses partial matching for single user_id
and exact matching for multiple user_ids.
"""
from litellm.proxy._types import UserAPIKeyAuth
mock_prisma_client = mocker.MagicMock()
mock_user_data = {
"user_id": "test-user-partial-match",
"user_email": "[email protected]",
"user_role": "internal_user",
"created_at": datetime.now(timezone.utc),
"updated_at": datetime.now(timezone.utc),
}
mock_user_row = mocker.MagicMock()
mock_user_row.model_dump.return_value = mock_user_data
captured_where_conditions = {}
async def mock_find_many(*args, **kwargs):
if "where" in kwargs:
captured_where_conditions.update(kwargs["where"])
return [mock_user_row]
async def mock_count(*args, **kwargs):
return 1
mock_prisma_client.db.litellm_usertable.find_many = mock_find_many
mock_prisma_client.db.litellm_usertable.count = mock_count
mocker.patch("litellm.proxy.proxy_server.prisma_client", mock_prisma_client)
async def mock_get_user_key_counts(*args, **kwargs):
return {"test-user-partial-match": 0}
mocker.patch(
"litellm.proxy.management_endpoints.internal_user_endpoints.get_user_key_counts",
mock_get_user_key_counts,
)
admin_key = UserAPIKeyAuth(user_id="admin", user_role=LitellmUserRoles.PROXY_ADMIN)
captured_where_conditions.clear()
await get_users(
user_ids="test-user",
page=1,
page_size=1,
user_api_key_dict=admin_key,
organization_ids=None,
)
assert "user_id" in captured_where_conditions
assert "contains" in captured_where_conditions["user_id"]
assert captured_where_conditions["user_id"]["contains"] == "test-user"
assert captured_where_conditions["user_id"]["mode"] == "insensitive"
captured_where_conditions.clear()
await get_users(
user_ids="user1,user2,user3",
page=1,
page_size=1,
user_api_key_dict=admin_key,
organization_ids=None,
)
assert "user_id" in captured_where_conditions
assert "in" in captured_where_conditions["user_id"]
assert captured_where_conditions["user_id"]["in"] == ["user1", "user2", "user3"]
def test_get_users_search_matches_user_id_or_email(mocker):
"""
`search` ORs a case-insensitive contains match over user_id and user_email on both the rows
query and the count, while the legacy `user_email` param keeps filtering only user_email.
"""
from litellm.proxy._types import UserAPIKeyAuth
from litellm.proxy.auth.user_api_key_auth import user_api_key_auth
searched_user_id = "a6f5c02b-0163-45ce-815f-f88d10e95686"
mock_user_row = mocker.MagicMock()
mock_user_row.user_id = searched_user_id
mock_user_row.model_dump.return_value = {
"user_id": searched_user_id,
"user_email": "[email protected]",
"user_role": "internal_user",
"created_at": datetime.now(timezone.utc),
"updated_at": datetime.now(timezone.utc),
}
find_many_wheres = []
count_wheres = []
async def mock_find_many(*args, **kwargs):
find_many_wheres.append(kwargs["where"])
return [mock_user_row]
async def mock_count(*args, **kwargs):
count_wheres.append(kwargs["where"])
return 1
async def mock_key_count(*args, **kwargs):
return 0
mock_prisma_client = mocker.MagicMock()
mock_prisma_client.db.litellm_usertable.find_many = mock_find_many
mock_prisma_client.db.litellm_usertable.count = mock_count
mock_prisma_client.db.litellm_verificationtoken.count = mock_key_count
mocker.patch( # test-quality-ok: /user/list reads prisma_client off proxy_server at call time
"litellm.proxy.proxy_server.prisma_client", mock_prisma_client
)
app.dependency_overrides[user_api_key_auth] = lambda: UserAPIKeyAuth(
user_id="admin", user_role=LitellmUserRoles.PROXY_ADMIN
)
try:
search_response = client.get("/user/list", params={"search": "A6F5C02B-0163"})
assert search_response.status_code == 200, search_response.text
expected_or = (
{"user_id": {"contains": "A6F5C02B-0163", "mode": "insensitive"}},
{"user_email": {"contains": "A6F5C02B-0163", "mode": "insensitive"}},
)
assert find_many_wheres == [{"OR": expected_or}]
assert count_wheres == [{"OR": expected_or}]
assert [user["user_id"] for user in search_response.json()["users"]] == [searched_user_id]
assert search_response.json()["total"] == 1
legacy_response = client.get("/user/list", params={"user_email": "[email protected]"})
assert legacy_response.status_code == 200, legacy_response.text
assert find_many_wheres[-1] == {"user_email": {"contains": "[email protected]", "mode": "insensitive"}}
finally:
app.dependency_overrides.pop(user_api_key_auth, None)
def test_update_internal_user_params_reset_max_budget_with_none():
"""
Test that _update_internal_user_params allows setting max_budget to None.
This verifies the fix for unsetting/resetting the budget to unlimited.
"""
# Case 1: max_budget is explicitly None in the input dictionary
data_json = {"max_budget": None, "user_id": "test_user"}
data = UpdateUserRequest(max_budget=None, user_id="test_user")
# Call the function
non_default_values = _update_internal_user_params(data_json=data_json, data=data)
# Assertions
assert "max_budget" in non_default_values
assert non_default_values["max_budget"] is None
assert non_default_values["user_id"] == "test_user"
def test_update_internal_user_params_explicit_duration_clear_overrides_role_default(monkeypatch):
import litellm
monkeypatch.setattr(litellm, "internal_user_budget_duration", "30d")
data = UpdateUserRequest(
user_id="duration-clear-test",
user_role=LitellmUserRoles.INTERNAL_USER,
budget_duration=None,
)
updated = _update_internal_user_params(data_json=data.model_dump(exclude_unset=True), data=data)
assert updated["budget_duration"] is None
assert updated["budget_reset_at"] is None
def test_update_internal_user_params_ignores_other_nones():
"""
Test that other fields are still filtered out if None
"""
# Create test data with other None fields
data_json = {"user_alias": None, "user_id": "test_user", "max_budget": 100.0}
data = UpdateUserRequest(user_alias=None, user_id="test_user", max_budget=100.0)
# Call the function
non_default_values = _update_internal_user_params(data_json=data_json, data=data)
# Assertions
assert "user_alias" not in non_default_values
assert non_default_values["max_budget"] == 100.0
@pytest.mark.parametrize("field", ["tpm_limit", "rpm_limit"], ids=["tpm_limit", "rpm_limit"])
def test_update_internal_user_params_explicit_null_clears_rate_limit_but_omitted_is_untouched(
field: str,
) -> None:
data: Final = UpdateUserRequest(user_id="limit-clear", **{field: None})
result: Final = _update_internal_user_params(data_json=data.model_dump(exclude_unset=True), data=data)
other_field: Final = "rpm_limit" if field == "tpm_limit" else "tpm_limit"
assert result[field] is None
assert other_field not in result
def test_update_internal_user_params_keeps_original_max_budget_when_not_provided():
"""
Test that _update_internal_user_params does not include max_budget
when it's not provided in the request (should keep original value).
"""
# Create test data without max_budget
data_json = {"user_id": "test_user", "user_alias": "test_alias"}
data = UpdateUserRequest(user_id="test_user", user_alias="test_alias")
# Call the function
non_default_values = _update_internal_user_params(data_json=data_json, data=data)
# Assertions: max_budget should NOT be in non_default_values
assert "max_budget" not in non_default_values
assert "user_id" in non_default_values
assert "user_alias" in non_default_values
@pytest.mark.parametrize("cleared_budget", [{}, None], ids=["empty-map", "null"])
def test_update_internal_user_params_clears_model_budget(cleared_budget: dict[str, object] | None) -> None:
request: Final = UpdateUserRequest(user_id="user-spruce", model_max_budget=cleared_budget)
update: Final = _update_internal_user_params(data_json=request.model_dump(exclude_unset=True), data=request)
assert update == {"user_id": "user-spruce", "model_max_budget": {}}
def test_update_internal_user_params_preserves_model_budget_presence_and_neighbors() -> None:
omitted: Final = UpdateUserRequest(user_id="user-spruce", user_alias="Spruce")
assert _update_internal_user_params(data_json=omitted.model_dump(), data=omitted) == {
"user_id": "user-spruce",
"user_alias": "Spruce",
}
replacement: Final = {"model-spruce": {"budget_limit": 0, "time_period": "1d"}, "model-birch": 5.0, "model-cedar": 0}
request: Final = UpdateUserRequest(
user_id="user-spruce",
model_max_budget=replacement,
max_budget=50,
user_alias=None,
models=[],
allowed_cache_controls=[],
config={},
)
assert _update_internal_user_params(data_json=request.model_dump(exclude_unset=True), data=request) == {
"user_id": "user-spruce",
"model_max_budget": replacement,
"max_budget": 50,
}
@pytest.mark.parametrize("invalid_budget", [{"model-spruce": "invalid"}, {"model-spruce": {"budget_limit": "invalid"}}])
def test_update_internal_user_params_rejects_invalid_model_budget(invalid_budget: dict[str, object]) -> None:
request: Final = UpdateUserRequest(user_id="user-spruce", model_max_budget=invalid_budget)
with pytest.raises(HTTPException) as exc:
_update_internal_user_params(data_json=request.model_dump(exclude_unset=True), data=request)
assert exc.value.status_code == 400
@pytest.mark.asyncio
async def test_user_model_budget_update_by_email_refreshes_cached_user(mocker: MockerFixture) -> None:
from litellm.proxy._types import LiteLLM_UserTable
from litellm.proxy.common_utils.user_api_key_cache import UserApiKeyCache
from litellm.proxy.management_endpoints.internal_user_endpoints import _update_single_user_helper
saved_user: Final = LiteLLM_UserTable(
user_id="user-spruce",
user_email="[email protected]",
model_max_budget={"model-spruce": {"budget_limit": 5, "time_period": "1d"}},
max_budget=50,
)
prisma_client: Final = mocker.MagicMock()
prisma_client.db.litellm_usertable.find_first = mocker.AsyncMock(return_value=saved_user)
prisma_client.get_data = mocker.AsyncMock(return_value=[saved_user])
prisma_client.update_data = mocker.AsyncMock(return_value={"user_id": saved_user.user_id, "data": saved_user})
mocker.patch("litellm.proxy.proxy_server.prisma_client", prisma_client) # test-quality-ok: substitute the database dependency
cache: Final = UserApiKeyCache()
await cache.async_set_cache(key=saved_user.user_id, value=saved_user, model_type=LiteLLM_UserTable)
mocker.patch("litellm.proxy.proxy_server.user_api_key_cache", cache) # test-quality-ok: exercise a real isolated cache
broadcast: Final = mocker.patch( # test-quality-ok: observe the Redis publication boundary
"litellm.proxy.common_utils.auth_cache_invalidation_pubsub.publish_auth_cache_invalidation",
new_callable=mocker.AsyncMock,
)
await _update_single_user_helper(
user_request=UpdateUserRequest(user_email=saved_user.user_email, model_max_budget={}),
user_api_key_dict=UserAPIKeyAuth(user_id="admin-spruce", user_role=LitellmUserRoles.PROXY_ADMIN),
)
assert prisma_client.update_data.call_args.kwargs["data"]["model_max_budget"] == {}
assert "max_budget" not in prisma_client.update_data.call_args.kwargs["data"]
assert await cache.async_get_cache(key=saved_user.user_id, model_type=LiteLLM_UserTable) is None
broadcast.assert_awaited_once_with(cache_key=saved_user.user_id)
@pytest.mark.asyncio
@pytest.mark.parametrize("by_email", [False, True])
@pytest.mark.parametrize("active", [False, True, None])
async def test_user_status_update_refreshes_cached_user(
mocker: MockerFixture, by_email: bool, active: bool | None
) -> None:
from litellm.proxy._types import LiteLLM_UserTable
from litellm.proxy.common_utils.user_api_key_cache import UserApiKeyCache
from litellm.proxy.management_endpoints.internal_user_endpoints import _update_single_user_helper
saved_user: Final = LiteLLM_UserTable(
user_id="user-spruce",
user_email="[email protected]",
metadata={"scim_active": False if active is None else not active, "department": "engineering"},
)
prisma_client: Final = mocker.MagicMock()
prisma_client.db.litellm_usertable.find_first = mocker.AsyncMock(return_value=saved_user)
prisma_client.get_data = mocker.AsyncMock(return_value=[saved_user])
prisma_client.update_data = mocker.AsyncMock(return_value={"user_id": saved_user.user_id, "data": saved_user})
mocker.patch("litellm.proxy.proxy_server.prisma_client", prisma_client) # test-quality-ok: substitute the database dependency
cache: Final = UserApiKeyCache()
await cache.async_set_cache(key=saved_user.user_id, value=saved_user, model_type=LiteLLM_UserTable)
mocker.patch("litellm.proxy.proxy_server.user_api_key_cache", cache) # test-quality-ok: exercise a real isolated cache
broadcast: Final = mocker.patch( # test-quality-ok: observe the Redis publication boundary
"litellm.proxy.common_utils.auth_cache_invalidation_pubsub.publish_auth_cache_invalidation",
new_callable=mocker.AsyncMock,
)
await _update_single_user_helper(
user_request=UpdateUserRequest(
user_id=None if by_email else saved_user.user_id,
user_email=saved_user.user_email if by_email else None,
metadata={"department": "engineering"} if active is None else {"scim_active": active},
),
user_api_key_dict=UserAPIKeyAuth(user_id="admin-spruce", user_role=LitellmUserRoles.PROXY_ADMIN),
)
assert prisma_client.update_data.call_args.kwargs["user_id"] == saved_user.user_id
assert prisma_client.update_data.call_args.kwargs["data"]["metadata"] == (
{"department": "engineering"} if active is None else {"scim_active": active}
)
assert await cache.async_get_cache(key=saved_user.user_id, model_type=LiteLLM_UserTable) is None
broadcast.assert_awaited_once_with(cache_key=saved_user.user_id)
@pytest.mark.asyncio
async def test_bulk_user_model_budget_clear_serializes_and_refreshes_cache(mocker: MockerFixture) -> None:
from litellm.proxy._types import LiteLLM_UserTable
from litellm.proxy.common_utils.user_api_key_cache import UserApiKeyCache
from litellm.proxy.management_endpoints.internal_user_endpoints import bulk_user_update
from litellm.types.proxy.management_endpoints.internal_user_endpoints import BulkUpdateUserRequest
saved_user: Final = LiteLLM_UserTable(user_id="user-spruce", model_max_budget={"model-spruce": {"budget_limit": 5}})
prisma_client: Final = mocker.MagicMock()
prisma_client.db.litellm_usertable.find_many = mocker.AsyncMock(return_value=[saved_user])
prisma_client.db.litellm_usertable.update_many = mocker.AsyncMock(return_value=1)
mocker.patch("litellm.proxy.proxy_server.prisma_client", prisma_client) # test-quality-ok: substitute the database dependency
cache: Final = UserApiKeyCache()
await cache.async_set_cache(key=saved_user.user_id, value=saved_user, model_type=LiteLLM_UserTable)
mocker.patch("litellm.proxy.proxy_server.user_api_key_cache", cache) # test-quality-ok: exercise a real isolated cache
broadcast: Final = mocker.patch( # test-quality-ok: observe the Redis publication boundary
"litellm.proxy.common_utils.auth_cache_invalidation_pubsub.publish_auth_cache_invalidation",
new_callable=mocker.AsyncMock,
)
with pytest.raises(HTTPException) as exc:
await bulk_user_update(
data=BulkUpdateUserRequest(all_users=True, user_updates={"model_max_budget": {"model-spruce": "invalid"}}),
user_api_key_dict=UserAPIKeyAuth(user_id="admin-spruce", user_role=LitellmUserRoles.PROXY_ADMIN),
litellm_changed_by=None,
)
assert exc.value.status_code == 400
prisma_client.db.litellm_usertable.update_many.assert_not_called()
assert await cache.async_get_cache(key=saved_user.user_id, model_type=LiteLLM_UserTable) == saved_user
response: Final = await bulk_user_update(
data=BulkUpdateUserRequest(all_users=True, user_updates={"model_max_budget": None}),
user_api_key_dict=UserAPIKeyAuth(user_id="admin-spruce", user_role=LitellmUserRoles.PROXY_ADMIN),
litellm_changed_by=None,
)
prisma_client.db.litellm_usertable.update_many.assert_awaited_once_with(where={}, data={"model_max_budget": "{}"})
prisma_client.update_data.assert_not_called()
assert response.successful_updates == 1
assert response.results[0].updated_user["model_max_budget"] == {}
assert await cache.async_get_cache(key=saved_user.user_id, model_type=LiteLLM_UserTable) is None
broadcast.assert_awaited_once_with(cache_key=saved_user.user_id)
@pytest.mark.asyncio
@pytest.mark.parametrize("all_users", [False, True], ids=["single-user", "bulk-all-users"])
async def test_user_max_budget_update_evicts_cached_user_on_every_worker(mocker: MockerFixture, all_users: bool) -> None:
from litellm.proxy._types import LiteLLM_UserTable
from litellm.proxy.common_utils.user_api_key_cache import UserApiKeyCache
from litellm.proxy.management_endpoints.internal_user_endpoints import _update_single_user_helper, bulk_user_update
from litellm.types.proxy.management_endpoints.internal_user_endpoints import BulkUpdateUserRequest
saved_user: Final = LiteLLM_UserTable(user_id="user-spruce", max_budget=500.0)
prisma_client: Final = mocker.MagicMock()
prisma_client.db.litellm_usertable.find_first = mocker.AsyncMock(return_value=saved_user)
prisma_client.db.litellm_usertable.find_many = mocker.AsyncMock(return_value=[saved_user])
prisma_client.db.litellm_usertable.update_many = mocker.AsyncMock(return_value=1)
prisma_client.get_data = mocker.AsyncMock(return_value=[saved_user])
prisma_client.update_data = mocker.AsyncMock(return_value={"user_id": saved_user.user_id, "data": saved_user})
mocker.patch("litellm.proxy.proxy_server.prisma_client", prisma_client) # test-quality-ok: substitute the database dependency
cache: Final = UserApiKeyCache()
await cache.async_set_cache(key=saved_user.user_id, value=saved_user, model_type=LiteLLM_UserTable)
mocker.patch("litellm.proxy.proxy_server.user_api_key_cache", cache) # test-quality-ok: exercise a real isolated cache
broadcast: Final = mocker.patch( # test-quality-ok: observe the Redis publication boundary
"litellm.proxy.common_utils.auth_cache_invalidation_pubsub.publish_auth_cache_invalidation",
new_callable=mocker.AsyncMock,
)
admin: Final = UserAPIKeyAuth(user_id="admin-spruce", user_role=LitellmUserRoles.PROXY_ADMIN)
if all_users:
await bulk_user_update(
data=BulkUpdateUserRequest(all_users=True, user_updates={"max_budget": 50.0}),
user_api_key_dict=admin,
litellm_changed_by=None,
)
prisma_client.db.litellm_usertable.update_many.assert_awaited_once_with(where={}, data={"max_budget": 50.0})
else:
await _update_single_user_helper(
user_request=UpdateUserRequest(user_id=saved_user.user_id, max_budget=50.0),
user_api_key_dict=admin,
)
assert prisma_client.update_data.call_args.kwargs["data"]["max_budget"] == 50.0
assert await cache.async_get_cache(key=saved_user.user_id, model_type=LiteLLM_UserTable) is None
broadcast.assert_awaited_once_with(cache_key=saved_user.user_id)
@pytest.mark.asyncio
@pytest.mark.parametrize(
("field", "new_value"),
[
("tpm_limit", 100),
("rpm_limit", 1),
("tpm_limit", None),
("rpm_limit", None),
("models", ["model-fir"]),
("user_role", LitellmUserRoles.INTERNAL_USER_VIEW_ONLY.value),
],
ids=[
"tpm_limit",
"rpm_limit",
"tpm_limit-cleared",
"rpm_limit-cleared",
"models",
"user_role",
],
)
@pytest.mark.parametrize("all_users", [False, True], ids=["single-user", "bulk-all-users"])
async def test_user_update_reaches_cached_user_on_every_worker(
mocker: MockerFixture, field: str, new_value: object, all_users: bool
) -> None:
from litellm.proxy._types import LiteLLM_UserTable
from litellm.proxy.auth.auth_checks import get_user_object
from litellm.proxy.common_utils.auth_cache_invalidation_pubsub import AuthCacheInvalidationSubscriber
from litellm.proxy.common_utils.user_api_key_cache import UserApiKeyCache
from litellm.proxy.management_endpoints.internal_user_endpoints import bulk_user_update, user_update
from litellm.types.proxy.management_endpoints.internal_user_endpoints import (
BulkUpdateUserRequest,
UpdateUserRequestNoUserIDorEmail,
)
published: Final[list[tuple[str, str]]] = [] # mutable-ok: captures messages from the async Redis publisher
class _RecordingRedisClient:
async def publish(self, channel: str, message: str) -> int:
published.append((channel, message))
return 1
class _FakeRedisCache:
namespace: str | None = None
def init_pubsub_client(self) -> _RecordingRedisClient:
return _RecordingRedisClient()
class _UserTableMocks:
def __init__(
self,
find_first: AsyncMock,
find_unique: AsyncMock,
find_many: AsyncMock,
update_many: AsyncMock,
) -> None:
self.find_first = find_first
self.find_unique = find_unique
self.find_many = find_many
self.update_many = update_many
class _DatabaseMocks:
def __init__(self, litellm_usertable: _UserTableMocks) -> None:
self.litellm_usertable = litellm_usertable
class _PrismaClientMock:
def __init__(
self,
db: _DatabaseMocks,
get_data: AsyncMock,
updated_user: LiteLLM_UserTable,
) -> None:
self.db = db
self.get_data = get_data
self.updated_user = updated_user
self.update_data_payload: dict[str, object] | None = None
async def update_data(self, user_id: str, data: dict[str, object], table_name: str) -> dict[str, object]:
self.update_data_payload = data
return {"user_id": user_id, "data": self.updated_user}
saved_user: Final = LiteLLM_UserTable(
user_id="user-spruce",
tpm_limit=100000,
rpm_limit=1000,
models=["model-spruce"],
user_role=LitellmUserRoles.INTERNAL_USER.value,
)
updated_user: Final = saved_user.model_copy(update={field: new_value})
old_value: Final = saved_user.model_dump()[field]
assert old_value != new_value
prisma_client: Final = _PrismaClientMock(
db=_DatabaseMocks(
litellm_usertable=_UserTableMocks(
find_first=mocker.AsyncMock(return_value=saved_user),
find_unique=mocker.AsyncMock(return_value=updated_user),
find_many=mocker.AsyncMock(
return_value=[*(LiteLLM_UserTable(user_id=f"user-pine-{index}") for index in range(50)), saved_user]
),
update_many=mocker.AsyncMock(return_value=1),
)
),
get_data=mocker.AsyncMock(return_value=saved_user),
updated_user=updated_user,
)
prisma_client_for_auth: Final = cast("PrismaClient", prisma_client)
mocker.patch( # test-quality-ok: substitute the database dependency
"litellm.proxy.proxy_server.prisma_client", prisma_client
)
handling_worker_cache: Final = UserApiKeyCache()
other_worker_cache: Final = UserApiKeyCache()
await handling_worker_cache.async_set_cache(
key=saved_user.user_id,
value=saved_user,
model_type=LiteLLM_UserTable,
)
await other_worker_cache.async_set_cache(
key=saved_user.user_id,
value=saved_user,
model_type=LiteLLM_UserTable,
)
mocker.patch( # test-quality-ok: exercise a real isolated cache for the endpoint's worker
"litellm.proxy.proxy_server.user_api_key_cache", handling_worker_cache
)
mocker.patch( # test-quality-ok: inject an in-memory pub/sub client without live Redis
"litellm.proxy.common_utils.auth_cache_invalidation_pubsub.coordination_redis_cache",
return_value=_FakeRedisCache(),
)
handling_user_before: Final = await get_user_object(
user_id=saved_user.user_id,
prisma_client=prisma_client_for_auth,
user_api_key_cache=handling_worker_cache,
user_id_upsert=False,
)
other_user_before: Final = await get_user_object(
user_id=saved_user.user_id,
prisma_client=prisma_client_for_auth,
user_api_key_cache=other_worker_cache,
user_id_upsert=False,
)
assert handling_user_before is not None
assert handling_user_before.model_dump()[field] == old_value
assert other_user_before is not None
assert other_user_before.model_dump()[field] == old_value
admin: Final = UserAPIKeyAuth(user_id="admin-spruce", user_role=LitellmUserRoles.PROXY_ADMIN)
if all_users:
await bulk_user_update(
data=BulkUpdateUserRequest(
all_users=True,
user_updates=UpdateUserRequestNoUserIDorEmail.model_validate({field: new_value}),
),
user_api_key_dict=admin,
litellm_changed_by=None,
)
prisma_client.db.litellm_usertable.update_many.assert_awaited_once_with(where={}, data={field: new_value})
else:
await user_update(
data=UpdateUserRequest.model_validate({"user_id": saved_user.user_id, field: new_value}),
user_api_key_dict=admin,
)
assert prisma_client.update_data_payload is not None
assert prisma_client.update_data_payload[field] == new_value
remote_subscriber: Final = AuthCacheInvalidationSubscriber(
redis_cache=cast("RedisCache", _FakeRedisCache()),
user_api_key_cache=other_worker_cache,
)
for _, message in published:
remote_subscriber._apply_message( # pyright: ignore[reportPrivateUsage] # exercising the real cross-worker message handler, not a public API
{"type": "message", "data": message}
)
handling_user_after: Final = await get_user_object(
user_id=saved_user.user_id,
prisma_client=prisma_client_for_auth,
user_api_key_cache=handling_worker_cache,
user_id_upsert=False,
)
other_user_after: Final = await get_user_object(
user_id=saved_user.user_id,
prisma_client=prisma_client_for_auth,
user_api_key_cache=other_worker_cache,
user_id_upsert=False,
)
assert handling_user_after is not None
assert handling_user_after.model_dump()[field] == new_value
assert other_user_after is not None
assert other_user_after.model_dump()[field] == new_value, (
"another worker still serves the old user row; the update was never broadcast"
)
def test_generate_request_base_validator():
"""
Test that GenerateRequestBase validator converts empty string to None for max_budget
"""
from litellm.proxy._types import GenerateRequestBase
# Test with empty string
req = GenerateRequestBase(max_budget="")
assert req.max_budget is None
# Test with actual float
req = GenerateRequestBase(max_budget=100.0)
assert req.max_budget == 100.0
# Test with None
req = GenerateRequestBase(max_budget=None)
assert req.max_budget is None
@pytest.mark.asyncio
async def test_get_user_daily_activity_non_admin_cannot_view_other_users(monkeypatch):
"""
Test that non-admin users cannot view another user's daily activity data.
The endpoint should raise 403 when user_id does not match the caller's own user_id.
Also verifies that omitting user_id defaults to the caller's own user_id.
"""
from unittest.mock import AsyncMock, MagicMock, patch
from fastapi import HTTPException
from litellm.proxy.management_endpoints.internal_user_endpoints import (
get_user_daily_activity,
)
# Mock the prisma client so the DB-not-connected check passes
mock_prisma_client = MagicMock()
monkeypatch.setattr("litellm.proxy.proxy_server.prisma_client", mock_prisma_client)
# Non-admin caller
non_admin_key_dict = UserAPIKeyAuth(
user_id="regular-user-123",
user_role=LitellmUserRoles.INTERNAL_USER,
)
# Case 1: Non-admin tries to view a different user's data — should get 403
with pytest.raises(HTTPException) as exc_info:
await get_user_daily_activity(
start_date="2025-01-01",
end_date="2025-01-31",
model=None,
api_key=None,
user_id="other-user-456",
page=1,
page_size=50,
timezone=None,
user_api_key_dict=non_admin_key_dict,
)
assert exc_info.value.status_code == 403
assert "Non-admin users can only view their own spend data" in str(exc_info.value.detail)
# Case 2: Non-admin omits user_id — should default to their own user_id
mock_response = MagicMock()
with patch(
"litellm.proxy.management_endpoints.internal_user_endpoints.get_daily_activity",
new_callable=AsyncMock,
return_value=mock_response,
) as mock_get_daily:
result = await get_user_daily_activity(
start_date="2025-01-01",
end_date="2025-01-31",
model=None,
api_key=None,
user_id=None,
page=1,
page_size=50,
timezone=None,
user_api_key_dict=non_admin_key_dict,
)
# Verify it called get_daily_activity with the caller's own user_id
mock_get_daily.assert_called_once()
call_kwargs = mock_get_daily.call_args
assert call_kwargs.kwargs["entity_id"] == "regular-user-123"
@pytest.mark.asyncio
async def test_get_user_daily_activity_rejects_service_account_caller(monkeypatch):
"""
Security regression: a non-admin caller with user_id=None (a service-account
key, where user_id is forced to None at key creation) must not be able to
bypass the entity filter and read every tenant's daily spend.
Before the fix, the endpoint silently defaulted user_id to
user_api_key_dict.user_id, which is itself None for service-account keys.
None != None is False, the same-user check passed, and entity_id=None
flowed into get_daily_activity, where the SQL builder treats None as
"no filter".
"""
from unittest.mock import AsyncMock, MagicMock
from fastapi import HTTPException
from litellm.proxy.management_endpoints.internal_user_endpoints import (
get_user_daily_activity,
)
mock_prisma_client = MagicMock()
monkeypatch.setattr("litellm.proxy.proxy_server.prisma_client", mock_prisma_client)
# Tripwire: ensure get_daily_activity is never reached
mock_get_daily = AsyncMock()
monkeypatch.setattr(
"litellm.proxy.management_endpoints.internal_user_endpoints.get_daily_activity",
mock_get_daily,
)
service_account_key = UserAPIKeyAuth(
user_id=None, # service-account keys have user_id forced to None
user_role=LitellmUserRoles.INTERNAL_USER,
)
with pytest.raises(HTTPException) as exc_info:
await get_user_daily_activity(
start_date="2025-01-01",
end_date="2025-01-31",
model=None,
api_key=None,
user_id=None,
page=1,
page_size=50,
timezone=None,
user_api_key_dict=service_account_key,
)
assert exc_info.value.status_code == 403
assert "Service-account keys" in str(exc_info.value.detail)
mock_get_daily.assert_not_called()
def _serve_locked_user_delete(prisma_client: MagicMock, *users: object) -> None:
@asynccontextmanager
async def tx(*, timeout: object = None) -> AsyncIterator[MagicMock]:
yield prisma_client.db
prisma_client.tx = tx
prisma_client.db.query_raw = AsyncMock(return_value=[])
prisma_client.db.litellm_usertable.find_many = AsyncMock(return_value=list(users))
prisma_client.db.litellm_teammembership.find_many = AsyncMock(return_value=[])
@pytest.mark.asyncio
async def test_delete_user_cleans_up_created_by_invitation_links(mocker):
"""
Test that delete_user removes invitation links where the deleted user is the
creator (created_by) or updater (updated_by), not just the invited person (user_id).
This prevents FK constraint violations when deleting a user who created pending invites.
"""
from litellm.proxy._types import DeleteUserRequest, UserAPIKeyAuth
from litellm.proxy.management_endpoints.internal_user_endpoints import delete_user
mock_prisma_client = mocker.MagicMock()
# Mock user lookup
mock_user_row = mocker.MagicMock()
mock_user_row.user_id = "admin-creator"
mock_user_row.user_email = "[email protected]"
mock_user_row.teams = []
mock_user_row.model_dump_json.return_value = "{}"
mock_user_row.model_dump.return_value = {
"user_id": "admin-creator",
"user_email": "[email protected]",
"teams": [],
}
async def mock_find_unique(*args, **kwargs):
return mock_user_row
mock_prisma_client.db.litellm_usertable.find_unique = mocker.AsyncMock(side_effect=mock_find_unique)
# Mock find_many for teams (no teams)
mock_prisma_client.db.litellm_teamtable.find_many = mocker.AsyncMock(return_value=[])
# Mock all delete_many calls
mock_prisma_client.db.litellm_verificationtoken.find_many = mocker.AsyncMock(
return_value=[]
)
mock_prisma_client.db.litellm_verificationtoken.delete_many = mocker.AsyncMock(
return_value=0
)
mock_prisma_client.db.litellm_invitationlink.delete_many = mocker.AsyncMock(
return_value=1
)
mock_prisma_client.db.litellm_organizationmembership.delete_many = mocker.AsyncMock(
return_value=0
)
mock_prisma_client.db.litellm_teammembership.delete_many = mocker.AsyncMock(
return_value=0
)
mock_prisma_client.db.litellm_usertable.delete_many = mocker.AsyncMock(
return_value=1
)
_serve_locked_user_delete(mock_prisma_client, mock_user_row)
mocker.patch("litellm.proxy.proxy_server.prisma_client", mock_prisma_client)
# Call delete_user
data = DeleteUserRequest(user_ids=["admin-creator"])
user_api_key_dict = UserAPIKeyAuth(user_id="proxy-admin", user_role=LitellmUserRoles.PROXY_ADMIN)
await delete_user(data=data, user_api_key_dict=user_api_key_dict)
# Verify invitation link deletion uses OR with user_id, created_by, updated_by
mock_prisma_client.db.litellm_invitationlink.delete_many.assert_called_once()
call_kwargs = mock_prisma_client.db.litellm_invitationlink.delete_many.call_args
where_clause = call_kwargs.kwargs.get("where") or call_kwargs[1].get("where")
assert "OR" in where_clause, "Should use OR to match user_id, created_by, and updated_by"
or_conditions = where_clause["OR"]
assert len(or_conditions) == 3, "Should have 3 OR conditions"
# Verify all three FK fields are covered
condition_keys = [list(c.keys())[0] for c in or_conditions]
assert "user_id" in condition_keys
assert "created_by" in condition_keys
assert "updated_by" in condition_keys
# Verify each condition uses {"in": ["admin-creator"]}
for condition in or_conditions:
field = list(condition.keys())[0]
assert condition[field] == {"in": ["admin-creator"]}
@pytest.mark.asyncio
async def test_delete_user_evicts_jwt_key_mapping_cache_of_its_keys(mocker):
"""/user/delete bulk-deletes the user's keys without going through /key/delete, so the
jwt_key_mapping cache entries pointing at those keys must be evicted here too. A surviving
entry keeps resolving the deleted token hash until the mapping cache TTL expires: the deleted
identity is either still served through the stale key cache or 401s on every JWT call, and it is
never re-registered (LIT-5387).
The FK cascade drops the mapping rows with the key rows, so the cache keys have to be read
before the delete: reading them afterwards finds nothing to evict.
"""
from litellm.proxy._types import DeleteUserRequest, UserAPIKeyAuth
from litellm.proxy.auth.auth_checks import jwt_key_mapping_cache_key
from litellm.proxy.common_utils.user_api_key_cache import UserApiKeyCache
from litellm.proxy.management_endpoints.internal_user_endpoints import delete_user
global_cache_key: Final = jwt_key_mapping_cache_key("sub", "jwt-user", None)
issuer_cache_key: Final = jwt_key_mapping_cache_key("sub", "jwt-user", "https://issuer.example")
unrelated_cache_key: Final = jwt_key_mapping_cache_key("sub", "other-user", None)
jwt_table: Final = CascadingJWTMappingTable(
[
JWTMappingRow("hashed-jwt-key", "sub", "jwt-user"),
JWTMappingRow("hashed-issuer-key", "sub", "jwt-user", "https://issuer.example"),
JWTMappingRow("hashed-unrelated-key", "sub", "other-user"),
]
)
cache: Final = UserApiKeyCache()
for cache_key, hashed_token in (
(global_cache_key, "hashed-jwt-key"),
(issuer_cache_key, "hashed-issuer-key"),
(unrelated_cache_key, "hashed-unrelated-key"),
):
cache.set_cache(key=cache_key, value=hashed_token)
cache.set_cache(key=hashed_token, value=UserAPIKeyAuth(token=hashed_token))
user_row: Final = mocker.MagicMock()
user_row.user_id = "jwt-user"
user_row.user_email = "[email protected]"
user_row.teams = []
user_row.model_dump_json.return_value = "{}"
user_row.model_dump.return_value = {"user_id": "jwt-user", "user_email": "[email protected]", "teams": []}
mock_prisma_client: Final = mocker.MagicMock()
mock_prisma_client.db.litellm_usertable.find_unique = mocker.AsyncMock(return_value=user_row)
mock_prisma_client.db.litellm_teamtable.find_many = mocker.AsyncMock(return_value=[])
mock_prisma_client.db.litellm_jwtkeymapping = jwt_table
mock_prisma_client.db.litellm_verificationtoken.find_many = mocker.AsyncMock(
return_value=[SimpleNamespace(token="hashed-jwt-key"), SimpleNamespace(token="hashed-issuer-key")]
)
async def cascading_delete_many(where):
jwt_table.cascade(("hashed-jwt-key", "hashed-issuer-key"))
return 2
mock_prisma_client.db.litellm_verificationtoken.delete_many = mocker.AsyncMock(side_effect=cascading_delete_many)
mock_prisma_client.db.litellm_invitationlink.delete_many = mocker.AsyncMock(return_value=0)
mock_prisma_client.db.litellm_organizationmembership.delete_many = mocker.AsyncMock(return_value=0)
mock_prisma_client.db.litellm_teammembership.delete_many = mocker.AsyncMock(return_value=0)
mock_prisma_client.db.litellm_usertable.delete_many = mocker.AsyncMock(return_value=1)
_serve_locked_user_delete(mock_prisma_client, user_row)
mocker.patch("litellm.proxy.proxy_server.prisma_client", mock_prisma_client) # test-quality-ok: substitute the database dependency
mocker.patch("litellm.proxy.proxy_server.user_api_key_cache", cache) # test-quality-ok: exercise a real isolated cache
mocker.patch("litellm.proxy.proxy_server.proxy_logging_obj", None) # test-quality-ok: delete_user reads it off proxy_server at call time
await delete_user(
data=DeleteUserRequest(user_ids=["jwt-user"]),
user_api_key_dict=UserAPIKeyAuth(user_id="proxy-admin", user_role=LitellmUserRoles.PROXY_ADMIN),
)
assert cache.get_cache(key=global_cache_key) is None
assert cache.get_cache(key=issuer_cache_key) is None
assert cache.get_cache(key="hashed-jwt-key") is None
assert cache.get_cache(key="hashed-issuer-key") is None
assert cache.get_cache(key=unrelated_cache_key) == "hashed-unrelated-key"
assert cache.get_cache(key="hashed-unrelated-key") is not None
assert [row.token for row in jwt_table.rows] == ["hashed-unrelated-key"]
@pytest.mark.asyncio
async def test_delete_user_rejects_org_admin_deleting_outside_scope(mocker):
"""Regression: an org admin of org-A must not be able to delete a user
whose org memberships include org-B.
Route-level gate accepts the request when the caller supplies an
`organization_id` they administer; without per-user org authorization
the handler would cascade-delete the victim's keys, memberships, and
user row regardless of where the victim actually belongs.
"""
from fastapi import HTTPException
from litellm.proxy._types import DeleteUserRequest, UserAPIKeyAuth
from litellm.proxy.management_endpoints.internal_user_endpoints import delete_user
mock_prisma_client = mocker.MagicMock()
# Target user exists and is a member of org-B only.
mock_target_user = mocker.MagicMock()
mock_target_user.user_id = "victim"
mock_target_user.user_email = "[email protected]"
mock_target_user.teams = []
mock_target_user.json.return_value = "{}"
async def mock_find_unique(*args, **kwargs):
return mock_target_user
mock_prisma_client.db.litellm_usertable.find_unique = mocker.AsyncMock(side_effect=mock_find_unique)
# Caller (org_admin_user) administers org-A.
caller_membership = mocker.MagicMock()
caller_membership.organization_id = "org-A"
# Target user is a member of org-B (outside caller's scope).
target_membership = mocker.MagicMock()
target_membership.organization_id = "org-B"
async def mock_find_memberships(*args, **kwargs):
where = kwargs.get("where") or (args[0] if args else {})
user_id_filter = where.get("user_id")
# Batched lookup: {"user_id": {"in": [...]}} returns target memberships.
# Caller role lookup: {"user_id": "<caller>", "user_role": ...}.
if isinstance(user_id_filter, dict) and "in" in user_id_filter:
if "victim" in user_id_filter["in"]:
# Attach user_id on the mock so the caller can build its
# per-user dict from the batch result.
target_membership.user_id = "victim"
return [target_membership]
return []
if user_id_filter == "org_admin_user":
return [caller_membership]
return []
mock_prisma_client.db.litellm_organizationmembership.find_many = mocker.AsyncMock(side_effect=mock_find_memberships)
mocker.patch("litellm.proxy.proxy_server.prisma_client", mock_prisma_client)
data = DeleteUserRequest(user_ids=["victim"])
user_api_key_dict = UserAPIKeyAuth(user_id="org_admin_user", user_role=LitellmUserRoles.ORG_ADMIN)
with pytest.raises(HTTPException) as exc:
await delete_user(data=data, user_api_key_dict=user_api_key_dict)
assert exc.value.status_code == 403
# Critical: no delete_many calls should have executed.
assert (
not hasattr(mock_prisma_client.db.litellm_verificationtoken.delete_many, "mock_calls")
or len(mock_prisma_client.db.litellm_verificationtoken.delete_many.mock_calls) == 0
)
@pytest.mark.asyncio
async def test_user_update_rejects_silent_create_for_non_proxy_admin(mocker):
"""Regression: `/user/update` with an unknown user_email used to fall
through to an INSERT, silently creating a new user with caller-supplied
budget, models, and metadata. An org admin could use this to spawn
arbitrary users outside the /user/new authorization flow."""
from fastapi import HTTPException
from litellm.proxy._types import UpdateUserRequest, UserAPIKeyAuth
from litellm.proxy.management_endpoints.internal_user_endpoints import (
_update_single_user_helper,
)
mock_prisma_client = mocker.MagicMock()
# user_email lookup yields None → would silently create pre-fix.
mock_prisma_client.db.litellm_usertable.find_first = mocker.AsyncMock(return_value=None)
mocker.patch("litellm.proxy.proxy_server.prisma_client", mock_prisma_client)
user_request = UpdateUserRequest(
user_email="[email protected]",
max_budget=1_000_000,
models=["gpt-4"],
)
org_admin = UserAPIKeyAuth(
user_id="org-admin",
user_role=LitellmUserRoles.ORG_ADMIN,
)
with pytest.raises(HTTPException) as exc:
await _update_single_user_helper(user_request=user_request, user_api_key_dict=org_admin)
assert exc.value.status_code == 404
# =====================================================================
# /v2/user/info endpoint tests
# =====================================================================
@pytest.mark.asyncio
async def test_user_info_v2_proxy_admin_can_query_any_user(mocker: MockerFixture) -> None:
"""
Test that proxy admin can query any user via /v2/user/info.
"""
from fastapi import Request
from litellm.proxy._types import LiteLLM_UserTable, UserInfoV2Response
from litellm.proxy.management_endpoints.internal_user_endpoints import user_info_v2
mock_user_row: Final = LiteLLM_UserTable(
user_id="target-user-123",
user_email="[email protected]",
user_alias="Target User",
user_role="internal_user",
spend=42.5,
max_budget=100.0,
tpm_limit=100000,
rpm_limit=1000,
models=["gpt-4"],
budget_duration="30d",
budget_reset_at=None,
metadata={"team": "engineering"},
created_at=datetime(2024, 1, 1, tzinfo=timezone.utc),
updated_at=datetime(2024, 6, 1, tzinfo=timezone.utc),
sso_user_id="sso-abc",
teams=["team-1", "team-2"],
)
class _UserTable:
def __init__(self, find_unique: AsyncMock) -> None:
self.find_unique = find_unique
class _Database:
def __init__(self, litellm_usertable: _UserTable) -> None:
self.litellm_usertable = litellm_usertable
class _PrismaClient:
def __init__(self, db: _Database) -> None:
self.db = db
async def mock_find_unique(*_args: object, **kwargs: object) -> LiteLLM_UserTable | None:
where: Final = kwargs.get("where")
if isinstance(where, Mapping) and where.get("user_id") == "target-user-123":
return mock_user_row
return None
mock_prisma_client: Final = _PrismaClient(
db=_Database(
litellm_usertable=_UserTable(find_unique=mocker.AsyncMock(side_effect=mock_find_unique))
)
)
mocker.patch("litellm.proxy.proxy_server.prisma_client", mock_prisma_client)
mock_request: Final = mocker.MagicMock(spec=Request)
admin_key: Final = UserAPIKeyAuth(user_id="admin-user", user_role=LitellmUserRoles.PROXY_ADMIN)
response: Final = await user_info_v2(
request=mock_request,
user_id="target-user-123",
user_api_key_dict=admin_key,
)
assert isinstance(response, UserInfoV2Response)
assert response.user_id == "target-user-123"
assert response.user_email == "[email protected]"
assert response.user_alias == "Target User"
assert response.user_role == "internal_user"
assert response.spend == 42.5
assert response.max_budget == 100.0
assert response.tpm_limit == 100000
assert response.rpm_limit == 1000
assert response.models == ["gpt-4"]
assert response.teams == ["team-1", "team-2"]
assert response.sso_user_id == "sso-abc"
assert response.metadata == {"team": "engineering"}
@pytest.mark.asyncio
async def test_user_info_v2_redacts_scim_enterprise_metadata(mocker):
"""
SCIM enterprise attributes are persisted in metadata for reporting, but
/v2/user/info must not surface them; the rest of metadata is preserved.
"""
from fastapi import Request
from litellm.proxy._types import UserInfoV2Response
from litellm.proxy.management_endpoints.internal_user_endpoints import user_info_v2
mock_prisma_client = mocker.MagicMock()
mock_user_row = mocker.MagicMock()
mock_user_row.model_dump.return_value = {
"user_id": "target-user-123",
"user_email": "[email protected]",
"metadata": {
"scim_metadata": {"givenName": "Jane", "familyName": "Doe"},
"scim_enterprise": {
"costCenter": "CC-42",
"department": "Platform",
"employeeNumber": "E-1001",
},
},
"teams": ["team-1"],
}
async def mock_find_unique(*args, **kwargs):
if kwargs.get("where", {}).get("user_id") == "target-user-123":
return mock_user_row
return None
mock_prisma_client.db.litellm_usertable.find_unique = mocker.AsyncMock(side_effect=mock_find_unique)
mocker.patch("litellm.proxy.proxy_server.prisma_client", mock_prisma_client)
mock_request = mocker.MagicMock(spec=Request)
admin_key = UserAPIKeyAuth(user_id="admin-user", user_role=LitellmUserRoles.PROXY_ADMIN)
response = await user_info_v2(
request=mock_request,
user_id="target-user-123",
user_api_key_dict=admin_key,
)
assert isinstance(response, UserInfoV2Response)
assert response.metadata == {"scim_metadata": {"givenName": "Jane", "familyName": "Doe"}}
assert "scim_enterprise" not in (response.metadata or {})
def test_build_user_info_response_redacts_scim_enterprise_metadata():
"""
The shared /user/info builder strips scim_enterprise from the returned user row
while leaving every other metadata key intact.
"""
from litellm.proxy.management_endpoints.internal_user_endpoints import (
_build_user_info_response,
)
user_row = {
"user_id": "target-user-123",
"metadata": {
"scim_metadata": {"givenName": "Jane"},
"scim_enterprise": {"costCenter": "CC-42"},
},
}
response = _build_user_info_response(
user_id="target-user-123",
user_info=user_row,
keys=None,
team_list=[],
teams_1=None,
)
assert response.user_info is not None
assert response.user_info["metadata"] == {"scim_metadata": {"givenName": "Jane"}}
assert "scim_enterprise" not in response.user_info["metadata"]
@pytest.mark.asyncio
async def test_user_info_v2_internal_user_can_query_self(mocker):
"""
Test that an internal user can query their own info.
"""
from fastapi import Request
from litellm.proxy._types import UserInfoV2Response
from litellm.proxy.management_endpoints.internal_user_endpoints import user_info_v2
mock_prisma_client = mocker.MagicMock()
mock_user_row = mocker.MagicMock()
mock_user_row.model_dump.return_value = {
"user_id": "self-user",
"user_email": "[email protected]",
"user_alias": None,
"user_role": "internal_user",
"spend": 10.0,
"max_budget": None,
"models": [],
"budget_duration": None,
"budget_reset_at": None,
"metadata": None,
"created_at": None,
"updated_at": None,
"sso_user_id": None,
"teams": [],
}
async def mock_find_unique(*args, **kwargs):
if kwargs.get("where", {}).get("user_id") == "self-user":
return mock_user_row
return None
mock_prisma_client.db.litellm_usertable.find_unique = mocker.AsyncMock(side_effect=mock_find_unique)
mocker.patch("litellm.proxy.proxy_server.prisma_client", mock_prisma_client)
mock_request = mocker.MagicMock(spec=Request)
user_key = UserAPIKeyAuth(user_id="self-user", user_role=LitellmUserRoles.INTERNAL_USER)
response = await user_info_v2(
request=mock_request,
user_id="self-user",
user_api_key_dict=user_key,
)
assert isinstance(response, UserInfoV2Response)
assert response.user_id == "self-user"
assert response.user_email == "[email protected]"
assert response.spend == 10.0
@pytest.mark.asyncio
async def test_user_info_v2_internal_user_cannot_query_other(mocker):
"""
Test that an internal user cannot query another user - returns 404.
"""
from fastapi import Request
from litellm.proxy.management_endpoints.internal_user_endpoints import user_info_v2
mock_prisma_client = mocker.MagicMock()
# Caller user has no teams (so no team admin access)
mock_caller_row = mocker.MagicMock()
mock_caller_row.teams = []
async def mock_find_unique(*args, **kwargs):
user_id = kwargs.get("where", {}).get("user_id")
if user_id == "caller-user":
return mock_caller_row
return None
mock_prisma_client.db.litellm_usertable.find_unique = mocker.AsyncMock(side_effect=mock_find_unique)
mocker.patch("litellm.proxy.proxy_server.prisma_client", mock_prisma_client)
mock_request = mocker.MagicMock(spec=Request)
user_key = UserAPIKeyAuth(user_id="caller-user", user_role=LitellmUserRoles.INTERNAL_USER)
with pytest.raises(ProxyException) as exc_info:
await user_info_v2(
request=mock_request,
user_id="other-user-456",
user_api_key_dict=user_key,
)
assert exc_info.value.code == "404"
@pytest.mark.asyncio
async def test_user_info_v2_no_user_id_defaults_to_self(mocker):
"""
Test that omitting user_id defaults to the caller's own user info.
"""
from fastapi import Request
from litellm.proxy._types import UserInfoV2Response
from litellm.proxy.management_endpoints.internal_user_endpoints import user_info_v2
mock_prisma_client = mocker.MagicMock()
mock_user_row = mocker.MagicMock()
mock_user_row.model_dump.return_value = {
"user_id": "my-user-id",
"user_email": "[email protected]",
"user_alias": None,
"user_role": "internal_user",
"spend": 0.0,
"max_budget": None,
"models": [],
"budget_duration": None,
"budget_reset_at": None,
"metadata": None,
"created_at": None,
"updated_at": None,
"sso_user_id": None,
"teams": [],
}
async def mock_find_unique(*args, **kwargs):
if kwargs.get("where", {}).get("user_id") == "my-user-id":
return mock_user_row
return None
mock_prisma_client.db.litellm_usertable.find_unique = mocker.AsyncMock(side_effect=mock_find_unique)
mocker.patch("litellm.proxy.proxy_server.prisma_client", mock_prisma_client)
mock_request = mocker.MagicMock(spec=Request)
user_key = UserAPIKeyAuth(user_id="my-user-id", user_role=LitellmUserRoles.INTERNAL_USER)
# Call without user_id
response = await user_info_v2(
request=mock_request,
user_id=None,
user_api_key_dict=user_key,
)
assert isinstance(response, UserInfoV2Response)
assert response.user_id == "my-user-id"
assert response.user_email == "[email protected]"
@pytest.mark.asyncio
async def test_user_info_v2_nonexistent_user_returns_404(mocker):
"""
Test that querying a nonexistent user returns 404.
"""
from fastapi import Request
from litellm.proxy.management_endpoints.internal_user_endpoints import user_info_v2
mock_prisma_client = mocker.MagicMock()
async def mock_find_unique(*args, **kwargs):
return None
mock_prisma_client.db.litellm_usertable.find_unique = mocker.AsyncMock(side_effect=mock_find_unique)
mocker.patch("litellm.proxy.proxy_server.prisma_client", mock_prisma_client)
mock_request = mocker.MagicMock(spec=Request)
admin_key = UserAPIKeyAuth(user_id="admin-user", user_role=LitellmUserRoles.PROXY_ADMIN)
with pytest.raises(ProxyException) as exc_info:
await user_info_v2(
request=mock_request,
user_id="nonexistent-user-id",
user_api_key_dict=admin_key,
)
assert exc_info.value.code == "404"
assert "nonexistent-user-id" in str(exc_info.value.message)
@pytest.mark.asyncio
async def test_user_info_v2_response_shape(mocker):
"""
Test that the response shape contains expected fields and
does NOT contain keys or teams objects (only team IDs).
"""
from fastapi import Request
from litellm.proxy._types import UserInfoV2Response
from litellm.proxy.management_endpoints.internal_user_endpoints import user_info_v2
mock_prisma_client = mocker.MagicMock()
mock_user_row = mocker.MagicMock()
mock_user_row.model_dump.return_value = {
"user_id": "shape-test-user",
"user_email": "[email protected]",
"user_alias": "Shape Test",
"user_role": "internal_user",
"spend": 5.0,
"max_budget": 50.0,
"models": ["gpt-3.5-turbo"],
"budget_duration": "7d",
"budget_reset_at": datetime(2024, 7, 1, tzinfo=timezone.utc),
"metadata": {"env": "test"},
"created_at": datetime(2024, 1, 1, tzinfo=timezone.utc),
"updated_at": datetime(2024, 6, 1, tzinfo=timezone.utc),
"sso_user_id": None,
"teams": ["team-a", "team-b"],
"model_max_budget": {"gpt-3.5-turbo": {"budget_limit": 5.0, "time_period": "30d"}},
}
async def mock_find_unique(*args, **kwargs):
return mock_user_row
mock_prisma_client.db.litellm_usertable.find_unique = mocker.AsyncMock(side_effect=mock_find_unique)
mocker.patch("litellm.proxy.proxy_server.prisma_client", mock_prisma_client)
mock_request = mocker.MagicMock(spec=Request)
admin_key = UserAPIKeyAuth(user_id="admin-user", user_role=LitellmUserRoles.PROXY_ADMIN)
response = await user_info_v2(
request=mock_request,
user_id="shape-test-user",
user_api_key_dict=admin_key,
)
assert isinstance(response, UserInfoV2Response)
# Verify all expected fields are present
response_dict = response.model_dump()
expected_fields = {
"user_id",
"user_email",
"user_alias",
"user_role",
"spend",
"max_budget",
"tpm_limit",
"rpm_limit",
"models",
"budget_duration",
"budget_reset_at",
"metadata",
"created_at",
"updated_at",
"sso_user_id",
"teams",
"object_permission",
"model_max_budget",
"model_max_budget_usage",
}
assert set(response_dict.keys()) == expected_fields
# The dashboard's user edit form hydrates its per-model budget rows from
# these two, so dropping them makes a save replace the user's budgets.
assert response_dict["model_max_budget"] == {"gpt-3.5-turbo": {"budget_limit": 5.0, "time_period": "30d"}}
assert response_dict["model_max_budget_usage"] == {
"gpt-3.5-turbo": {"current_spend": 0.0, "budget_limit": 5.0, "time_period": "30d", "budget_reset_at": None}
}
# Verify teams is a list of strings (team IDs), not team objects
assert isinstance(response.teams, list)
assert all(isinstance(t, str) for t in response.teams)
assert response.teams == ["team-a", "team-b"]
# Verify models is a list of strings
assert isinstance(response.models, list)
assert response.models == ["gpt-3.5-turbo"]
@pytest.mark.asyncio
async def test_user_info_v2_team_admin_can_query_team_member(mocker):
"""
Test that a team admin can query info of a user in their team.
"""
from fastapi import Request
from litellm.proxy._types import LiteLLM_TeamTable, UserInfoV2Response
from litellm.proxy.management_endpoints.internal_user_endpoints import user_info_v2
mock_prisma_client = mocker.MagicMock()
# Caller (team admin)
mock_caller = mocker.MagicMock()
mock_caller.teams = ["shared-team-id"]
# Target user (team member)
mock_target = mocker.MagicMock()
mock_target.teams = ["shared-team-id"]
mock_target.model_dump.return_value = {
"user_id": "target-member",
"user_email": "[email protected]",
"user_alias": None,
"user_role": "internal_user",
"spend": 0.0,
"max_budget": None,
"models": [],
"budget_duration": None,
"budget_reset_at": None,
"metadata": None,
"created_at": None,
"updated_at": None,
"sso_user_id": None,
"teams": ["shared-team-id"],
}
async def mock_find_unique(*args, **kwargs):
uid = kwargs.get("where", {}).get("user_id")
if uid == "team-admin-user":
return mock_caller
elif uid == "target-member":
return mock_target
return None
mock_prisma_client.db.litellm_usertable.find_unique = mocker.AsyncMock(side_effect=mock_find_unique)
# Mock team with caller as admin
mock_team = mocker.MagicMock()
mock_team.team_id = "shared-team-id"
mock_team.model_dump.return_value = {
"team_id": "shared-team-id",
"team_alias": "Shared Team",
"members_with_roles": [
{"user_id": "team-admin-user", "role": "admin"},
{"user_id": "target-member", "role": "user"},
],
}
async def mock_find_many_teams(*args, **kwargs):
return [mock_team]
mock_prisma_client.db.litellm_teamtable.find_many = mocker.AsyncMock(side_effect=mock_find_many_teams)
mocker.patch("litellm.proxy.proxy_server.prisma_client", mock_prisma_client)
mock_request = mocker.MagicMock(spec=Request)
team_admin_key = UserAPIKeyAuth(user_id="team-admin-user", user_role=LitellmUserRoles.INTERNAL_USER)
response = await user_info_v2(
request=mock_request,
user_id="target-member",
user_api_key_dict=team_admin_key,
)
assert isinstance(response, UserInfoV2Response)
assert response.user_id == "target-member"
assert response.user_email == "[email protected]"
@pytest.mark.asyncio
async def test_user_info_v2_team_admin_cannot_query_non_team_member(mocker):
"""
Test that a team admin cannot query a user NOT in their team - returns 404.
"""
from fastapi import Request
from litellm.proxy.management_endpoints.internal_user_endpoints import user_info_v2
mock_prisma_client = mocker.MagicMock()
# Caller (team admin of team-A)
mock_caller = mocker.MagicMock()
mock_caller.teams = ["team-A"]
# Target user (in team-B only)
mock_target = mocker.MagicMock()
mock_target.teams = ["team-B"]
async def mock_find_unique(*args, **kwargs):
uid = kwargs.get("where", {}).get("user_id")
if uid == "team-admin-user":
return mock_caller
elif uid == "non-member-user":
return mock_target
return None
mock_prisma_client.db.litellm_usertable.find_unique = mocker.AsyncMock(side_effect=mock_find_unique)
# Mock team where caller is admin
mock_team = mocker.MagicMock()
mock_team.team_id = "team-A"
mock_team.model_dump.return_value = {
"team_id": "team-A",
"team_alias": "Team A",
"members_with_roles": [
{"user_id": "team-admin-user", "role": "admin"},
],
}
async def mock_find_many_teams(*args, **kwargs):
return [mock_team]
mock_prisma_client.db.litellm_teamtable.find_many = mocker.AsyncMock(side_effect=mock_find_many_teams)
mocker.patch("litellm.proxy.proxy_server.prisma_client", mock_prisma_client)
mock_request = mocker.MagicMock(spec=Request)
team_admin_key = UserAPIKeyAuth(user_id="team-admin-user", user_role=LitellmUserRoles.INTERNAL_USER)
with pytest.raises(ProxyException) as exc_info:
await user_info_v2(
request=mock_request,
user_id="non-member-user",
user_api_key_dict=team_admin_key,
)
assert exc_info.value.code == "404"
@pytest.mark.asyncio
async def test_user_info_v2_url_encoding_plus_character(mocker):
"""
Test that /v2/user/info properly handles email addresses with + characters.
"""
from fastapi import Request
from litellm.proxy._types import UserInfoV2Response
from litellm.proxy.management_endpoints.internal_user_endpoints import user_info_v2
mock_prisma_client = mocker.MagicMock()
expected_user_id = "[email protected]"
mock_user_row = mocker.MagicMock()
mock_user_row.model_dump.return_value = {
"user_id": expected_user_id,
"user_email": expected_user_id,
"user_alias": None,
"user_role": "internal_user",
"spend": 0.0,
"max_budget": None,
"models": [],
"budget_duration": None,
"budget_reset_at": None,
"metadata": None,
"created_at": None,
"updated_at": None,
"sso_user_id": None,
"teams": [],
}
async def mock_find_unique(*args, **kwargs):
uid = kwargs.get("where", {}).get("user_id")
if uid == expected_user_id:
return mock_user_row
return None
mock_prisma_client.db.litellm_usertable.find_unique = mocker.AsyncMock(side_effect=mock_find_unique)
mocker.patch("litellm.proxy.proxy_server.prisma_client", mock_prisma_client)
mock_request = mocker.MagicMock(spec=Request)
mock_request.url.query = f"user_id={expected_user_id}"
admin_key = UserAPIKeyAuth(user_id="admin-user", user_role=LitellmUserRoles.PROXY_ADMIN)
# Simulate FastAPI converting + to space
decoded_user_id = "machine-user [email protected]"
response = await user_info_v2(
request=mock_request,
user_id=decoded_user_id,
user_api_key_dict=admin_key,
)
assert isinstance(response, UserInfoV2Response)
assert response.user_id == expected_user_id
class TestGetUserIdFromRequestValidation:
"""Tests for user_id input validation in get_user_id_from_request."""
def _make_request(self, query_string: str):
from unittest.mock import MagicMock
from starlette.requests import Request
request = MagicMock(spec=Request)
request.url.query = query_string
return request
def test_valid_uuid(self):
from litellm.proxy.management_endpoints.internal_user_endpoints import (
get_user_id_from_request,
)
request = self._make_request("user_id=550e8400-e29b-41d4-a716-446655440000")
result = get_user_id_from_request(request)
assert result == "550e8400-e29b-41d4-a716-446655440000"
def test_valid_email(self):
from litellm.proxy.management_endpoints.internal_user_endpoints import (
get_user_id_from_request,
)
request = self._make_request("user_id=user%40example.com")
result = get_user_id_from_request(request)
assert result == "[email protected]"
def test_rejects_overlong_user_id(self):
from litellm.proxy.management_endpoints.internal_user_endpoints import (
get_user_id_from_request,
)
long_id = "a" * 513
request = self._make_request(f"user_id={long_id}")
result = get_user_id_from_request(request)
assert result is None
def test_rejects_null_byte(self):
from litellm.proxy.management_endpoints.internal_user_endpoints import (
get_user_id_from_request,
)
request = self._make_request("user_id=admin%00evil")
result = get_user_id_from_request(request)
assert result is None
def test_rejects_control_characters(self):
from litellm.proxy.management_endpoints.internal_user_endpoints import (
get_user_id_from_request,
)
# Tab character (0x09)
request = self._make_request("user_id=admin%09evil")
result = get_user_id_from_request(request)
assert result is None
def test_allows_512_char_user_id(self):
from litellm.proxy.management_endpoints.internal_user_endpoints import (
get_user_id_from_request,
)
exact_id = "a" * 512
request = self._make_request(f"user_id={exact_id}")
result = get_user_id_from_request(request)
assert result == exact_id
# ---------------------------------------------------------------------------
# VERIA-60: /user/info post-decode re-authorization
# ---------------------------------------------------------------------------
def test_enforce_user_info_access_admin_bypass():
"""Proxy admins must always be allowed past the re-check."""
from litellm.proxy._types import LitellmUserRoles, UserAPIKeyAuth
from litellm.proxy.management_endpoints.internal_user_endpoints import (
_enforce_user_info_access,
)
admin = UserAPIKeyAuth(user_id="admin", user_role=LitellmUserRoles.PROXY_ADMIN.value)
# Should not raise even when querying a different user
_enforce_user_info_access(user_id="someone_else", user_api_key_dict=admin)
def test_enforce_user_info_access_view_only_admin_can_read_other_users():
"""PROXY_ADMIN_VIEW_ONLY has read parity with PROXY_ADMIN, so the ownership
re-check must wave it through for another user's id."""
from litellm.proxy._types import LitellmUserRoles, UserAPIKeyAuth
from litellm.proxy.management_endpoints.internal_user_endpoints import (
_enforce_user_info_access,
)
viewer = UserAPIKeyAuth(
user_id="viewer",
user_role=LitellmUserRoles.PROXY_ADMIN_VIEW_ONLY.value,
)
_enforce_user_info_access(user_id="someone_else", user_api_key_dict=viewer)
def test_enforce_user_info_access_view_only_admin_can_read_own():
from litellm.proxy._types import LitellmUserRoles, UserAPIKeyAuth
from litellm.proxy.management_endpoints.internal_user_endpoints import (
_enforce_user_info_access,
)
viewer = UserAPIKeyAuth(
user_id="viewer",
user_role=LitellmUserRoles.PROXY_ADMIN_VIEW_ONLY.value,
)
_enforce_user_info_access(user_id="viewer", user_api_key_dict=viewer)
def test_enforce_user_info_access_owner_allowed():
from litellm.proxy._types import LitellmUserRoles, UserAPIKeyAuth
from litellm.proxy.management_endpoints.internal_user_endpoints import (
_enforce_user_info_access,
)
user = UserAPIKeyAuth(user_id="alice", user_role=LitellmUserRoles.INTERNAL_USER.value)
_enforce_user_info_access(user_id="alice", user_api_key_dict=user)
def test_enforce_user_info_access_no_user_id_allowed():
"""No user_id in query → handler resolves to caller's own id later, so
this branch must not raise."""
from litellm.proxy._types import LitellmUserRoles, UserAPIKeyAuth
from litellm.proxy.management_endpoints.internal_user_endpoints import (
_enforce_user_info_access,
)
user = UserAPIKeyAuth(user_id="alice", user_role=LitellmUserRoles.INTERNAL_USER.value)
_enforce_user_info_access(user_id=None, user_api_key_dict=user)
def test_enforce_user_info_access_blocks_cross_user_lookup():
"""A non-admin caller may not query another user's row, even if URL
re-parsing produced a user_id that differs from the one the route check
saw (the VERIA-60 bypass)."""
import pytest
from fastapi import HTTPException
from litellm.proxy._types import LitellmUserRoles, UserAPIKeyAuth
from litellm.proxy.management_endpoints.internal_user_endpoints import (
_enforce_user_info_access,
)
attacker = UserAPIKeyAuth(
user_id="attacker space", # original (URL-decoded) id seen by route check
user_role=LitellmUserRoles.INTERNAL_USER.value,
)
with pytest.raises(HTTPException) as exc_info:
# Re-parsed id (with literal '+') belongs to the victim
_enforce_user_info_access(user_id="victim+target", user_api_key_dict=attacker)
assert exc_info.value.status_code == 403
assert "key not allowed to access this user's info" in str(exc_info.value.detail)
# ---------------------------------------------------------------------------
# Regression tests for GHSA-wvg4-6222-3q4r: budget self-escalation via
# /user/update
# ---------------------------------------------------------------------------
@pytest.mark.asyncio
@pytest.mark.parametrize(
("budget_field", "budget_value"),
[("max_budget", 999999), ("model_max_budget", {}), ("model_max_budget", None)],
)
async def test_ghsa_wvg4_non_admin_cannot_self_escalate_max_budget(mocker, budget_field, budget_value):
"""Non-admin updating their own record must be blocked from modifying
max_budget (self-escalation)."""
from fastapi import HTTPException
from litellm.proxy.management_endpoints.internal_user_endpoints import (
_update_single_user_helper,
)
mock_prisma_client = mocker.MagicMock()
mock_prisma_client.update_data = mocker.AsyncMock(return_value={"user_id": "user-1", "data": {"user_id": "user-1"}})
existing_user = mocker.MagicMock()
existing_user.model_dump.return_value = {
"user_id": "user-1",
"max_budget": 100,
}
existing_user.user_id = "user-1"
mock_prisma_client.db.litellm_usertable.find_first = mocker.AsyncMock(return_value=existing_user)
mocker.patch("litellm.proxy.proxy_server.prisma_client", mock_prisma_client)
user_request = UpdateUserRequest.model_validate({"user_id": "user-1", budget_field: budget_value})
caller = UserAPIKeyAuth(
user_id="user-1",
user_role=LitellmUserRoles.INTERNAL_USER,
)
with pytest.raises(HTTPException) as exc:
await _update_single_user_helper(user_request=user_request, user_api_key_dict=caller)
assert exc.value.status_code == 403
assert budget_field in str(exc.value.detail)
mock_prisma_client.update_data.assert_not_called()
@pytest.mark.asyncio
async def test_ghsa_wvg4_non_admin_cannot_self_escalate_spend(mocker):
"""Non-admin must not be able to reset their own spend to zero."""
from fastapi import HTTPException
from litellm.proxy.management_endpoints.internal_user_endpoints import (
_update_single_user_helper,
)
mock_prisma_client = mocker.MagicMock()
existing_user = mocker.MagicMock()
existing_user.model_dump.return_value = {
"user_id": "user-1",
"spend": 50.0,
}
existing_user.user_id = "user-1"
mock_prisma_client.db.litellm_usertable.find_first = mocker.AsyncMock(return_value=existing_user)
mocker.patch("litellm.proxy.proxy_server.prisma_client", mock_prisma_client)
user_request = UpdateUserRequest(
user_id="user-1",
spend=0,
)
caller = UserAPIKeyAuth(
user_id="user-1",
user_role=LitellmUserRoles.INTERNAL_USER,
)
with pytest.raises(HTTPException) as exc:
await _update_single_user_helper(user_request=user_request, user_api_key_dict=caller)
assert exc.value.status_code == 403
assert "spend" in str(exc.value.detail)
@pytest.mark.asyncio
async def test_ghsa_wvg4_proxy_admin_can_update_user_budget(mocker):
"""PROXY_ADMIN must still be able to modify another user's budget."""
from litellm.proxy.management_endpoints.internal_user_endpoints import (
_update_single_user_helper,
)
mock_prisma_client = mocker.MagicMock()
existing_user = mocker.MagicMock()
existing_user.model_dump.return_value = {
"user_id": "target-user",
"max_budget": 100,
}
existing_user.user_id = "target-user"
mock_prisma_client.db.litellm_usertable.find_first = mocker.AsyncMock(return_value=existing_user)
mock_prisma_client.update_data = mocker.AsyncMock(return_value={"user_id": "target-user", "max_budget": 500})
mock_prisma_client.jsonify_object = mocker.MagicMock(side_effect=lambda x: x)
mocker.patch("litellm.proxy.proxy_server.prisma_client", mock_prisma_client)
mocker.patch("litellm.proxy.proxy_server.litellm_proxy_admin_name", "admin")
user_request = UpdateUserRequest(
user_id="target-user",
max_budget=500,
)
admin_caller = UserAPIKeyAuth(
user_id="admin-1",
user_role=LitellmUserRoles.PROXY_ADMIN,
)
result = await _update_single_user_helper(user_request=user_request, user_api_key_dict=admin_caller)
assert result is not None
@pytest.mark.asyncio
async def test_admin_user_update_spend_invalidates_counter(mocker):
"""A direct /user/update spend change must invalidate the cross-pod
spend counter so enforcement re-reads the new DB value."""
from litellm.proxy.management_endpoints.internal_user_endpoints import (
_update_single_user_helper,
)
mock_prisma_client = mocker.MagicMock()
existing_user = mocker.MagicMock()
existing_user.model_dump.return_value = {"user_id": "target-user", "spend": 50.0}
existing_user.user_id = "target-user"
mock_prisma_client.db.litellm_usertable.find_first = mocker.AsyncMock(return_value=existing_user)
mock_prisma_client.update_data = mocker.AsyncMock(return_value={"user_id": "target-user", "spend": -25.0})
mock_prisma_client.jsonify_object = mocker.MagicMock(side_effect=lambda x: x)
mocker.patch("litellm.proxy.proxy_server.prisma_client", mock_prisma_client)
mocker.patch("litellm.proxy.proxy_server.litellm_proxy_admin_name", "admin")
mock_invalidate = mocker.patch(
"litellm.proxy.proxy_server.invalidate_spend_counter",
new=mocker.AsyncMock(),
)
# Use a negative spend: this also implicitly validates that negative spend
# is allowed, which is desirable. Admins may grant an entity extra
# allowance for the current budget period only (a one-time spend grant)
# without raising the recurring budget ceiling. Future changes should
# continue allowing negative spend counters.
user_request = UpdateUserRequest(user_id="target-user", spend=-25)
admin_caller = UserAPIKeyAuth(user_id="admin-1", user_role=LitellmUserRoles.PROXY_ADMIN)
await _update_single_user_helper(user_request=user_request, user_api_key_dict=admin_caller)
mock_invalidate.assert_awaited_once_with(counter_key="spend:user:target-user")
@pytest.mark.asyncio
async def test_user_update_rejects_non_finite_spend(mocker):
"""NaN/inf spend is rejected before any DB write or counter invalidation."""
from fastapi import HTTPException
from litellm.proxy.management_endpoints.internal_user_endpoints import (
_update_single_user_helper,
)
mock_prisma_client = mocker.MagicMock()
existing_user = mocker.MagicMock()
existing_user.model_dump.return_value = {"user_id": "target-user", "spend": 50.0}
existing_user.user_id = "target-user"
mock_prisma_client.db.litellm_usertable.find_first = mocker.AsyncMock(return_value=existing_user)
mock_prisma_client.update_data = mocker.AsyncMock()
mocker.patch("litellm.proxy.proxy_server.prisma_client", mock_prisma_client)
mocker.patch("litellm.proxy.proxy_server.litellm_proxy_admin_name", "admin")
mock_invalidate = mocker.patch(
"litellm.proxy.proxy_server.invalidate_spend_counter",
new=mocker.AsyncMock(),
)
user_request = UpdateUserRequest(user_id="target-user", spend=float("nan"))
admin_caller = UserAPIKeyAuth(user_id="admin-1", user_role=LitellmUserRoles.PROXY_ADMIN)
with pytest.raises(HTTPException) as exc:
await _update_single_user_helper(user_request=user_request, user_api_key_dict=admin_caller)
assert exc.value.status_code == 400
mock_prisma_client.update_data.assert_not_called()
mock_invalidate.assert_not_awaited()
@pytest.mark.asyncio
async def test_resolve_user_email_metadata_maps_page_user_ids_to_email(mocker):
"""Regression for LIT-3889.
The Spend Per User chart rendered raw UUIDs because the per-user activity
breakdown carried no email. This resolver must turn the user_ids on the
page into {user_id: {user_email, user_alias}} so the chart can label each
spender, and it must only look up the user_ids actually present (not the
whole user table).
"""
mock_prisma_client = mocker.MagicMock()
find_many = mocker.AsyncMock(
return_value=[
SimpleNamespace(user_id="u1", user_email="[email protected]", user_alias="Alice"),
SimpleNamespace(user_id="u2", user_email=None, user_alias="bob-alias"),
]
)
mock_prisma_client.db.litellm_usertable.find_many = find_many
records = [
SimpleNamespace(user_id="u1"),
SimpleNamespace(user_id="u1"), # duplicate -> deduped
SimpleNamespace(user_id="u2"),
]
result = await _resolve_user_email_metadata(mock_prisma_client, records)
assert result == {
"u1": {"user_email": "[email protected]", "user_alias": "Alice"},
"u2": {"user_email": None, "user_alias": "bob-alias"},
}
where_arg = find_many.call_args.kwargs["where"]
assert set(where_arg["user_id"]["in"]) == {"u1", "u2"}
@pytest.mark.asyncio
async def test_resolve_user_email_metadata_skips_db_when_no_user_ids(mocker):
"""No user_ids on the page (e.g. all spend is unattributed) means no query."""
mock_prisma_client = mocker.MagicMock()
find_many = mocker.AsyncMock(return_value=[])
mock_prisma_client.db.litellm_usertable.find_many = find_many
records = [SimpleNamespace(user_id=None), SimpleNamespace(user_id="")]
result = await _resolve_user_email_metadata(mock_prisma_client, records)
assert result == {}
find_many.assert_not_called()
@pytest.mark.asyncio
async def test_add_new_user_to_default_team_propagates_max_budget_in_team(mocker):
"""A configured per-member budget on a default team must reach the membership
write; dropping it means the member is unlimited within the team budget."""
from litellm.proxy._types import NewUserRequestTeam
from litellm.proxy.management_endpoints.internal_user_endpoints import (
add_new_user_to_default_team,
)
mock_add = mocker.patch(
"litellm.proxy.management_endpoints.internal_user_endpoints._add_user_to_team",
new_callable=mocker.AsyncMock,
)
await add_new_user_to_default_team(
user_id="jwt-user",
user_email="[email protected]",
user_api_key_dict=UserAPIKeyAuth(user_role=LitellmUserRoles.PROXY_ADMIN),
teams=[
NewUserRequestTeam(team_id="budgeted-team", max_budget_in_team=25.0, user_role="admin"),
NewUserRequestTeam(team_id="uncapped-team"),
],
prisma_client=mocker.MagicMock(),
)
calls = {c.kwargs["team_id"]: c.kwargs for c in mock_add.call_args_list}
assert calls["budgeted-team"]["max_budget_in_team"] == 25.0
assert calls["budgeted-team"]["user_role"] == "admin"
assert calls["uncapped-team"]["max_budget_in_team"] is None
@pytest.mark.asyncio
async def test_add_new_user_to_default_team_string_teams_have_no_member_budget(mocker):
"""Bare-string default teams carry no per-member budget."""
from litellm.proxy.management_endpoints.internal_user_endpoints import (
add_new_user_to_default_team,
)
mock_add = mocker.patch(
"litellm.proxy.management_endpoints.internal_user_endpoints._add_user_to_team",
new_callable=mocker.AsyncMock,
)
await add_new_user_to_default_team(
user_id="jwt-user",
user_email=None,
user_api_key_dict=UserAPIKeyAuth(user_role=LitellmUserRoles.PROXY_ADMIN),
teams=["string-team"],
prisma_client=mocker.MagicMock(),
)
assert mock_add.call_args.kwargs["max_budget_in_team"] is None
assert mock_add.call_args.kwargs["team_id"] == "string-team"
@pytest.mark.asyncio
async def test_add_user_to_team_logs_unknown_team_at_error(mocker, caplog):
"""A default team that no longer exists makes every membership write 404.
The failure is swallowed so user creation still succeeds, so the log line is
the only signal an operator gets; it must be ERROR and name the team.
"""
import logging
from fastapi import HTTPException
from litellm.proxy.management_endpoints.internal_user_endpoints import (
_add_user_to_team,
)
mocker.patch(
"litellm.proxy.management_endpoints.team_endpoints.team_member_add",
new_callable=mocker.AsyncMock,
side_effect=HTTPException(status_code=404, detail={"error": "Team not found"}),
)
with caplog.at_level(logging.DEBUG, logger="LiteLLM Proxy"):
await _add_user_to_team(
user_id="sso-user",
team_id="deleted-team",
user_api_key_dict=UserAPIKeyAuth(user_role=LitellmUserRoles.PROXY_ADMIN),
)
errors = [r.getMessage() for r in caplog.records if r.levelno >= logging.ERROR]
assert len(errors) == 1, f"expected exactly one ERROR log, got {errors}"
assert "deleted-team" in errors[0]
assert "sso-user" in errors[0]
@pytest.mark.asyncio
async def test_add_user_to_team_keeps_already_a_member_quiet(mocker, caplog):
"""Re-adding an existing member is expected on every login and must not
produce an ERROR, otherwise the real failures above are lost in the noise."""
import logging
from fastapi import HTTPException
from litellm.proxy.management_endpoints.internal_user_endpoints import (
_add_user_to_team,
)
mocker.patch(
"litellm.proxy.management_endpoints.team_endpoints.team_member_add",
new_callable=mocker.AsyncMock,
side_effect=HTTPException(status_code=400, detail={"error": "User already exists in team"}),
)
with caplog.at_level(logging.DEBUG, logger="LiteLLM Proxy"):
await _add_user_to_team(
user_id="sso-user",
team_id="existing-team",
user_api_key_dict=UserAPIKeyAuth(user_role=LitellmUserRoles.PROXY_ADMIN),
)
assert [r.getMessage() for r in caplog.records if r.levelno >= logging.ERROR] == []
@pytest.mark.asyncio
async def test_get_user_info_for_proxy_admin_validates_keys_and_teams():
from unittest.mock import AsyncMock, MagicMock, patch
from litellm.proxy._types import LiteLLM_TeamTable, UserAPIKeyAuth
from litellm.proxy.management_endpoints.internal_user_endpoints import (
_get_user_info_for_proxy_admin,
)
raw_rows = [
{
"teams": [
{"team_id": "team-b", "team_alias": "beta"},
{"team_id": "team-a", "team_alias": "alpha"},
],
"keys": [
{"token": "hashed-token-1", "team_id": "team-a", "models": None, "spend": 1.0},
],
}
]
mock_prisma_client = MagicMock()
mock_prisma_client.db.query_raw = AsyncMock(return_value=raw_rows)
with patch("litellm.proxy.proxy_server.prisma_client", mock_prisma_client):
result = await _get_user_info_for_proxy_admin(user_api_key_dict=UserAPIKeyAuth(user_id=None))
assert all(isinstance(team, LiteLLM_TeamTable) for team in result.teams)
assert [team.team_alias for team in result.teams] == ["alpha", "beta"]
assert len(result.keys) == 1
returned_key = result.keys[0]
assert returned_key["team_id"] == "team-a"
assert returned_key["models"] == []
def _object_permission_mocks(mocker, existing_object_permission_id=None):
"""Prisma double whose user row optionally already links a permission row."""
mock_prisma_client = mocker.MagicMock()
existing_user = mocker.MagicMock()
existing_user.model_dump.return_value = {
"user_id": "target-user",
"object_permission_id": existing_object_permission_id,
}
existing_user.user_id = "target-user"
existing_user.object_permission_id = existing_object_permission_id
mock_prisma_client.db.litellm_usertable.find_first = mocker.AsyncMock(return_value=existing_user)
mock_prisma_client.db.litellm_objectpermissiontable.find_unique = mocker.AsyncMock(return_value=None)
mock_prisma_client.db.litellm_objectpermissiontable.upsert = mocker.AsyncMock(
return_value=SimpleNamespace(object_permission_id="perm-new")
)
mock_prisma_client.db.litellm_mcpservertable.find_many = mocker.AsyncMock(return_value=[])
mock_prisma_client.update_data = mocker.AsyncMock(return_value={"user_id": "target-user"})
mock_prisma_client.jsonify_object = mocker.MagicMock(side_effect=lambda x: x)
mocker.patch("litellm.proxy.proxy_server.prisma_client", mock_prisma_client)
mocker.patch("litellm.proxy.proxy_server.litellm_proxy_admin_name", "admin")
mocker.patch(
"litellm.proxy.proxy_server.invalidate_spend_counter",
new=mocker.AsyncMock(),
)
return mock_prisma_client
@pytest.mark.asyncio
async def test_user_update_persists_mcp_entitlement_and_links_it(mocker):
"""/user/update documents an object_permission param; it must actually be stored.
The grants live in their own table, so the endpoint has to upsert them and hand the user row
only the resulting object_permission_id. Passing object_permission through to the user update
would not even be a column.
"""
from litellm.proxy.management_endpoints.internal_user_endpoints import (
_update_single_user_helper,
)
mock_prisma_client = _object_permission_mocks(mocker)
cache = mocker.MagicMock()
cache.async_delete_cache = mocker.AsyncMock()
mocker.patch("litellm.proxy.proxy_server.user_api_key_cache", cache)
await _update_single_user_helper(
user_request=UpdateUserRequest(
user_id="target-user",
object_permission={
"mcp_servers": ["github"],
"mcp_tool_permissions": {"github": ["list_issues"]},
},
),
user_api_key_dict=UserAPIKeyAuth(user_id="admin-1", user_role=LitellmUserRoles.PROXY_ADMIN),
)
upsert_kwargs = mock_prisma_client.db.litellm_objectpermissiontable.upsert.call_args.kwargs
created = upsert_kwargs["data"]["create"]
assert created["mcp_servers"] == ["github"]
assert json.loads(created["mcp_tool_permissions"]) == {"github": ["list_issues"]}
written = mock_prisma_client.update_data.call_args.kwargs["data"]
assert written["object_permission_id"] == "perm-new"
assert "object_permission" not in written
@pytest.mark.asyncio
async def test_user_update_invalidates_the_cached_entitlement(mocker):
"""An admin revoking a tool must take effect now, not at the end of the cache TTL.
Three entries go stale: the permission row (keyed by its own id), the user -> permission link
(which carries a "no entitlement" sentinel), and the cached user row.
"""
from litellm.proxy.management_endpoints.internal_user_endpoints import (
_update_single_user_helper,
)
_object_permission_mocks(mocker)
cache = mocker.MagicMock()
cache.async_delete_cache = mocker.AsyncMock()
mocker.patch("litellm.proxy.proxy_server.user_api_key_cache", cache)
await _update_single_user_helper(
user_request=UpdateUserRequest(
user_id="target-user",
object_permission={"mcp_tool_permissions": {"github": []}},
),
user_api_key_dict=UserAPIKeyAuth(user_id="admin-1", user_role=LitellmUserRoles.PROXY_ADMIN),
)
deleted = {call.kwargs["key"] for call in cache.async_delete_cache.call_args_list}
assert deleted == {
"object_permission_id:perm-new",
"user_object_permission_id:target-user",
"target-user",
}
@pytest.mark.asyncio
async def test_user_update_broadcasts_the_entitlement_invalidation_to_other_workers(mocker: MockerFixture):
from litellm.proxy.management_endpoints.internal_user_endpoints import (
_update_single_user_helper,
)
_object_permission_mocks(mocker)
cache: Final = mocker.MagicMock()
cache.async_delete_cache = mocker.AsyncMock()
mocker.patch("litellm.proxy.proxy_server.user_api_key_cache", cache) # test-quality-ok: substitute the cache dependency
broadcast: Final = mocker.patch( # test-quality-ok: observe the Redis publication boundary
"litellm.proxy.common_utils.auth_cache_invalidation_pubsub.publish_auth_cache_invalidation",
new_callable=mocker.AsyncMock,
)
await _update_single_user_helper(
user_request=UpdateUserRequest(user_id="target-user", object_permission={"vector_stores": []}),
user_api_key_dict=UserAPIKeyAuth(user_id="admin-1", user_role=LitellmUserRoles.PROXY_ADMIN),
)
broadcast_keys: Final = {call.kwargs["cache_key"] for call in broadcast.await_args_list}
assert broadcast_keys == {
"object_permission_id:perm-new",
"user_object_permission_id:target-user",
"target-user",
}
@pytest.mark.asyncio
async def test_admin_can_clear_a_users_mcp_entitlement(mocker):
"""An explicit empty object_permission means "no object permission", so it must unlink.
The merge-based upsert cannot express this: merging an empty grant set over the existing row
leaves every grant in place, and the empty-value filter drops the field before the upsert runs,
so without the explicit clear path the documented operation silently returns success unchanged.
A clear also leaves no incoming permission id, so invalidation keyed off one would skip it and
the gateway would keep enforcing the cleared grants until the cache expired.
"""
from litellm.proxy.management_endpoints.internal_user_endpoints import (
_update_single_user_helper,
)
mock_prisma_client = _object_permission_mocks(mocker, "perm-existing")
cache = mocker.MagicMock()
cache.async_delete_cache = mocker.AsyncMock()
mocker.patch("litellm.proxy.proxy_server.user_api_key_cache", cache)
await _update_single_user_helper(
user_request=UpdateUserRequest(user_id="target-user", object_permission={}),
user_api_key_dict=UserAPIKeyAuth(user_id="admin-1", user_role=LitellmUserRoles.PROXY_ADMIN),
)
written = mock_prisma_client.update_data.call_args.kwargs["data"]
assert written["object_permission_id"] is None
assert "object_permission" not in written
mock_prisma_client.db.litellm_objectpermissiontable.upsert.assert_not_called()
deleted = {call.kwargs["key"] for call in cache.async_delete_cache.call_args_list}
assert deleted == {
"object_permission_id:perm-existing",
"user_object_permission_id:target-user",
"target-user",
}
@pytest.mark.asyncio
async def test_user_update_invalidates_both_the_old_and_new_permission_rows(mocker):
"""An upsert can mint a new permission row, which leaves the outgoing one cached under its id.
Only the link cache knows the user moved; the old row's own entry still holds the pre-update
grants, so anything still resolving that id keeps reading them.
"""
from litellm.proxy.management_endpoints.internal_user_endpoints import (
_update_single_user_helper,
)
_object_permission_mocks(mocker, "perm-existing")
cache = mocker.MagicMock()
cache.async_delete_cache = mocker.AsyncMock()
mocker.patch("litellm.proxy.proxy_server.user_api_key_cache", cache)
await _update_single_user_helper(
user_request=UpdateUserRequest(
user_id="target-user",
object_permission={"mcp_tool_permissions": {"github": ["list_issues"]}},
),
user_api_key_dict=UserAPIKeyAuth(user_id="admin-1", user_role=LitellmUserRoles.PROXY_ADMIN),
)
deleted = {call.kwargs["key"] for call in cache.async_delete_cache.call_args_list}
assert deleted == {
"object_permission_id:perm-existing",
"object_permission_id:perm-new",
"user_object_permission_id:target-user",
"target-user",
}
@pytest.mark.asyncio
async def test_non_admin_cannot_clear_their_own_mcp_entitlement(mocker):
"""The empty-value filter drops `object_permission: {}` before the guard saw it, so a non-admin
could clear the very ceiling an admin placed on them. The guard reads the fields the caller SENT.
"""
from fastapi import HTTPException
from litellm.proxy.management_endpoints.internal_user_endpoints import (
_update_single_user_helper,
)
mock_prisma_client = _object_permission_mocks(mocker, "perm-existing")
cache = mocker.MagicMock()
cache.async_delete_cache = mocker.AsyncMock()
mocker.patch("litellm.proxy.proxy_server.user_api_key_cache", cache)
with pytest.raises(HTTPException) as exc:
await _update_single_user_helper(
user_request=UpdateUserRequest(user_id="target-user", object_permission={}),
user_api_key_dict=UserAPIKeyAuth(user_id="target-user", user_role=LitellmUserRoles.INTERNAL_USER),
)
assert exc.value.status_code == 403
mock_prisma_client.update_data.assert_not_called()
@pytest.mark.asyncio
async def test_non_admin_cannot_rewrite_their_own_mcp_entitlement(mocker):
"""The entitlement bounds the human, so a self-write is an escalation path: an empty grant list
means "no restriction" and would lift a ceiling the admin placed on them."""
from fastapi import HTTPException
from litellm.proxy.management_endpoints.internal_user_endpoints import (
_update_single_user_helper,
)
mock_prisma_client = _object_permission_mocks(mocker, "perm-existing")
cache = mocker.MagicMock()
cache.async_delete_cache = mocker.AsyncMock()
mocker.patch("litellm.proxy.proxy_server.user_api_key_cache", cache)
with pytest.raises(HTTPException) as exc:
await _update_single_user_helper(
user_request=UpdateUserRequest(
user_id="target-user",
object_permission={"mcp_servers": [], "mcp_tool_permissions": {}},
),
user_api_key_dict=UserAPIKeyAuth(user_id="target-user", user_role=LitellmUserRoles.INTERNAL_USER),
)
assert exc.value.status_code == 403
mock_prisma_client.db.litellm_objectpermissiontable.upsert.assert_not_called()
mock_prisma_client.update_data.assert_not_called()
@pytest.mark.asyncio
async def test_new_user_persists_the_requested_mcp_entitlement(mocker):
"""generate_key_helper_fn only forwards object_permission_id, so /user/new has to create the
grants row itself; otherwise the entitlement the admin sent is silently dropped."""
mock_prisma_client = mocker.MagicMock()
mock_prisma_client.db.litellm_objectpermissiontable.create = mocker.AsyncMock(
return_value=SimpleNamespace(object_permission_id="perm-created")
)
mock_prisma_client.db.litellm_mcpservertable.find_many = mocker.AsyncMock(return_value=[])
mock_prisma_client.db.litellm_usertable.find_first = mocker.AsyncMock(return_value=None)
mock_prisma_client.db.litellm_usertable.count = mocker.AsyncMock(return_value=0)
mocker.patch("litellm.proxy.proxy_server.prisma_client", mock_prisma_client)
mocker.patch(
"litellm.proxy.management_endpoints.internal_user_endpoints.check_if_default_team_set",
return_value=None,
)
mock_generate = mocker.patch(
"litellm.proxy.management_endpoints.internal_user_endpoints.generate_key_helper_fn",
new=mocker.AsyncMock(return_value={"user_id": "new-human", "token": "sk-x", "expires": None}),
)
mocker.patch(
"litellm.proxy.hooks.user_management_event_hooks.UserManagementEventHooks.async_user_created_hook",
new=mocker.AsyncMock(),
)
await new_user(
data=NewUserRequest(
user_id="new-human",
object_permission={"mcp_tool_permissions": {"github": ["list_issues"]}},
),
user_api_key_dict=UserAPIKeyAuth(user_id="admin-1", user_role=LitellmUserRoles.PROXY_ADMIN),
)
created = mock_prisma_client.db.litellm_objectpermissiontable.create.call_args.kwargs["data"]
assert json.loads(created["mcp_tool_permissions"]) == {"github": ["list_issues"]}
forwarded = mock_generate.call_args.kwargs
assert forwarded["object_permission_id"] == "perm-created"
assert "object_permission" not in forwarded
@pytest.mark.asyncio
async def test_user_info_v2_returns_the_mcp_entitlement(mocker):
"""The admin UI reads the current entitlement off this endpoint, so the grants have to come back
with the user row rather than only their id."""
from litellm.proxy.management_endpoints.internal_user_endpoints import user_info_v2
user_row = SimpleNamespace(
object_permission=SimpleNamespace(
object_permission_id="perm-1",
mcp_servers=["github"],
mcp_access_groups=[],
mcp_tool_permissions={"github": ["list_issues"]},
),
)
user_row.model_dump = lambda: {
"user_id": "human-1",
"object_permission": {
"object_permission_id": "perm-1",
"mcp_servers": ["github"],
"mcp_access_groups": [],
"mcp_tool_permissions": {"github": ["list_issues"]},
},
}
mocker.patch("litellm.proxy.proxy_server.prisma_client", mocker.MagicMock())
mocker.patch(
"litellm.proxy.management_endpoints.internal_user_endpoints._check_user_info_v2_access",
new=mocker.AsyncMock(return_value=user_row),
)
response = await user_info_v2(
request=SimpleNamespace(query_params={}),
user_id="human-1",
user_api_key_dict=UserAPIKeyAuth(user_id="admin-1", user_role=LitellmUserRoles.PROXY_ADMIN),
)
assert response.object_permission is not None
assert response.object_permission.mcp_servers == ["github"]
assert response.object_permission.mcp_tool_permissions == {"github": ["list_issues"]}
@pytest.mark.asyncio
@pytest.mark.parametrize(
"model_max_budget,expected_written",
[
(
{"claude-opus-4-8": {"budget_limit": 200.0, "time_period": "1mo"}},
'{"claude-opus-4-8": {"budget_limit": 200.0, "time_period": "1mo"}}',
),
(None, None),
({}, None),
],
ids=["supplied", "omitted", "empty"],
)
async def test_user_new_persists_model_max_budget(monkeypatch, model_max_budget, expected_written):
"""
/user/new used to echo model_max_budget back while writing {} to the user row,
so a per-model budget looked configured and was read by nothing.
The omitted/empty cases are the other half: SSO and default-key callers reach
generate_key_helper_fn with no budget, and writing "{}" for them would clear
an existing user's budgets.
"""
from litellm.proxy.management_endpoints import key_management_endpoints
captured = {}
class _FakeUserRow:
models = []
class _FakePrisma:
async def insert_data(self, data, table_name):
if table_name == "user":
captured["user_data"] = dict(data)
return _FakeUserRow()
captured["key_data"] = dict(data)
return SimpleNamespace(
token=data.get("token"),
litellm_budget_table=None,
created_at=None,
updated_at=None,
)
async def get_data(self, *args, **kwargs):
return None
import litellm.proxy.proxy_server as proxy_server
monkeypatch.setattr(proxy_server, "prisma_client", _FakePrisma(), raising=False)
# model_max_budget is an enterprise feature; without this the call is rejected
# before it ever reaches the write this test is about.
monkeypatch.setattr(proxy_server, "premium_user", True, raising=False)
await key_management_endpoints.generate_key_helper_fn(
request_type="user",
user_id="u-1",
model_max_budget=model_max_budget,
)
assert captured["user_data"].get("model_max_budget") == expected_written
@pytest.fixture
def _admin_prisma(mocker):
"""A mocked prisma_client wired in as proxy_server's module globals, for
the password-policy tests below (mirrors the pattern every other test in
this file repeats per-test; consolidated here since these three share it
verbatim)."""
mock_prisma_client = mocker.MagicMock()
mocker.patch( # test-quality-ok: same module-global mocking every test in this file already uses
"litellm.proxy.proxy_server.prisma_client", mock_prisma_client
)
mocker.patch( # test-quality-ok: same module-global mocking every test in this file already uses
"litellm.proxy.proxy_server.litellm_proxy_admin_name", "admin"
)
return mock_prisma_client
@pytest.mark.asyncio
async def test_user_update_rejects_weak_password(_admin_prisma):
"""/user/update must reject a password that fails the configured
policy before it ever reaches the DB write."""
from litellm.proxy._types import ProxyException
from litellm.proxy.management_endpoints.internal_user_endpoints import (
_update_single_user_helper,
)
user_request = UpdateUserRequest(user_id="target-user", password="short1!")
admin_caller = UserAPIKeyAuth(user_id="admin-1", user_role=LitellmUserRoles.PROXY_ADMIN)
with pytest.raises(ProxyException) as exc_info:
await _update_single_user_helper(user_request=user_request, user_api_key_dict=admin_caller)
assert exc_info.value.code == "400"
_admin_prisma.db.litellm_usertable.find_first.assert_not_called()
@pytest.mark.asyncio
async def test_user_update_rejects_weak_password_against_configured_policy(_admin_prisma, mocker):
"""A password that meets the default policy but not a stricter
admin-configured one must still be rejected."""
from litellm.proxy._types import ProxyException
from litellm.proxy.management_endpoints.internal_user_endpoints import (
_update_single_user_helper,
)
mocker.patch( # test-quality-ok: same module-global mocking every test in this file already uses
"litellm.proxy.proxy_server.general_settings",
{"password_policy_min_length": 24},
)
user_request = UpdateUserRequest(user_id="target-user", password="Str0ng!Passw0rd")
admin_caller = UserAPIKeyAuth(user_id="admin-1", user_role=LitellmUserRoles.PROXY_ADMIN)
with pytest.raises(ProxyException) as exc_info:
await _update_single_user_helper(user_request=user_request, user_api_key_dict=admin_caller)
assert "24 characters" in exc_info.value.message
@pytest.mark.asyncio
async def test_user_update_hashes_and_persists_strong_password(_admin_prisma, mocker):
"""A password meeting the policy is hashed (never stored in plaintext)
and reaches the DB write."""
from litellm.proxy.management_endpoints.internal_user_endpoints import (
_update_single_user_helper,
)
mocker.patch( # test-quality-ok: same module-global mocking every test in this file already uses
"litellm.proxy.proxy_server.general_settings",
{"password_policy_check_breached_passwords": False},
)
mock_prisma_client = _admin_prisma
existing_user = mocker.MagicMock()
existing_user.model_dump.return_value = {"user_id": "target-user"}
existing_user.user_id = "target-user"
mock_prisma_client.db.litellm_usertable.find_first = mocker.AsyncMock(return_value=existing_user)
mock_prisma_client.update_data = mocker.AsyncMock(return_value={"user_id": "target-user"})
mock_prisma_client.jsonify_object = mocker.MagicMock(side_effect=lambda x: x)
strong_password = "Str0ng!Passw0rd"
user_request = UpdateUserRequest(user_id="target-user", password=strong_password)
admin_caller = UserAPIKeyAuth(user_id="admin-1", user_role=LitellmUserRoles.PROXY_ADMIN)
await _update_single_user_helper(user_request=user_request, user_api_key_dict=admin_caller)
written_data = mock_prisma_client.update_data.call_args.kwargs["data"]
assert written_data.get("password") is not None
assert written_data["password"] != strong_password
# An admin-set password is known to the admin, so the user must be forced
# to change it at next login and the breach screen re-armed.
assert written_data["password_reset_required"] is True
assert written_data["last_breach_check_at"] is None
@pytest.mark.asyncio
async def test_user_update_rejects_breached_password(_admin_prisma):
"""A strength-passing password found in the HIBP corpus must be rejected
before it ever reaches the DB write."""
from litellm.proxy.management_endpoints.internal_user_endpoints import (
_update_single_user_helper,
)
password = "Str0ng!Passw0rd"
sha1 = hashlib.sha1(password.encode("utf-8"), usedforsecurity=False).hexdigest().upper()
lookups: Final[list[tuple[str, str]]] = [] # mutable-ok: capture the injected handler request method and URL
def handler(request: httpx.Request) -> httpx.Response:
lookups.append((request.method, str(request.url)))
return httpx.Response(200, text=f"{sha1[5:]}:1387")
user_request = UpdateUserRequest(user_id="target-user", password=password)
admin_caller = UserAPIKeyAuth(user_id="admin-1", user_role=LitellmUserRoles.PROXY_ADMIN)
with pytest.raises(ProxyException) as exc_info:
await _update_single_user_helper(
user_request=user_request,
user_api_key_dict=admin_caller,
hibp_client=_hibp_client_with_handler(handler),
)
assert exc_info.value.code == "400"
assert "data breaches" in exc_info.value.message
_admin_prisma.db.litellm_usertable.find_first.assert_not_called()
assert lookups == [("GET", f"https://api.pwnedpasswords.com/range/{sha1[:5]}")]
@pytest.mark.asyncio
async def test_bulk_update_all_users_rejects_a_password(_admin_prisma):
"""The all_users fast path writes user_updates straight to update_many,
bypassing _update_single_user_helper. A password riding along would be
stored as unvalidated plaintext on every row, so it must be rejected
before any DB access."""
from fastapi import HTTPException
from litellm.proxy._types import UpdateUserRequestNoUserIDorEmail
from litellm.proxy.management_endpoints.internal_user_endpoints import bulk_user_update
from litellm.types.proxy.management_endpoints.internal_user_endpoints import (
BulkUpdateUserRequest,
)
data = BulkUpdateUserRequest(
all_users=True,
user_updates=UpdateUserRequestNoUserIDorEmail(password="Str0ng!Passw0rd"),
)
admin_caller = UserAPIKeyAuth(user_id="admin-1", user_role=LitellmUserRoles.PROXY_ADMIN)
with pytest.raises(HTTPException) as exc_info:
await bulk_user_update(data=data, user_api_key_dict=admin_caller)
assert exc_info.value.status_code == 400
assert "not supported" in str(exc_info.value.detail)
_admin_prisma.db.litellm_usertable.find_many.assert_not_called()
_admin_prisma.db.litellm_usertable.update_many.assert_not_called()
def _hibp_client_with_handler(handler) -> AsyncHTTPHandler:
"""A real AsyncHTTPHandler over httpx.MockTransport (the DI seam used
throughout test_password_policy.py), so no network is touched."""
http_handler = AsyncHTTPHandler()
http_handler.client = httpx.AsyncClient(transport=httpx.MockTransport(handler))
return http_handler
@pytest.mark.asyncio
async def test_bulk_update_breached_password_fails_only_that_user(_admin_prisma, mocker):
"""In a bulk batch, a breached password fails only its own entry, before
any DB write for it; sibling entries with acceptable passwords persist."""
from litellm.proxy.management_endpoints.internal_user_endpoints import (
bulk_update_processed_users,
)
breached = "Br3ached!Passw0rd"
clean = "NewP@ssw0rd123"
breached_sha1 = hashlib.sha1(breached.encode("utf-8"), usedforsecurity=False).hexdigest().upper()
def handler(request: httpx.Request) -> httpx.Response:
if request.url.path == f"/range/{breached_sha1[:5]}":
return httpx.Response(200, text=f"{breached_sha1[5:]}:1387")
return httpx.Response(200, text="0000000000000000000000000000000000A:1")
mock_prisma_client = _admin_prisma
existing_user = mocker.MagicMock()
existing_user.model_dump.return_value = {"user_id": "user-clean"}
existing_user.user_id = "user-clean"
mock_prisma_client.db.litellm_usertable.find_first = mocker.AsyncMock(return_value=existing_user)
mock_prisma_client.update_data = mocker.AsyncMock(return_value={"user_id": "user-clean"})
mock_prisma_client.jsonify_object = mocker.MagicMock(side_effect=lambda x: x)
admin_caller = UserAPIKeyAuth(user_id="admin-1", user_role=LitellmUserRoles.PROXY_ADMIN)
response = await bulk_update_processed_users(
users_to_update=[
UpdateUserRequest(user_id="user-breached", password=breached),
UpdateUserRequest(user_id="user-clean", password=clean),
],
user_api_key_dict=admin_caller,
hibp_client=_hibp_client_with_handler(handler),
)
assert response.successful_updates == 1
assert response.failed_updates == 1
by_user = {r.user_id: r for r in response.results}
assert by_user["user-breached"].success is False
assert "data breaches" in by_user["user-breached"].error
assert by_user["user-clean"].success is True
(write_call,) = mock_prisma_client.update_data.call_args_list
assert write_call.kwargs["user_id"] == "user-clean"
@pytest.mark.asyncio
async def test_bulk_update_screens_shared_password_with_single_lookup(_admin_prisma, mocker):
"""A batch where every user gets the same password costs one HIBP lookup,
not one per user (the serial per-user checks this regresses against)."""
from litellm.proxy.management_endpoints.internal_user_endpoints import (
bulk_update_processed_users,
)
lookup_count = 0
def handler(request: httpx.Request) -> httpx.Response:
nonlocal lookup_count
lookup_count += 1
return httpx.Response(200, text="0000000000000000000000000000000000A:1")
mock_prisma_client = _admin_prisma
existing_user = mocker.MagicMock()
existing_user.model_dump.return_value = {"user_id": "user-0"}
existing_user.user_id = "user-0"
mock_prisma_client.db.litellm_usertable.find_first = mocker.AsyncMock(return_value=existing_user)
mock_prisma_client.update_data = mocker.AsyncMock(return_value={"user_id": "user-0"})
mock_prisma_client.jsonify_object = mocker.MagicMock(side_effect=lambda x: x)
admin_caller = UserAPIKeyAuth(user_id="admin-1", user_role=LitellmUserRoles.PROXY_ADMIN)
response = await bulk_update_processed_users(
users_to_update=[UpdateUserRequest(user_id=f"user-{i}", password="NewP@ssw0rd123") for i in range(5)],
user_api_key_dict=admin_caller,
hibp_client=_hibp_client_with_handler(handler),
)
assert response.successful_updates == 5
assert lookup_count == 1
@pytest.mark.asyncio
async def test_delete_user_evicts_cached_user_rows(mocker: MockerFixture) -> None:
from litellm.proxy._types import DeleteUserRequest, LiteLLM_UserTable
from litellm.proxy.common_utils.user_api_key_cache import UserApiKeyCache
from litellm.proxy.management_endpoints.internal_user_endpoints import delete_user
deleted: Final = LiteLLM_UserTable(user_id="user-gone", user_email="[email protected]", teams=[])
survivor: Final = LiteLLM_UserTable(user_id="user-stays", user_email="[email protected]", teams=[])
prisma_client: Final = mocker.MagicMock()
prisma_client.db.litellm_usertable.find_unique = mocker.AsyncMock(return_value=deleted)
prisma_client.db.litellm_teamtable.find_many = mocker.AsyncMock(return_value=[])
prisma_client.db.litellm_jwtkeymapping.find_many = mocker.AsyncMock(return_value=[])
prisma_client.db.litellm_verificationtoken.find_many = mocker.AsyncMock(return_value=[])
prisma_client.db.litellm_verificationtoken.delete_many = mocker.AsyncMock(return_value=0)
prisma_client.db.litellm_invitationlink.delete_many = mocker.AsyncMock(return_value=0)
prisma_client.db.litellm_organizationmembership.delete_many = mocker.AsyncMock(return_value=0)
prisma_client.db.litellm_teammembership.delete_many = mocker.AsyncMock(return_value=0)
prisma_client.db.litellm_usertable.delete_many = mocker.AsyncMock(return_value=1)
_serve_locked_user_delete(prisma_client, deleted)
mocker.patch("litellm.proxy.proxy_server.prisma_client", prisma_client) # test-quality-ok: substitute the database dependency
cache: Final = UserApiKeyCache()
for row in (deleted, survivor):
await cache.async_set_cache(key=row.user_id, value=row, model_type=LiteLLM_UserTable)
mocker.patch("litellm.proxy.proxy_server.user_api_key_cache", cache) # test-quality-ok: exercise a real isolated cache
mocker.patch("litellm.proxy.proxy_server.proxy_logging_obj", None) # test-quality-ok: delete_user reads it off proxy_server at call time
broadcast: Final = mocker.patch( # test-quality-ok: observe the Redis publication boundary
"litellm.proxy.common_utils.auth_cache_invalidation_pubsub.publish_auth_cache_invalidation",
new_callable=mocker.AsyncMock,
)
await delete_user(
data=DeleteUserRequest(user_ids=[deleted.user_id]),
user_api_key_dict=UserAPIKeyAuth(user_id="proxy-admin", user_role=LitellmUserRoles.PROXY_ADMIN),
)
assert await cache.async_get_cache(key=deleted.user_id, model_type=LiteLLM_UserTable) is None
assert await cache.async_get_cache(key=survivor.user_id, model_type=LiteLLM_UserTable) == survivor
broadcast.assert_awaited_once_with(cache_key=deleted.user_id)
_DB_OUTAGE_503_BODY: Final = {
"error": {
"message": "Service Unavailable, the authentication database is temporarily unreachable. Please retry shortly.",
"type": "no_db_connection",
"param": "None",
"code": "503",
}
}
def _user_read_raising(mocker: MockerFixture, error: Exception) -> tuple[MagicMock, MagicMock]:
prisma_client = MagicMock()
prisma_client.db.litellm_usertable.find_unique = AsyncMock(side_effect=error)
cache = MagicMock()
cache.async_get_cache = AsyncMock(return_value=None)
cache.async_set_cache = AsyncMock()
mocker.patch("litellm.proxy.auth.auth_checks._should_check_db", return_value=True)
return prisma_client, cache
def _db_unavailable_fallback_identity(route: str) -> UserAPIKeyAuth:
from litellm.proxy.auth.auth_exception_handler import DB_UNAVAILABLE_FALLBACK_USER_ID
return UserAPIKeyAuth(
key_name="failed-to-connect-to-db",
token="failed-to-connect-to-db",
user_id=DB_UNAVAILABLE_FALLBACK_USER_ID,
user_role=LitellmUserRoles.INTERNAL_USER,
request_route=route,
)
@pytest.mark.asyncio
async def test_authorize_user_list_request_propagates_a_db_outage_instead_of_answering_403(mocker):
prisma_client, cache = _user_read_raising(mocker, httpx.ConnectError("All connection attempts failed"))
with pytest.raises(httpx.ConnectError):
await _authorize_user_list_request(
user_api_key_dict=_db_unavailable_fallback_identity("/user/list"),
organization_ids=None,
prisma_client=prisma_client,
user_api_key_cache=cache,
proxy_logging_obj=None,
)
@pytest.mark.asyncio
async def test_resolve_org_filter_for_user_search_propagates_a_db_outage_instead_of_answering_403(mocker):
prisma_client, cache = _user_read_raising(mocker, httpx.ConnectError("All connection attempts failed"))
mocker.patch(
"litellm.proxy.ui_crud_endpoints.proxy_setting_endpoints.get_ui_settings_cached",
return_value={"scope_user_search_to_org": True},
)
with pytest.raises(httpx.ConnectError):
await _resolve_org_filter_for_user_search(
user_api_key_dict=_db_unavailable_fallback_identity("/user/filter/ui"),
team_id=None,
prisma_client=prisma_client,
user_api_key_cache=cache,
proxy_logging_obj=None,
)
@pytest.mark.asyncio
async def test_ui_view_users_answers_a_db_outage_as_503_no_db_connection_not_as_its_own_500(mocker, caplog):
prisma_client, cache = _user_read_raising(mocker, httpx.ConnectError("All connection attempts failed"))
mocker.patch(
"litellm.proxy.ui_crud_endpoints.proxy_setting_endpoints.get_ui_settings_cached",
return_value={"scope_user_search_to_org": True},
)
proxy_logging_obj = MagicMock()
proxy_logging_obj.service_logging_obj.async_service_failure_hook = AsyncMock()
mocker.patch("litellm.proxy.proxy_server.prisma_client", prisma_client)
mocker.patch("litellm.proxy.proxy_server.user_api_key_cache", cache)
mocker.patch("litellm.proxy.proxy_server.proxy_logging_obj", proxy_logging_obj)
with caplog.at_level(logging.WARNING, logger="LiteLLM Proxy"), pytest.raises(ProxyException) as raised:
await ui_view_users(
user_api_key_dict=_db_unavailable_fallback_identity("/user/filter/ui"),
user_id=None,
user_email="lit",
team_id=None,
page=1,
page_size=50,
)
assert raised.value.code == "503"
assert raised.value.type == ProxyErrorTypes.no_db_connection
assert isinstance(raised.value.__cause__, httpx.ConnectError)
outage_logs: Final = [r.getMessage() for r in caplog.records if r.levelno == logging.WARNING and "ConnectError" in r.getMessage()]
assert outage_logs == ["Database unavailable during user search: ConnectError"]
@pytest.mark.parametrize(
("route", "params"),
[("/user/list", {}), ("/user/filter/ui", {"user_email": "lit"})],
ids=["user_list", "user_filter_ui"],
)
def test_user_routes_answer_503_no_db_connection_when_the_callers_user_read_hits_a_db_outage(
mocker, route: str, params: dict[str, str]
):
from litellm.proxy.auth.user_api_key_auth import user_api_key_auth
prisma_client, cache = _user_read_raising(mocker, httpx.ConnectError("All connection attempts failed"))
mocker.patch(
"litellm.proxy.ui_crud_endpoints.proxy_setting_endpoints.get_ui_settings_cached",
return_value={"scope_user_search_to_org": True},
)
mocker.patch("litellm.proxy.proxy_server.prisma_client", prisma_client)
mocker.patch("litellm.proxy.proxy_server.user_api_key_cache", cache)
app.dependency_overrides[user_api_key_auth] = lambda: _db_unavailable_fallback_identity(route)
try:
response = TestClient(app, raise_server_exceptions=False).get(route, params=params)
finally:
app.dependency_overrides.pop(user_api_key_auth, None)
assert response.status_code == 503, response.text
assert response.json() == _DB_OUTAGE_503_BODY
@pytest.mark.asyncio
async def test_delete_user_writes_deleted_audit_log_for_user_keys(mocker):
from litellm.proxy._types import (
DeleteUserRequest,
LiteLLM_VerificationToken,
LitellmTableNames,
UserAPIKeyAuth,
)
from litellm.proxy.management_endpoints.internal_user_endpoints import delete_user
mock_prisma_client = mocker.MagicMock()
mock_user_row = mocker.MagicMock()
mock_user_row.user_id = "doomed-user"
mock_user_row.user_email = "[email protected]"
mock_user_row.teams = []
mock_user_row.model_dump_json.return_value = "{}"
mock_user_row.model_dump.return_value = {"user_id": "doomed-user", "user_email": "[email protected]", "teams": []}
mock_prisma_client.db.litellm_usertable.find_unique = mocker.AsyncMock(return_value=mock_user_row)
mock_prisma_client.db.litellm_teamtable.find_many = mocker.AsyncMock(return_value=[])
user_key = LiteLLM_VerificationToken(token="hashed-user-key", user_id="doomed-user")
mock_prisma_client.db.litellm_verificationtoken.find_many = mocker.AsyncMock(return_value=[user_key])
mock_prisma_client.db.litellm_verificationtoken.delete_many = mocker.AsyncMock(return_value=1)
mock_prisma_client.db.litellm_invitationlink.delete_many = mocker.AsyncMock(return_value=0)
mock_prisma_client.db.litellm_organizationmembership.delete_many = mocker.AsyncMock(return_value=0)
mock_prisma_client.db.litellm_teammembership.delete_many = mocker.AsyncMock(return_value=0)
mock_prisma_client.db.litellm_jwtkeymapping.find_many = mocker.AsyncMock(return_value=[])
mock_prisma_client.db.litellm_usertable.delete_many = mocker.AsyncMock(return_value=1)
_serve_locked_user_delete(mock_prisma_client, mock_user_row)
mocker.patch("litellm.proxy.proxy_server.prisma_client", mock_prisma_client)
mocker.patch("litellm.store_audit_logs", True)
captured: Final[list] = []
async def _capture(rows):
captured.extend(rows)
mocker.patch(
"litellm.proxy.management_helpers.audit_logs.create_audit_logs_for_updates",
new=_capture,
)
caller = UserAPIKeyAuth(user_id="proxy-admin", user_role=LitellmUserRoles.PROXY_ADMIN)
await delete_user(data=DeleteUserRequest(user_ids=["doomed-user"]), user_api_key_dict=caller)
for _ in range(100):
if captured:
break
await asyncio.sleep(0.01)
key_rows: Final = [r for r in captured if r.table_name == LitellmTableNames.KEY_TABLE_NAME]
assert len(key_rows) == 1
audit_row: Final = key_rows[0]
assert audit_row.action == "deleted"
assert audit_row.object_id == user_key.token
assert audit_row.changed_by
assert json.loads(audit_row.before_value)["token"] == user_key.token
@pytest.mark.asyncio
async def test_user_update_password_revokes_target_sessions(_admin_prisma, mocker):
"""An admin-set password implies the old one may be compromised: every UI
session belonging to the target user must be revoked after the write."""
from litellm.proxy.management_endpoints.internal_user_endpoints import (
_update_single_user_helper,
)
mocker.patch( # test-quality-ok: same module-global mocking every test in this file already uses
"litellm.proxy.proxy_server.general_settings",
{"password_policy_check_breached_passwords": False},
)
mock_prisma_client = _admin_prisma
existing_user = mocker.MagicMock()
existing_user.model_dump.return_value = {"user_id": "target-user"}
existing_user.user_id = "target-user"
mock_prisma_client.db.litellm_usertable.find_first = mocker.AsyncMock(return_value=existing_user)
mock_prisma_client.update_data = mocker.AsyncMock(return_value={"user_id": "target-user"})
mock_prisma_client.jsonify_object = mocker.MagicMock(side_effect=lambda x: x)
revoke_mock = mocker.patch(
"litellm.proxy.management_endpoints.session_endpoints.revoke_ui_session_keys",
new=mocker.AsyncMock(return_value=2),
)
user_request = UpdateUserRequest(user_id="target-user", password="Str0ng!Passw0rd")
admin_caller = UserAPIKeyAuth(user_id="admin-1", user_role=LitellmUserRoles.PROXY_ADMIN)
await _update_single_user_helper(user_request=user_request, user_api_key_dict=admin_caller)
revoke_mock.assert_awaited_once()
revoke_kwargs = revoke_mock.await_args.kwargs
assert revoke_kwargs["user_id"] == "target-user"
# Revoke-all: the admin's own session is not among the target's sessions.
assert revoke_kwargs.get("keep_hashed_token") is None
@pytest.mark.asyncio
async def test_user_update_without_password_revokes_nothing(_admin_prisma, mocker):
"""A non-password /user/update must not touch the target's sessions."""
from litellm.proxy.management_endpoints.internal_user_endpoints import (
_update_single_user_helper,
)
mock_prisma_client = _admin_prisma
existing_user = mocker.MagicMock()
existing_user.model_dump.return_value = {"user_id": "target-user"}
existing_user.user_id = "target-user"
mock_prisma_client.db.litellm_usertable.find_first = mocker.AsyncMock(return_value=existing_user)
mock_prisma_client.update_data = mocker.AsyncMock(return_value={"user_id": "target-user"})
mock_prisma_client.jsonify_object = mocker.MagicMock(side_effect=lambda x: x)
revoke_mock = mocker.patch(
"litellm.proxy.management_endpoints.session_endpoints.revoke_ui_session_keys",
new=mocker.AsyncMock(return_value=0),
)
user_request = UpdateUserRequest(user_id="target-user", user_email="[email protected]")
admin_caller = UserAPIKeyAuth(user_id="admin-1", user_role=LitellmUserRoles.PROXY_ADMIN)
await _update_single_user_helper(user_request=user_request, user_api_key_dict=admin_caller)
revoke_mock.assert_not_awaited()