Skip to content

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]

202 KB
Raw Blame
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()