From 35e3210edbf647543348d5e596acd0e13654e29b Mon Sep 17 00:00:00 2001 From: shrey kharbanda Date: Fri, 23 Oct 2026 15:02:34 -0700 Subject: [PATCH 1/6] feat(teams): move custom member budgets onto a new team default in one update /team/update takes team_member_budget_backfill (none, raise_to_default, lower_to_default, all_to_default) next to team_member_budget. The server picks which members with their own budget move onto the new default, comparing permanent budgets of members on the default's reset schedule, and reports how many moved. The default row, the member moves and the team row now commit in one transaction under the team lock, so a failed update leaves nothing half applied. One update moves at most 50,000 members. The Admin UI prompt becomes a choice between keeping, raising, lowering or both, sent in that same request instead of chunked bulk updates, and team admins who may edit the member budget get it too. Clearing a member's last limit used to unlink them from every budget row, so their spend never reset again. They are linked back to the team default now, and default member budget cache evictions reach every worker. Resolves LIT-8926 --- litellm/litellm_core_utils/duration_parser.py | 18 + litellm/proxy/_types.py | 26 + litellm/proxy/auth/auth_checks.py | 3 +- .../proxy/common_utils/user_api_key_cache.py | 4 + .../budget_management_endpoints.py | 11 +- .../management_endpoints/common_utils.py | 25 +- .../team_admin_field_permissions.py | 11 +- .../management_endpoints/team_endpoints.py | 410 +++----- .../bulk_team_member_budgets.py | 14 +- .../team_member_default_budget.py | 321 ++++++ .../spend_tracking/budget_reservation.py | 3 +- .../test_team_member_budget_backfill.py | 253 +++++ .../test_duration_parser.py | 26 +- .../test_upsert_budget_membership.py | 20 + .../management_v1/test_teams.py | 23 +- .../test_team_admin_field_permissions.py | 31 +- .../test_team_endpoints.py | 969 +----------------- .../test_management_helpers_utils.py | 224 +--- .../test_team_member_default_budget.py | 88 ++ .../src/components/networking.tsx | 7 +- .../team/ResetMemberBudgetsDialog.test.tsx | 148 ++- .../team/ResetMemberBudgetsDialog.tsx | 129 ++- .../team/TeamInfo.integration.test.tsx | 386 ++----- .../src/components/team/TeamInfo.test.tsx | 49 + .../src/components/team/TeamInfo.tsx | 64 +- .../components/team/memberBudgetReset.test.ts | 151 ++- .../src/components/team/memberBudgetReset.ts | 77 +- .../team/useMemberBudgetReset.test.tsx | 357 ++----- .../components/team/useMemberBudgetReset.ts | 116 +-- ui/litellm-dashboard/src/lib/http/schema.d.ts | 10 + 30 files changed, 1649 insertions(+), 2325 deletions(-) create mode 100644 litellm/proxy/management_helpers/team_member_default_budget.py create mode 100644 tests/integration/management/test_team_member_budget_backfill.py create mode 100644 tests/unit/proxy/management_helpers/test_team_member_default_budget.py diff --git a/litellm/litellm_core_utils/duration_parser.py b/litellm/litellm_core_utils/duration_parser.py index d52716951df..ad79ef1a293 100644 --- a/litellm/litellm_core_utils/duration_parser.py +++ b/litellm/litellm_core_utils/duration_parser.py @@ -9,6 +9,7 @@ duration_in_seconds is used in diff parts of the code base, example import re import time as time_module from datetime import datetime, time, timedelta, timezone, tzinfo +from types import MappingProxyType from typing import Final from zoneinfo import ZoneInfo @@ -22,10 +23,27 @@ _BUDGET_DURATION_WORD_ALIASES: Final[dict[str, str]] = { } +_FIXED_UNIT_SECONDS: Final = MappingProxyType({"s": 1, "m": 60, "h": 3600, "d": 86400, "w": 604800}) + + def _normalize_duration(duration: str) -> str: return _BUDGET_DURATION_WORD_ALIASES.get(duration.strip().lower(), duration) +def budget_reset_period_key(duration: str | None) -> str | None: + """Equal keys mean the same reset schedule: fixed-length periods compare by length, so "7d" matches "1w", + while a calendar month only matches the same number of months.""" + if duration is None: + return None + normalized: Final = _normalize_duration(duration).strip() + parsed: Final = re.fullmatch(r"(\d+)(mo|[smhdw])", normalized) + if parsed is None: + return normalized + value: Final = int(parsed[1]) + unit: Final = parsed[2] + return f"{value}mo" if unit == "mo" else f"{value * _FIXED_UNIT_SECONDS[unit]}s" + + def _extract_from_regex(duration: str) -> tuple[int, str]: match: Final = re.match(r"(\d+)(mo|[smhdw]?)", duration) diff --git a/litellm/proxy/_types.py b/litellm/proxy/_types.py index 28d3c08bb31..32be562d237 100644 --- a/litellm/proxy/_types.py +++ b/litellm/proxy/_types.py @@ -1936,6 +1936,9 @@ class GlobalEndUsersSpend(LiteLLMPydanticObjectBase): endTime: datetime | None = None +TeamMemberBudgetBackfill: TypeAlias = Literal["none", "raise_to_default", "lower_to_default", "all_to_default"] + + class UpdateTeamRequest(LiteLLMPydanticObjectBase): """ UpdateTeamRequest, used by /team/update when you need to update a team @@ -1978,6 +1981,14 @@ class UpdateTeamRequest(LiteLLMPydanticObjectBase): team_member_model_max_budget: GenericBudgetConfigType | None = None team_member_rpm_limit: int | None = None team_member_tpm_limit: int | None = None + team_member_budget_backfill: TeamMemberBudgetBackfill | None = Field( + default=None, + description=( + "Which members with their own budget move onto the team_member_budget sent in the same request: " + "'raise_to_default' moves those below it, 'lower_to_default' those above it, 'all_to_default' both. " + "Members whose budget resets on a different schedule than the default are left alone" + ), + ) team_member_key_duration: str | None = None allowed_passthrough_routes: list | None = None denied_passthrough_routes: list[str] | None = None @@ -2003,6 +2014,21 @@ class UpdateTeamRequest(LiteLLMPydanticObjectBase): ), ) + @model_validator(mode="after") + def _backfill_needs_a_positive_default(self) -> "UpdateTeamRequest": + if self.team_member_budget_backfill in (None, "none"): + return self + if self.team_member_budget is None or self.team_member_budget <= 0: + raise ValueError("team_member_budget_backfill needs a positive team_member_budget in the same request") + return self + + +class TeamMemberBudgetBackfillResult(LiteLLMBaseModel): + model_config = ConfigDict(frozen=True) + + moved_to_default: int + skipped_other_reset_period: int + class PatchTeamRequest(UpdateTeamRequest): """ diff --git a/litellm/proxy/auth/auth_checks.py b/litellm/proxy/auth/auth_checks.py index 8887d86570a..6c5385d5654 100644 --- a/litellm/proxy/auth/auth_checks.py +++ b/litellm/proxy/auth/auth_checks.py @@ -128,6 +128,7 @@ from litellm.proxy.common_utils.user_api_key_cache import ( project_spend_counter_key, tag_cache_key, tag_registry_cache_key, + team_member_default_budget_cache_key, team_membership_auth_cache_key, team_membership_reservation_cache_key, ) @@ -1766,7 +1767,7 @@ async def get_team_member_default_budget( if prisma_client is None: return None - cache_key: Final = f"team_member_default_budget:{budget_id}" + cache_key: Final = team_member_default_budget_cache_key(budget_id) cached_budget: Final = await user_api_key_cache.async_get_cache( key=cache_key, diff --git a/litellm/proxy/common_utils/user_api_key_cache.py b/litellm/proxy/common_utils/user_api_key_cache.py index e64fd755ef9..e5e217a067c 100644 --- a/litellm/proxy/common_utils/user_api_key_cache.py +++ b/litellm/proxy/common_utils/user_api_key_cache.py @@ -392,6 +392,10 @@ def team_membership_reservation_cache_key(user_id: str, team_id: str) -> str: return f"team_membership:{user_id}:{team_id}" +def team_member_default_budget_cache_key(budget_id: str) -> str: + return f"team_member_default_budget:{budget_id}" + + #: Cached under ``team_membership_reservation_cache_key`` when a member has no ``LiteLLM_TeamMembership`` #: row, so a session-token member without a per-member budget costs no DB read per request. Lives beside #: the key builder because it is part of the same cache protocol: every reader of the key must know that diff --git a/litellm/proxy/management_endpoints/budget_management_endpoints.py b/litellm/proxy/management_endpoints/budget_management_endpoints.py index b3f372327dc..4862435a8c7 100644 --- a/litellm/proxy/management_endpoints/budget_management_endpoints.py +++ b/litellm/proxy/management_endpoints/budget_management_endpoints.py @@ -20,10 +20,11 @@ from typing import Final from fastapi import APIRouter, Depends, HTTPException from litellm._internal_context import service_target -from litellm._logging import verbose_proxy_logger from litellm.proxy._types import * from litellm.proxy.auth.user_api_key_auth import user_api_key_auth +from litellm.proxy.common_utils.auth_cache_invalidation_pubsub import evict_and_broadcast from litellm.proxy.common_utils.timezone_utils import get_budget_reset_time +from litellm.proxy.common_utils.user_api_key_cache import team_member_default_budget_cache_key from litellm.proxy.management_endpoints.common_utils import ( # noqa: F401 # legacy module exports _user_has_admin_view, # pyright: ignore[reportPrivateUsage,reportUnusedImport] # backwards-compatible package export user_api_key_has_admin_view, @@ -202,10 +203,10 @@ async def update_budget( data=budget_obj_jsonified, ) with service_target("team_member_budgets"): - try: - await user_api_key_cache.async_delete_cache(key=f"team_member_default_budget:{budget_obj.budget_id}") - except Exception: # noqa: BLE001 # Cache failure must not fail a committed budget update. - verbose_proxy_logger.warning("Failed to evict the team member default budget cache", exc_info=True) + await evict_and_broadcast( + cache_keys=(team_member_default_budget_cache_key(budget_obj.budget_id),), + user_api_key_cache=user_api_key_cache, + ) return response diff --git a/litellm/proxy/management_endpoints/common_utils.py b/litellm/proxy/management_endpoints/common_utils.py index adf89c29279..0f05a14c519 100644 --- a/litellm/proxy/management_endpoints/common_utils.py +++ b/litellm/proxy/management_endpoints/common_utils.py @@ -619,7 +619,7 @@ def _is_set_budget_value(value: object) -> bool: return True -def _has_meaningful_budget_limit(budget_values: Mapping[str, object]) -> bool: +def has_meaningful_budget_limit(budget_values: Mapping[str, object]) -> bool: """A budget is meaningful if at least one limit is actually set; an empty list (no model restriction) and None both count as unset.""" return any(_is_set_budget_value(budget_values.get(field)) for field in _TEAM_MEMBER_BUDGET_LIMIT_FIELDS) @@ -642,8 +642,9 @@ async def upsert_budget_and_membership( ``budget_patch`` holds only the budget columns the caller explicitly sent (RFC 7396 semantics): a value sets the column, ``None`` clears it, and a column that is absent from the dict is left untouched. Once the patch is - applied, if the budget has no meaningful limit left the member's private - budget is disconnected so they fall back to the team default. + applied, if the budget has no meaningful limit left the member is linked + back to the team default budget, so their spend keeps resetting on its + schedule, or unlinked when the team has none. ``team_default_budget_id`` is the team's shared default member budget id (from team metadata.team_member_budget_id). When the membership still @@ -687,18 +688,24 @@ async def upsert_budget_and_membership( ) temp_only: Final = frozenset(write_data) <= _TEMP_BUDGET_FIELDS - async def _disconnect(): + async def _fall_back_to_team_default(): await tx.litellm_teammembership.update( where={"user_id_team_id": {"user_id": user_id, "team_id": team_id}}, - data={"litellm_budget_table": {"disconnect": True}}, + data={ + "litellm_budget_table": ( + {"disconnect": True} + if team_default_budget_id is None + else {"connect": {"budget_id": team_default_budget_id}} + ) + }, ) if existing_budget_id is not None and not is_shared_default: existing_budget: Final = await tx.litellm_budgettable.find_unique(where={"budget_id": existing_budget_id}) merged: Final = existing_budget.model_dump() if existing_budget is not None else {} merged.update(write_data) - if not _has_meaningful_budget_limit(merged): - await _disconnect() + if not has_meaningful_budget_limit(merged): + await _fall_back_to_team_default() return await tx.litellm_budgettable.update( where={"budget_id": existing_budget_id}, @@ -739,9 +746,9 @@ async def upsert_budget_and_membership( if create_data.get("budget_reset_at") is None: create_data.pop("budget_reset_at", None) - if not _has_meaningful_budget_limit(create_data): + if not has_meaningful_budget_limit(create_data): if existing_budget_id is not None and not temp_only: - await _disconnect() + await _fall_back_to_team_default() return new_budget: Final = await tx.litellm_budgettable.create( diff --git a/litellm/proxy/management_endpoints/team_admin_field_permissions.py b/litellm/proxy/management_endpoints/team_admin_field_permissions.py index 0ece14eb90a..a30ec44e474 100644 --- a/litellm/proxy/management_endpoints/team_admin_field_permissions.py +++ b/litellm/proxy/management_endpoints/team_admin_field_permissions.py @@ -123,6 +123,7 @@ class TeamMemberDefaults: TEAM_MEMBER_DEFAULT_FIELDS: Final[frozenset[str]] = frozenset( {"team_member_budget", "team_member_budget_duration", "team_member_tpm_limit", "team_member_rpm_limit"} ) +_MEMBER_BUDGET_BACKFILL_FIELD: Final = "team_member_budget_backfill" @dataclass(frozen=True, slots=True) @@ -447,7 +448,10 @@ def _only_changes(data: UpdateTeamRequest, changed: frozenset[str]) -> UpdateTea such as a resent budget_duration pushing budget_reset_at back.""" sent: Final = frozenset(data.model_fields_set) via_metadata: Final = frozenset({"metadata"}) if changed - sent else frozenset[str]() - kept: Final = frozenset({"team_id"}) | (changed & sent) | via_metadata + backfilled_default: Final = ( + frozenset({"team_member_budget"}) & sent if _MEMBER_BUDGET_BACKFILL_FIELD in changed else frozenset[str]() + ) + kept: Final = frozenset({"team_id"}) | (changed & sent) | via_metadata | backfilled_default return UpdateTeamRequest.model_validate(data.model_dump(include=MappingProxyType({field: True for field in kept}))) @@ -466,7 +470,10 @@ def team_admin_edit_verdict( if controlled: return TeamAdminMetadataKeyProxyControlled(key=controlled[0]) changed: Final = changed_team_fields(data, existing, member_defaults) - blocked: Final = sorted(changed - permitted) + may_backfill: Final = ( + frozenset({_MEMBER_BUDGET_BACKFILL_FIELD}) if "team_member_budget" in permitted else frozenset[str]() + ) + blocked: Final = sorted(changed - permitted - may_backfill) if blocked: return TeamAdminFieldNotPermitted(field=blocked[0]) cleared: Final = sorted( diff --git a/litellm/proxy/management_endpoints/team_endpoints.py b/litellm/proxy/management_endpoints/team_endpoints.py index d9763f72741..11e83150d8c 100644 --- a/litellm/proxy/management_endpoints/team_endpoints.py +++ b/litellm/proxy/management_endpoints/team_endpoints.py @@ -88,6 +88,8 @@ from litellm.proxy._types import ( TeamInfoResponseObjectTeamTable, TeamListResponseObject, TeamMemberAddRequest, + TeamMemberBudgetBackfill, + TeamMemberBudgetBackfillResult, TeamMemberBudgetSource, TeamMemberDeleteRequest, TeamMemberResetBudgetResponse, @@ -131,6 +133,7 @@ from litellm.proxy.common_utils.callback_utils import encrypt_callback_vars from litellm.proxy.common_utils.json_merge_patch import apply_json_merge_patch from litellm.proxy.common_utils.user_api_key_cache import ( UserApiKeyCache, + team_member_default_budget_cache_key, team_membership_auth_cache_key, team_membership_reservation_cache_key, ) @@ -202,6 +205,15 @@ from litellm.proxy.management_helpers.object_permission_utils import ( # noqa: set_object_permission, ) from litellm.proxy.management_helpers.ptu_share_guard import raise_if_teams_hold_ptu_shares +from litellm.proxy.management_helpers.team_member_default_budget import ( + MAX_MEMBER_BUDGETS_MOVED_PER_UPDATE, + MovedMemberBudgets, + TeamMemberDefaultBudgetWrite, + TooManyMemberBudgetsToMove, + move_member_budgets_to_default, + plan_team_member_default_budget_write, + write_team_member_default_budget, +) from litellm.proxy.management_helpers.team_member_permission_checks import ( TeamMemberPermissionChecks, ) @@ -643,10 +655,9 @@ class TeamMemberBudgetHandler: user_api_key_cache: UserApiKeyCache | None, ) -> None: if user_api_key_cache is not None: - try: - await user_api_key_cache.async_delete_cache(key=f"team_member_default_budget:{budget_id}") - except Exception: # noqa: BLE001 # Cache failure must not fail a committed budget update. - verbose_proxy_logger.warning("Failed to evict the team member default budget cache", exc_info=True) + await evict_and_broadcast( + cache_keys=(team_member_default_budget_cache_key(budget_id),), user_api_key_cache=user_api_key_cache + ) @staticmethod async def create_team_member_budget_table( @@ -716,89 +727,6 @@ class TeamMemberBudgetHandler: return new_team_data_json - @staticmethod - async def upsert_team_member_budget_table( - team_table: _TeamBudgetRow, - user_api_key_dict: UserAPIKeyAuth, - updated_kv: dict, - team_member_budget: float | None = None, - team_member_rpm_limit: int | None = None, - team_member_tpm_limit: int | None = None, - team_member_budget_duration: str | None = None, - team_member_model_max_budget: GenericBudgetConfigType | None = None, - user_api_key_cache: UserApiKeyCache | None = None, - explicitly_set_fields: AbstractSet[str] = frozenset(), - ) -> dict: - """Upsert team member budget table with provided limits. - - A field the caller explicitly sent as null is written as null, so a - team can keep a member budget while dropping its reset period. - """ - from litellm.proxy._types import BudgetNewRequest - from litellm.proxy.management_endpoints.budget_management_endpoints import ( - update_budget, - ) - - if team_table.metadata is None: - team_table.metadata = {} - - team_member_budget_id: Final = team_table.metadata.get("team_member_budget_id") - if team_member_budget_id is not None and isinstance(team_member_budget_id, str): - # Budget exists - create update request with only provided values - budget_request: Final = BudgetNewRequest(budget_id=team_member_budget_id) - - if team_member_budget is not None or "team_member_budget" in explicitly_set_fields: - budget_request.max_budget = team_member_budget - if team_member_rpm_limit is not None or "team_member_rpm_limit" in explicitly_set_fields: - budget_request.rpm_limit = team_member_rpm_limit - if team_member_tpm_limit is not None or "team_member_tpm_limit" in explicitly_set_fields: - budget_request.tpm_limit = team_member_tpm_limit - if team_member_budget_duration is not None or "team_member_budget_duration" in explicitly_set_fields: - budget_request.budget_duration = team_member_budget_duration - if team_member_budget_duration is None: - budget_request.budget_reset_at = None - if team_member_model_max_budget is not None or "team_member_model_max_budget" in explicitly_set_fields: - budget_request.model_max_budget = ( - {} if team_member_model_max_budget is None else team_member_model_max_budget - ) - - budget_row: Final = await _as_budget_write(update_budget)( - budget_obj=budget_request, - user_api_key_dict=user_api_key_dict, - ) - await TeamMemberBudgetHandler._evict_default_budget_cache( - budget_id=team_member_budget_id, - user_api_key_cache=user_api_key_cache, - ) - verbose_proxy_logger.info( - "Updated team member budget table: %s, with team_member_budget=%s, team_member_rpm_limit=%s, team_member_tpm_limit=%s", - budget_row.budget_id, - team_member_budget, - team_member_rpm_limit, - team_member_tpm_limit, - ) - if updated_kv.get("metadata") is None: - updated_kv["metadata"] = {} - updated_kv["metadata"]["team_member_budget_id"] = budget_row.budget_id - - else: # budget does not exist - updated_kv = await TeamMemberBudgetHandler.create_team_member_budget_table( - data=team_table, - new_team_data_json=updated_kv, - user_api_key_dict=user_api_key_dict, - team_member_budget=team_member_budget, - team_member_rpm_limit=team_member_rpm_limit, - team_member_tpm_limit=team_member_tpm_limit, - team_member_budget_duration=team_member_budget_duration, - team_member_model_max_budget=team_member_model_max_budget, - user_api_key_cache=user_api_key_cache, - explicitly_set_fields=explicitly_set_fields, - ) - - # Remove team member fields from updated_kv - TeamMemberBudgetHandler.clean_team_member_fields(updated_kv) - return updated_kv - @staticmethod def clean_team_member_fields(data_dict: dict) -> None: """Remove team member fields from data dictionary""" @@ -809,119 +737,12 @@ class TeamMemberBudgetHandler: data_dict.pop( # pyright: ignore[reportUnknownMemberType] # legacy raw dict lacks key typing "team_member_model_max_budget", None ) + data_dict.pop( # pyright: ignore[reportUnknownMemberType] # legacy raw dict lacks key typing + "team_member_budget_backfill", None + ) _clean_team_member_fields = clean_team_member_fields - @staticmethod - async def clear_team_member_budget_fields( - team_table: _TeamBudgetRow, - user_api_key_dict: "UserAPIKeyAuth", - updated_kv: dict, - explicitly_set_fields: set, - user_api_key_cache: UserApiKeyCache | None = None, - ) -> dict: - """Clear explicitly-nulled fields on the team member budget row.""" - from litellm.proxy._types import BudgetNewRequest - from litellm.proxy.management_endpoints.budget_management_endpoints import ( - update_budget, - ) - - if team_table.metadata is None: - team_table.metadata = {} - - team_member_budget_id: Final = team_table.metadata.get("team_member_budget_id") - if team_member_budget_id is not None and isinstance(team_member_budget_id, str): - budget_request: Final = BudgetNewRequest(budget_id=team_member_budget_id) - if "team_member_budget" in explicitly_set_fields: - budget_request.max_budget = None - if "team_member_budget_duration" in explicitly_set_fields: - budget_request.budget_duration = None - budget_request.budget_reset_at = None - if "team_member_rpm_limit" in explicitly_set_fields: - budget_request.rpm_limit = None - if "team_member_tpm_limit" in explicitly_set_fields: - budget_request.tpm_limit = None - if "team_member_model_max_budget" in explicitly_set_fields: - budget_request.model_max_budget = {} - await update_budget( - budget_obj=budget_request, - user_api_key_dict=user_api_key_dict, - ) - await TeamMemberBudgetHandler._evict_default_budget_cache( - budget_id=team_member_budget_id, - user_api_key_cache=user_api_key_cache, - ) - - TeamMemberBudgetHandler.clean_team_member_fields(updated_kv) - return updated_kv - - @staticmethod - async def backfill_team_member_budget_entries( - team_id: str, - members_with_roles: Sequence[Member | dict[str, object]], - team_member_budget_id: str, - prisma_client: PrismaClient, - ) -> None: - """ - Ensure every team member has a TeamMembership row linked to the - team_member_budget. - - Called after team_member_budget is set/updated on a team. Creates - rows for members who don't have one, and populates budget_id on - existing rows where it is NULL. Rows with a non-NULL budget_id - are left untouched, which preserves per-member overrides but also - means rows pointing to a prior team-default budget_id are not - migrated to the new one. - """ - if not members_with_roles: - return - - # Batch-fetch existing memberships for this team (avoids N+1 queries) - existing_memberships: Final = await _team_membership_db(prisma_client).find_many(where={"team_id": team_id}) - existing_user_ids: Final = {m.user_id for m in existing_memberships} - - # Identify members with no existing membership row. - # members_with_roles may contain Member instances or raw dicts depending - # on how the team was fetched/deserialized. - missing: Final = [] - for m in members_with_roles: - user_id = m.get("user_id") if isinstance(m, dict) else m.user_id - if user_id is not None and user_id not in existing_user_ids: - missing.append( - { - "team_id": team_id, - "user_id": user_id, - "budget_id": team_member_budget_id, - } - ) - - if missing: - await _team_membership_db(prisma_client).create_many( - data=missing, - skip_duplicates=True, # safety net against concurrent races - ) - verbose_proxy_logger.info( - "Backfilled %d team_memberships for team %s with budget %s", - len(missing), - _sanitize_for_log(team_id), - _sanitize_for_log(team_member_budget_id), - ) - - # Heal existing membership rows that predate the team_member_budget - # configuration: populate budget_id where it is currently NULL. - # Rows with an explicit budget_id (per-member override) are left alone. - updated: Final = await _team_membership_db(prisma_client).update_many( - where={"team_id": team_id, "budget_id": None}, - data={"budget_id": team_member_budget_id}, - ) - if updated: - verbose_proxy_logger.info( - "Populated budget_id on %d existing team_memberships for team %s with budget %s", - updated, - _sanitize_for_log(team_id), - _sanitize_for_log(team_member_budget_id), - ) - def _get_default_team_param(field: str) -> object: """ @@ -1382,6 +1203,8 @@ def _check_team_budget_update_authority( return guard +_TEAM_MEMBER_BUDGET_TX_TIMEOUT: Final = timedelta(seconds=60) + _TEAM_UPDATE_INCLUDE: Final = MappingProxyType( { "litellm_model_table": True, @@ -1394,26 +1217,96 @@ _TEAM_UPDATE_INCLUDE: Final = MappingProxyType( async def _write_team_update( - prisma_client: PrismaClient | None, + teams: "TableActions[prisma_models.LiteLLM_TeamTable]", team_id: str, team_update_data: Mapping[str, object], max_budget_guard: _MaxBudgetGuard | None, ) -> "prisma_models.LiteLLM_TeamTable | None": by_id: Final[_TeamIdWhere] = {"team_id": team_id} if max_budget_guard is None: - return await _team_db(prisma_client).update(where=by_id, data=team_update_data, include=_TEAM_UPDATE_INCLUDE) + return await teams.update(where=by_id, data=team_update_data, include=_TEAM_UPDATE_INCLUDE) as_checked: Final[_TeamBudgetGuardWhere] = { "team_id": team_id, "max_budget": max_budget_guard.max_budget, "organization_id": max_budget_guard.organization_id, } - written: Final = await _team_db(prisma_client).update_many(where=as_checked, data=team_update_data) + written: Final = await teams.update_many(where=as_checked, data=team_update_data) if written == 0: conflict: Final[_ErrorDetail] = { "error": "The team's organization or max_budget changed during this update. Reload the team and try again." } raise HTTPException(status_code=409, detail=conflict) - return await _team_db(prisma_client).find_unique(where=by_id, include=_TEAM_UPDATE_INCLUDE) + return await teams.find_unique(where=by_id, include=_TEAM_UPDATE_INCLUDE) + + +@dataclass(frozen=True, slots=True) +class _TeamWrite: + team_row: "prisma_models.LiteLLM_TeamTable | None" + linked_member_user_ids: tuple[str, ...] + moved_member_budgets: MovedMemberBudgets | None + + def backfill_response(self) -> Mapping[str, TeamMemberBudgetBackfillResult]: + if self.moved_member_budgets is None: + return MappingProxyType({}) + return MappingProxyType({"team_member_budget_backfill_result": self.moved_member_budgets.result()}) + + def backfill_audit(self) -> Mapping[str, object]: + return MappingProxyType({key: result.model_dump() for key, result in self.backfill_response().items()}) + + def changed_member_user_ids(self) -> tuple[str, ...]: + moved: Final = () if self.moved_member_budgets is None else self.moved_member_budgets.user_ids + return tuple(dict.fromkeys((*self.linked_member_user_ids, *moved))) + + +async def _write_team_with_member_default_budget( + prisma_client: PrismaClient, + *, + team_id: str, + team_update_data: Mapping[str, object], + max_budget_guard: _MaxBudgetGuard | None, + default_budget_write: TeamMemberDefaultBudgetWrite, + backfill: TeamMemberBudgetBackfill, + user_api_key_dict: UserAPIKeyAuth, + changed_by: str, +) -> _TeamWrite: + """One transaction under the team lock, so the default, every member it reaches and the team row commit + together or not at all.""" + async with prisma_client.tx(timeout=_TEAM_MEMBER_BUDGET_TX_TIMEOUT) as tx: + await tx.query_raw(TEAM_ADVISORY_LOCK_SQL, team_id) + members: Final = await TeamRepository(prisma_client).get_members_with_roles_locked(tx, team_id) + if members is None: + raise HTTPException( + status_code=404, detail={"error": f"Team={team_id} was deleted while this update was running"} + ) + member_user_ids: Final = tuple(member.user_id for member in members if member.user_id is not None) + await write_team_member_default_budget( + tx, default_budget_write, team_id=team_id, member_user_ids=member_user_ids, changed_by=changed_by + ) + moved: Final = await move_member_budgets_to_default( + tx, + team_id=team_id, + default_budget_id=default_budget_write.budget_id, + backfill=backfill, + changed_by=user_api_key_dict, + ) + if isinstance(moved, TooManyMemberBudgetsToMove): + raise HTTPException( + status_code=422, + detail={ + "error": ( + f"{moved.count} members would move onto the new default, more than the " + f"{MAX_MEMBER_BUDGETS_MOVED_PER_UPDATE} one update can move. Save with " + "team_member_budget_backfill set to 'none', then move members in batches with " + f"POST /management/v1/teams/{team_id}/members/bulk_update" + ) + }, + ) + team_row: Final = await _write_team_update(_team_tx_db(tx), team_id, team_update_data, max_budget_guard) + return _TeamWrite( + team_row=team_row, + linked_member_user_ids=member_user_ids if default_budget_write.links_members else (), + moved_member_budgets=moved if backfill != "none" else None, + ) def _existing_model_cap(raw_budget_config: object) -> BudgetConfig | None: @@ -2244,15 +2137,6 @@ def validate_team_org_change( return True -def _member_user_ids(members_with_roles: Sequence[dict[str, object]]) -> tuple[str, ...]: - """Extract the string ``user_id`` of each team member, dropping rows without one. - - ``members_with_roles`` is a Prisma-deserialized JSON column, so its ``user_id`` is typed - ``object``; the ``isinstance`` narrows it to the ``str`` ``invalidate_team_member_spend_state`` needs. - """ - return tuple(user_id for member in members_with_roles if isinstance((user_id := member.get("user_id")), str)) - - async def _evict_created_membership_caches( user_ids: Iterable[str], team_id: str, @@ -2321,6 +2205,7 @@ async def update_team( - team_member_model_max_budget: Optional[dict] - Per-model budgets shared by team members without an override. - team_member_rpm_limit: Optional[int] - The RPM (Requests Per Minute) limit for individual team members. - team_member_tpm_limit: Optional[int] - The TPM (Tokens Per Minute) limit for individual team members. + - team_member_budget_backfill: Optional[str] - Moves members with their own budget onto the team_member_budget sent in the same request: "raise_to_default" (those below it), "lower_to_default" (those above it), "all_to_default" (both) or "none". Members on a different reset schedule are skipped, and the response's team_member_budget_backfill_result counts who moved. - team_member_key_duration: Optional[str] - The duration for a team member's key. e.g. "1d", "1w", "1mo" - allowed_passthrough_routes: Optional[List[str]] - List of allowed pass through routes for the team. - denied_passthrough_routes: Optional[List[str]] - List of pass through routes the team's keys may not call, even if allowed. Applies together with each key's `denied_passthrough_routes`. @@ -2662,50 +2547,18 @@ async def update_team( }, } - if _team_member_fields_in_request and TeamMemberBudgetHandler.should_create_budget( - team_member_budget=data.team_member_budget, - team_member_rpm_limit=data.team_member_rpm_limit, - team_member_tpm_limit=data.team_member_tpm_limit, - team_member_budget_duration=data.team_member_budget_duration, - team_member_model_max_budget=data.team_member_model_max_budget, - ): - updated_kv = await TeamMemberBudgetHandler.upsert_team_member_budget_table( - team_table=existing_team_row, - user_api_key_dict=user_api_key_dict, - updated_kv=updated_kv, - team_member_budget=data.team_member_budget, - team_member_rpm_limit=data.team_member_rpm_limit, - team_member_tpm_limit=data.team_member_tpm_limit, - team_member_budget_duration=data.team_member_budget_duration, - team_member_model_max_budget=data.team_member_model_max_budget, - user_api_key_cache=user_api_key_cache, - explicitly_set_fields=_team_member_fields_in_request, - ) - # Backfill team_memberships for members who joined before the - # budget was configured — they won't have a membership row yet. - _backfill_budget_id: Final = (updated_kv.get("metadata") or {}).get("team_member_budget_id") - if _backfill_budget_id and existing_team_row.members_with_roles: - await TeamMemberBudgetHandler.backfill_team_member_budget_entries( - team_id=data.team_id, - members_with_roles=existing_team_row.members_with_roles, - team_member_budget_id=_backfill_budget_id, - prisma_client=prisma_client, - ) - await _evict_created_membership_caches( - user_ids=_member_user_ids(existing_team_row.members_with_roles), - team_id=data.team_id, - user_api_key_cache=user_api_key_cache, - ) - elif _team_member_fields_in_request: - updated_kv = await TeamMemberBudgetHandler.clear_team_member_budget_fields( - team_table=existing_team_row, - user_api_key_dict=user_api_key_dict, - updated_kv=updated_kv, - explicitly_set_fields=_team_member_fields_in_request, - user_api_key_cache=user_api_key_cache, - ) - else: - TeamMemberBudgetHandler.clean_team_member_fields(updated_kv) + default_budget_write: Final = plan_team_member_default_budget_write( + data=data, + existing_budget_id=stored_team_member_budget_id(existing_team), + team_alias=existing_team_row.team_alias, + team_budget_duration=existing_team_row.budget_duration, + ) + if default_budget_write is not None: + updated_kv["metadata"] = { + **(updated_kv.get("metadata") or {}), + "team_member_budget_id": default_budget_write.budget_id, + } + TeamMemberBudgetHandler.clean_team_member_fields(updated_kv) # Check object permission if data.object_permission is not None: @@ -2744,7 +2597,27 @@ async def update_team( updated_kv = prisma_client.jsonify_team_object(db_data=updated_kv) team_update_data: Final[Mapping[str, object]] = updated_kv - team_row: Final = await _write_team_update(prisma_client, data.team_id, team_update_data, max_budget_guard) + team_write: Final = ( + _TeamWrite( + team_row=await _write_team_update( + _team_db(prisma_client), data.team_id, team_update_data, max_budget_guard + ), + linked_member_user_ids=(), + moved_member_budgets=None, + ) + if default_budget_write is None + else await _write_team_with_member_default_budget( + prisma_client, + team_id=data.team_id, + team_update_data=team_update_data, + max_budget_guard=max_budget_guard, + default_budget_write=default_budget_write, + backfill=data.team_member_budget_backfill or "none", + user_api_key_dict=user_api_key_dict, + changed_by=user_api_key_dict.user_id or litellm_proxy_admin_name, + ) + ) + team_row: Final = team_write.team_row if team_row is None or team_row.team_id is None: raise HTTPException( @@ -2753,6 +2626,16 @@ async def update_team( ) verbose_proxy_logger.info("Successfully updated team - %s, info", team_row.team_id) + if default_budget_write is not None: + await TeamMemberBudgetHandler._evict_default_budget_cache( + budget_id=default_budget_write.budget_id, user_api_key_cache=user_api_key_cache + ) + await _evict_team_member_cache_keys( + team_id=team_row.team_id, + member_user_ids=team_write.changed_member_user_ids(), + cache_keys=tuple(team_membership_cache_keys(team_row.team_id, team_write.changed_member_user_ids())), + user_api_key_cache=user_api_key_cache, + ) await sync_team_access_group_membership(prisma_client=prisma_client, team_id=team_row.team_id) await invalidate_cached_object_permissions( object_permission_ids=(existing_team.object_permission_id, team_row.object_permission_id), @@ -2767,14 +2650,14 @@ async def update_team( if is_audit_logging_enabled(): await _create_team_update_audit_log( existing_team_row=existing_team_row, - updated_kv=updated_kv, + updated_kv=updated_kv | team_write.backfill_audit(), team_id=data.team_id, litellm_changed_by=litellm_changed_by, user_api_key_dict=user_api_key_dict, litellm_proxy_admin_name=litellm_proxy_admin_name, ) - return {"team_id": team_row.team_id, "data": team_row} + return {"team_id": team_row.team_id, "data": team_row} | team_write.backfill_response() except Exception as e: raise handle_exception_on_proxy(e) @@ -4094,6 +3977,7 @@ async def team_member_update( ### upsert new budget budget_patch: Final = member_budget_patch(data) async with prisma_client.tx() as tx: + await tx.query_raw(TEAM_ADVISORY_LOCK_SQL, data.team_id) role_change: Final = ( await _update_team_member_role( tx=tx, @@ -4955,22 +4839,23 @@ async def _invalidate_deleted_team_member_cache( user_api_key_cache: UserApiKeyCache, ) -> None: for team_id, member_user_ids in member_ids_per_team: - await _evict_deleted_team_member_cache( + await _evict_team_member_cache_keys( team_id=team_id, member_user_ids=member_user_ids, + cache_keys=tuple(member_cache_keys(team_id, member_user_ids)), user_api_key_cache=user_api_key_cache, ) -async def _evict_deleted_team_member_cache( +async def _evict_team_member_cache_keys( team_id: str, member_user_ids: Sequence[str], + cache_keys: Sequence[str], user_api_key_cache: UserApiKeyCache, ) -> None: _ = await asyncio.gather( *(await_inflight_team_membership_load(user_id=user_id, team_id=team_id) for user_id in member_user_ids) ) - cache_keys: Final = tuple(member_cache_keys(team_id, member_user_ids)) evict_local(cache_keys=cache_keys, user_api_key_cache=user_api_key_cache) await evict_shared(cache_keys=cache_keys, cache=user_api_key_cache) await broadcast_evictions(cache_keys=cache_keys) @@ -4979,6 +4864,11 @@ async def _evict_deleted_team_member_cache( def member_cache_keys(team_id: str, user_ids: Sequence[str]) -> Iterator[str]: for user_id in user_ids: yield user_id + yield from team_membership_cache_keys(team_id, (user_id,)) + + +def team_membership_cache_keys(team_id: str, user_ids: Sequence[str]) -> Iterator[str]: + for user_id in user_ids: yield team_membership_auth_cache_key(team_id=team_id, user_id=user_id) yield team_membership_reservation_cache_key(user_id=user_id, team_id=team_id) diff --git a/litellm/proxy/management_helpers/bulk_team_member_budgets.py b/litellm/proxy/management_helpers/bulk_team_member_budgets.py index 08169eab761..11f54cb02d5 100644 --- a/litellm/proxy/management_helpers/bulk_team_member_budgets.py +++ b/litellm/proxy/management_helpers/bulk_team_member_budgets.py @@ -30,6 +30,7 @@ from litellm.proxy.management_endpoints.common_utils import ( # noqa: F401 # l member_budget_patch, upsert_budget_and_membership, # pyright: ignore[reportPrivateUsage] # the single-member write, shared so the two surfaces cannot drift ) +from litellm.proxy.management_helpers.access_group_team_sync import TEAM_ADVISORY_LOCK_SQL from litellm.proxy.management_helpers.audit_logs import create_object_audit_log from litellm.proxy.management_helpers.bulk_user_deletion import ( _duplicate_member_indexes, # pyright: ignore[reportPrivateUsage] # same duplicate rule as members/bulk_delete @@ -141,6 +142,7 @@ def _result( user_id: str | None, error: str | None, budget_of: "MappingProxyType[str, prisma_models.LiteLLM_BudgetTable | None]", + team_default_budget_id: str | None, team_default_max_budget: float | None, ) -> TeamMemberBudgetUpdateResult: if error is not None or user_id is None: @@ -151,7 +153,8 @@ def _result( error=error or "User not found in team", ) budget: Final = budget_of.get(user_id) - own_max_budget: Final = budget.max_budget if budget is not None else None + on_team_default: Final = budget is not None and budget.budget_id == team_default_budget_id + own_max_budget: Final = budget.max_budget if budget is not None and not on_team_default else None inherits: Final = own_max_budget is None and team_default_max_budget is not None and team_default_max_budget > 0 return TeamMemberBudgetUpdateResult( user_id=user_id, @@ -198,7 +201,12 @@ async def bulk_update_team_member_budgets( if not applied: return tuple( _result( - member, None, "Duplicate member in request" if index in duplicates else None, MappingProxyType({}), None + member, + None, + "Duplicate member in request" if index in duplicates else None, + MappingProxyType({}), + None, + None, ) for index, member in enumerate(data.members) ) @@ -208,6 +216,7 @@ async def bulk_update_team_member_budgets( team_members_filter: Final = _team_users_filter(team_id, user_ids) async with prisma_client.tx(timeout=_BATCH_TX_TIMEOUT) as tx: + await tx.query_raw(TEAM_ADVISORY_LOCK_SQL, team_id) memberships: Final = await _membership_tx_db(tx).find_many(where=team_members_filter, include=_WITH_BUDGET) budget_id_of: Final = MappingProxyType({m.user_id: m.budget_id for m in memberships}) shared: Final = await _shared_budget_ids( @@ -254,6 +263,7 @@ async def bulk_update_team_member_budgets( named[index], "Duplicate member in request" if index in duplicates else None, budget_of, + default_budget_id, team_default.max_budget if team_default is not None else None, ) for index, member in enumerate(data.members) diff --git a/litellm/proxy/management_helpers/team_member_default_budget.py b/litellm/proxy/management_helpers/team_member_default_budget.py new file mode 100644 index 00000000000..a8d2721ae38 --- /dev/null +++ b/litellm/proxy/management_helpers/team_member_default_budget.py @@ -0,0 +1,321 @@ +import json +import uuid +from collections.abc import Mapping, Sequence +from dataclasses import dataclass +from datetime import datetime +from types import MappingProxyType +from typing import TYPE_CHECKING, Final, assert_never + +from pydantic import BaseModel, ConfigDict, JsonValue, TypeAdapter, field_validator + +from litellm.litellm_core_utils.duration_parser import budget_reset_period_key +from litellm.proxy._types import ( + TeamMemberBudgetBackfill, + TeamMemberBudgetBackfillResult, + UpdateTeamRequest, + UserAPIKeyAuth, +) +from litellm.proxy.common_utils.timezone_utils import get_budget_reset_time +from litellm.proxy.management_endpoints.common_utils import ( + has_meaningful_budget_limit, + upsert_budget_and_membership, +) +from litellm.proxy.utils import jsonify_object + +if TYPE_CHECKING: + from prisma import Prisma + from prisma import models as prisma_models + + from litellm.repositories.prisma_protocols import TableActions + +MAX_MEMBER_BUDGETS_MOVED_PER_UPDATE: Final = 50_000 + +_DEFAULT_BUDGET_COLUMNS: Final = MappingProxyType( + { + "team_member_budget": "max_budget", + "team_member_rpm_limit": "rpm_limit", + "team_member_tpm_limit": "tpm_limit", + "team_member_budget_duration": "budget_duration", + "team_member_model_max_budget": "model_max_budget", + } +) + +_LINK_MISSING_MEMBERSHIPS_SQL: Final = """ +INSERT INTO "LiteLLM_TeamMembership" (user_id, team_id, budget_id) +SELECT member.user_id, $1, $2 FROM unnest($3::text[]) AS member(user_id) +ON CONFLICT (user_id, team_id) DO NOTHING +""" +_LINK_UNBUDGETED_MEMBERSHIPS_SQL: Final = ( + 'UPDATE "LiteLLM_TeamMembership" SET budget_id = $2 WHERE team_id = $1 AND budget_id IS NULL' +) +_RELINK_TO_DEFAULT_SQL: Final = ( + 'UPDATE "LiteLLM_TeamMembership" SET budget_id = $2 WHERE team_id = $1 AND user_id = ANY($3::text[])' +) +_CLEAR_MAX_BUDGET_SQL: Final = """ +UPDATE "LiteLLM_BudgetTable" SET max_budget = NULL, updated_by = $2, updated_at = (NOW() AT TIME ZONE 'UTC') +WHERE budget_id = ANY($1::text[]) +""" +_SHARED_BUDGET_IDS_SQL: Final = """ +SELECT budget_id FROM "LiteLLM_TeamMembership" WHERE budget_id = ANY($1::text[]) +GROUP BY budget_id HAVING COUNT(*) > 1 +""" +_CANDIDATES_BY_SCHEDULE_SQL: Final = """ +SELECT b.budget_duration AS duration, COUNT(*)::int AS members +FROM "LiteLLM_TeamMembership" m JOIN "LiteLLM_BudgetTable" b ON b.budget_id = m.budget_id +WHERE m.team_id = $1 AND m.budget_id <> $2 AND {direction} +GROUP BY b.budget_duration +""" +_CANDIDATES_SQL: Final = """ +SELECT m.user_id, b.budget_id, b.soft_budget, b.max_parallel_requests, b.tpm_limit, b.rpm_limit, + b.model_max_budget, b.budget_duration, b.allowed_models, b.temp_budget_increase, b.temp_budget_expiry +FROM "LiteLLM_TeamMembership" m JOIN "LiteLLM_BudgetTable" b ON b.budget_id = m.budget_id +WHERE m.team_id = $1 AND m.budget_id <> $2 AND {direction} + AND (b.budget_duration = ANY($4::text[]) OR ($5::boolean AND b.budget_duration IS NULL)) +""" + + +@dataclass(frozen=True, slots=True) +class TeamMemberDefaultBudgetWrite: + budget_id: str + update: Mapping[str, object] + create: Mapping[str, object] + links_members: bool + + +@dataclass(frozen=True, slots=True) +class MovedMemberBudgets: + user_ids: tuple[str, ...] + skipped_other_reset_period: int + + def result(self) -> TeamMemberBudgetBackfillResult: + return TeamMemberBudgetBackfillResult( + moved_to_default=len(self.user_ids), skipped_other_reset_period=self.skipped_other_reset_period + ) + + +@dataclass(frozen=True, slots=True) +class TooManyMemberBudgetsToMove: + count: int + + +class _ScheduleCount(BaseModel): + model_config = ConfigDict(frozen=True) + + duration: str | None + members: int + + +class _BudgetLimits(BaseModel): + model_config = ConfigDict(frozen=True) + + soft_budget: float | None = None + max_parallel_requests: int | None = None + tpm_limit: int | None = None + rpm_limit: int | None = None + model_max_budget: JsonValue = None + budget_duration: str | None = None + allowed_models: tuple[str, ...] | None = None + temp_budget_increase: float | None = None + temp_budget_expiry: datetime | None = None + + @field_validator("model_max_budget", mode="before") + @classmethod + def _decode_json_column(cls, value: object) -> object: + return json.loads(value) if isinstance(value, str) else value + + def has_own_limits_beyond(self, default: "_BudgetLimits") -> bool: + return has_meaningful_budget_limit( + {field: value for field, value in self.model_dump().items() if value != getattr(default, field)} + ) + + +class _MemberBudgetRef(BaseModel): + model_config = ConfigDict(frozen=True) + + user_id: str + budget_id: str + + +@dataclass(frozen=True, slots=True) +class _CustomMemberBudget: + ref: _MemberBudgetRef + keeps_own_limits: bool + + +class _BudgetIdRow(BaseModel): + model_config = ConfigDict(frozen=True) + + budget_id: str + + +_SCHEDULE_COUNTS: Final = TypeAdapter(tuple[_ScheduleCount, ...]) +_MEMBER_BUDGET_REFS: Final = TypeAdapter(tuple[_MemberBudgetRef, ...]) +_MEMBER_BUDGET_LIMITS: Final = TypeAdapter(tuple[_BudgetLimits, ...]) +_BUDGET_IDS: Final = TypeAdapter(tuple[_BudgetIdRow, ...]) + + +def plan_team_member_default_budget_write( + data: UpdateTeamRequest, + existing_budget_id: str | None, + team_alias: str | None, + team_budget_duration: str | None, +) -> TeamMemberDefaultBudgetWrite | None: + requested: Final = data.model_dump(include=frozenset(_DEFAULT_BUDGET_COLUMNS) & data.model_fields_set) + sent: Final = MappingProxyType({_DEFAULT_BUDGET_COLUMNS[field]: value for field, value in requested.items()}) + links_members: Final = any(value is not None for value in sent.values()) + if not sent or (existing_budget_id is None and not links_members): + return None + create_duration: Final = sent["budget_duration"] if "budget_duration" in sent else team_budget_duration + created: Final = {**sent, "budget_duration": create_duration} + return TeamMemberDefaultBudgetWrite( + budget_id=existing_budget_id or _new_default_budget_id(team_alias), + update=_with_reset_at( + {column: {} if column == "model_max_budget" and value is None else value for column, value in sent.items()} + ), + create=_with_reset_at({column: value for column, value in created.items() if value is not None}), + links_members=links_members, + ) + + +async def write_team_member_default_budget( + tx: "Prisma", + write: TeamMemberDefaultBudgetWrite, + *, + team_id: str, + member_user_ids: Sequence[str], + changed_by: str, +) -> None: + """The caller holds the team advisory lock on ``tx``, so the members linked here are the whole roster.""" + stamps: Final = {"updated_by": changed_by} + await _budget_tx_db(tx).upsert( + where={"budget_id": write.budget_id}, + data={ + "create": jsonify_object( + {**write.create, **stamps, "budget_id": write.budget_id, "created_by": changed_by} + ), + "update": jsonify_object({**write.update, **stamps}), + }, + ) + if not write.links_members: + return + await tx.execute_raw(_LINK_MISSING_MEMBERSHIPS_SQL, team_id, write.budget_id, list(member_user_ids)) + await tx.execute_raw(_LINK_UNBUDGETED_MEMBERSHIPS_SQL, team_id, write.budget_id) + + +async def move_member_budgets_to_default( + tx: "Prisma", + *, + team_id: str, + default_budget_id: str, + backfill: TeamMemberBudgetBackfill, + changed_by: UserAPIKeyAuth, +) -> MovedMemberBudgets | TooManyMemberBudgetsToMove: + """Members compare on their permanent ``max_budget``, and only those resetting on the default's schedule move. + A member whose other limits all match the default is linked to the default row, while one holding a limit of its + own keeps its row with ``max_budget`` cleared.""" + direction: Final = _direction_sql(backfill) + if direction is None: + return MovedMemberBudgets(user_ids=(), skipped_other_reset_period=0) + default: Final = await _budget_tx_db(tx).find_unique(where={"budget_id": default_budget_id}) + if default is None or default.max_budget is None: + return MovedMemberBudgets(user_ids=(), skipped_other_reset_period=0) + schedule: Final = budget_reset_period_key(default.budget_duration) + counts: Final = _SCHEDULE_COUNTS.validate_python( + await tx.query_raw( + _CANDIDATES_BY_SCHEDULE_SQL.format(direction=direction), team_id, default_budget_id, default.max_budget + ) + ) + matching: Final = tuple(count for count in counts if budget_reset_period_key(count.duration) == schedule) + moving: Final = sum(count.members for count in matching) + skipped: Final = sum(count.members for count in counts) - moving + if moving > MAX_MEMBER_BUDGETS_MOVED_PER_UPDATE: + return TooManyMemberBudgetsToMove(count=moving) + if moving == 0: + return MovedMemberBudgets(user_ids=(), skipped_other_reset_period=skipped) + rows: Final = await tx.query_raw( + _CANDIDATES_SQL.format(direction=direction), + team_id, + default_budget_id, + default.max_budget, + [count.duration for count in matching if count.duration is not None], + any(count.duration is None for count in matching), + ) + default_limits: Final = _BudgetLimits.model_validate(default.model_dump()) + candidates: Final = tuple( + _CustomMemberBudget(ref=ref, keeps_own_limits=limits.has_own_limits_beyond(default_limits)) + for ref, limits in zip( + _MEMBER_BUDGET_REFS.validate_python(rows), _MEMBER_BUDGET_LIMITS.validate_python(rows), strict=True + ) + ) + await _move_to_default(tx, candidates, team_id=team_id, default_budget_id=default_budget_id, changed_by=changed_by) + return MovedMemberBudgets( + user_ids=tuple(candidate.ref.user_id for candidate in candidates), skipped_other_reset_period=skipped + ) + + +async def _move_to_default( + tx: "Prisma", + candidates: Sequence[_CustomMemberBudget], + *, + team_id: str, + default_budget_id: str, + changed_by: UserAPIKeyAuth, +) -> None: + keeping: Final = tuple(candidate.ref for candidate in candidates if candidate.keeps_own_limits) + relinking: Final = tuple(candidate.ref.user_id for candidate in candidates if not candidate.keeps_own_limits) + shared: Final = frozenset( + row.budget_id + for row in _BUDGET_IDS.validate_python( + await tx.query_raw(_SHARED_BUDGET_IDS_SQL, list({ref.budget_id for ref in keeping})) + ) + ) + await tx.execute_raw(_RELINK_TO_DEFAULT_SQL, team_id, default_budget_id, list(relinking)) + await tx.execute_raw( + _CLEAR_MAX_BUDGET_SQL, + list({ref.budget_id for ref in keeping if ref.budget_id not in shared}), + changed_by.user_id or "", + ) + for ref in keeping: + if ref.budget_id in shared: + await upsert_budget_and_membership( + tx, + team_id=team_id, + user_id=ref.user_id, + existing_budget_id=ref.budget_id, + user_api_key_dict=changed_by, + budget_patch=MappingProxyType({"max_budget": None}), + team_default_budget_id=default_budget_id, + shared_budget_ids=shared, + ) + + +def _budget_tx_db(tx: "Prisma") -> "TableActions[prisma_models.LiteLLM_BudgetTable]": + return tx.litellm_budgettable # pyright: ignore[reportReturnType] # TableActions widens the generated inputs to Mapping, as the repositories do + + +def _direction_sql(backfill: TeamMemberBudgetBackfill) -> str | None: + match backfill: + case "none": + return None + case "raise_to_default": + return "b.max_budget < $3::double precision" + case "lower_to_default": + return "b.max_budget > $3::double precision" + case "all_to_default": + return "b.max_budget <> $3::double precision" + case _: + assert_never(backfill) + + +def _with_reset_at(columns: Mapping[str, object]) -> Mapping[str, object]: + if "budget_duration" not in columns: + return MappingProxyType(dict(columns)) + duration: Final = columns["budget_duration"] + reset_at: Final = get_budget_reset_time(budget_duration=duration) if isinstance(duration, str) else None + return MappingProxyType({**columns, "budget_reset_at": reset_at}) + + +def _new_default_budget_id(team_alias: str | None) -> str: + if team_alias is None: + return f"team-budget-{uuid.uuid4().hex}" + return f"team-{team_alias.replace(' ', '-')}-budget-{uuid.uuid4().hex}" diff --git a/litellm/proxy/spend_tracking/budget_reservation.py b/litellm/proxy/spend_tracking/budget_reservation.py index 803df9f83ca..6e5322cdb32 100644 --- a/litellm/proxy/spend_tracking/budget_reservation.py +++ b/litellm/proxy/spend_tracking/budget_reservation.py @@ -37,6 +37,7 @@ from litellm.proxy.common_utils.user_api_key_cache import ( project_cache_key, project_spend_counter_key, tag_cache_key, + team_member_default_budget_cache_key, team_membership_reservation_cache_key, ) from litellm.proxy.spend_tracking.input_tokens import count_input_tokens, count_input_tokens_for_model @@ -744,7 +745,7 @@ async def _get_team_member_budget_counter( default_budget_id: Final = (team_object.metadata or {}).get("team_member_budget_id") if isinstance(default_budget_id, str): default_budget: Final = _CACHED_VALUE.validate_python( - await user_api_key_cache.async_get_cache(key=f"team_member_default_budget:{default_budget_id}") + await user_api_key_cache.async_get_cache(key=team_member_default_budget_cache_key(default_budget_id)) ) default_cap: Final = _to_float(_get_value(default_budget, "max_budget")) if default_cap is not None and default_cap > 0: diff --git a/tests/integration/management/test_team_member_budget_backfill.py b/tests/integration/management/test_team_member_budget_backfill.py new file mode 100644 index 00000000000..fbf64f80b29 --- /dev/null +++ b/tests/integration/management/test_team_member_budget_backfill.py @@ -0,0 +1,253 @@ +from collections.abc import Mapping +from dataclasses import dataclass + +import pytest +from prisma import Json + +from litellm.proxy.management_helpers.team_member_default_budget import MAX_MEMBER_BUDGETS_MOVED_PER_UPDATE +from tests.integration._support.actors import create_scratch_team + +pytestmark = pytest.mark.asyncio(loop_scope="session") + +_OLD_DEFAULT = 40.0 +_NEW_DEFAULT = 50.0 +_PERIOD = "30d" + + +@dataclass(frozen=True) +class _Budget: + max_budget: float + budget_duration: str | None = _PERIOD + rpm_limit: int | None = None + + +_ROSTER: Mapping[str, _Budget | None] = { + "below": _Budget(20.0), + "above": _Budget(80.0), + "equal": _Budget(_NEW_DEFAULT), + "weekly": _Budget(10.0, budget_duration="7d"), + "own_rpm": _Budget(20.0, rpm_limit=5), + "on_default": None, +} + + +async def _seed_budget(db, budget_id: str, budget: _Budget) -> str: + await db.db.litellm_budgettable.create( + data={ + "budget_id": budget_id, + "max_budget": budget.max_budget, + "budget_duration": budget.budget_duration, + "rpm_limit": budget.rpm_limit, + "created_by": "backfill-test", + "updated_by": "backfill-test", + } + ) + return budget_id + + +async def _seed_membership(db, resources, name: str, budget_id: str | None) -> None: + key = {"user_id": resources.tag(name), "team_id": resources.prefix} + await db.db.litellm_teammembership.upsert( + where={"user_id_team_id": key}, + data={"create": {**key, "budget_id": budget_id}, "update": {"budget_id": budget_id}}, + ) + + +async def _seed_team( + db, + resources, + roster: Mapping[str, _Budget | None], + *, + unbudgeted: tuple[str, ...] = (), + rowless: tuple[str, ...] = (), +) -> str: + """``roster`` members hold their own budget, or the default when None. ``unbudgeted`` members have a membership + row with no budget, ``rowless`` ones are on the team with no membership row at all.""" + default_budget_id = await _seed_budget(db, resources.tag("default"), _Budget(_OLD_DEFAULT)) + await create_scratch_team( + db, resources.prefix, member_user_ids=[resources.tag(name) for name in (*roster, *unbudgeted, *rowless)] + ) + await db.db.litellm_teamtable.update( + where={"team_id": resources.prefix}, data={"metadata": Json({"team_member_budget_id": default_budget_id})} + ) + for name, budget in roster.items(): + own = None if budget is None else await _seed_budget(db, resources.tag(f"own-{name}"), budget) + await _seed_membership(db, resources, name, own or default_budget_id) + for name in unbudgeted: + await _seed_membership(db, resources, name, None) + await db.db.litellm_teammembership.delete_many( + where={"team_id": resources.prefix, "user_id": {"in": [resources.tag(name) for name in rowless]}} + ) + return default_budget_id + + +def _update_team(db, team_id: str, body: Mapping[str, object]): + return db.gateway.request("POST", "/team/update", {"team_id": team_id, **body}) + + +async def _member_budget(db, resources, name: str): + membership = await db.db.litellm_teammembership.find_unique( + where={"user_id_team_id": {"user_id": resources.tag(name), "team_id": resources.prefix}}, + include={"litellm_budget_table": True}, + ) + assert membership is not None + return membership + + +@pytest.mark.parametrize( + "backfill,moved,skipped", + [ + ("raise_to_default", {"below", "own_rpm"}, 1), + ("lower_to_default", {"above"}, 0), + ("all_to_default", {"below", "own_rpm", "above"}, 1), + ], +) +async def test_backfill_moves_only_members_on_the_chosen_side_of_the_new_default( + backfill: str, moved: set[str], skipped: int, db, resources +): + default_budget_id = await _seed_team(db, resources, _ROSTER) + + response = _update_team( + db, + resources.prefix, + {"team_member_budget": _NEW_DEFAULT, "team_member_budget_backfill": backfill}, + ) + + assert response.status_code == 200, response.text + assert response.json()["team_member_budget_backfill_result"] == { + "moved_to_default": len(moved), + "skipped_other_reset_period": skipped, + } + for name, budget in _ROSTER.items(): + membership = await _member_budget(db, resources, name) + if name == "own_rpm" and name in moved: + assert membership.budget_id == resources.tag("own-own_rpm") + assert membership.litellm_budget_table.max_budget is None + assert membership.litellm_budget_table.rpm_limit == 5 + elif name in moved or budget is None: + assert membership.budget_id == default_budget_id, name + else: + assert membership.litellm_budget_table.max_budget == budget.max_budget, name + default = await db.db.litellm_budgettable.find_unique(where={"budget_id": default_budget_id}) + assert default.max_budget == _NEW_DEFAULT + + +async def test_saving_a_new_default_without_backfill_keeps_every_custom_budget(db, resources): + await _seed_team(db, resources, _ROSTER) + + response = _update_team(db, resources.prefix, {"team_member_budget": _NEW_DEFAULT}) + + assert response.status_code == 200, response.text + assert "team_member_budget_backfill_result" not in response.json() + for name, budget in _ROSTER.items(): + if budget is not None: + assert (await _member_budget(db, resources, name)).litellm_budget_table.max_budget == budget.max_budget + + +async def test_backfill_gives_members_sharing_a_custom_budget_their_own_copy(db, resources): + await _seed_team(db, resources, {}) + shared_budget_id = await _seed_budget(db, resources.tag("shared"), _Budget(20.0, rpm_limit=5)) + for name in ("first", "second"): + await _seed_membership(db, resources, name, shared_budget_id) + + response = _update_team( + db, + resources.prefix, + {"team_member_budget": _NEW_DEFAULT, "team_member_budget_backfill": "raise_to_default"}, + ) + + assert response.status_code == 200, response.text + copies = [await _member_budget(db, resources, name) for name in ("first", "second")] + assert len({copy.budget_id for copy in copies} | {shared_budget_id}) == 3 + assert [(copy.litellm_budget_table.max_budget, copy.litellm_budget_table.rpm_limit) for copy in copies] == [ + (None, 5), + (None, 5), + ] + shared = await db.db.litellm_budgettable.find_unique(where={"budget_id": shared_budget_id}) + assert shared.max_budget == 20.0 + + +async def test_backfill_links_members_sharing_a_plain_custom_budget_to_the_default(db, resources): + default_budget_id = await _seed_team(db, resources, {}) + shared_budget_id = await _seed_budget(db, resources.tag("shared"), _Budget(20.0)) + for name in ("first", "second"): + await _seed_membership(db, resources, name, shared_budget_id) + + response = _update_team( + db, + resources.prefix, + {"team_member_budget": _NEW_DEFAULT, "team_member_budget_backfill": "raise_to_default"}, + ) + + assert response.status_code == 200, response.text + assert [(await _member_budget(db, resources, name)).budget_id for name in ("first", "second")] == [ + default_budget_id, + default_budget_id, + ] + shared = await db.db.litellm_budgettable.find_unique(where={"budget_id": shared_budget_id}) + assert shared.max_budget == 20.0 + + +async def test_backfill_over_the_member_cap_rolls_back_the_new_default(db, resources): + default_budget_id = await _seed_team(db, resources, {}) + over_cap = MAX_MEMBER_BUDGETS_MOVED_PER_UPDATE + 1 + await db.db.execute_raw( + """ + WITH members AS (SELECT $1 || '-bulk-' || n AS user_id FROM generate_series(1, $3::int) AS n), + budgets AS ( + INSERT INTO "LiteLLM_BudgetTable" (budget_id, max_budget, budget_duration, created_by, updated_by) + SELECT user_id, 20.0, $4, 'backfill-test', 'backfill-test' FROM members RETURNING budget_id + ) + INSERT INTO "LiteLLM_TeamMembership" (user_id, team_id, budget_id) + SELECT budget_id, $2, budget_id FROM budgets + """, + resources.prefix, + resources.prefix, + over_cap, + _PERIOD, + ) + + response = _update_team( + db, + resources.prefix, + {"team_member_budget": _NEW_DEFAULT, "team_member_budget_backfill": "raise_to_default"}, + ) + + assert response.status_code == 422, response.text + assert str(over_cap) in response.text + default = await db.db.litellm_budgettable.find_unique(where={"budget_id": default_budget_id}) + assert default.max_budget == _OLD_DEFAULT + sample = await db.db.litellm_budgettable.find_unique(where={"budget_id": f"{resources.prefix}-bulk-1"}) + assert sample.max_budget == 20.0 + + +async def test_backfill_without_a_new_default_is_rejected(resources, db): + await _seed_team(db, resources, {}) + + response = _update_team(db, resources.prefix, {"team_member_budget_backfill": "raise_to_default"}) + + assert response.status_code == 422, response.text + assert "team_member_budget_backfill needs a positive team_member_budget" in response.text + + +async def test_clearing_a_members_only_limit_links_them_back_to_the_team_default(db, resources): + default_budget_id = await _seed_team(db, resources, {"capped": _Budget(20.0, budget_duration=None)}) + + response = db.gateway.request( + "POST", + f"/management/v1/teams/{resources.prefix}/members/bulk_update", + {"members": [{"user_id": resources.tag("capped"), "max_budget_in_team": None}]}, + ) + + assert response.status_code == 200, response.text + assert (await _member_budget(db, resources, "capped")).budget_id == default_budget_id + + +async def test_saving_a_default_links_every_roster_member_without_a_budget_to_it(db, resources): + default_budget_id = await _seed_team(db, resources, {}, unbudgeted=("no-budget",), rowless=("no-row",)) + + response = _update_team(db, resources.prefix, {"team_member_budget": _NEW_DEFAULT}) + + assert response.status_code == 200, response.text + for name in ("no-row", "no-budget"): + assert (await _member_budget(db, resources, name)).budget_id == default_budget_id, name diff --git a/tests/unit/litellm_core_utils/test_duration_parser.py b/tests/unit/litellm_core_utils/test_duration_parser.py index f14015effe6..4414542b019 100644 --- a/tests/unit/litellm_core_utils/test_duration_parser.py +++ b/tests/unit/litellm_core_utils/test_duration_parser.py @@ -6,8 +6,9 @@ from zoneinfo import ZoneInfo import pytest -import litellm.litellm_core_utils.duration_parser as duration_parser +from litellm.litellm_core_utils import duration_parser from litellm.litellm_core_utils.duration_parser import ( + budget_reset_period_key, duration_in_seconds, duration_in_seconds_from, get_budget_window_start, @@ -407,3 +408,26 @@ def test_a_month_starting_now_matches_duration_in_seconds(): if __name__ == "__main__": unittest.main() + + +@pytest.mark.parametrize( + "first,second,same_schedule", + [ + ("7d", "1w", True), + ("24h", "1d", True), + ("daily", "1d", True), + ("60s", "1m", True), + ("monthly", "30d", True), + (" 30d ", "30d", True), + ("1mo", "1mo", True), + (None, None, True), + ("1mo", "30d", False), + ("2mo", "1mo", False), + ("7d", "1d", False), + ("30d", None, False), + ("garbage", "garbage", True), + ("garbage", "30d", False), + ], +) +def test_budget_reset_period_key_matches_only_identical_schedules(first, second, same_schedule): + assert (budget_reset_period_key(first) == budget_reset_period_key(second)) is same_schedule diff --git a/tests/unit/proxy/common_utils/test_upsert_budget_membership.py b/tests/unit/proxy/common_utils/test_upsert_budget_membership.py index 1f7154f0a74..9bd3217067a 100644 --- a/tests/unit/proxy/common_utils/test_upsert_budget_membership.py +++ b/tests/unit/proxy/common_utils/test_upsert_budget_membership.py @@ -85,6 +85,26 @@ async def test_empty_patch_is_noop(mock_tx, fake_user): mock_tx.litellm_budgettable.create.assert_not_called() +@pytest.mark.asyncio +async def test_clearing_all_limits_links_the_member_to_the_team_default(mock_tx, fake_user): + mock_tx.litellm_budgettable.find_unique = AsyncMock(return_value=budget_row(max_budget=100.0)) + + await upsert_budget_and_membership( + mock_tx, + team_id="team-1", + user_id="user-1", + existing_budget_id="bud-1", + user_api_key_dict=fake_user, + budget_patch={"max_budget": None}, + team_default_budget_id="team-default", + ) + + mock_tx.litellm_teammembership.update.assert_awaited_once_with( + where={"user_id_team_id": {"user_id": "user-1", "team_id": "team-1"}}, + data={"litellm_budget_table": {"connect": {"budget_id": "team-default"}}}, + ) + + # TEST: clearing every limit on a member's private budget disconnects it, so the # member falls back to the team default instead of keeping an empty private row. @pytest.mark.asyncio diff --git a/tests/unit/proxy/management_endpoints/management_v1/test_teams.py b/tests/unit/proxy/management_endpoints/management_v1/test_teams.py index 5d1c658b143..9b47e0575bd 100644 --- a/tests/unit/proxy/management_endpoints/management_v1/test_teams.py +++ b/tests/unit/proxy/management_endpoints/management_v1/test_teams.py @@ -137,6 +137,8 @@ class _MembershipTable: relation: Final = data.get("litellm_budget_table") if isinstance(relation, dict) and relation.get("disconnect"): self.rows[index] = self.rows[index].model_copy(update={"budget_id": None}) + if isinstance(relation, dict) and isinstance(connected := relation.get("connect"), dict): + self.rows[index] = self.rows[index].model_copy(update={"budget_id": connected["budget_id"]}) return self.rows[index] async def upsert(self, where: Mapping[str, Mapping[str, str]], data: Mapping[str, object]) -> _MembershipRow: @@ -180,6 +182,9 @@ class _Db: self.litellm_budgettable = _BudgetTable(budgets) self.litellm_teammembership = _MembershipTable(self.litellm_budgettable, memberships) + async def query_raw(self, query: str, *args: object) -> list[object]: + return [] + class _FakePrisma: def __init__( @@ -406,6 +411,20 @@ async def test_an_omitted_field_is_kept_an_explicit_null_clears_it_and_clearing_ assert _budget_id_of(prisma, "m1") is None +@pytest.mark.asyncio +async def test_clearing_the_last_limit_links_the_member_back_to_the_team_default(): + prisma = _FakePrisma( + teams=[_team("m1", default_budget_id="team-default")], + memberships=[_membership("m1", "priv-m1")], + budgets=[_budget("team-default", max_budget=50.0), _budget("priv-m1", max_budget=10.0)], + ) + + emptied = await _bulk_update(prisma, [{"user_id": "m1", "max_budget_in_team": None}]) + + assert emptied[0].success is True + assert _budget_id_of(prisma, "m1") == "team-default" + + @pytest.mark.asyncio async def test_budget_duration_seeds_a_reset_time_derived_from_the_duration_and_clearing_it_clears_the_reset(): prisma = _FakePrisma( @@ -566,8 +585,8 @@ async def test_an_explicit_cap_reports_as_the_members_own_while_clearing_one_fal ("m1", 50.0, "member"), ("m2", 25.0, "team_default"), ] - assert results[1].budget_id is None - assert _budget_id_of(prisma, "m2") is None + assert results[1].budget_id == "team-default" + assert _budget_id_of(prisma, "m2") == "team-default" assert prisma.db.litellm_budgettable.rows["team-default"].max_budget == 25.0 diff --git a/tests/unit/proxy/management_endpoints/test_team_admin_field_permissions.py b/tests/unit/proxy/management_endpoints/test_team_admin_field_permissions.py index 4af57a83395..d3da03c51a8 100644 --- a/tests/unit/proxy/management_endpoints/test_team_admin_field_permissions.py +++ b/tests/unit/proxy/management_endpoints/test_team_admin_field_permissions.py @@ -19,7 +19,11 @@ from litellm.proxy.management_endpoints.team_admin_field_permissions import ( TeamAdminEditingDisabled, TeamAdminFieldNotPermitted, TeamAdminKeyEditAllowed, + TeamAdminMemberKeyCreationAllowed, + TeamAdminMemberKeyCreationDisabled, TeamAdminMemberKeyEditingDisabled, + TeamAdminMemberKeyOwnerNotPermitted, + TeamAdminMemberKeyTypeNotPermitted, TeamAdminMetadataKeyProxyControlled, TeamMemberDefaults, changed_key_fields, @@ -34,10 +38,6 @@ from litellm.proxy.management_endpoints.team_admin_field_permissions import ( team_admin_may_raise_max_budget, team_admin_member_key_creation_or_raise, team_admin_member_key_creation_verdict, - TeamAdminMemberKeyCreationAllowed, - TeamAdminMemberKeyCreationDisabled, - TeamAdminMemberKeyOwnerNotPermitted, - TeamAdminMemberKeyTypeNotPermitted, team_admin_request_or_raise, ) @@ -240,6 +240,29 @@ class TestTeamMemberDefaultEdits: assert isinstance(verdict, TeamAdminEditAllowed) assert verdict.request.model_dump(exclude_unset=True) == {"team_id": "team-1", "tpm_limit": 6} + def test_backfill_onto_the_unchanged_default_keeps_the_default_it_compares_against(self): + data: Final = UpdateTeamRequest( + team_id="team-1", team_member_budget=10.0, team_member_budget_backfill="raise_to_default" + ) + verdict: Final = team_admin_edit_verdict( + data, _team(), _permitted("team_member_budget"), _STORED_MEMBER_DEFAULTS + ) + assert isinstance(verdict, TeamAdminEditAllowed) + assert verdict.request.model_dump(exclude_unset=True) == { + "team_id": "team-1", + "team_member_budget": 10.0, + "team_member_budget_backfill": "raise_to_default", + } + + def test_backfill_needs_the_member_budget_enabled(self): + data: Final = UpdateTeamRequest( + team_id="team-1", team_member_budget=10.0, team_member_budget_backfill="lower_to_default" + ) + verdict: Final = team_admin_edit_verdict( + data, _team(), _permitted("team_member_budget_duration"), _STORED_MEMBER_DEFAULTS + ) + assert verdict == TeamAdminFieldNotPermitted(field="team_member_budget_backfill") + def test_nulls_resent_for_a_team_without_member_defaults_are_dropped(self): data: Final = UpdateTeamRequest( team_id="team-1", diff --git a/tests/unit/proxy/management_endpoints/test_team_endpoints.py b/tests/unit/proxy/management_endpoints/test_team_endpoints.py index 37028558af3..9e3946daaec 100644 --- a/tests/unit/proxy/management_endpoints/test_team_endpoints.py +++ b/tests/unit/proxy/management_endpoints/test_team_endpoints.py @@ -1,4 +1,5 @@ import asyncio +import contextlib import json from collections.abc import Mapping, Sequence from contextlib import AbstractContextManager, ExitStack, asynccontextmanager, contextmanager @@ -2866,172 +2867,6 @@ async def test_team_write_404s_when_row_vanishes_before_update(endpoint_name): assert exc_info.value.detail == {"error": "Team not found, passed team_id=team-1234"} -@pytest.mark.asyncio -async def test_update_team_team_member_budget_not_passed_to_db( - disable_audit_logging_for_mocked_team, -): - """ - Test that 'team_member_budget' is never passed to prisma_client.db.litellm_teamtable.update - regardless of whether the value is set or None. - - This ensures that team_member_budget is properly handled via the separate budget table - and not accidentally passed to the team table update operation. - """ - from unittest.mock import AsyncMock, MagicMock, Mock, patch - - from fastapi import Request - - from litellm.proxy._types import LitellmUserRoles, UpdateTeamRequest, UserAPIKeyAuth - from litellm.proxy.management_endpoints.team_endpoints import update_team - - # Mock dependencies - mock_request = Mock(spec=Request) - mock_user_api_key_dict = UserAPIKeyAuth( - user_role=LitellmUserRoles.PROXY_ADMIN, user_id="test_user_id" - ) - - with ( - patch("litellm.proxy.proxy_server.prisma_client") as mock_prisma_client, - patch("litellm.proxy.proxy_server.llm_router") as mock_llm_router, - patch("litellm.proxy.proxy_server.user_api_key_cache") as mock_cache, - patch("litellm.proxy.proxy_server.proxy_logging_obj") as mock_logging, - patch("litellm.proxy.proxy_server.litellm_proxy_admin_name", "admin"), - patch( - "litellm.proxy.management_endpoints.team_endpoints.cache_team_object", - new_callable=AsyncMock, - ) as mock_cache_team, - patch( - "litellm.proxy.management_endpoints.team_endpoints.TeamMemberBudgetHandler.upsert_team_member_budget_table" - ) as mock_upsert_budget, - ): - # Setup mock prisma client - mock_existing_team = MagicMock() - mock_existing_team.model_dump.return_value = { - "team_id": "test_team_id", - "team_alias": "test_team", - "metadata": {"team_member_budget_id": "budget_123"}, - } - mock_prisma_client.db.litellm_teamtable.find_unique = AsyncMock( - return_value=mock_existing_team - ) - - # Mock the update return value - mock_updated_team = MagicMock() - mock_updated_team.team_id = "test_team_id" - mock_updated_team.model_dump.return_value = {"team_id": "test_team_id"} - mock_prisma_client.db.litellm_teamtable.update = AsyncMock( - return_value=mock_updated_team - ) - mock_prisma_client.jsonify_team_object = MagicMock( - side_effect=lambda db_data: db_data - ) - - # Mock budget upsert to return updated_kv without team_member_budget - def mock_upsert_side_effect( - team_table, - user_api_key_dict, - updated_kv, - team_member_budget=None, - team_member_rpm_limit=None, - team_member_tpm_limit=None, - team_member_budget_duration=None, - team_member_model_max_budget=None, - user_api_key_cache=None, - explicitly_set_fields=frozenset(), - ): - # Remove team_member_budget from updated_kv as the real function does - result_kv = updated_kv.copy() - result_kv.pop("team_member_budget", None) - return result_kv - - mock_upsert_budget.side_effect = mock_upsert_side_effect - - # Test Case 1: team_member_budget is set (not None) - update_request_with_budget = UpdateTeamRequest( - team_id="test_team_id", team_member_budget=100.0, team_alias="updated_alias" - ) - - result = await update_team( - data=update_request_with_budget, - http_request=mock_request, - user_api_key_dict=mock_user_api_key_dict, - ) - - # Verify update was called - assert mock_prisma_client.db.litellm_teamtable.update.called - - # Get the call arguments - call_args = mock_prisma_client.db.litellm_teamtable.update.call_args - update_data = call_args[1]["data"] # data parameter from the update call - - # Verify team_member_budget is NOT in the update data - assert ( - "team_member_budget" not in update_data - ), f"team_member_budget should not be in update data, but found: {update_data}" - - # Verify other fields are present (team_alias should be there) - assert "team_alias" in update_data or "team_id" in str( - call_args - ), "Expected team update fields should be present" - - # Reset mock for second test - mock_prisma_client.db.litellm_teamtable.update.reset_mock() - - # Test Case 2: team_member_budget is None - update_request_without_budget = UpdateTeamRequest( - team_id="test_team_id", - team_member_budget=None, - team_alias="updated_alias_2", - ) - - result = await update_team( - data=update_request_without_budget, - http_request=mock_request, - user_api_key_dict=mock_user_api_key_dict, - ) - - # Verify update was called again - assert mock_prisma_client.db.litellm_teamtable.update.called - - # Get the call arguments for second call - call_args = mock_prisma_client.db.litellm_teamtable.update.call_args - update_data = call_args[1]["data"] # data parameter from the update call - - # Verify team_member_budget is NOT in the update data - assert ( - "team_member_budget" not in update_data - ), f"team_member_budget should not be in update data, but found: {update_data}" - - # Test Case 3: No team_member_budget field at all (excluded from request) - mock_prisma_client.db.litellm_teamtable.update.reset_mock() - - update_request_no_budget_field = UpdateTeamRequest( - team_id="test_team_id", - team_alias="updated_alias_3", - # team_member_budget not specified at all - ) - - result = await update_team( - data=update_request_no_budget_field, - http_request=mock_request, - user_api_key_dict=mock_user_api_key_dict, - ) - - # Verify update was called again - assert mock_prisma_client.db.litellm_teamtable.update.called - - # Get the call arguments for third call - call_args = mock_prisma_client.db.litellm_teamtable.update.call_args - update_data = call_args[1]["data"] # data parameter from the update call - - # Verify team_member_budget is NOT in the update data - assert ( - "team_member_budget" not in update_data - ), f"team_member_budget should not be in update data, but found: {update_data}" - - print( - "✅ All test cases passed: team_member_budget is properly excluded from database update operations" - ) def test_clean_team_member_fields(): @@ -3197,165 +3032,10 @@ async def test_create_team_member_budget_table_without_team_alias(): assert budget_request.budget_id.startswith("team-budget-") -@pytest.mark.asyncio -async def test_upsert_team_member_budget_table_existing_budget(): - """ - Test that upsert_team_member_budget_table updates an existing budget when team_member_budget_id exists. - """ - from unittest.mock import AsyncMock, MagicMock, patch - - from litellm.proxy._types import LiteLLM_TeamTable, LitellmUserRoles, UserAPIKeyAuth - from litellm.proxy.management_endpoints.team_endpoints import ( - TeamMemberBudgetHandler, - ) - - mock_user_api_key_dict = UserAPIKeyAuth( - user_role=LitellmUserRoles.PROXY_ADMIN, user_id="test_user_id" - ) - - team_table = MagicMock(spec=LiteLLM_TeamTable) - team_table.metadata = {"team_member_budget_id": "existing_budget_123"} - - updated_kv = { - "team_id": "test_team_id", - "team_member_budget": 200.0, - "team_member_budget_duration": "60d", - "team_member_rpm_limit": 100, - } - - mock_budget_response = MagicMock() - mock_budget_response.budget_id = "existing_budget_123" - - with patch( - "litellm.proxy.management_endpoints.budget_management_endpoints.update_budget", - new_callable=AsyncMock, - ) as mock_update_budget: - mock_update_budget.return_value = mock_budget_response - - result = await TeamMemberBudgetHandler.upsert_team_member_budget_table( - team_table=team_table, - user_api_key_dict=mock_user_api_key_dict, - updated_kv=updated_kv, - team_member_budget=200.0, - team_member_budget_duration="60d", - team_member_rpm_limit=100, - ) - - assert mock_update_budget.called - call_args = mock_update_budget.call_args - budget_request = call_args[1]["budget_obj"] - - assert budget_request.budget_id == "existing_budget_123" - assert budget_request.max_budget == 200.0 - assert budget_request.budget_duration == "60d" - assert budget_request.rpm_limit == 100 - - assert "team_member_budget_id" in result["metadata"] - assert result["metadata"]["team_member_budget_id"] == "existing_budget_123" - - assert "team_member_budget" not in result - assert "team_member_budget_duration" not in result - assert "team_member_rpm_limit" not in result -@pytest.mark.asyncio -async def test_upsert_team_member_budget_table_no_existing_budget(): - """ - Test that upsert_team_member_budget_table creates a new budget when team_member_budget_id does not exist. - """ - from unittest.mock import AsyncMock, MagicMock, patch - - from litellm.proxy._types import LiteLLM_TeamTable, LitellmUserRoles, UserAPIKeyAuth - from litellm.proxy.management_endpoints.team_endpoints import ( - TeamMemberBudgetHandler, - ) - - mock_user_api_key_dict = UserAPIKeyAuth( - user_role=LitellmUserRoles.PROXY_ADMIN, user_id="test_user_id" - ) - - team_table = MagicMock(spec=LiteLLM_TeamTable) - team_table.metadata = {} - team_table.team_alias = "Test Team" - team_table.budget_duration = None - - updated_kv = { - "team_id": "test_team_id", - "team_member_budget": 150.0, - "team_member_budget_duration": "45d", - } - - mock_budget_response = MagicMock() - mock_budget_response.budget_id = "new_budget_456" - - with patch( - "litellm.proxy.management_endpoints.budget_management_endpoints.new_budget", - new_callable=AsyncMock, - ) as mock_new_budget: - mock_new_budget.return_value = mock_budget_response - - result = await TeamMemberBudgetHandler.upsert_team_member_budget_table( - team_table=team_table, - user_api_key_dict=mock_user_api_key_dict, - updated_kv=updated_kv, - team_member_budget=150.0, - team_member_budget_duration="45d", - ) - - assert mock_new_budget.called - assert "team_member_budget_id" in result["metadata"] - assert result["metadata"]["team_member_budget_id"] == "new_budget_456" - - assert "team_member_budget" not in result - assert "team_member_budget_duration" not in result -@pytest.mark.asyncio -async def test_upsert_team_member_budget_table_clears_duration_kept_budget(mock_db_client): - """ - A request that keeps team_member_budget but explicitly nulls - team_member_budget_duration must clear the reset period and its reset time. - """ - from litellm.proxy.management_endpoints.team_endpoints import ( - TeamMemberBudgetHandler, - ) - - mock_user_api_key_dict = UserAPIKeyAuth( - user_role=LitellmUserRoles.PROXY_ADMIN, user_id="test_user_id" - ) - - team_table = MagicMock(spec=LiteLLM_TeamTable) - team_table.metadata = {"team_member_budget_id": "existing_budget_123"} - - mock_db_client.db.litellm_budgettable.update = AsyncMock( - side_effect=lambda where, data: SimpleNamespace(**data) - ) - - result = await TeamMemberBudgetHandler.upsert_team_member_budget_table( - team_table=team_table, - user_api_key_dict=mock_user_api_key_dict, - updated_kv={ - "team_id": "test_team_id", - "team_member_budget": 100.0, - "team_member_budget_duration": None, - }, - team_member_budget=100.0, - team_member_budget_duration=None, - explicitly_set_fields={ - "team_member_budget", - "team_member_budget_duration", - }, - ) - - written = mock_db_client.db.litellm_budgettable.update.call_args.kwargs["data"] - assert written["max_budget"] == 100.0 - assert written["budget_duration"] is None - assert written["budget_reset_at"] is None - assert "rpm_limit" not in written - assert "tpm_limit" not in written - assert result["metadata"]["team_member_budget_id"] == "existing_budget_123" - assert "team_member_budget" not in result - assert "team_member_budget_duration" not in result @pytest.mark.asyncio @@ -3442,299 +3122,14 @@ async def test_create_team_member_budget_table_inherits_team_duration_when_durat assert result["metadata"]["team_member_budget_id"] == written["budget_id"] -@pytest.mark.asyncio -async def test_update_team_with_team_member_budget_duration( - disable_audit_logging_for_mocked_team, -): - """ - Test that team/update endpoint properly handles team_member_budget_duration. - """ - from unittest.mock import AsyncMock, MagicMock, Mock, patch - - from fastapi import Request - - from litellm.proxy._types import LitellmUserRoles, UpdateTeamRequest, UserAPIKeyAuth - from litellm.proxy.management_endpoints.team_endpoints import update_team - - mock_request = Mock(spec=Request) - mock_user_api_key_dict = UserAPIKeyAuth( - user_role=LitellmUserRoles.PROXY_ADMIN, user_id="test_user_id" - ) - - with ( - patch("litellm.proxy.proxy_server.prisma_client") as mock_prisma_client, - patch("litellm.proxy.proxy_server.llm_router") as mock_llm_router, - patch("litellm.proxy.proxy_server.user_api_key_cache") as mock_cache, - patch("litellm.proxy.proxy_server.proxy_logging_obj") as mock_logging, - patch("litellm.proxy.proxy_server.litellm_proxy_admin_name", "admin"), - patch( - "litellm.proxy.management_endpoints.team_endpoints.cache_team_object", - new_callable=AsyncMock, - ) as mock_cache_team, - patch( - "litellm.proxy.management_endpoints.team_endpoints.TeamMemberBudgetHandler.upsert_team_member_budget_table" - ) as mock_upsert_budget, - ): - mock_existing_team = MagicMock() - mock_existing_team.model_dump.return_value = { - "team_id": "test_team_id", - "team_alias": "test_team", - "metadata": {"team_member_budget_id": "budget_123"}, - } - mock_existing_team.metadata = {"team_member_budget_id": "budget_123"} - mock_existing_team.members_with_roles = [] - mock_prisma_client.db.litellm_teamtable.find_unique = AsyncMock( - return_value=mock_existing_team - ) - - mock_updated_team = MagicMock() - mock_updated_team.team_id = "test_team_id" - mock_updated_team.model_dump.return_value = {"team_id": "test_team_id"} - mock_prisma_client.db.litellm_teamtable.update = AsyncMock( - return_value=mock_updated_team - ) - mock_prisma_client.jsonify_team_object = MagicMock( - side_effect=lambda db_data: db_data - ) - - def mock_upsert_side_effect( - team_table, - user_api_key_dict, - updated_kv, - team_member_budget=None, - team_member_rpm_limit=None, - team_member_tpm_limit=None, - team_member_budget_duration=None, - team_member_model_max_budget=None, - user_api_key_cache=None, - explicitly_set_fields=frozenset(), - ): - result_kv = updated_kv.copy() - result_kv.pop("team_member_budget", None) - result_kv.pop("team_member_budget_duration", None) - return result_kv - - mock_upsert_budget.side_effect = mock_upsert_side_effect - - update_request = UpdateTeamRequest( - team_id="test_team_id", - team_alias="updated_alias", - team_member_budget=100.0, - team_member_budget_duration="30d", - ) - - result = await update_team( - data=update_request, - http_request=mock_request, - user_api_key_dict=mock_user_api_key_dict, - ) - - assert mock_upsert_budget.called - call_args = mock_upsert_budget.call_args - assert call_args[1]["team_member_budget"] == 100.0 - assert call_args[1]["team_member_budget_duration"] == "30d" - - assert mock_prisma_client.db.litellm_teamtable.update.called - update_call_args = mock_prisma_client.db.litellm_teamtable.update.call_args - update_data = update_call_args[1]["data"] - - assert "team_member_budget" not in update_data - assert "team_member_budget_duration" not in update_data -@pytest.mark.asyncio -async def test_backfill_team_member_budget_entries_creates_missing_memberships(): - """ - When backfill_team_member_budget_entries is called, it should create - team_memberships rows only for members that don't already have one. - - Regression test for: https://github.com/BerriAI/litellm/issues/25506 - """ - from unittest.mock import AsyncMock, MagicMock - - from litellm.proxy._types import Member - from litellm.proxy.management_endpoints.team_endpoints import ( - TeamMemberBudgetHandler, - ) - - team_id = "team-abc" - budget_id = "budget-xyz" - - # user-A already has a membership; user-B does not - existing_membership = MagicMock() - existing_membership.user_id = "user-A" - - mock_prisma = MagicMock() - mock_prisma.db.litellm_teammembership.find_many = AsyncMock( - return_value=[existing_membership] - ) - mock_prisma.db.litellm_teammembership.create_many = AsyncMock(return_value=None) - mock_prisma.db.litellm_teammembership.update_many = AsyncMock(return_value=0) - - # Test with Member instances - members = [ - Member(user_id="user-A", role="user"), - Member(user_id="user-B", role="user"), - ] - - await TeamMemberBudgetHandler.backfill_team_member_budget_entries( - team_id=team_id, - members_with_roles=members, - team_member_budget_id=budget_id, - prisma_client=mock_prisma, - ) - - # find_many should have been called to fetch existing memberships - mock_prisma.db.litellm_teammembership.find_many.assert_awaited_once_with( - where={"team_id": team_id} - ) - - # create_many should only create an entry for user-B (user-A already has one) - mock_prisma.db.litellm_teammembership.create_many.assert_awaited_once_with( - data=[{"team_id": team_id, "user_id": "user-B", "budget_id": budget_id}], - skip_duplicates=True, - ) - - # Also test with raw dicts (members_with_roles may be dicts when deserialized from DB) - mock_prisma.db.litellm_teammembership.find_many.reset_mock() - mock_prisma.db.litellm_teammembership.create_many.reset_mock() - mock_prisma.db.litellm_teammembership.update_many.reset_mock() - - members_as_dicts = [ - {"user_id": "user-A", "role": "user"}, - {"user_id": "user-B", "role": "user"}, - ] - - await TeamMemberBudgetHandler.backfill_team_member_budget_entries( - team_id=team_id, - members_with_roles=members_as_dicts, - team_member_budget_id=budget_id, - prisma_client=mock_prisma, - ) - - mock_prisma.db.litellm_teammembership.create_many.assert_awaited_once_with( - data=[{"team_id": team_id, "user_id": "user-B", "budget_id": budget_id}], - skip_duplicates=True, - ) -@pytest.mark.asyncio -async def test_backfill_team_member_budget_entries_no_op_when_all_exist(): - """ - backfill_team_member_budget_entries should not call create_many when all - members already have a team_memberships entry. - """ - from unittest.mock import AsyncMock, MagicMock - - from litellm.proxy._types import Member - from litellm.proxy.management_endpoints.team_endpoints import ( - TeamMemberBudgetHandler, - ) - - team_id = "team-abc" - budget_id = "budget-xyz" - - existing_a = MagicMock() - existing_a.user_id = "user-A" - existing_b = MagicMock() - existing_b.user_id = "user-B" - - mock_prisma = MagicMock() - mock_prisma.db.litellm_teammembership.find_many = AsyncMock( - return_value=[existing_a, existing_b] - ) - mock_prisma.db.litellm_teammembership.create_many = AsyncMock(return_value=None) - mock_prisma.db.litellm_teammembership.update_many = AsyncMock(return_value=0) - - members = [ - Member(user_id="user-A", role="user"), - Member(user_id="user-B", role="user"), - ] - - await TeamMemberBudgetHandler.backfill_team_member_budget_entries( - team_id=team_id, - members_with_roles=members, - team_member_budget_id=budget_id, - prisma_client=mock_prisma, - ) - - mock_prisma.db.litellm_teammembership.create_many.assert_not_awaited() -@pytest.mark.asyncio -async def test_backfill_team_member_budget_entries_populates_null_budget_id_on_existing_rows(): - """ - backfill_team_member_budget_entries should populate budget_id on - existing TeamMembership rows where it is currently NULL, so admins - can configure a team member budget after members have already joined - and have enforcement apply to those pre-existing members. - """ - from unittest.mock import AsyncMock, MagicMock - - from litellm.proxy._types import Member - from litellm.proxy.management_endpoints.team_endpoints import ( - TeamMemberBudgetHandler, - ) - - team_id = "team-abc" - budget_id = "budget-xyz" - - # Both members already have rows, so create_many must not fire; - # update_many must fire with the NULL-budget_id filter. - existing_a = MagicMock() - existing_a.user_id = "user-A" - existing_b = MagicMock() - existing_b.user_id = "user-B" - - mock_prisma = MagicMock() - mock_prisma.db.litellm_teammembership.find_many = AsyncMock( - return_value=[existing_a, existing_b] - ) - mock_prisma.db.litellm_teammembership.create_many = AsyncMock(return_value=None) - mock_prisma.db.litellm_teammembership.update_many = AsyncMock(return_value=2) - - await TeamMemberBudgetHandler.backfill_team_member_budget_entries( - team_id=team_id, - members_with_roles=[ - Member(user_id="user-A", role="user"), - Member(user_id="user-B", role="user"), - ], - team_member_budget_id=budget_id, - prisma_client=mock_prisma, - ) - - mock_prisma.db.litellm_teammembership.create_many.assert_not_awaited() - mock_prisma.db.litellm_teammembership.update_many.assert_awaited_once_with( - where={"team_id": team_id, "budget_id": None}, - data={"budget_id": budget_id}, - ) -@pytest.mark.asyncio -async def test_backfill_team_member_budget_entries_empty_members(): - """ - backfill_team_member_budget_entries should be a no-op when the member list - is empty (no DB queries at all). - """ - from unittest.mock import AsyncMock, MagicMock - - from litellm.proxy.management_endpoints.team_endpoints import ( - TeamMemberBudgetHandler, - ) - - mock_prisma = MagicMock() - mock_prisma.db.litellm_teammembership.find_many = AsyncMock(return_value=[]) - mock_prisma.db.litellm_teammembership.create_many = AsyncMock(return_value=None) - - await TeamMemberBudgetHandler.backfill_team_member_budget_entries( - team_id="team-abc", - members_with_roles=[], - team_member_budget_id="budget-xyz", - prisma_client=mock_prisma, - ) - - mock_prisma.db.litellm_teammembership.find_many.assert_not_awaited() - mock_prisma.db.litellm_teammembership.create_many.assert_not_awaited() @pytest.mark.asyncio @@ -9978,7 +9373,7 @@ async def test_deleting_a_500_member_team_reaches_every_member_cache_on_other_wo team_membership_auth_cache_key, team_membership_reservation_cache_key, ) - from litellm.proxy.management_endpoints.team_endpoints import _evict_deleted_team_member_cache + from litellm.proxy.management_endpoints.team_endpoints import _evict_team_member_cache_keys, member_cache_keys redis: Final = _BroadcastRecordingRedis(round_trip_seconds=0.001) monkeypatch.setattr(pubsub_module, "coordination_redis_cache", lambda: redis) @@ -9986,8 +9381,11 @@ async def test_deleting_a_500_member_team_reaches_every_member_cache_on_other_wo monkeypatch.setattr(pubsub_module, "_in_flight_publishes", asyncio.Semaphore(16)) members: Final = tuple(f"member-{index:03d}" for index in range(500)) - await _evict_deleted_team_member_cache( - team_id="team-large", member_user_ids=members, user_api_key_cache=UserApiKeyCache() + await _evict_team_member_cache_keys( + team_id="team-large", + member_user_ids=members, + cache_keys=tuple(member_cache_keys("team-large", members)), + user_api_key_cache=UserApiKeyCache(), ) await asyncio.gather(*pubsub_module._pending_publishes) # pyright: ignore[reportPrivateUsage] # drain module-level tasks @@ -11612,45 +11010,6 @@ async def test_create_team_member_budget_table_with_duration(): assert result["metadata"]["team_member_budget_id"] == "budget-abc" -@pytest.mark.asyncio -async def test_upsert_team_member_model_max_budget_updates_default_budget_and_evicts_cache(): - from litellm.proxy.management_endpoints.team_endpoints import TeamMemberBudgetHandler - - model_budget: Final = {"gpt-4o": {"max_budget": 5.0, "budget_duration": "1d"}} - team_table: Final = LiteLLM_TeamTable( - team_id="test-team", - metadata={"team_member_budget_id": "member-budget-1"}, - members_with_roles=[], - ) - cache: Final = MagicMock() - cache.async_delete_cache = AsyncMock() - budget_cache: Final = MagicMock() - budget_cache.async_delete_cache = AsyncMock() - prisma: Final = MagicMock() - prisma.db.litellm_budgettable.update = AsyncMock(return_value=MagicMock(budget_id="member-budget-1")) - - with ( - patch("litellm.proxy.proxy_server.prisma_client", prisma), - patch("litellm.proxy.proxy_server.user_api_key_cache", budget_cache), - patch("litellm.proxy.proxy_server.premium_user", True), - ): - result: Final = await TeamMemberBudgetHandler.upsert_team_member_budget_table( - team_table=team_table, - user_api_key_dict=UserAPIKeyAuth(user_role=LitellmUserRoles.PROXY_ADMIN, user_id="admin"), - updated_kv={"team_id": "test-team", "team_member_model_max_budget": model_budget}, - team_member_model_max_budget=model_budget, - user_api_key_cache=cache, - explicitly_set_fields={"team_member_model_max_budget"}, - ) - - budget_update: Final = prisma.db.litellm_budgettable.update.call_args.kwargs - assert budget_update["where"]["budget_id"] == "member-budget-1" - assert budget_update["data"]["budget_id"] == "member-budget-1" - assert json.loads(budget_update["data"]["model_max_budget"]) == model_budget - assert result["metadata"]["team_member_budget_id"] == "member-budget-1" - assert "team_member_model_max_budget" not in result - cache.async_delete_cache.assert_awaited_once_with(key="team_member_default_budget:member-budget-1") - budget_cache.async_delete_cache.assert_awaited_once_with(key="team_member_default_budget:member-budget-1") @pytest.mark.asyncio @@ -11675,7 +11034,6 @@ async def test_update_team_clears_explicitly_null_member_model_budget_and_evicts updated.metadata = {"team_member_budget_id": "member-budget-1"} updated.model_dump.return_value.update({"metadata": updated.metadata, "members_with_roles": []}) updated.litellm_model_table = None - update_budget_response: Final = MagicMock(budget_id="member-budget-1") prisma: Final = MagicMock() with ( @@ -11687,7 +11045,7 @@ async def test_update_team_clears_explicitly_null_member_model_budget_and_evicts prisma.db.litellm_teamtable.find_unique = AsyncMock(return_value=existing) prisma.jsonify_team_object = lambda db_data: db_data prisma.db.litellm_teamtable.update = AsyncMock(return_value=updated) - prisma.db.litellm_budgettable.update = AsyncMock(return_value=update_budget_response) + _transaction_over(prisma) request_data: Final = UpdateTeamRequest(team_id="standalone-team-123", team_member_model_max_budget=None) await update_team( @@ -11696,16 +11054,10 @@ async def test_update_team_clears_explicitly_null_member_model_budget_and_evicts user_api_key_dict=UserAPIKeyAuth(user_role=LitellmUserRoles.PROXY_ADMIN, user_id="admin"), ) - budget_update: Final = prisma.db.litellm_budgettable.update.call_args.kwargs - assert budget_update["where"]["budget_id"] == "member-budget-1" - assert budget_update["data"]["budget_id"] == "member-budget-1" - assert budget_update["data"]["model_max_budget"] == "{}" - assert "team_member_model_max_budget" in request_data.model_fields_set - assert "model_max_budget" in budget_update["data"] - assert cache.async_delete_cache.await_args_list == [ - call(key="team_member_default_budget:member-budget-1"), - call(key="team_member_default_budget:member-budget-1"), - ] + budget_upsert: Final = prisma.db.litellm_budgettable.upsert.call_args.kwargs + assert budget_upsert["where"]["budget_id"] == "member-budget-1" + assert budget_upsert["data"]["update"]["model_max_budget"] == "{}" + assert cache.async_delete_cache.await_args_list == [call(key="team_member_default_budget:member-budget-1")] @pytest.mark.asyncio @@ -11731,7 +11083,6 @@ async def test_update_team_persists_member_model_budget_to_default_budget_row( updated.metadata = {"team_member_budget_id": "member-budget-1"} updated.model_dump.return_value.update({"metadata": updated.metadata, "members_with_roles": []}) updated.litellm_model_table = None - update_budget_response: Final = MagicMock(budget_id="member-budget-1") prisma: Final = MagicMock() with ( @@ -11743,7 +11094,7 @@ async def test_update_team_persists_member_model_budget_to_default_budget_row( prisma.db.litellm_teamtable.find_unique = AsyncMock(return_value=existing) prisma.jsonify_team_object = lambda db_data: db_data prisma.db.litellm_teamtable.update = AsyncMock(return_value=updated) - prisma.db.litellm_budgettable.update = AsyncMock(return_value=update_budget_response) + _transaction_over(prisma) await update_team( data=UpdateTeamRequest(team_id="standalone-team-123", team_member_model_max_budget=member_caps), @@ -11751,10 +11102,9 @@ async def test_update_team_persists_member_model_budget_to_default_budget_row( user_api_key_dict=UserAPIKeyAuth(user_role=LitellmUserRoles.PROXY_ADMIN, user_id="admin"), ) - budget_update: Final = prisma.db.litellm_budgettable.update.call_args.kwargs - assert budget_update["where"]["budget_id"] == "member-budget-1" - assert budget_update["data"]["budget_id"] == "member-budget-1" - stored_member_model_caps: Final = json.loads(budget_update["data"]["model_max_budget"]) + budget_upsert: Final = prisma.db.litellm_budgettable.upsert.call_args.kwargs + assert budget_upsert["where"]["budget_id"] == "member-budget-1" + stored_member_model_caps: Final = json.loads(budget_upsert["data"]["update"]["model_max_budget"]) assert { model: { **budget, @@ -11770,10 +11120,7 @@ async def test_update_team_persists_member_model_budget_to_default_budget_row( "rpm_limit": None, } } - assert cache.async_delete_cache.await_args_list == [ - call(key="team_member_default_budget:member-budget-1"), - call(key="team_member_default_budget:member-budget-1"), - ] + assert cache.async_delete_cache.await_args_list == [call(key="team_member_default_budget:member-budget-1")] # --------------------------------------------------------------------------- @@ -12795,209 +12142,12 @@ def test_set_budget_reset_at_sets_value_when_budget_duration_provided(): assert updated_kv["budget_reset_at"] is not None -@pytest.mark.asyncio -async def test_clear_team_member_budget_duration_calls_update_budget(): - """ - When team_member_budget_duration is explicitly null and a budget row - exists, clear_team_member_budget_fields should call update_budget - with budget_duration=None and budget_reset_at=None. - """ - from litellm.proxy.management_endpoints.team_endpoints import ( - TeamMemberBudgetHandler, - ) - - mock_user_api_key_dict = UserAPIKeyAuth( - user_role=LitellmUserRoles.PROXY_ADMIN, - api_key=MASTER_KEY, - user_id="admin-user", - ) - - team_table = LiteLLM_TeamTable( - team_id="test-team", - metadata={"team_member_budget_id": "budget-123"}, - members_with_roles=[], - ) - - updated_kv = { - "team_id": "test-team", - "team_member_budget_duration": None, - } - - with patch( - "litellm.proxy.management_endpoints.budget_management_endpoints.update_budget", - new_callable=AsyncMock, - ) as mock_update_budget: - result = await TeamMemberBudgetHandler.clear_team_member_budget_fields( - team_table=team_table, - user_api_key_dict=mock_user_api_key_dict, - updated_kv=updated_kv, - explicitly_set_fields={"team_member_budget_duration"}, - ) - - mock_update_budget.assert_awaited_once() - budget_request = mock_update_budget.call_args.kwargs["budget_obj"] - assert budget_request.budget_id == "budget-123" - assert "budget_duration" in budget_request.model_fields_set - assert budget_request.budget_duration is None - assert "budget_reset_at" in budget_request.model_fields_set - assert budget_request.budget_reset_at is None - assert "team_member_budget_duration" not in result -@pytest.mark.asyncio -async def test_clear_team_member_budget_clears_max_budget(): - """ - When team_member_budget is explicitly null, clear_team_member_budget_fields - should call update_budget with max_budget=None. - """ - from litellm.proxy.management_endpoints.team_endpoints import ( - TeamMemberBudgetHandler, - ) - - mock_user_api_key_dict = UserAPIKeyAuth( - user_role=LitellmUserRoles.PROXY_ADMIN, - api_key=MASTER_KEY, - user_id="admin-user", - ) - - team_table = LiteLLM_TeamTable( - team_id="test-team", - metadata={"team_member_budget_id": "budget-456"}, - members_with_roles=[], - ) - - updated_kv = { - "team_id": "test-team", - "team_member_budget": None, - } - - with patch( - "litellm.proxy.management_endpoints.budget_management_endpoints.update_budget", - new_callable=AsyncMock, - ) as mock_update_budget: - result = await TeamMemberBudgetHandler.clear_team_member_budget_fields( - team_table=team_table, - user_api_key_dict=mock_user_api_key_dict, - updated_kv=updated_kv, - explicitly_set_fields={"team_member_budget"}, - ) - - mock_update_budget.assert_awaited_once() - budget_request = mock_update_budget.call_args.kwargs["budget_obj"] - assert budget_request.budget_id == "budget-456" - assert "max_budget" in budget_request.model_fields_set - assert budget_request.max_budget is None - assert "team_member_budget" not in result -@pytest.mark.asyncio -async def test_clear_team_member_rpm_tpm_limits(): - """ - When team_member_rpm_limit and team_member_tpm_limit are explicitly null, - clear_team_member_budget_fields should clear both on the budget row. - """ - from litellm.proxy.management_endpoints.team_endpoints import ( - TeamMemberBudgetHandler, - ) - - mock_user_api_key_dict = UserAPIKeyAuth( - user_role=LitellmUserRoles.PROXY_ADMIN, - api_key=MASTER_KEY, - user_id="admin-user", - ) - - team_table = LiteLLM_TeamTable( - team_id="test-team", - metadata={"team_member_budget_id": "budget-789"}, - members_with_roles=[], - ) - - updated_kv = { - "team_id": "test-team", - "team_member_rpm_limit": None, - "team_member_tpm_limit": None, - } - - with patch( - "litellm.proxy.management_endpoints.budget_management_endpoints.update_budget", - new_callable=AsyncMock, - ) as mock_update_budget: - result = await TeamMemberBudgetHandler.clear_team_member_budget_fields( - team_table=team_table, - user_api_key_dict=mock_user_api_key_dict, - updated_kv=updated_kv, - explicitly_set_fields={"team_member_rpm_limit", "team_member_tpm_limit"}, - ) - - mock_update_budget.assert_awaited_once() - budget_request = mock_update_budget.call_args.kwargs["budget_obj"] - assert budget_request.budget_id == "budget-789" - assert "rpm_limit" in budget_request.model_fields_set - assert budget_request.rpm_limit is None - assert "tpm_limit" in budget_request.model_fields_set - assert budget_request.tpm_limit is None - assert "team_member_rpm_limit" not in result - assert "team_member_tpm_limit" not in result -@pytest.mark.asyncio -async def test_clear_all_team_member_fields_at_once(): - """ - When all team_member fields are explicitly null, all corresponding - budget row fields should be cleared in a single update. - """ - from litellm.proxy.management_endpoints.team_endpoints import ( - TeamMemberBudgetHandler, - ) - - mock_user_api_key_dict = UserAPIKeyAuth( - user_role=LitellmUserRoles.PROXY_ADMIN, - api_key=MASTER_KEY, - user_id="admin-user", - ) - - team_table = LiteLLM_TeamTable( - team_id="test-team", - metadata={"team_member_budget_id": "budget-all"}, - members_with_roles=[], - ) - - updated_kv = { - "team_id": "test-team", - "team_member_budget": None, - "team_member_budget_duration": None, - "team_member_rpm_limit": None, - "team_member_tpm_limit": None, - } - - all_fields = { - "team_member_budget", - "team_member_budget_duration", - "team_member_rpm_limit", - "team_member_tpm_limit", - } - - with patch( - "litellm.proxy.management_endpoints.budget_management_endpoints.update_budget", - new_callable=AsyncMock, - ) as mock_update_budget: - result = await TeamMemberBudgetHandler.clear_team_member_budget_fields( - team_table=team_table, - user_api_key_dict=mock_user_api_key_dict, - updated_kv=updated_kv, - explicitly_set_fields=all_fields, - ) - - mock_update_budget.assert_awaited_once() - budget_request = mock_update_budget.call_args.kwargs["budget_obj"] - assert budget_request.budget_id == "budget-all" - assert budget_request.max_budget is None - assert budget_request.budget_duration is None - assert budget_request.budget_reset_at is None - assert budget_request.rpm_limit is None - assert budget_request.tpm_limit is None - for field in all_fields: - assert field not in result @pytest.mark.asyncio @@ -13031,44 +12181,6 @@ async def test_team_member_budget_duration_not_sent_does_not_update(): assert "team_member_budget" not in updated_kv -@pytest.mark.asyncio -async def test_clear_team_member_budget_fields_no_budget_row_skips_update(): - from litellm.proxy.management_endpoints.team_endpoints import ( - TeamMemberBudgetHandler, - ) - - mock_user_api_key_dict = UserAPIKeyAuth( - user_role=LitellmUserRoles.PROXY_ADMIN, - api_key=MASTER_KEY, - user_id="admin-user", - ) - - team_table = LiteLLM_TeamTable( - team_id="test-team", - metadata=None, - members_with_roles=[], - ) - - updated_kv = { - "team_id": "test-team", - "team_member_budget": None, - "team_member_rpm_limit": None, - } - - with patch( - "litellm.proxy.management_endpoints.budget_management_endpoints.update_budget", - new_callable=AsyncMock, - ) as mock_update_budget: - result = await TeamMemberBudgetHandler.clear_team_member_budget_fields( - team_table=team_table, - user_api_key_dict=mock_user_api_key_dict, - updated_kv=updated_kv, - explicitly_set_fields={"team_member_budget", "team_member_rpm_limit"}, - ) - - mock_update_budget.assert_not_awaited() - assert "team_member_budget" not in result - assert "team_member_rpm_limit" not in result @pytest.mark.asyncio @@ -13435,6 +12547,7 @@ async def _drive_team_write( return_value=LiteLLM_TeamTable(team_id=_PATCH_TEAM_ID, team_alias="t") ) pc.jsonify_team_object = MagicMock(side_effect=lambda db_data: db_data) + _transaction_over(pc) if mock_sink is not None: mock_sink["update"] = pc.db.litellm_teamtable.update @@ -13567,14 +12680,8 @@ _STORED_METADATA_WITH_BUDGET: Final = { async def _written_metadata_with_budget(kind, body): """Like ``_written_metadata`` but the team already owns a member budget row.""" - from litellm.proxy._types import LiteLLM_BudgetTable - - with ( - patch("litellm.proxy.proxy_server.premium_user", True), # test-quality-ok: proxy_server module global is the endpoint's only injection point - patch( # test-quality-ok: update_team imports update_budget at call time; the module attribute is its only seam - "litellm.proxy.management_endpoints.budget_management_endpoints.update_budget", - AsyncMock(return_value=LiteLLM_BudgetTable(budget_id="budget-existing-123")), - ), + with patch( # test-quality-ok: proxy_server module global is the endpoint's only injection point + "litellm.proxy.proxy_server.premium_user", True ): return await _written_metadata(kind, dict(_STORED_METADATA_WITH_BUDGET), body) @@ -16743,25 +15850,6 @@ async def test_evict_created_membership_caches_drops_the_negative_sentinel(): assert await cache.async_get_cache(key=kept_key) == NO_TEAM_MEMBERSHIP_SENTINEL -def test_member_user_ids_keeps_only_string_user_ids(): - """ - The /team/update backfill feeds Prisma-deserialized member dicts here; a row can be missing - user_id or carry a non-string value. Only real string ids may reach invalidate_team_member_spend_state, - so those get eviction and the malformed rows are dropped rather than crashing the update. - """ - from litellm.proxy.management_endpoints.team_endpoints import _member_user_ids - - members = [ - {"user_id": "alice", "role": "admin"}, - {"role": "user"}, - {"user_id": None, "role": "user"}, - {"user_id": 123, "role": "user"}, - {"user_id": "bob", "role": "user"}, - ] - - assert _member_user_ids(members) == ("alice", "bob") - - def _team_spend_by_user_team(team_id: str, team_alias: str, member: Member, permissions: list[str]) -> MagicMock: team = MagicMock(spec=LiteLLM_TeamTable) team.team_id = team_id @@ -17292,6 +16380,23 @@ async def test_new_team_rejects_unenforceable_model_max_budget(mock_db_client, m mock_db_client.db.litellm_teamtable.create.assert_not_awaited() +def _transaction_over(prisma: MagicMock) -> MagicMock: + """A transaction that writes through ``prisma.db``'s own table mocks, as the real one writes the same rows.""" + tx: Final = MagicMock() + tx.litellm_teamtable = prisma.db.litellm_teamtable + tx.litellm_budgettable = prisma.db.litellm_budgettable + tx.query_raw = AsyncMock(return_value=[{"members_with_roles": []}]) + tx.execute_raw = AsyncMock(return_value=0) + prisma.db.litellm_budgettable.upsert = AsyncMock() + + @contextlib.asynccontextmanager + async def transaction(**_options: object): + yield tx + + prisma.tx = transaction + return tx + + def _existing_team_with_model_caps(caps): existing = MagicMock() existing.team_id = "standalone-team-123" diff --git a/tests/unit/proxy/management_helpers/test_management_helpers_utils.py b/tests/unit/proxy/management_helpers/test_management_helpers_utils.py index 644f0656c7a..d16ec9921a2 100644 --- a/tests/unit/proxy/management_helpers/test_management_helpers_utils.py +++ b/tests/unit/proxy/management_helpers/test_management_helpers_utils.py @@ -44,9 +44,7 @@ async def test_management_otel_span_redacts_mcp_global_env_var_secrets(monkeypat captured = {} class _FakeOtelLogger: - async def async_management_endpoint_success_hook( - self, logging_payload, parent_otel_span - ): + async def async_management_endpoint_success_hook(self, logging_payload, parent_otel_span): captured["response"] = logging_payload.response from litellm.proxy import proxy_server @@ -119,9 +117,7 @@ async def test_management_otel_span_redacts_nested_submission_env_var_secrets( captured = {} class _FakeOtelLogger: - async def async_management_endpoint_success_hook( - self, logging_payload, parent_otel_span - ): + async def async_management_endpoint_success_hook(self, logging_payload, parent_otel_span): captured["response"] = logging_payload.response from litellm.proxy import proxy_server @@ -141,9 +137,7 @@ async def test_management_otel_span_redacts_nested_submission_env_var_secrets( created_at=datetime.datetime.now(), updated_at=datetime.datetime.now(), ) - result = MCPSubmissionsSummary( - total=1, pending_review=1, active=0, rejected=0, items=[server] - ) + result = MCPSubmissionsSummary(total=1, pending_review=1, active=0, rejected=0, items=[server]) await mgmt_utils._emit_management_endpoint_otel_span( func=lambda: None, @@ -158,11 +152,7 @@ async def test_management_otel_span_redacts_nested_submission_env_var_secrets( assert secret not in str(captured["response"]) redacted_item = captured["response"]["items"][0] - redacted_env_vars = ( - redacted_item["env_vars"] - if isinstance(redacted_item, dict) - else redacted_item.env_vars - ) + redacted_env_vars = redacted_item["env_vars"] if isinstance(redacted_item, dict) else redacted_item.env_vars assert [entry["value"] for entry in redacted_env_vars] == [""] assert redacted_env_vars[0]["name"] == "DB_PASSWORD" # The endpoint's own return value is untouched for the admin UI. @@ -180,9 +170,7 @@ async def test_add_new_member_links_default_team_budget_id(): new_member = Member(user_id=test_user_id, role="user") - user_api_key_dict = UserAPIKeyAuth( - user_id="admin_user", user_role=LitellmUserRoles.PROXY_ADMIN - ) + user_api_key_dict = UserAPIKeyAuth(user_id="admin_user", user_role=LitellmUserRoles.PROXY_ADMIN) mock_prisma_client = AsyncMock() @@ -195,15 +183,11 @@ async def test_add_new_member_links_default_team_budget_id(): "user_role": "internal_user", } mock_prisma_client.db.litellm_usertable.upsert = AsyncMock(return_value=mock_user_response) - mock_prisma_client.db.litellm_usertable.find_unique = AsyncMock( - return_value=mock_user_response - ) + mock_prisma_client.db.litellm_usertable.find_unique = AsyncMock(return_value=mock_user_response) mock_default_budget_row = MagicMock() mock_default_budget_row.budget_id = test_default_budget_id - mock_prisma_client.db.litellm_budgettable.find_unique = AsyncMock( - return_value=mock_default_budget_row - ) + mock_prisma_client.db.litellm_budgettable.find_unique = AsyncMock(return_value=mock_default_budget_row) mock_prisma_client.db.litellm_budgettable.create = AsyncMock() # Mock the team membership creation @@ -214,9 +198,7 @@ async def test_add_new_member_links_default_team_budget_id(): "budget_id": test_default_budget_id, "litellm_budget_table": None, } - mock_prisma_client.db.litellm_teammembership.upsert = AsyncMock( - return_value=mock_team_membership_response - ) + mock_prisma_client.db.litellm_teammembership.upsert = AsyncMock(return_value=mock_team_membership_response) result_user, result_team_membership = await add_new_member( new_member=new_member, @@ -242,9 +224,7 @@ async def test_add_new_member_links_default_team_budget_id(): ) mock_prisma_client.db.litellm_budgettable.create.assert_not_called() - team_membership_call_args = ( - mock_prisma_client.db.litellm_teammembership.upsert.call_args - ) + team_membership_call_args = mock_prisma_client.db.litellm_teammembership.upsert.call_args create_data = team_membership_call_args.kwargs["data"]["create"] assert create_data["budget_id"] == test_default_budget_id @@ -314,9 +294,7 @@ async def test_add_new_member_no_budget_when_default_budget_row_is_missing(): from litellm.proxy._types import LitellmUserRoles new_member = Member(user_id="missing-default-user", role="user") - user_api_key_dict = UserAPIKeyAuth( - user_id="admin_user", user_role=LitellmUserRoles.PROXY_ADMIN - ) + user_api_key_dict = UserAPIKeyAuth(user_id="admin_user", user_role=LitellmUserRoles.PROXY_ADMIN) mock_prisma_client = AsyncMock() mock_user_response = MagicMock() @@ -327,9 +305,7 @@ async def test_add_new_member_no_budget_when_default_budget_row_is_missing(): "user_role": "internal_user", } mock_prisma_client.db.litellm_usertable.upsert = AsyncMock(return_value=mock_user_response) - mock_prisma_client.db.litellm_usertable.find_unique = AsyncMock( - return_value=mock_user_response - ) + mock_prisma_client.db.litellm_usertable.find_unique = AsyncMock(return_value=mock_user_response) mock_prisma_client.db.litellm_budgettable.find_unique = AsyncMock(return_value=None) mock_prisma_client.db.litellm_budgettable.create = AsyncMock() mock_membership = MagicMock() @@ -367,9 +343,7 @@ async def test_add_new_member_budget_duration_only_clones_default_max_budget(): from litellm.proxy._types import LitellmUserRoles new_member = Member(user_id="dur-clone-user", role="user") - user_api_key_dict = UserAPIKeyAuth( - user_id="admin_user", user_role=LitellmUserRoles.PROXY_ADMIN - ) + user_api_key_dict = UserAPIKeyAuth(user_id="admin_user", user_role=LitellmUserRoles.PROXY_ADMIN) mock_prisma_client = AsyncMock() mock_user_response = MagicMock() @@ -380,9 +354,7 @@ async def test_add_new_member_budget_duration_only_clones_default_max_budget(): "user_role": "internal_user", } mock_prisma_client.db.litellm_usertable.upsert = AsyncMock(return_value=mock_user_response) - mock_prisma_client.db.litellm_usertable.find_unique = AsyncMock( - return_value=mock_user_response - ) + mock_prisma_client.db.litellm_usertable.find_unique = AsyncMock(return_value=mock_user_response) mock_default_budget_row = MagicMock() mock_default_budget_row.model_dump.return_value = { "budget_id": "default-dc", @@ -395,14 +367,10 @@ async def test_add_new_member_budget_duration_only_clones_default_max_budget(): "budget_duration": "1d", "allowed_models": [], } - mock_prisma_client.db.litellm_budgettable.find_unique = AsyncMock( - return_value=mock_default_budget_row - ) + mock_prisma_client.db.litellm_budgettable.find_unique = AsyncMock(return_value=mock_default_budget_row) mock_cloned_budget_row = MagicMock() mock_cloned_budget_row.budget_id = "cloned-dc" - mock_prisma_client.db.litellm_budgettable.create = AsyncMock( - return_value=mock_cloned_budget_row - ) + mock_prisma_client.db.litellm_budgettable.create = AsyncMock(return_value=mock_cloned_budget_row) mock_team_membership_response = MagicMock() mock_team_membership_response.model_dump.return_value = { "team_id": "team-dc", @@ -410,9 +378,7 @@ async def test_add_new_member_budget_duration_only_clones_default_max_budget(): "budget_id": "cloned-dc", "litellm_budget_table": None, } - mock_prisma_client.db.litellm_teammembership.upsert = AsyncMock( - return_value=mock_team_membership_response - ) + mock_prisma_client.db.litellm_teammembership.upsert = AsyncMock(return_value=mock_team_membership_response) await add_new_member( new_member=new_member, @@ -426,9 +392,7 @@ async def test_add_new_member_budget_duration_only_clones_default_max_budget(): ) mock_prisma_client.db.litellm_budgettable.create.assert_called_once() - cloned_create_data = ( - mock_prisma_client.db.litellm_budgettable.create.call_args.kwargs["data"] - ) + cloned_create_data = mock_prisma_client.db.litellm_budgettable.create.call_args.kwargs["data"] assert cloned_create_data["max_budget"] == 100.0 # kept from the team default assert cloned_create_data["budget_duration"] == "7d" # overridden by the caller assert cloned_create_data["budget_reset_at"] > datetime.now(timezone.utc) @@ -451,9 +415,7 @@ async def test_add_new_member_no_budget_when_no_default_and_no_max_budget(): new_member = Member(user_id=test_user_id, role="user") - user_api_key_dict = UserAPIKeyAuth( - user_id="admin_user", user_role=LitellmUserRoles.PROXY_ADMIN - ) + user_api_key_dict = UserAPIKeyAuth(user_id="admin_user", user_role=LitellmUserRoles.PROXY_ADMIN) mock_prisma_client = AsyncMock() @@ -465,9 +427,7 @@ async def test_add_new_member_no_budget_when_no_default_and_no_max_budget(): "user_role": "internal_user", } mock_prisma_client.db.litellm_usertable.upsert = AsyncMock(return_value=mock_user_response) - mock_prisma_client.db.litellm_usertable.find_unique = AsyncMock( - return_value=mock_user_response - ) + mock_prisma_client.db.litellm_usertable.find_unique = AsyncMock(return_value=mock_user_response) # Even though we mock these, they must NOT be called on the no-budget path. mock_prisma_client.db.litellm_budgettable.find_unique = AsyncMock() @@ -482,9 +442,7 @@ async def test_add_new_member_no_budget_when_no_default_and_no_max_budget(): "total_spend": 0.0, "litellm_budget_table": None, } - mock_prisma_client.db.litellm_teammembership.upsert = AsyncMock( - return_value=mock_team_membership_response - ) + mock_prisma_client.db.litellm_teammembership.upsert = AsyncMock(return_value=mock_team_membership_response) result_user, result_team_membership = await add_new_member( new_member=new_member, @@ -508,9 +466,7 @@ async def test_add_new_member_no_budget_when_no_default_and_no_max_budget(): assert result_team_membership.budget_id is None mock_prisma_client.db.litellm_teammembership.upsert.assert_awaited_once() upsert_kwargs = mock_prisma_client.db.litellm_teammembership.upsert.call_args.kwargs - assert upsert_kwargs["where"] == { - "user_id_team_id": {"user_id": test_user_id, "team_id": test_team_id} - } + assert upsert_kwargs["where"] == {"user_id_team_id": {"user_id": test_user_id, "team_id": test_team_id}} assert upsert_kwargs["data"]["create"] == {"user_id": test_user_id, "team_id": test_team_id} assert "budget_id" not in upsert_kwargs["data"]["update"] @@ -540,9 +496,7 @@ async def test_add_new_member_creates_new_budget_when_max_budget_provided(): new_member = Member(user_id=test_user_id, role="user") # Create UserAPIKeyAuth object - user_api_key_dict = UserAPIKeyAuth( - user_id="admin_user", user_role=LitellmUserRoles.PROXY_ADMIN - ) + user_api_key_dict = UserAPIKeyAuth(user_id="admin_user", user_role=LitellmUserRoles.PROXY_ADMIN) # Mock the prisma client mock_prisma_client = AsyncMock() @@ -556,16 +510,12 @@ async def test_add_new_member_creates_new_budget_when_max_budget_provided(): "user_role": "internal_user", } mock_prisma_client.db.litellm_usertable.upsert = AsyncMock(return_value=mock_user_response) - mock_prisma_client.db.litellm_usertable.find_unique = AsyncMock( - return_value=mock_user_response - ) + mock_prisma_client.db.litellm_usertable.find_unique = AsyncMock(return_value=mock_user_response) # Mock the budget table creation mock_budget_response = MagicMock() mock_budget_response.budget_id = test_new_budget_id - mock_prisma_client.db.litellm_budgettable.create = AsyncMock( - return_value=mock_budget_response - ) + mock_prisma_client.db.litellm_budgettable.create = AsyncMock(return_value=mock_budget_response) # Mock the team membership creation mock_team_membership_response = MagicMock() @@ -575,9 +525,7 @@ async def test_add_new_member_creates_new_budget_when_max_budget_provided(): "budget_id": test_new_budget_id, "litellm_budget_table": None, } - mock_prisma_client.db.litellm_teammembership.upsert = AsyncMock( - return_value=mock_team_membership_response - ) + mock_prisma_client.db.litellm_teammembership.upsert = AsyncMock(return_value=mock_team_membership_response) # Call the function with max_budget_in_team provided result_user, result_team_membership = await add_new_member( @@ -603,9 +551,7 @@ async def test_add_new_member_creates_new_budget_when_max_budget_provided(): assert result_team_membership.budget_id == test_new_budget_id # Verify the team membership was created with the correct budget_id - team_membership_call_args = ( - mock_prisma_client.db.litellm_teammembership.upsert.call_args - ) + team_membership_call_args = mock_prisma_client.db.litellm_teammembership.upsert.call_args assert team_membership_call_args is not None create_data = team_membership_call_args.kwargs["data"]["create"] assert create_data["budget_id"] == test_new_budget_id @@ -621,9 +567,7 @@ async def test_add_new_member_persists_budget_duration(): from litellm.proxy._types import LitellmUserRoles new_member = Member(user_id="user-dur", role="user") - user_api_key_dict = UserAPIKeyAuth( - user_id="admin_user", user_role=LitellmUserRoles.PROXY_ADMIN - ) + user_api_key_dict = UserAPIKeyAuth(user_id="admin_user", user_role=LitellmUserRoles.PROXY_ADMIN) mock_prisma_client = AsyncMock() mock_user_response = MagicMock() @@ -634,14 +578,10 @@ async def test_add_new_member_persists_budget_duration(): "user_role": "internal_user", } mock_prisma_client.db.litellm_usertable.upsert = AsyncMock(return_value=mock_user_response) - mock_prisma_client.db.litellm_usertable.find_unique = AsyncMock( - return_value=mock_user_response - ) + mock_prisma_client.db.litellm_usertable.find_unique = AsyncMock(return_value=mock_user_response) mock_budget_response = MagicMock() mock_budget_response.budget_id = "budget-dur" - mock_prisma_client.db.litellm_budgettable.create = AsyncMock( - return_value=mock_budget_response - ) + mock_prisma_client.db.litellm_budgettable.create = AsyncMock(return_value=mock_budget_response) mock_team_membership_response = MagicMock() mock_team_membership_response.model_dump.return_value = { "team_id": "team-dur", @@ -649,9 +589,7 @@ async def test_add_new_member_persists_budget_duration(): "budget_id": "budget-dur", "litellm_budget_table": None, } - mock_prisma_client.db.litellm_teammembership.upsert = AsyncMock( - return_value=mock_team_membership_response - ) + mock_prisma_client.db.litellm_teammembership.upsert = AsyncMock(return_value=mock_team_membership_response) await add_new_member( new_member=new_member, @@ -666,9 +604,7 @@ async def test_add_new_member_persists_budget_duration(): ) mock_prisma_client.db.litellm_budgettable.create.assert_called_once() - budget_data = mock_prisma_client.db.litellm_budgettable.create.call_args.kwargs[ - "data" - ] + budget_data = mock_prisma_client.db.litellm_budgettable.create.call_args.kwargs["data"] assert budget_data["max_budget"] == 10.0 assert budget_data["allowed_models"] == ["gpt-4o-mini"] assert budget_data["budget_duration"] == "30d" @@ -685,9 +621,7 @@ async def test_add_new_member_persists_budget_duration_without_max_budget(): from litellm.proxy._types import LitellmUserRoles new_member = Member(user_id="user-dur2", role="user") - user_api_key_dict = UserAPIKeyAuth( - user_id="admin_user", user_role=LitellmUserRoles.PROXY_ADMIN - ) + user_api_key_dict = UserAPIKeyAuth(user_id="admin_user", user_role=LitellmUserRoles.PROXY_ADMIN) mock_prisma_client = AsyncMock() mock_user_response = MagicMock() @@ -698,14 +632,10 @@ async def test_add_new_member_persists_budget_duration_without_max_budget(): "user_role": "internal_user", } mock_prisma_client.db.litellm_usertable.upsert = AsyncMock(return_value=mock_user_response) - mock_prisma_client.db.litellm_usertable.find_unique = AsyncMock( - return_value=mock_user_response - ) + mock_prisma_client.db.litellm_usertable.find_unique = AsyncMock(return_value=mock_user_response) mock_budget_response = MagicMock() mock_budget_response.budget_id = "budget-dur2" - mock_prisma_client.db.litellm_budgettable.create = AsyncMock( - return_value=mock_budget_response - ) + mock_prisma_client.db.litellm_budgettable.create = AsyncMock(return_value=mock_budget_response) mock_team_membership_response = MagicMock() mock_team_membership_response.model_dump.return_value = { "team_id": "team-dur2", @@ -713,9 +643,7 @@ async def test_add_new_member_persists_budget_duration_without_max_budget(): "budget_id": "budget-dur2", "litellm_budget_table": None, } - mock_prisma_client.db.litellm_teammembership.upsert = AsyncMock( - return_value=mock_team_membership_response - ) + mock_prisma_client.db.litellm_teammembership.upsert = AsyncMock(return_value=mock_team_membership_response) _, result_team_membership = await add_new_member( new_member=new_member, @@ -729,9 +657,7 @@ async def test_add_new_member_persists_budget_duration_without_max_budget(): ) mock_prisma_client.db.litellm_budgettable.create.assert_called_once() - budget_data = mock_prisma_client.db.litellm_budgettable.create.call_args.kwargs[ - "data" - ] + budget_data = mock_prisma_client.db.litellm_budgettable.create.call_args.kwargs["data"] assert budget_data["budget_duration"] == "7d" assert budget_data["budget_reset_at"] > datetime.now(timezone.utc) assert result_team_membership is not None @@ -749,9 +675,7 @@ async def test_add_new_member_with_user_email_links_default_budget(): new_member = Member(user_email=test_user_email, role="user") - user_api_key_dict = UserAPIKeyAuth( - user_id="admin_user", user_role=LitellmUserRoles.PROXY_ADMIN - ) + user_api_key_dict = UserAPIKeyAuth(user_id="admin_user", user_role=LitellmUserRoles.PROXY_ADMIN) mock_prisma_client = AsyncMock() @@ -768,9 +692,7 @@ async def test_add_new_member_with_user_email_links_default_budget(): mock_default_budget_row = MagicMock() mock_default_budget_row.budget_id = test_default_budget_id - mock_prisma_client.db.litellm_budgettable.find_unique = AsyncMock( - return_value=mock_default_budget_row - ) + mock_prisma_client.db.litellm_budgettable.find_unique = AsyncMock(return_value=mock_default_budget_row) mock_prisma_client.db.litellm_budgettable.create = AsyncMock() mock_team_membership_response = MagicMock() @@ -780,9 +702,7 @@ async def test_add_new_member_with_user_email_links_default_budget(): "budget_id": test_default_budget_id, "litellm_budget_table": None, } - mock_prisma_client.db.litellm_teammembership.upsert = AsyncMock( - return_value=mock_team_membership_response - ) + mock_prisma_client.db.litellm_teammembership.upsert = AsyncMock(return_value=mock_team_membership_response) result_user, result_team_membership = await add_new_member( new_member=new_member, @@ -905,7 +825,6 @@ async def test_team_update_reaches_inherited_members_but_not_overridden_ones(): from litellm.proxy._types import LitellmUserRoles from litellm.proxy.auth.auth_checks import _check_team_member_budget from litellm.proxy.management_endpoints.common_utils import upsert_budget_and_membership - from litellm.proxy.management_endpoints.team_endpoints import TeamMemberBudgetHandler from litellm.proxy.utils import ProxyLogging db: Final = _FakeDb() @@ -940,15 +859,7 @@ async def test_team_update_reaches_inherited_members_but_not_overridden_ones(): assert db.litellm_teammembership.membership(team_id, "overridden").budget_id != default_budget.budget_id assert db.litellm_budgettable.rows[default_budget.budget_id]["max_budget"] == 100.0 - with patch( # test-quality-ok: update_budget reads this module global; no dependency injection seam exists - "litellm.proxy.proxy_server.prisma_client", prisma_client - ): - await TeamMemberBudgetHandler.upsert_team_member_budget_table( - team_table=team, - user_api_key_dict=admin, - updated_kv={}, - team_member_budget=1.0, - ) + await db.litellm_budgettable.update(where={"budget_id": default_budget.budget_id}, data={"max_budget": 1.0}) async def spend_from_membership(counter_key: str, fallback_spend: float, max_budget: float | None = None) -> float: return fallback_spend @@ -1011,14 +922,10 @@ async def test_attach_object_permission_to_dict_with_object_permission_id(): mock_object_permission.model_dump.return_value = expected_object_permission # Mock the database query - mock_prisma_client.db.litellm_objectpermissiontable.find_unique = AsyncMock( - return_value=mock_object_permission - ) + mock_prisma_client.db.litellm_objectpermissiontable.find_unique = AsyncMock(return_value=mock_object_permission) # Call the function - result = await attach_object_permission_to_dict( - data_dict=test_data_dict, prisma_client=mock_prisma_client - ) + result = await attach_object_permission_to_dict(data_dict=test_data_dict, prisma_client=mock_prisma_client) # Verify the result assert result is not None @@ -1050,9 +957,7 @@ async def test_attach_object_permission_to_dict_without_object_permission_id(): mock_prisma_client = AsyncMock() # Call the function - result = await attach_object_permission_to_dict( - data_dict=test_data_dict, prisma_client=mock_prisma_client - ) + result = await attach_object_permission_to_dict(data_dict=test_data_dict, prisma_client=mock_prisma_client) # Verify the result is unchanged assert result == test_data_dict @@ -1084,14 +989,10 @@ async def test_attach_object_permission_to_dict_object_permission_not_found(): mock_prisma_client = AsyncMock() # Mock the database query to return None (not found) - mock_prisma_client.db.litellm_objectpermissiontable.find_unique = AsyncMock( - return_value=None - ) + mock_prisma_client.db.litellm_objectpermissiontable.find_unique = AsyncMock(return_value=None) # Call the function - result = await attach_object_permission_to_dict( - data_dict=test_data_dict, prisma_client=mock_prisma_client - ) + result = await attach_object_permission_to_dict(data_dict=test_data_dict, prisma_client=mock_prisma_client) # Verify the result is unchanged assert result == test_data_dict @@ -1132,20 +1033,14 @@ async def test_attach_object_permission_to_dict_with_dict_method(): # Mock the object permission response that uses .dict() method mock_object_permission = MagicMock() - mock_object_permission.model_dump.side_effect = AttributeError( - "No model_dump method" - ) + mock_object_permission.model_dump.side_effect = AttributeError("No model_dump method") mock_object_permission.dict.return_value = expected_object_permission # Mock the database query - mock_prisma_client.db.litellm_objectpermissiontable.find_unique = AsyncMock( - return_value=mock_object_permission - ) + mock_prisma_client.db.litellm_objectpermissiontable.find_unique = AsyncMock(return_value=mock_object_permission) # Call the function - result = await attach_object_permission_to_dict( - data_dict=test_data_dict, prisma_client=mock_prisma_client - ) + result = await attach_object_permission_to_dict(data_dict=test_data_dict, prisma_client=mock_prisma_client) # Verify the result assert result is not None @@ -1174,7 +1069,8 @@ async def test_attach_object_permission_to_dict_with_none_prisma_client(): # Call the function with None prisma_client with pytest.raises(ValueError, match="Prisma client not found"): await attach_object_permission_to_dict( - data_dict=test_data_dict, prisma_client=None # type: ignore + data_dict=test_data_dict, + prisma_client=None, # type: ignore ) @@ -1194,9 +1090,7 @@ async def test_attach_object_permission_to_dict_with_empty_dict(): mock_prisma_client = AsyncMock() # Call the function - result = await attach_object_permission_to_dict( - data_dict=test_data_dict, prisma_client=mock_prisma_client - ) + result = await attach_object_permission_to_dict(data_dict=test_data_dict, prisma_client=mock_prisma_client) # Verify the result is unchanged assert result == {} @@ -1226,9 +1120,7 @@ async def test_attach_object_permission_to_dict_with_none_object_permission_id() mock_prisma_client = AsyncMock() # Call the function - result = await attach_object_permission_to_dict( - data_dict=test_data_dict, prisma_client=mock_prisma_client - ) + result = await attach_object_permission_to_dict(data_dict=test_data_dict, prisma_client=mock_prisma_client) # Verify the result is unchanged assert result == test_data_dict @@ -1254,9 +1146,7 @@ async def test_add_new_member_appends_team_only_if_absent_for_existing_user(): from litellm.proxy._types import LitellmUserRoles new_member = Member(user_id="existing-user", role="user") - user_api_key_dict = UserAPIKeyAuth( - user_id="admin_user", user_role=LitellmUserRoles.PROXY_ADMIN - ) + user_api_key_dict = UserAPIKeyAuth(user_id="admin_user", user_role=LitellmUserRoles.PROXY_ADMIN) mock_prisma_client = AsyncMock() @@ -1327,9 +1217,7 @@ async def test_add_new_member_creates_missing_user_atomically_via_upsert(): from litellm.proxy._types import LitellmUserRoles new_member = Member(user_id="brand-new-user", role="user") - user_api_key_dict = UserAPIKeyAuth( - user_id="admin_user", user_role=LitellmUserRoles.PROXY_ADMIN - ) + user_api_key_dict = UserAPIKeyAuth(user_id="admin_user", user_role=LitellmUserRoles.PROXY_ADMIN) mock_prisma_client = AsyncMock() @@ -1433,9 +1321,7 @@ async def test_add_new_member_runs_every_write_on_the_caller_transaction(new_mem max_budget_in_team=50.0, prisma_client=prisma_client, team_id="team-pool", - user_api_key_dict=UserAPIKeyAuth( - user_id="admin_user", user_role=LitellmUserRoles.PROXY_ADMIN - ), + user_api_key_dict=UserAPIKeyAuth(user_id="admin_user", user_role=LitellmUserRoles.PROXY_ADMIN), litellm_proxy_admin_name="admin", tx=tx, ) diff --git a/tests/unit/proxy/management_helpers/test_team_member_default_budget.py b/tests/unit/proxy/management_helpers/test_team_member_default_budget.py new file mode 100644 index 00000000000..a3a7fa5dcce --- /dev/null +++ b/tests/unit/proxy/management_helpers/test_team_member_default_budget.py @@ -0,0 +1,88 @@ +import json +from datetime import datetime, timezone + +import pytest +from pydantic import ValidationError + +from litellm.proxy._types import UpdateTeamRequest +from litellm.proxy.management_helpers.team_member_default_budget import plan_team_member_default_budget_write + + +def _plan(existing_budget_id: str | None = None, team_budget_duration: str | None = None, **fields: object): + return plan_team_member_default_budget_write( + data=UpdateTeamRequest(team_id="team-1", **fields), + existing_budget_id=existing_budget_id, + team_alias="My Team", + team_budget_duration=team_budget_duration, + ) + + +def test_a_request_without_member_defaults_writes_nothing(): + assert _plan(existing_budget_id="default-1", max_budget=10.0) is None + + +def test_clearing_a_default_the_team_never_had_writes_nothing(): + assert _plan(team_member_budget=None) is None + + +def test_clearing_an_existing_default_updates_it_without_relinking_members(): + write = _plan(existing_budget_id="default-1", team_member_budget=None, team_member_model_max_budget=None) + + assert write is not None + assert write.budget_id == "default-1" + assert dict(write.update) == {"max_budget": None, "model_max_budget": {}} + assert write.links_members is False + + +def test_a_first_default_gets_a_new_row_that_inherits_the_team_reset_period(): + before = datetime.now(timezone.utc) + + write = _plan(team_budget_duration="30d", team_member_budget=25.0) + + assert write is not None + assert write.budget_id.startswith("team-My-Team-budget-") + assert write.create["max_budget"] == 25.0 + assert write.create["budget_duration"] == "30d" + assert write.create["budget_reset_at"] > before + assert write.links_members is True + + +def test_an_explicit_null_reset_period_is_not_replaced_by_the_team_period(): + write = _plan(team_budget_duration="30d", team_member_budget=25.0, team_member_budget_duration=None) + + assert write is not None + assert "budget_duration" not in write.create + assert write.update["budget_duration"] is None + assert write.update["budget_reset_at"] is None + + +def test_changing_the_reset_period_restarts_the_window(): + before = datetime.now(timezone.utc) + + write = _plan(existing_budget_id="default-1", team_member_budget_duration="7d") + + assert write is not None + assert write.update["budget_duration"] == "7d" + assert write.update["budget_reset_at"] > before + + +@pytest.mark.parametrize("team_member_budget", [None, 0.0]) +def test_backfill_without_a_positive_default_in_the_same_request_is_rejected(team_member_budget): + with pytest.raises(ValidationError, match="team_member_budget_backfill needs a positive team_member_budget"): + UpdateTeamRequest( + team_id="team-1", team_member_budget=team_member_budget, team_member_budget_backfill="raise_to_default" + ) + + +@pytest.mark.parametrize("backfill", [None, "none"]) +def test_keeping_custom_budgets_needs_no_default(backfill): + assert UpdateTeamRequest(team_id="team-1", team_member_budget_backfill=backfill).team_member_budget is None + + +def test_per_model_member_budgets_are_stored_as_plain_json(): + caps = {"gpt-4o": {"max_budget": 5.0, "budget_duration": "1d"}} + + write = _plan(existing_budget_id="default-1", team_member_model_max_budget=caps) + + assert write is not None + assert json.loads(json.dumps(write.update["model_max_budget"]))["gpt-4o"]["max_budget"] == 5.0 diff --git a/ui/litellm-dashboard/src/components/networking.tsx b/ui/litellm-dashboard/src/components/networking.tsx index 4df34275923..4f8b785e3b3 100644 --- a/ui/litellm-dashboard/src/components/networking.tsx +++ b/ui/litellm-dashboard/src/components/networking.tsx @@ -97,6 +97,7 @@ import type { ListPluginsResponse, SkillRegisterRequest } from "./claude_code_pl import type { ModelBudgetUsage, ModelMaxBudget } from "./key_team_helpers/ModelMaxBudgetEditor"; import type { StoredModelMaxBudget } from "./key_team_helpers/modelMaxBudgetPayload"; import type { ObjectPermission } from "./object_permission_types"; +import type { MemberBudgetBackfillResult } from "./team/memberBudgetReset"; import type { components } from "@/lib/http/schema"; import type { DecisionTestBody } from "@/app/(dashboard)/guardrails/_components/decision_model/decisionModelQuestion"; import { fetchClient } from "@/lib/http/api"; @@ -2828,7 +2829,11 @@ export const teamUpdateCall = async ( toast.fromError("Failed to update team settings: " + unwrapProxyErrorMessage(errorData)); throw new Error(errorData); } - const data = (await response.json()) as { data: Team; team_id: string }; + const data = (await response.json()) as { + data: Team; + team_id: string; + team_member_budget_backfill_result?: MemberBudgetBackfillResult; + }; return data; // Handle success - you might want to update some state or UI based on the updated team } catch (error) { diff --git a/ui/litellm-dashboard/src/components/team/ResetMemberBudgetsDialog.test.tsx b/ui/litellm-dashboard/src/components/team/ResetMemberBudgetsDialog.test.tsx index 7132ec13fbb..439c383255c 100644 --- a/ui/litellm-dashboard/src/components/team/ResetMemberBudgetsDialog.test.tsx +++ b/ui/litellm-dashboard/src/components/team/ResetMemberBudgetsDialog.test.tsx @@ -1,103 +1,91 @@ import { render, screen } from "@testing-library/react"; import userEvent from "@testing-library/user-event"; import { describe, expect, it, vi } from "vitest"; -import ResetMemberBudgetsDialog from "./ResetMemberBudgetsDialog"; +import type { MemberBudgetBackfillPreview } from "./memberBudgetReset"; +import ResetMemberBudgetsDialog, { backfillOptions } from "./ResetMemberBudgetsDialog"; import type { MemberBudgetResetState } from "./useMemberBudgetReset"; -const pendingFor = (memberCount: number, newBudget = 10) => ({ - teamId: "team-123", - updateData: {}, - userIds: Array.from({ length: memberCount }, (_, i) => `u-${i}`), - newBudget, +const preview = (below: number, above: number, otherResetPeriod = 0): MemberBudgetBackfillPreview => ({ + below, + above, + otherResetPeriod, }); -const promptingWith = (memberCount: number, newBudget = 10): MemberBudgetResetState => ({ - phase: "prompting", - pending: pendingFor(memberCount, newBudget), +const state = (phase: "prompting" | "saving", shown: MemberBudgetBackfillPreview): MemberBudgetResetState => ({ + phase, + pending: { updateData: { team_id: "team-123" }, newBudget: 1250, preview: shown }, }); -const defaultHandlers = () => ({ - onReset: vi.fn(), - onRetry: vi.fn(), - onKeep: vi.fn(), - onDismiss: vi.fn(), +const renderDialog = (dialogState: MemberBudgetResetState) => { + const handlers = { onSave: vi.fn(), onDismiss: vi.fn() }; + render(); + return handlers; +}; + +describe("backfillOptions", () => { + it("offers every direction when members sit on both sides of the default", () => { + expect(backfillOptions(preview(2, 1), 20)).toEqual([ + { value: "none", label: "Keep all custom budgets" }, + { value: "raise_to_default", label: "Raise 2 members below $20.00" }, + { value: "lower_to_default", label: "Lower 1 member above $20.00" }, + { value: "all_to_default", label: "Raise and lower all 3 members" }, + ]); + }); + + it.each([ + [preview(1, 0), ["none", "raise_to_default"]], + [preview(0, 4), ["none", "lower_to_default"]], + ])("hides directions that would move nobody", (shown, values) => { + expect(backfillOptions(shown, 20).map((option) => option.value)).toEqual(values); + }); }); describe("ResetMemberBudgetsDialog", () => { - it("names the members and the new default so the prompt is self-explanatory", () => { - render(); - - expect( - screen.getByText( - "3 members have a custom budget, so the new team default of $10.00 will not apply to them. " + - "Reset them to the default, or keep the custom budgets?", - ), - ).toBeInTheDocument(); - }); - - it("switches to singular for one member", () => { - render(); - - expect( - screen.getByText( - "1 member has a custom budget, so the new team default of $10.00 will not apply to that member. " + - "Reset it to the default, or keep the custom budget?", - ), - ).toBeInTheDocument(); - expect(screen.getByRole("button", { name: "Reset to $10.00" })).toBeInTheDocument(); - expect(screen.getByRole("button", { name: "Keep custom budget" })).toBeInTheDocument(); - }); - - it("formats large budgets like the rest of the team page", () => { - render(); - - expect(screen.getByRole("button", { name: "Reset all to $1,000.00" })).toBeInTheDocument(); - expect(screen.getByText(/new team default of \$1,000\.00/)).toBeInTheDocument(); - }); - - it("routes each choice to the matching action", async () => { - const handlers = defaultHandlers(); + it("keeps custom budgets unless another direction is picked", async () => { const user = userEvent.setup(); - render(); + const { onSave } = renderDialog(state("prompting", preview(2, 1))); - await user.click(screen.getByRole("button", { name: "Reset all to $10.00" })); - expect(handlers.onReset).toHaveBeenCalledTimes(1); + expect(screen.getByText("Apply the new $1,250.00 default to members with a custom budget?")).toBeInTheDocument(); + expect(screen.getByRole("radio", { name: "Keep all custom budgets" })).toBeChecked(); + await user.click(screen.getByRole("button", { name: "Save" })); - await user.click(screen.getByRole("button", { name: "Keep custom budgets" })); - expect(handlers.onKeep).toHaveBeenCalledTimes(1); + expect(onSave).toHaveBeenCalledWith("none"); + }); + + it("saves the picked direction", async () => { + const user = userEvent.setup(); + const { onSave } = renderDialog(state("prompting", preview(2, 1))); + + await user.click(screen.getByRole("radio", { name: "Raise and lower all 3 members" })); + await user.click(screen.getByRole("button", { name: "Save" })); + + expect(onSave).toHaveBeenCalledWith("all_to_default"); + }); + + it("says how many members reset on another schedule", () => { + renderDialog(state("prompting", preview(1, 0, 2))); + + expect(screen.getByText("2 members reset on a different schedule and won't change")).toBeInTheDocument(); + }); + + it("cancels without saving", async () => { + const user = userEvent.setup(); + const { onSave, onDismiss } = renderDialog(state("prompting", preview(1, 0))); await user.click(screen.getByRole("button", { name: "Cancel" })); - expect(handlers.onDismiss).toHaveBeenCalledTimes(1); + + expect(onDismiss).toHaveBeenCalledTimes(1); + expect(onSave).not.toHaveBeenCalled(); }); - it("locks every button while the reset is in flight", () => { - const state: MemberBudgetResetState = { phase: "resetting", pending: pendingFor(2), attempted: 0 }; - render(); + it("locks every control while the save is in flight", () => { + renderDialog(state("saving", preview(1, 0))); - expect(screen.getByRole("button", { name: "Reset all to $10.00" })).toBeDisabled(); - expect(screen.getByRole("button", { name: "Keep custom budgets" })).toBeDisabled(); + expect(screen.getByRole("button", { name: "Save" })).toBeDisabled(); expect(screen.getByRole("button", { name: "Cancel" })).toBeDisabled(); - }); - - it("offers retry or cancel after a failed reset", async () => { - const handlers = defaultHandlers(); - const user = userEvent.setup(); - const state: MemberBudgetResetState = { phase: "resetFailed", pending: pendingFor(2), attempted: 0 }; - render(); - - await user.click(screen.getByRole("button", { name: "Retry reset" })); - expect(handlers.onRetry).toHaveBeenCalledTimes(1); - - await user.click(screen.getByRole("button", { name: "Cancel" })); - expect(handlers.onDismiss).toHaveBeenCalledTimes(1); - - expect(screen.queryByRole("button", { name: "Keep custom budgets" })).not.toBeInTheDocument(); - expect(screen.queryByRole("button", { name: "Reset all to $10.00" })).not.toBeInTheDocument(); - }); - - it("renders nothing while idle", () => { - render(); - - expect(screen.queryByRole("dialog")).not.toBeInTheDocument(); + expect(screen.getByRole("radio", { name: "Raise 1 member below $1,250.00" })).toHaveAttribute( + "aria-disabled", + "true", + ); }); }); diff --git a/ui/litellm-dashboard/src/components/team/ResetMemberBudgetsDialog.tsx b/ui/litellm-dashboard/src/components/team/ResetMemberBudgetsDialog.tsx index 95714e3df33..045bb18e780 100644 --- a/ui/litellm-dashboard/src/components/team/ResetMemberBudgetsDialog.tsx +++ b/ui/litellm-dashboard/src/components/team/ResetMemberBudgetsDialog.tsx @@ -1,70 +1,101 @@ -import React from "react"; +import React, { useState } from "react"; import { Button } from "@/components/ui/button"; import { Dialog, DialogContent, DialogFooter, DialogHeader, DialogTitle } from "@/components/ui/dialog"; +import { FieldLabel } from "@/components/ui/field"; +import { RadioGroup, RadioGroupItem } from "@/components/ui/radio-group"; import { formatNumberWithCommas } from "@/utils/dataUtils"; -import { pluralize } from "./memberBudgetReset"; +import { + pluralize, + type MemberBudgetBackfill, + type MemberBudgetBackfillPreview, + type MemberBudgetResetPending, +} from "./memberBudgetReset"; import type { MemberBudgetResetState } from "./useMemberBudgetReset"; interface ResetMemberBudgetsDialogProps { state: MemberBudgetResetState; - onReset: () => void; - onRetry: () => void; - onKeep: () => void; + onSave: (backfill: MemberBudgetBackfill) => void; onDismiss: () => void; } -export default function ResetMemberBudgetsDialog({ - state, - onReset, - onRetry, - onKeep, - onDismiss, -}: ResetMemberBudgetsDialogProps) { - const open = state.phase !== "idle"; - const busy = state.phase === "resetting"; - const failed = state.phase === "resetFailed"; - const memberCount = state.phase === "idle" ? 0 : state.pending.userIds.length; - const newBudget = state.phase === "idle" ? 0 : state.pending.newBudget; +interface BackfillOption { + value: MemberBudgetBackfill; + label: string; +} + +const members = (count: number) => `${count} ${pluralize(count, "member", "members")}`; + +export const backfillOptions = (preview: MemberBudgetBackfillPreview, newBudget: number): BackfillOption[] => { + const amount = `$${formatNumberWithCommas(newBudget, 2)}`; + const options: (BackfillOption | null)[] = [ + { value: "none", label: "Keep all custom budgets" }, + preview.below > 0 ? { value: "raise_to_default", label: `Raise ${members(preview.below)} below ${amount}` } : null, + preview.above > 0 ? { value: "lower_to_default", label: `Lower ${members(preview.above)} above ${amount}` } : null, + preview.below > 0 && preview.above > 0 + ? { value: "all_to_default", label: `Raise and lower all ${members(preview.below + preview.above)}` } + : null, + ]; + return options.filter((option): option is BackfillOption => option !== null); +}; + +interface BackfillChoiceProps { + pending: MemberBudgetResetPending; + busy: boolean; + onSave: (backfill: MemberBudgetBackfill) => void; + onDismiss: () => void; +} + +function BackfillChoice({ pending, busy, onSave, onDismiss }: BackfillChoiceProps) { + const [choice, setChoice] = useState("none"); + const otherResetPeriod = pending.preview.otherResetPeriod; + + return ( + <> + + + Apply the new ${formatNumberWithCommas(pending.newBudget, 2)} default to members with a custom budget? + + + setChoice(value as MemberBudgetBackfill)}> + {backfillOptions(pending.preview, pending.newBudget).map((option) => ( + + + {option.label} + + ))} + + {otherResetPeriod > 0 && ( +

+ {members(otherResetPeriod)} {pluralize(otherResetPeriod, "resets", "reset")} on a different schedule and + won't change +

+ )} + + + + + + ); +} + +export default function ResetMemberBudgetsDialog({ state, onSave, onDismiss }: ResetMemberBudgetsDialogProps) { + const busy = state.phase === "saving"; return ( { if (!nextOpen && !busy) onDismiss(); }} > - - Reset member budgets? - -

- {memberCount} {pluralize(memberCount, "member has", "members have")} a custom budget, so the new team default - of ${formatNumberWithCommas(newBudget, 2)} will not apply to {pluralize(memberCount, "that member", "them")}. - Reset {pluralize(memberCount, "it", "them")} to the default, or keep the custom{" "} - {pluralize(memberCount, "budget", "budgets")}? -

- - {failed ? ( - <> - - - - ) : ( - <> - - - - - )} - + {state.phase !== "idle" && ( + + )}
); diff --git a/ui/litellm-dashboard/src/components/team/TeamInfo.integration.test.tsx b/ui/litellm-dashboard/src/components/team/TeamInfo.integration.test.tsx index fc054e51e5b..016b60338ee 100644 --- a/ui/litellm-dashboard/src/components/team/TeamInfo.integration.test.tsx +++ b/ui/litellm-dashboard/src/components/team/TeamInfo.integration.test.tsx @@ -6,7 +6,6 @@ import { afterEach, beforeEach, describe, expect, it, vi } from "vitest"; import { renderWithProviders } from "../../../tests/test-utils"; import { toast } from "@/lib/toast"; import type { Team } from "../key_team_helpers/key_list"; -import { MAX_BULK_TEAM_MEMBER_BUDGET_UPDATES } from "./memberBudgetReset"; import TeamInfoView, { type TeamData } from "./TeamInfo"; const authState = vi.hoisted(() => ({ userRole: "Admin" })); @@ -49,12 +48,6 @@ vi.mock("@/components/networking", () => ({ getClaudeCodePluginsList: vi.fn().mockResolvedValue({ plugins: [], count: 0 }), })); -const { bulkUpdatePOST } = vi.hoisted(() => ({ bulkUpdatePOST: vi.fn() })); -vi.mock("@/lib/http/api", async (importOriginal) => { - const actual = await importOriginal(); - return { ...actual, fetchClient: { ...actual.fetchClient, POST: bulkUpdatePOST } }; -}); - const can = vi.fn(); vi.mock("@/app/(dashboard)/hooks/useCan", () => ({ default: (...args: unknown[]) => can(...args), @@ -358,6 +351,7 @@ describe("TeamInfoView - member budget reset prompt", () => { const customBudgetMembership = ( userId: string, maxBudget: number | null = 50, + budgetDuration: string | null = null, ): TeamData["team_memberships"][number] => ({ user_id: userId, team_id: "123", @@ -373,7 +367,7 @@ describe("TeamInfoView - member budget reset prompt", () => { tpm_limit: null, rpm_limit: null, model_max_budget: null, - budget_duration: null, + budget_duration: budgetDuration, budget_reset_at: null, }, }); @@ -393,333 +387,147 @@ describe("TeamInfoView - member budget reset prompt", () => { spend: 0, }; - const openEditorWithCustomMembers = async ( - user: ReturnType, - userIds: string[] = ["user-custom"], - maxBudget: number | null = 50, - ) => { - const data = { - ...createMockTeamData({ - team_member_budget_table: { max_budget: 10, budget_duration: null, tpm_limit: null, rpm_limit: null }, - }), - team_memberships: userIds.map((id) => customBudgetMembership(id, maxBudget)), - } as TeamData; - vi.mocked(networking.teamInfoCall).mockResolvedValue(data); - vi.mocked(networking.teamUpdateCall).mockResolvedValue({ data: savedTeam, team_id: "123" }); - - renderWithProviders(); - await waitFor(() => expect(screen.queryAllByText("Test Team").length).toBeGreaterThan(0)); - await user.click(screen.getByRole("tab", { name: "Settings" })); - await user.click(await screen.findByRole("button", { name: /edit settings/i })); - await user.click(screen.getByText("Team Member Settings")); - return await screen.findByLabelText("Default Budget (USD)"); - }; - const submitNewDefault = async (user: ReturnType, input: HTMLElement, value: string) => { fireEvent.change(input, { target: { value } }); await user.click(screen.getByRole("button", { name: /save changes/i })); }; + const memberships = (...rows: TeamData["team_memberships"]) => rows; + + const openEditor = async (user: ReturnType, rows: TeamData["team_memberships"]) => { + const data = { + ...createMockTeamData({ + team_member_budget_table: { max_budget: 10, budget_duration: null, tpm_limit: null, rpm_limit: null }, + }), + team_memberships: rows, + } as TeamData; + vi.mocked(networking.teamInfoCall).mockResolvedValue(data); + vi.mocked(networking.teamUpdateCall).mockResolvedValue({ data: savedTeam, team_id: "123" }); + + const view = renderWithProviders(); + await waitFor(() => expect(screen.queryAllByText("Test Team").length).toBeGreaterThan(0)); + await user.click(screen.getByRole("tab", { name: "Settings" })); + await user.click(await screen.findByRole("button", { name: /edit settings/i })); + await user.click(screen.getByText("Team Member Settings")); + return { input: await screen.findByLabelText("Default Budget (USD)"), view }; + }; + + const savedBody = () => vi.mocked(networking.teamUpdateCall).mock.calls[0][1]; + const promptTitle = "Apply the new $20.00 default to members with a custom budget?"; + beforeEach(() => { seedDefaultMocks(); - bulkUpdatePOST.mockResolvedValue({ data: { data: [] } }); }); afterEach(() => { vi.clearAllMocks(); }); - it("holds the save behind the prompt when the default changes while a member has a custom budget", async () => { + it("holds the save behind a prompt that counts members on each side of the new default", async () => { const user = userEvent.setup({ delay: null }); - const input = await openEditorWithCustomMembers(user); - - await submitNewDefault(user, input, "20"); - - expect(await screen.findByText("Reset member budgets?")).toBeInTheDocument(); - expect(screen.getByText(/1 member has a custom budget/)).toBeInTheDocument(); - expect(screen.getByRole("button", { name: "Reset to $20.00" })).toBeInTheDocument(); - expect(networking.teamUpdateCall).not.toHaveBeenCalled(); - expect(bulkUpdatePOST).not.toHaveBeenCalled(); - }); - - it("saves the new default and leaves custom budgets alone on keep", async () => { - const user = userEvent.setup({ delay: null }); - const input = await openEditorWithCustomMembers(user); - - await submitNewDefault(user, input, "20"); - await user.click(await screen.findByRole("button", { name: "Keep custom budget" })); - - await waitFor(() => expect(networking.teamUpdateCall).toHaveBeenCalled()); - expect(vi.mocked(networking.teamUpdateCall).mock.calls[0][1].team_member_budget).toBe(20); - expect(bulkUpdatePOST).not.toHaveBeenCalled(); - await waitFor(() => expect(screen.queryByText("Reset member budgets?")).not.toBeInTheDocument()); - }); - - it("saves the new default then clears each custom budget through the bulk endpoint on reset all", async () => { - const user = userEvent.setup({ delay: null }); - const input = await openEditorWithCustomMembers(user, ["user-a", "user-b"]); - bulkUpdatePOST.mockResolvedValue({ - data: { - data: [ - { success: true, user_id: "user-a" }, - { success: true, user_id: "user-b" }, - ], - }, - }); - - await submitNewDefault(user, input, "20"); - await user.click(await screen.findByRole("button", { name: "Reset all to $20.00" })); - - await waitFor(() => expect(bulkUpdatePOST).toHaveBeenCalledTimes(1)); - expect(networking.teamUpdateCall).toHaveBeenCalled(); - expect(vi.mocked(networking.teamUpdateCall).mock.calls[0][1].team_member_budget).toBe(20); - expect(bulkUpdatePOST).toHaveBeenCalledWith("/management/v1/teams/{team_id}/members/bulk_update", { - params: { path: { team_id: "123" } }, - body: { - members: [ - { user_id: "user-a", max_budget_in_team: null }, - { user_id: "user-b", max_budget_in_team: null }, - ], - }, - }); - await waitFor(() => expect(toast.success).toHaveBeenCalledWith("Reset 2 member budgets to the team default")); - }); - - it("keeps the prompt mounted while the member-budget reset is in flight", async () => { - const user = userEvent.setup({ delay: null }); - const input = await openEditorWithCustomMembers(user); - const bulk = Promise.withResolvers<{ data: { data: { success: boolean; user_id: string }[] } }>(); - vi.mocked(networking.teamInfoCall).mockImplementationOnce(() => new Promise(() => {})); - bulkUpdatePOST.mockImplementationOnce(() => bulk.promise); - - await submitNewDefault(user, input, "20"); - await user.click(await screen.findByRole("button", { name: "Reset to $20.00" })); - - await waitFor(() => expect(bulkUpdatePOST).toHaveBeenCalled()); - expect(screen.getByText("Reset member budgets?")).toBeInTheDocument(); - expect(screen.queryByText("Loading...")).not.toBeInTheDocument(); - - bulk.resolve({ data: { data: [{ success: true, user_id: "user-custom" }] } }); - await waitFor(() => expect(screen.queryByText("Reset member budgets?")).not.toBeInTheDocument()); - }); - - it("offers a retry after a failed reset and never re-saves the team", async () => { - const user = userEvent.setup({ delay: null }); - const input = await openEditorWithCustomMembers(user); - bulkUpdatePOST - .mockRejectedValueOnce(new Error("bulk update down")) - .mockResolvedValueOnce({ data: { data: [{ success: true, user_id: "user-custom" }] } }); - - await submitNewDefault(user, input, "20"); - await user.click(await screen.findByRole("button", { name: "Reset to $20.00" })); - - await waitFor(() => - expect(toast.fromError).toHaveBeenCalledWith("Team updated, but member budgets could not be reset"), + const { input } = await openEditor( + user, + memberships( + customBudgetMembership("user-low", 5), + customBudgetMembership("user-high", 50), + customBudgetMembership("user-weekly", 5, "7d"), + ), ); - expect(screen.getByText("Reset member budgets?")).toBeInTheDocument(); - expect(screen.queryByText("Loading...")).not.toBeInTheDocument(); - await waitFor(() => expect(vi.mocked(networking.teamInfoCall).mock.calls.length).toBeGreaterThan(1)); - await user.click(screen.getByRole("button", { name: "Retry reset" })); + await submitNewDefault(user, input, "20"); - await waitFor(() => expect(bulkUpdatePOST).toHaveBeenCalledTimes(2)); - expect(vi.mocked(networking.teamUpdateCall).mock.calls).toHaveLength(1); - await waitFor(() => expect(toast.success).toHaveBeenCalledWith("Reset 1 member budget to the team default")); - await waitFor(() => expect(screen.queryByText("Reset member budgets?")).not.toBeInTheDocument()); + expect(await screen.findByText(promptTitle)).toBeInTheDocument(); + expect(screen.getByRole("radio", { name: "Raise 1 member below $20.00" })).toBeInTheDocument(); + expect(screen.getByRole("radio", { name: "Lower 1 member above $20.00" })).toBeInTheDocument(); + expect(screen.getByRole("radio", { name: "Raise and lower all 2 members" })).toBeInTheDocument(); + expect(screen.getByText("1 member resets on a different schedule and won't change")).toBeInTheDocument(); + expect(networking.teamUpdateCall).not.toHaveBeenCalled(); }); - it("returns to the prompt without its own toast when the team save fails", async () => { + it("keeps every custom budget when saved with the default choice", async () => { const user = userEvent.setup({ delay: null }); - const input = await openEditorWithCustomMembers(user); + const { input } = await openEditor(user, memberships(customBudgetMembership("user-high"))); + + await submitNewDefault(user, input, "20"); + await user.click(await screen.findByRole("button", { name: "Save" })); + + await waitFor(() => expect(networking.teamUpdateCall).toHaveBeenCalledTimes(1)); + expect(savedBody()).toMatchObject({ team_member_budget: 20, team_member_budget_backfill: "none" }); + await waitFor(() => expect(toast.success).toHaveBeenCalledWith("Team settings updated successfully")); + expect(screen.queryByText(promptTitle)).not.toBeInTheDocument(); + }); + + it("sends the chosen direction in the same save and reports what the server moved", async () => { + const user = userEvent.setup({ delay: null }); + const { input } = await openEditor(user, memberships(customBudgetMembership("user-high"))); + vi.mocked(networking.teamUpdateCall).mockResolvedValue({ + data: savedTeam, + team_id: "123", + team_member_budget_backfill_result: { moved_to_default: 1, skipped_other_reset_period: 0 }, + }); + + await submitNewDefault(user, input, "20"); + await user.click(await screen.findByRole("radio", { name: "Lower 1 member above $20.00" })); + await user.click(screen.getByRole("button", { name: "Save" })); + + await waitFor(() => expect(networking.teamUpdateCall).toHaveBeenCalledTimes(1)); + expect(savedBody()).toMatchObject({ team_member_budget: 20, team_member_budget_backfill: "lower_to_default" }); + await waitFor(() => expect(toast.success).toHaveBeenCalledWith("Moved 1 member to the $20.00 default")); + }); + + it("returns to the prompt without its own toast when the save fails", async () => { + const user = userEvent.setup({ delay: null }); + const { input } = await openEditor(user, memberships(customBudgetMembership("user-high"))); vi.mocked(networking.teamUpdateCall).mockRejectedValueOnce(new Error("save failed")); await submitNewDefault(user, input, "20"); - await user.click(await screen.findByRole("button", { name: "Reset to $20.00" })); + await user.click(await screen.findByRole("button", { name: "Save" })); - expect(await screen.findByRole("button", { name: "Reset to $20.00" })).toBeEnabled(); - expect(bulkUpdatePOST).not.toHaveBeenCalled(); - expect(toast.fromError).not.toHaveBeenCalled(); - expect(toast.error).not.toHaveBeenCalled(); - expect(screen.queryByText("Loading...")).not.toBeInTheDocument(); - }); - - it("reports how many budgets were already reset when a later batch fails", async () => { - const user = userEvent.setup({ delay: null }); - const userIds = Array.from({ length: MAX_BULK_TEAM_MEMBER_BUDGET_UPDATES + 1 }, (_, i) => `user-${i}`); - const input = await openEditorWithCustomMembers(user, userIds); - bulkUpdatePOST - .mockResolvedValueOnce({ - data: { - data: userIds.slice(0, MAX_BULK_TEAM_MEMBER_BUDGET_UPDATES).map((user_id) => ({ success: true, user_id })), - }, - }) - .mockRejectedValueOnce(new Error("second batch down")) - .mockResolvedValueOnce({ - data: { data: [{ success: true, user_id: `user-${MAX_BULK_TEAM_MEMBER_BUDGET_UPDATES}` }] }, - }); - - await submitNewDefault(user, input, "20"); - await user.click(await screen.findByRole("button", { name: "Reset all to $20.00" })); - - await waitFor(() => - expect(toast.error).toHaveBeenCalledWith( - `Reset ${MAX_BULK_TEAM_MEMBER_BUDGET_UPDATES} of ${MAX_BULK_TEAM_MEMBER_BUDGET_UPDATES + 1} member budgets; the rest could not be reset`, - ), - ); - expect(bulkUpdatePOST).toHaveBeenCalledTimes(2); - - await user.click(screen.getByRole("button", { name: "Retry reset" })); - - await waitFor(() => expect(bulkUpdatePOST).toHaveBeenCalledTimes(3)); - expect(vi.mocked(bulkUpdatePOST).mock.calls[2][1]).toEqual({ - params: { path: { team_id: "123" } }, - body: { - members: [{ user_id: `user-${MAX_BULK_TEAM_MEMBER_BUDGET_UPDATES}`, max_budget_in_team: null }], - }, - }); - expect(vi.mocked(networking.teamUpdateCall).mock.calls).toHaveLength(1); - await waitFor(() => - expect(toast.success).toHaveBeenCalledWith( - `Reset ${MAX_BULK_TEAM_MEMBER_BUDGET_UPDATES + 1} member budgets to the team default`, - ), - ); - }); - - it("surfaces a failure toast when some members cannot be reset", async () => { - const user = userEvent.setup({ delay: null }); - const input = await openEditorWithCustomMembers(user, ["user-a", "user-b"]); - bulkUpdatePOST.mockResolvedValue({ - data: { - data: [ - { success: true, user_id: "user-a" }, - { success: false, user_id: "user-b", error: "no such member" }, - ], - }, - }); - - await submitNewDefault(user, input, "20"); - await user.click(await screen.findByRole("button", { name: "Reset all to $20.00" })); - - await waitFor(() => - expect(toast.error).toHaveBeenCalledWith("Team updated, but 1 member budget could not be reset"), - ); + await waitFor(() => expect(networking.teamUpdateCall).toHaveBeenCalledTimes(1)); + expect(await screen.findByRole("button", { name: "Save" })).toBeEnabled(); + expect(toast.success).not.toHaveBeenCalled(); }); it("aborts the save entirely on cancel", async () => { const user = userEvent.setup({ delay: null }); - const input = await openEditorWithCustomMembers(user); + const { input } = await openEditor(user, memberships(customBudgetMembership("user-high"))); await submitNewDefault(user, input, "20"); await user.click(await screen.findByRole("button", { name: "Cancel" })); - await waitFor(() => expect(screen.queryByText("Reset member budgets?")).not.toBeInTheDocument()); + await waitFor(() => expect(screen.queryByText(promptTitle)).not.toBeInTheDocument()); expect(networking.teamUpdateCall).not.toHaveBeenCalled(); - expect(bulkUpdatePOST).not.toHaveBeenCalled(); }); - it("saves directly when no member carries a custom budget", async () => { + it.each([ + ["no member has a custom budget", memberships(), "20"], + ["a custom member's cap is null", memberships(customBudgetMembership("user-limits-only", null)), "20"], + ["the only custom member resets on another schedule", memberships(customBudgetMembership("u", 5, "7d")), "20"], + ["the only custom member already matches", memberships(customBudgetMembership("user-equal", 20)), "20"], + ["the default is resubmitted unchanged", memberships(customBudgetMembership("user-high")), "10"], + ])("saves directly when %s", async (_case, rows, value) => { const user = userEvent.setup({ delay: null }); - const input = await openEditorWithCustomMembers(user, []); + const { input } = await openEditor(user, rows); - await submitNewDefault(user, input, "20"); + await submitNewDefault(user, input, value); - await waitFor(() => expect(networking.teamUpdateCall).toHaveBeenCalled()); - expect(vi.mocked(networking.teamUpdateCall).mock.calls[0][1].team_member_budget).toBe(20); - expect(screen.queryByText("Reset member budgets?")).not.toBeInTheDocument(); - expect(bulkUpdatePOST).not.toHaveBeenCalled(); - }); - - it("saves directly when the default is resubmitted unchanged", async () => { - const user = userEvent.setup({ delay: null }); - await openEditorWithCustomMembers(user); - - await user.click(screen.getByRole("button", { name: /save changes/i })); - - await waitFor(() => expect(networking.teamUpdateCall).toHaveBeenCalled()); - expect(vi.mocked(networking.teamUpdateCall).mock.calls[0][1].team_member_budget).toBe(10); - expect(screen.queryByText("Reset member budgets?")).not.toBeInTheDocument(); - expect(bulkUpdatePOST).not.toHaveBeenCalled(); + await waitFor(() => expect(networking.teamUpdateCall).toHaveBeenCalledTimes(1)); + expect(savedBody().team_member_budget).toBe(Number(value)); + expect(savedBody()).not.toHaveProperty("team_member_budget_backfill"); + expect(screen.queryByText(/default to members with a custom budget/)).not.toBeInTheDocument(); }); it("dismisses a pending prompt when the selected team changes", async () => { const user = userEvent.setup({ delay: null }); - const data = { - ...createMockTeamData({ - team_member_budget_table: { max_budget: 10, budget_duration: null, tpm_limit: null, rpm_limit: null }, - }), - team_memberships: [customBudgetMembership("user-custom")], - } as TeamData; - vi.mocked(networking.teamInfoCall).mockResolvedValue(data); - vi.mocked(networking.teamUpdateCall).mockResolvedValue({ data: savedTeam, team_id: "123" }); - - const { rerender } = renderWithProviders(); - await waitFor(() => expect(screen.queryAllByText("Test Team").length).toBeGreaterThan(0)); - await user.click(screen.getByRole("tab", { name: "Settings" })); - await user.click(await screen.findByRole("button", { name: /edit settings/i })); - await user.click(screen.getByText("Team Member Settings")); - const input = await screen.findByLabelText("Default Budget (USD)"); + const { input, view } = await openEditor(user, memberships(customBudgetMembership("user-high"))); await submitNewDefault(user, input, "20"); - expect(await screen.findByText("Reset member budgets?")).toBeInTheDocument(); + expect(await screen.findByText(promptTitle)).toBeInTheDocument(); - rerender(); + view.rerender(); - await waitFor(() => expect(screen.queryByText("Reset member budgets?")).not.toBeInTheDocument()); - expect(bulkUpdatePOST).not.toHaveBeenCalled(); - }); - - it("does not reopen the dialog or refetch the old team when the team changes mid-reset", async () => { - const user = userEvent.setup({ delay: null }); - const data = { - ...createMockTeamData({ - team_member_budget_table: { max_budget: 10, budget_duration: null, tpm_limit: null, rpm_limit: null }, - }), - team_memberships: [customBudgetMembership("user-custom")], - } as TeamData; - vi.mocked(networking.teamInfoCall).mockResolvedValue(data); - vi.mocked(networking.teamUpdateCall).mockResolvedValue({ data: savedTeam, team_id: "123" }); - const bulkDone = Promise.withResolvers<{ data: { data: { success: boolean; user_id: string }[] } }>(); - bulkUpdatePOST.mockReturnValue(bulkDone.promise); - - const { rerender } = renderWithProviders(); - await waitFor(() => expect(screen.queryAllByText("Test Team").length).toBeGreaterThan(0)); - await user.click(screen.getByRole("tab", { name: "Settings" })); - await user.click(await screen.findByRole("button", { name: /edit settings/i })); - await user.click(screen.getByText("Team Member Settings")); - const input = await screen.findByLabelText("Default Budget (USD)"); - - await submitNewDefault(user, input, "20"); - await user.click(await screen.findByRole("button", { name: "Reset to $20.00" })); - await waitFor(() => expect(bulkUpdatePOST).toHaveBeenCalled()); - - const infoCallsBeforeSwitch = vi.mocked(networking.teamInfoCall).mock.calls.length; - rerender(); - bulkDone.resolve({ data: { data: [{ success: true, user_id: "user-custom" }] } }); - - await waitFor(() => expect(screen.queryByText("Reset member budgets?")).not.toBeInTheDocument()); - await waitFor(() => - expect( - vi - .mocked(networking.teamInfoCall) - .mock.calls.slice(infoCallsBeforeSwitch) - .some((call) => call[1] === "456"), - ).toBe(true), - ); - const infoCallsAfterSwitch = vi.mocked(networking.teamInfoCall).mock.calls.slice(infoCallsBeforeSwitch); - expect(infoCallsAfterSwitch.every((call) => call[1] === "456")).toBe(true); - expect(screen.queryByRole("button", { name: "Retry reset" })).not.toBeInTheDocument(); - }); - - it("saves directly when a custom member's cap is null and already inherits the default", async () => { - const user = userEvent.setup({ delay: null }); - const input = await openEditorWithCustomMembers(user, ["user-limits-only"], null); - - await submitNewDefault(user, input, "20"); - - await waitFor(() => expect(networking.teamUpdateCall).toHaveBeenCalled()); - expect(vi.mocked(networking.teamUpdateCall).mock.calls[0][1].team_member_budget).toBe(20); - expect(screen.queryByText("Reset member budgets?")).not.toBeInTheDocument(); - expect(bulkUpdatePOST).not.toHaveBeenCalled(); + await waitFor(() => expect(screen.queryByText(promptTitle)).not.toBeInTheDocument()); + expect(networking.teamUpdateCall).not.toHaveBeenCalled(); }); it("omits the default member model budget when it has not changed", async () => { diff --git a/ui/litellm-dashboard/src/components/team/TeamInfo.test.tsx b/ui/litellm-dashboard/src/components/team/TeamInfo.test.tsx index e4bf67ab72f..d5ac82faa2f 100644 --- a/ui/litellm-dashboard/src/components/team/TeamInfo.test.tsx +++ b/ui/litellm-dashboard/src/components/team/TeamInfo.test.tsx @@ -8,6 +8,7 @@ import { toast } from "@/lib/toast"; import type { Member } from "@/components/networking"; import type { EffectiveMcpServer } from "../mcp_server_management/effectiveMcpServers"; import type { MCPServer } from "../mcp_tools/types"; +import type { Team } from "../key_team_helpers/key_list"; import TeamInfoView, { grantedMcpServerIds, type McpGrantInput, @@ -2152,6 +2153,54 @@ describe("TeamInfoView", () => { expect(screen.getByRole("button", { name: /save changes/i })).toBeDisabled(); }); + it("asks a team admin which custom member budgets follow a new member default and sends the choice", async () => { + const user = userEvent.setup({ delay: null }); + vi.mocked(networking.teamInfoCall).mockResolvedValue({ + ...createMockTeamData({ + team_member_budget_table: { max_budget: 10, budget_duration: "30d", tpm_limit: null, rpm_limit: null }, + caller_edit_access: { kind: "team_admin", editable_fields: ["team_member_budget"] }, + }), + team_memberships: [ + { + user_id: "user-high", + team_id: "123", + budget_id: "budget-user-high", + budget_source: "custom", + spend: 0, + total_spend: 0, + litellm_budget_table: { + budget_id: "budget-user-high", + soft_budget: null, + max_budget: 50, + max_parallel_requests: null, + tpm_limit: null, + rpm_limit: null, + model_max_budget: null, + budget_duration: "30d", + budget_reset_at: null, + }, + }, + ], + }); + vi.mocked(networking.teamUpdateCall).mockResolvedValue({ data: {} as Team, team_id: "123" }); + + renderWithProviders(); + + await user.click(await screen.findByRole("tab", { name: "Settings" })); + await user.click(await screen.findByRole("button", { name: /edit settings/i })); + fireEvent.change(await screen.findByLabelText("Member Default Budget (USD)"), { target: { value: "20" } }); + await user.click(screen.getByRole("button", { name: /save changes/i })); + await user.click(await screen.findByRole("radio", { name: "Lower 1 member above $20.00" })); + await user.click(screen.getByRole("button", { name: "Save" })); + + await waitFor(() => expect(networking.teamUpdateCall).toHaveBeenCalledTimes(1)); + expect(vi.mocked(networking.teamUpdateCall).mock.calls[0][1]).toStrictEqual({ + team_id: "123", + team_member_budget: 20, + team_member_budget_backfill: "lower_to_default", + }); + }); + it("opens the form when the proxy reports unrestricted access although the props only mark a team admin", async () => { const user = userEvent.setup({ delay: null }); vi.mocked(networking.teamInfoCall).mockResolvedValue( diff --git a/ui/litellm-dashboard/src/components/team/TeamInfo.tsx b/ui/litellm-dashboard/src/components/team/TeamInfo.tsx index 0d63f5d0833..8d4aedc6626 100644 --- a/ui/litellm-dashboard/src/components/team/TeamInfo.tsx +++ b/ui/litellm-dashboard/src/components/team/TeamInfo.tsx @@ -132,9 +132,12 @@ import { } from "./teamMemberBudgetAlertEmails"; import { TeamVirtualKeysTable } from "./TeamVirtualKeysTable"; import ResetMemberBudgetsDialog from "./ResetMemberBudgetsDialog"; -import { customBudgetMemberUserIds, shouldPromptMemberBudgetReset } from "./memberBudgetReset"; +import { + previewMemberBudgetBackfill, + shouldPromptMemberBudgetReset, + type TeamUpdatePayload, +} from "./memberBudgetReset"; import { useMemberBudgetReset } from "./useMemberBudgetReset"; -import { fetchClient } from "@/lib/http/api"; const UI_MANAGED_METADATA_KEYS: ReadonlySet = new Set([ "logging", @@ -941,32 +944,38 @@ const TeamInfoView: React.FC = ({ }; const persistTeamUpdate = async (token: string, updateData: Record) => { - await teamUpdateCall(token, updateData); + const response = await teamUpdateCall(token, updateData); void queryClient.invalidateQueries({ queryKey: organizationKeys.all }); void invalidateTeamQueries(queryClient); setIsEditing(false); + return response.team_member_budget_backfill_result; }; const memberBudgetReset = useMemberBudgetReset({ saveTeam: async (updateData) => { - if (!accessToken) return; + if (!accessToken) return undefined; setIsTeamSaving(true); try { - await persistTeamUpdate(accessToken, updateData); + return await persistTeamUpdate(accessToken, updateData); } finally { setIsTeamSaving(false); } }, - resetMemberBudgets: async (bulkTeamId, userIds) => { - const { data } = await fetchClient.POST("/management/v1/teams/{team_id}/members/bulk_update", { - params: { path: { team_id: bulkTeamId } }, - body: { members: userIds.map((user_id) => ({ user_id, max_budget_in_team: null })) }, - }); - return data?.data ?? []; - }, refreshTeamData, }); + const promptsMemberBudgetBackfill = ( + updateData: TeamUpdatePayload, + newBudget: number | null | undefined, + newBudgetDuration: string | null | undefined, + ): boolean => { + if (typeof newBudget !== "number") return false; + const preview = previewMemberBudgetBackfill(teamData?.team_memberships ?? [], newBudget, newBudgetDuration); + if (!shouldPromptMemberBudgetReset(newBudget, info.team_member_budget_table?.max_budget, preview)) return false; + memberBudgetReset.prompt({ updateData, newBudget, preview }); + return true; + }; + const { dismiss: dismissMemberBudgetReset } = memberBudgetReset; useEffect(() => { dismissMemberBudgetReset(); @@ -974,9 +983,15 @@ const TeamInfoView: React.FC = ({ const saveTeamAdminSettings = async (changes: TeamAdminSettingsChanges) => { if (!accessToken) return; + const updateData = { team_id: teamId, ...changes }; + const newBudgetDuration = + "team_member_budget_duration" in changes + ? changes.team_member_budget_duration + : info.team_member_budget_table?.budget_duration; + if (promptsMemberBudgetBackfill(updateData, changes.team_member_budget, newBudgetDuration)) return; setIsTeamSaving(true); try { - await persistTeamUpdate(accessToken, { team_id: teamId, ...changes }); + await persistTeamUpdate(accessToken, updateData); toast.success("Team settings updated successfully"); await fetchTeamInfo(); } catch (error) { @@ -1257,24 +1272,7 @@ const TeamInfoView: React.FC = ({ } } - const customBudgetUserIds = customBudgetMemberUserIds(teamData?.team_memberships ?? []); - if ( - typeof newTeamMemberBudget === "number" && - shouldPromptMemberBudgetReset( - newTeamMemberBudget, - info.team_member_budget_table?.max_budget, - customBudgetUserIds, - ) - ) { - const pendingReset = { - teamId, - updateData, - userIds: customBudgetUserIds, - newBudget: newTeamMemberBudget, - }; - memberBudgetReset.prompt(pendingReset); - return; - } + if (promptsMemberBudgetBackfill(updateData, newTeamMemberBudget, values.team_member_budget_duration)) return; await persistTeamUpdate(accessToken, updateData); toast.success("Team settings updated successfully"); @@ -2711,9 +2709,7 @@ const TeamInfoView: React.FC = ({ diff --git a/ui/litellm-dashboard/src/components/team/memberBudgetReset.test.ts b/ui/litellm-dashboard/src/components/team/memberBudgetReset.test.ts index e673840203f..71c1621fd17 100644 --- a/ui/litellm-dashboard/src/components/team/memberBudgetReset.test.ts +++ b/ui/litellm-dashboard/src/components/team/memberBudgetReset.test.ts @@ -1,101 +1,90 @@ import { describe, expect, it } from "vitest"; import { - chunk, - customBudgetMemberUserIds, - MAX_BULK_TEAM_MEMBER_BUDGET_UPDATES, - pluralize, + budgetResetPeriodKey, + previewMemberBudgetBackfill, shouldPromptMemberBudgetReset, + type MemberBudgetBackfillPreview, } from "./memberBudgetReset"; -describe("customBudgetMemberUserIds", () => { - const customRow = (user_id: string, max_budget: number | null = 50) => ({ - user_id, - budget_source: "custom" as const, - litellm_budget_table: { max_budget }, +const custom = (max_budget: number | null, budget_duration: string | null = "30d") => ({ + budget_source: "custom" as const, + litellm_budget_table: { max_budget, budget_duration }, +}); + +describe("budgetResetPeriodKey", () => { + it.each([ + ["7d", "1w", true], + ["24h", "1d", true], + ["daily", "1d", true], + ["60s", "1m", true], + ["monthly", "30d", true], + [" 30d ", "30d", true], + ["1mo", "1mo", true], + [null, undefined, true], + ["1mo", "30d", false], + ["2mo", "1mo", false], + ["7d", "1d", false], + ["30d", null, false], + ["garbage", "garbage", true], + ["garbage", "30d", false], + ])("treats %s and %s as the same schedule: %s", (first, second, same) => { + expect(budgetResetPeriodKey(first) === budgetResetPeriodKey(second)).toBe(same); + }); +}); + +describe("previewMemberBudgetBackfill", () => { + it("counts custom budgets on each side of the new default that reset on its schedule", () => { + const preview = previewMemberBudgetBackfill( + [custom(5), custom(10, "1mo"), custom(80, "30d"), custom(90, "monthly"), custom(3, "7d"), custom(70, null)], + 20, + "30d", + ); + + expect(preview).toEqual({ below: 1, above: 2, otherResetPeriod: 3 }); }); - it("returns only members whose budget_source is custom with a private cap", () => { - const memberships = [ - customRow("u-custom"), - { user_id: "u-default", budget_source: "team_default" as const }, - { user_id: "u-none", budget_source: "none" as const }, - ]; + it("ignores members on the default, members without a cap of their own and caps already at the new default", () => { + const preview = previewMemberBudgetBackfill( + [ + { budget_source: "team_default" as const, litellm_budget_table: { max_budget: 5, budget_duration: "30d" } }, + { budget_source: "none" as const }, + custom(null), + { budget_source: "custom" as const, litellm_budget_table: null }, + custom(20), + custom(20, "7d"), + ], + 20, + "30d", + ); - expect(customBudgetMemberUserIds(memberships)).toEqual(["u-custom"]); + expect(preview).toEqual({ below: 0, above: 0, otherResetPeriod: 0 }); }); - it("skips a custom row whose cap is null since it already inherits the default", () => { - const memberships = [customRow("u-rate-limits-only", null), customRow("u-custom")]; - - expect(customBudgetMemberUserIds(memberships)).toEqual(["u-custom"]); - }); - - it("skips a custom row that has no budget table at all", () => { - const memberships = [ - { user_id: "u-no-table", budget_source: "custom" as const, litellm_budget_table: null }, - customRow("u-custom"), - ]; - - expect(customBudgetMemberUserIds(memberships)).toEqual(["u-custom"]); + it("matches a default that never resets only to caps that never reset", () => { + expect(previewMemberBudgetBackfill([custom(5, null), custom(5, "30d")], 20, null)).toEqual({ + below: 1, + above: 0, + otherResetPeriod: 1, + }); }); }); describe("shouldPromptMemberBudgetReset", () => { - it("prompts when the default changes and custom-budget members exist", () => { - expect(shouldPromptMemberBudgetReset(10, 5, ["u-1"])).toBe(true); + const movable: MemberBudgetBackfillPreview = { below: 1, above: 0, otherResetPeriod: 0 }; + const nothingMovable: MemberBudgetBackfillPreview = { below: 0, above: 0, otherResetPeriod: 4 }; + + it("prompts when the default changes and some member could move onto it", () => { + expect(shouldPromptMemberBudgetReset(10, 5, movable)).toBe(true); + expect(shouldPromptMemberBudgetReset(10, null, { below: 0, above: 1, otherResetPeriod: 0 })).toBe(true); }); - it("prompts when a default is set for the first time", () => { - expect(shouldPromptMemberBudgetReset(10, null, ["u-1"])).toBe(true); - expect(shouldPromptMemberBudgetReset(10, undefined, ["u-1"])).toBe(true); + it("does not prompt when the default is unchanged, cleared or zero", () => { + expect(shouldPromptMemberBudgetReset(10, 10, movable)).toBe(false); + expect(shouldPromptMemberBudgetReset(undefined, 10, movable)).toBe(false); + expect(shouldPromptMemberBudgetReset(0, 10, movable)).toBe(false); }); - it("does not prompt when the submitted budget is unchanged", () => { - expect(shouldPromptMemberBudgetReset(10, 10, ["u-1"])).toBe(false); - }); - - it("does not prompt when the budget is cleared or zero", () => { - expect(shouldPromptMemberBudgetReset(undefined, 10, ["u-1"])).toBe(false); - expect(shouldPromptMemberBudgetReset(0, 10, ["u-1"])).toBe(false); - }); - - it("does not prompt when no member has a custom budget", () => { - expect(shouldPromptMemberBudgetReset(10, 5, [])).toBe(false); - }); -}); - -describe("chunk", () => { - it("splits selections larger than the bulk endpoint limit", () => { - const ids = Array.from({ length: MAX_BULK_TEAM_MEMBER_BUDGET_UPDATES + 1 }, (_, i) => `u-${i}`); - - const chunks = chunk(ids, MAX_BULK_TEAM_MEMBER_BUDGET_UPDATES); - - expect(chunks).toHaveLength(2); - expect(chunks[0]).toHaveLength(MAX_BULK_TEAM_MEMBER_BUDGET_UPDATES); - expect(chunks[1]).toEqual([`u-${MAX_BULK_TEAM_MEMBER_BUDGET_UPDATES}`]); - }); - - it("keeps a selection under the limit in a single chunk", () => { - expect(chunk(["u-1", "u-2"], MAX_BULK_TEAM_MEMBER_BUDGET_UPDATES)).toEqual([["u-1", "u-2"]]); - }); - - it("returns no chunks for an empty selection", () => { - expect(chunk([], MAX_BULK_TEAM_MEMBER_BUDGET_UPDATES)).toEqual([]); - }); - - it("returns no chunks for a non-positive size", () => { - expect(chunk(["u-1"], 0)).toEqual([]); - expect(chunk(["u-1"], -3)).toEqual([]); - }); -}); - -describe("pluralize", () => { - it("uses the singular form for exactly one", () => { - expect(pluralize(1, "budget", "budgets")).toBe("budget"); - }); - - it("uses the plural form for zero and for more than one", () => { - expect(pluralize(0, "budget", "budgets")).toBe("budgets"); - expect(pluralize(3, "budget", "budgets")).toBe("budgets"); + it("does not prompt when only members on another schedule differ", () => { + expect(shouldPromptMemberBudgetReset(10, 5, nothingMovable)).toBe(false); }); }); diff --git a/ui/litellm-dashboard/src/components/team/memberBudgetReset.ts b/ui/litellm-dashboard/src/components/team/memberBudgetReset.ts index 2b24a5ebbb0..40cec94f184 100644 --- a/ui/litellm-dashboard/src/components/team/memberBudgetReset.ts +++ b/ui/litellm-dashboard/src/components/team/memberBudgetReset.ts @@ -1,38 +1,75 @@ import type { components } from "@/lib/http/schema"; import type { TeamMembership } from "./TeamInfo"; -export const MAX_BULK_TEAM_MEMBER_BUDGET_UPDATES = 500; - export type TeamUpdatePayload = components["schemas"]["UpdateTeamRequest"]; -export interface MemberBudgetResetPending { - readonly teamId: string; - readonly updateData: TeamUpdatePayload; - readonly userIds: readonly string[]; - readonly newBudget: number; +export type MemberBudgetBackfill = NonNullable; + +export interface MemberBudgetBackfillResult { + readonly moved_to_default: number; + readonly skipped_other_reset_period: number; } -type MembershipBudgetRow = Pick & { - litellm_budget_table?: Pick | null; +export interface MemberBudgetBackfillPreview { + readonly below: number; + readonly above: number; + readonly otherResetPeriod: number; +} + +export interface MemberBudgetResetPending { + readonly updateData: TeamUpdatePayload; + readonly newBudget: number; + readonly preview: MemberBudgetBackfillPreview; +} + +type MembershipBudgetRow = Pick & { + litellm_budget_table?: Pick | null; }; -export const customBudgetMemberUserIds = (memberships: readonly MembershipBudgetRow[]): string[] => - memberships - .filter((m) => m.budget_source === "custom" && m.litellm_budget_table?.max_budget != null) - .map((m) => m.user_id); +const FIXED_UNIT_SECONDS: Readonly> = { s: 1, m: 60, h: 3600, d: 86400, w: 604800 }; +const DURATION_WORD_ALIASES: Readonly> = { + hourly: "1h", + daily: "24h", + weekly: "7d", + monthly: "30d", +}; + +export const budgetResetPeriodKey = (duration: string | null | undefined): string | null => { + if (duration == null) return null; + const normalized = (DURATION_WORD_ALIASES[duration.trim().toLowerCase()] ?? duration).trim(); + const parsed = /^(\d+)(mo|[smhdw])$/.exec(normalized); + if (parsed === null) return normalized; + const value = Number(parsed[1]); + const unit = parsed[2]; + return unit === "mo" ? `${value}mo` : `${value * FIXED_UNIT_SECONDS[unit]}s`; +}; + +export const previewMemberBudgetBackfill = ( + memberships: readonly MembershipBudgetRow[], + newBudget: number, + newBudgetDuration: string | null | undefined, +): MemberBudgetBackfillPreview => { + const schedule = budgetResetPeriodKey(newBudgetDuration); + const differing = memberships.flatMap((m) => { + const budget = m.litellm_budget_table; + if (m.budget_source !== "custom" || budget?.max_budget == null || budget.max_budget === newBudget) return []; + return [{ amount: budget.max_budget, sameSchedule: budgetResetPeriodKey(budget.budget_duration) === schedule }]; + }); + const comparable = differing.filter((m) => m.sameSchedule); + return { + below: comparable.filter((m) => m.amount < newBudget).length, + above: comparable.filter((m) => m.amount > newBudget).length, + otherResetPeriod: differing.length - comparable.length, + }; +}; export const shouldPromptMemberBudgetReset = ( nextBudget: number | undefined, previousBudget: number | null | undefined, - customBudgetUserIds: string[], + preview: MemberBudgetBackfillPreview, ): boolean => { const budgetChanged = typeof nextBudget === "number" && nextBudget > 0 && nextBudget !== previousBudget; - return budgetChanged && customBudgetUserIds.length > 0; -}; - -export const chunk = (items: readonly T[], size: number): T[][] => { - if (size <= 0) return []; - return Array.from({ length: Math.ceil(items.length / size) }, (_, i) => items.slice(i * size, i * size + size)); + return budgetChanged && preview.below + preview.above > 0; }; export const pluralize = (count: number, singular: string, plural: string): string => (count === 1 ? singular : plural); diff --git a/ui/litellm-dashboard/src/components/team/useMemberBudgetReset.test.tsx b/ui/litellm-dashboard/src/components/team/useMemberBudgetReset.test.tsx index 71318b635a3..61b65d9a4b0 100644 --- a/ui/litellm-dashboard/src/components/team/useMemberBudgetReset.test.tsx +++ b/ui/litellm-dashboard/src/components/team/useMemberBudgetReset.test.tsx @@ -1,345 +1,126 @@ import { act, renderHook } from "@testing-library/react"; import { afterEach, describe, expect, it, vi } from "vitest"; import { toast } from "@/lib/toast"; -import { MAX_BULK_TEAM_MEMBER_BUDGET_UPDATES } from "./memberBudgetReset"; -import { useMemberBudgetReset, type MemberBudgetResetGateway } from "./useMemberBudgetReset"; +import type { MemberBudgetBackfillResult, MemberBudgetResetPending } from "./memberBudgetReset"; +import { backfillToastMessage, useMemberBudgetReset, type MemberBudgetResetGateway } from "./useMemberBudgetReset"; -const buildGateway = () => ({ - saveTeam: vi.fn(async (_updateData: Record) => {}), - resetMemberBudgets: vi.fn(async (_teamId: string, userIds: readonly string[]) => - userIds.map((user_id) => ({ success: true, user_id })), - ), +const pending: MemberBudgetResetPending = { + updateData: { team_id: "team-123", team_member_budget: 20 }, + newBudget: 20, + preview: { below: 2, above: 1, otherResetPeriod: 0 }, +}; + +const buildGateway = (result?: MemberBudgetBackfillResult) => ({ + saveTeam: vi.fn(async (_updateData: Record) => result), refreshTeamData: vi.fn(async () => {}), }); -const pendingFor = (userIds: string[]) => ({ - teamId: "team-123", - updateData: { team_id: "team-123", team_member_budget: 20 }, - userIds, - newBudget: 20, -}); - const renderReset = (gateway: MemberBudgetResetGateway) => renderHook(() => useMemberBudgetReset(gateway)); +const promptedReset = async (gateway: MemberBudgetResetGateway) => { + const rendered = renderReset(gateway); + await act(async () => { + rendered.result.current.prompt(pending); + }); + return rendered; +}; + +describe("backfillToastMessage", () => { + it.each([ + [undefined, "Team settings updated successfully"], + [{ moved_to_default: 1, skipped_other_reset_period: 0 }, "Moved 1 member to the $20.00 default"], + [ + { moved_to_default: 3, skipped_other_reset_period: 1 }, + "Moved 3 members to the $20.00 default. 1 member resets on a different schedule and was not changed", + ], + [ + { moved_to_default: 0, skipped_other_reset_period: 2 }, + "Moved 0 members to the $20.00 default. 2 members reset on a different schedule and were not changed", + ], + ])("reports %j as %s", (result, message) => { + expect(backfillToastMessage(result, 20)).toBe(message); + }); +}); + describe("useMemberBudgetReset", () => { afterEach(() => { vi.clearAllMocks(); }); - it("starts idle and prompts with the pending update", async () => { + it("holds the update until a choice is saved", async () => { const gateway = buildGateway(); - const { result } = renderReset(gateway); + const { result } = await promptedReset(gateway); - expect(result.current.state.phase).toBe("idle"); - - await act(async () => { - result.current.prompt(pendingFor(["u-1"])); - }); - - expect(result.current.state).toEqual({ - phase: "prompting", - pending: pendingFor(["u-1"]), - }); + expect(result.current.state).toEqual({ phase: "prompting", pending }); expect(gateway.saveTeam).not.toHaveBeenCalled(); }); - it("saves the team once, resets every member, and refreshes on success", async () => { - const gateway = buildGateway(); - const { result } = renderReset(gateway); + it("saves the update and the chosen direction in one request and reports the server's counts", async () => { + const gateway = buildGateway({ moved_to_default: 2, skipped_other_reset_period: 0 }); + const { result } = await promptedReset(gateway); await act(async () => { - result.current.prompt(pendingFor(["u-1", "u-2"])); - }); - await act(async () => { - await result.current.reset(); + await result.current.save("raise_to_default"); }); expect(gateway.saveTeam).toHaveBeenCalledTimes(1); - expect(gateway.saveTeam).toHaveBeenCalledWith({ team_id: "team-123", team_member_budget: 20 }); - expect(gateway.resetMemberBudgets).toHaveBeenCalledWith("team-123", ["u-1", "u-2"]); - expect(toast.success).toHaveBeenCalledWith("Reset 2 member budgets to the team default"); - expect(gateway.refreshTeamData).toHaveBeenCalledTimes(1); - expect(result.current.state.phase).toBe("idle"); - }); - - it("resets members in batches no larger than the bulk endpoint limit", async () => { - const userIds = Array.from({ length: MAX_BULK_TEAM_MEMBER_BUDGET_UPDATES + 1 }, (_, i) => `u-${i}`); - const gateway = buildGateway(); - const { result } = renderReset(gateway); - - await act(async () => { - result.current.prompt(pendingFor(userIds)); + expect(gateway.saveTeam).toHaveBeenCalledWith({ + team_id: "team-123", + team_member_budget: 20, + team_member_budget_backfill: "raise_to_default", }); - await act(async () => { - await result.current.reset(); - }); - - expect(gateway.resetMemberBudgets).toHaveBeenCalledTimes(2); - expect(gateway.resetMemberBudgets.mock.calls[0][0]).toBe("team-123"); - expect(gateway.resetMemberBudgets.mock.calls[0][1]).toHaveLength(MAX_BULK_TEAM_MEMBER_BUDGET_UPDATES); - expect(gateway.resetMemberBudgets.mock.calls[1][1]).toEqual([`u-${MAX_BULK_TEAM_MEMBER_BUDGET_UPDATES}`]); - expect(result.current.state.phase).toBe("idle"); - }); - - it("resets against the team carried by the pending update", async () => { - const gateway = buildGateway(); - const { result } = renderReset(gateway); - - const pending = { - teamId: "team-999", - updateData: { team_id: "team-999", team_member_budget: 20 }, - userIds: ["u-1"], - newBudget: 20, - }; - await act(async () => { - result.current.prompt(pending); - }); - await act(async () => { - await result.current.reset(); - }); - - expect(gateway.resetMemberBudgets).toHaveBeenCalledWith("team-999", ["u-1"]); - expect(gateway.resetMemberBudgets).not.toHaveBeenCalledWith("team-123", expect.anything()); - }); - - it("returns to prompting without its own toast when the team save fails", async () => { - const gateway = buildGateway(); - gateway.saveTeam.mockRejectedValueOnce(new Error("team update failed")); - const { result } = renderReset(gateway); - - await act(async () => { - result.current.prompt(pendingFor(["u-1"])); - }); - await act(async () => { - await result.current.reset(); - }); - - expect(result.current.state.phase).toBe("prompting"); - expect(gateway.resetMemberBudgets).not.toHaveBeenCalled(); - expect(gateway.refreshTeamData).not.toHaveBeenCalled(); - expect(toast.error).not.toHaveBeenCalled(); - expect(toast.fromError).not.toHaveBeenCalled(); - expect(toast.success).not.toHaveBeenCalled(); - }); - - it("retries only the unsent members when a later batch fails, without re-saving the team", async () => { - const userIds = Array.from({ length: MAX_BULK_TEAM_MEMBER_BUDGET_UPDATES + 1 }, (_, i) => `u-${i}`); - const gateway = buildGateway(); - gateway.resetMemberBudgets - .mockResolvedValueOnce( - userIds.slice(0, MAX_BULK_TEAM_MEMBER_BUDGET_UPDATES).map((user_id) => ({ success: true, user_id })), - ) - .mockRejectedValueOnce(new Error("second batch failed")); - const { result } = renderReset(gateway); - - await act(async () => { - result.current.prompt(pendingFor(userIds)); - }); - await act(async () => { - await result.current.reset(); - }); - - expect(result.current.state.phase).toBe("resetFailed"); - expect(toast.error).toHaveBeenCalledWith( - `Reset ${MAX_BULK_TEAM_MEMBER_BUDGET_UPDATES} of ${MAX_BULK_TEAM_MEMBER_BUDGET_UPDATES + 1} member budgets; the rest could not be reset`, - ); - - gateway.resetMemberBudgets.mockResolvedValueOnce([ - { success: true, user_id: `u-${MAX_BULK_TEAM_MEMBER_BUDGET_UPDATES}` }, - ]); - await act(async () => { - await result.current.retry(); - }); - - expect(gateway.saveTeam).toHaveBeenCalledTimes(1); - expect(gateway.resetMemberBudgets).toHaveBeenCalledTimes(3); - expect(gateway.resetMemberBudgets.mock.calls[2][0]).toBe("team-123"); - expect(gateway.resetMemberBudgets.mock.calls[2][1]).toEqual([`u-${MAX_BULK_TEAM_MEMBER_BUDGET_UPDATES}`]); - expect(toast.success).toHaveBeenCalledWith( - `Reset ${MAX_BULK_TEAM_MEMBER_BUDGET_UPDATES + 1} member budgets to the team default`, - ); - expect(result.current.state.phase).toBe("idle"); - }); - - it("reports partial progress when the first batch fails", async () => { - const gateway = buildGateway(); - gateway.resetMemberBudgets.mockRejectedValueOnce(new Error("batch failed")); - const { result } = renderReset(gateway); - - await act(async () => { - result.current.prompt(pendingFor(["u-1", "u-2"])); - }); - await act(async () => { - await result.current.reset(); - }); - - expect(result.current.state.phase).toBe("resetFailed"); - expect(toast.fromError).toHaveBeenCalledWith("Team updated, but member budgets could not be reset"); - expect(gateway.refreshTeamData).toHaveBeenCalledTimes(1); - }); - - it("reports members the backend could not reset and closes", async () => { - const gateway = buildGateway(); - gateway.resetMemberBudgets.mockResolvedValueOnce([ - { success: true, user_id: "u-1" }, - { success: false, user_id: "u-2" }, - ]); - const { result } = renderReset(gateway); - - await act(async () => { - result.current.prompt(pendingFor(["u-1", "u-2"])); - }); - await act(async () => { - await result.current.reset(); - }); - - expect(toast.error).toHaveBeenCalledWith("Team updated, but 1 member budget could not be reset"); - expect(toast.success).not.toHaveBeenCalled(); + expect(toast.success).toHaveBeenCalledWith("Moved 2 members to the $20.00 default"); expect(result.current.state.phase).toBe("idle"); expect(gateway.refreshTeamData).toHaveBeenCalledTimes(1); }); - it("saves the team once and closes on keep custom", async () => { - const gateway = buildGateway(); - const { result } = renderReset(gateway); + it("confirms a plain save when custom budgets are kept", async () => { + const gateway = buildGateway({ moved_to_default: 0, skipped_other_reset_period: 0 }); + const { result } = await promptedReset(gateway); await act(async () => { - result.current.prompt(pendingFor(["u-1"])); - }); - await act(async () => { - await result.current.keepCustom(); + await result.current.save("none"); }); - expect(gateway.saveTeam).toHaveBeenCalledTimes(1); + expect(gateway.saveTeam).toHaveBeenCalledWith({ ...pending.updateData, team_member_budget_backfill: "none" }); expect(toast.success).toHaveBeenCalledWith("Team settings updated successfully"); - expect(gateway.resetMemberBudgets).not.toHaveBeenCalled(); - expect(gateway.refreshTeamData).toHaveBeenCalledTimes(1); - expect(result.current.state.phase).toBe("idle"); }); - it("abandons the pending update on dismiss", async () => { + it("returns to the prompt when the save fails", async () => { const gateway = buildGateway(); - const { result } = renderReset(gateway); + gateway.saveTeam.mockRejectedValueOnce(new Error("save failed")); + const { result } = await promptedReset(gateway); await act(async () => { - result.current.prompt(pendingFor(["u-1"])); - }); - await act(async () => { - result.current.dismiss(); + await result.current.save("lower_to_default"); }); - expect(result.current.state.phase).toBe("idle"); - expect(gateway.saveTeam).not.toHaveBeenCalled(); - expect(gateway.resetMemberBudgets).not.toHaveBeenCalled(); - }); - - it("skips the refresh and stays idle when dismissed while a reset is in flight", async () => { - const gateway = buildGateway(); - const bulkDone = Promise.withResolvers<{ success: boolean; user_id: string }[]>(); - gateway.resetMemberBudgets.mockReturnValueOnce(bulkDone.promise); - const { result } = renderReset(gateway); - - await act(async () => { - result.current.prompt(pendingFor(["u-1"])); - }); - let resetPromise = Promise.resolve(); - await act(async () => { - resetPromise = result.current.reset(); - }); - expect(result.current.state.phase).toBe("resetting"); - - act(() => { - result.current.dismiss(); - }); - await act(async () => { - bulkDone.resolve([{ success: true, user_id: "u-1" }]); - await resetPromise; - }); - - expect(result.current.state.phase).toBe("idle"); - expect(gateway.refreshTeamData).not.toHaveBeenCalled(); + expect(result.current.state).toEqual({ phase: "prompting", pending }); expect(toast.success).not.toHaveBeenCalled(); + expect(gateway.refreshTeamData).not.toHaveBeenCalled(); }); - it("does not return to prompting when the team save fails after a dismiss", async () => { + it("drops the outcome of a save that was dismissed while in flight", async () => { + const save = Promise.withResolvers(); const gateway = buildGateway(); - const saveDone = Promise.withResolvers(); - gateway.saveTeam.mockReturnValueOnce(saveDone.promise); - const { result } = renderReset(gateway); + gateway.saveTeam.mockReturnValueOnce(save.promise); + const { result } = await promptedReset(gateway); - await act(async () => { - result.current.prompt(pendingFor(["u-1"])); + let saving: Promise = Promise.resolve(); + act(() => { + saving = result.current.save("all_to_default"); }); - let resetPromise = Promise.resolve(); - await act(async () => { - resetPromise = result.current.reset(); - }); - + expect(result.current.state.phase).toBe("saving"); act(() => { result.current.dismiss(); }); await act(async () => { - saveDone.reject(new Error("team update failed")); - await resetPromise; + save.resolve({ moved_to_default: 3, skipped_other_reset_period: 0 }); + await saving; }); expect(result.current.state.phase).toBe("idle"); - expect(gateway.resetMemberBudgets).not.toHaveBeenCalled(); - expect(gateway.refreshTeamData).not.toHaveBeenCalled(); - }); - - it("stays idle without a refresh when the reset fails after a dismiss", async () => { - const gateway = buildGateway(); - const bulkDone = Promise.withResolvers<{ success: boolean; user_id: string }[]>(); - gateway.resetMemberBudgets.mockReturnValueOnce(bulkDone.promise); - const { result } = renderReset(gateway); - - await act(async () => { - result.current.prompt(pendingFor(["u-1"])); - }); - let resetPromise = Promise.resolve(); - await act(async () => { - resetPromise = result.current.reset(); - }); - - act(() => { - result.current.dismiss(); - }); - await act(async () => { - bulkDone.reject(new Error("bulk failed")); - await resetPromise; - }); - - expect(result.current.state.phase).toBe("idle"); - expect(gateway.refreshTeamData).not.toHaveBeenCalled(); - expect(toast.error).not.toHaveBeenCalled(); - expect(toast.fromError).not.toHaveBeenCalled(); - }); - - it("skips the refresh when dismissed while keep-custom is saving", async () => { - const gateway = buildGateway(); - const saveDone = Promise.withResolvers(); - gateway.saveTeam.mockReturnValueOnce(saveDone.promise); - const { result } = renderReset(gateway); - - await act(async () => { - result.current.prompt(pendingFor(["u-1"])); - }); - let keepPromise = Promise.resolve(); - await act(async () => { - keepPromise = result.current.keepCustom(); - }); - - act(() => { - result.current.dismiss(); - }); - await act(async () => { - saveDone.resolve(); - await keepPromise; - }); - - expect(result.current.state.phase).toBe("idle"); - expect(gateway.refreshTeamData).not.toHaveBeenCalled(); expect(toast.success).not.toHaveBeenCalled(); + expect(gateway.refreshTeamData).not.toHaveBeenCalled(); }); }); diff --git a/ui/litellm-dashboard/src/components/team/useMemberBudgetReset.ts b/ui/litellm-dashboard/src/components/team/useMemberBudgetReset.ts index f0ff832b34a..78e8b1a0474 100644 --- a/ui/litellm-dashboard/src/components/team/useMemberBudgetReset.ts +++ b/ui/litellm-dashboard/src/components/team/useMemberBudgetReset.ts @@ -1,128 +1,54 @@ import { useCallback, useRef, useState } from "react"; -import type { components } from "@/lib/http/schema"; import { toast } from "@/lib/toast"; +import { formatNumberWithCommas } from "@/utils/dataUtils"; import { - chunk, - MAX_BULK_TEAM_MEMBER_BUDGET_UPDATES, pluralize, + type MemberBudgetBackfill, + type MemberBudgetBackfillResult, type MemberBudgetResetPending, type TeamUpdatePayload, } from "./memberBudgetReset"; -export type MemberBudgetBulkResult = components["schemas"]["TeamMemberBudgetUpdateResult"]; - export type MemberBudgetResetState = | { phase: "idle" } | { phase: "prompting"; pending: MemberBudgetResetPending } - | { phase: "resetting"; pending: MemberBudgetResetPending; attempted: number } - | { phase: "resetFailed"; pending: MemberBudgetResetPending; attempted: number }; + | { phase: "saving"; pending: MemberBudgetResetPending }; export interface MemberBudgetResetGateway { - saveTeam: (updateData: TeamUpdatePayload) => Promise; - resetMemberBudgets: (teamId: string, userIds: readonly string[]) => Promise; + saveTeam: (updateData: TeamUpdatePayload) => Promise; refreshTeamData: () => Promise; } -type ResetRun = - | { ok: true; attempted: number; results: readonly MemberBudgetBulkResult[] } - | { ok: false; attempted: number; error: unknown }; +export const backfillToastMessage = (result: MemberBudgetBackfillResult | undefined, newBudget: number): string => { + if (result === undefined) return "Team settings updated successfully"; + const moved = `Moved ${result.moved_to_default} ${pluralize(result.moved_to_default, "member", "members")} to the $${formatNumberWithCommas(newBudget, 2)} default`; + const skipped = result.skipped_other_reset_period; + if (skipped === 0) return moved; + return `${moved}. ${skipped} ${pluralize(skipped, "member resets", "members reset")} on a different schedule and ${pluralize(skipped, "was", "were")} not changed`; +}; export const useMemberBudgetReset = (gateway: MemberBudgetResetGateway) => { const [state, setState] = useState({ phase: "idle" }); const activeRun = useRef(null); - const isCurrent = (run: object) => activeRun.current === run; - - const runReset = async (pending: MemberBudgetResetPending, attempted: number, run: object) => { - const { resetMemberBudgets, refreshTeamData } = gateway; - - const runChunks = ( - chunks: readonly (readonly string[])[], - attemptedSoFar: number, - results: readonly MemberBudgetBulkResult[], - ): Promise => { - const [ids, ...rest] = chunks; - if (ids === undefined) return Promise.resolve({ ok: true, attempted: attemptedSoFar, results }); - return resetMemberBudgets(pending.teamId, ids).then( - (batch) => runChunks(rest, attemptedSoFar + ids.length, [...results, ...batch]), - (error: unknown) => ({ ok: false as const, attempted: attemptedSoFar, error }), - ); - }; - - const outcome = await runChunks( - chunk(pending.userIds.slice(attempted), MAX_BULK_TEAM_MEMBER_BUDGET_UPDATES), - attempted, - [], - ); - - if (!isCurrent(run)) return; - if (!outcome.ok) { - console.error("Error resetting member budgets:", outcome.error); - const total = pending.userIds.length; - if (outcome.attempted > 0) { - toast.error( - `Reset ${outcome.attempted} of ${total} member ${pluralize(total, "budget", "budgets")}; the rest could not be reset`, - ); - } else { - toast.fromError("Team updated, but member budgets could not be reset"); - } - setState({ phase: "resetFailed", pending, attempted: outcome.attempted }); - await refreshTeamData(); - return; - } - const failed = outcome.results.filter((r) => !r.success); - if (failed.length > 0) { - toast.error( - `Team updated, but ${failed.length} member ${pluralize(failed.length, "budget", "budgets")} could not be reset`, - ); - } else { - toast.success( - `Reset ${outcome.attempted} member ${pluralize(outcome.attempted, "budget", "budgets")} to the team default`, - ); - } - setState({ phase: "idle" }); - await refreshTeamData(); - }; const prompt = (pending: MemberBudgetResetPending) => setState({ phase: "prompting", pending }); - const reset = async () => { + const save = async (backfill: MemberBudgetBackfill) => { if (state.phase !== "prompting") return; const { pending } = state; const run = {}; activeRun.current = run; - setState({ phase: "resetting", pending, attempted: 0 }); + setState({ phase: "saving", pending }); try { - await gateway.saveTeam(pending.updateData); + const result = await gateway.saveTeam({ ...pending.updateData, team_member_budget_backfill: backfill }); + if (activeRun.current !== run) return; + toast.success(backfillToastMessage(backfill === "none" ? undefined : result, pending.newBudget)); + setState({ phase: "idle" }); + await gateway.refreshTeamData(); } catch (error) { console.error("Error updating team:", error); - if (isCurrent(run)) setState({ phase: "prompting", pending }); - return; + if (activeRun.current === run) setState({ phase: "prompting", pending }); } - await runReset(pending, 0, run); - }; - - const retry = async () => { - if (state.phase !== "resetFailed") return; - const { pending, attempted } = state; - const run = {}; - activeRun.current = run; - setState({ phase: "resetting", pending, attempted }); - await runReset(pending, attempted, run); - }; - - const keepCustom = async () => { - if (state.phase !== "prompting") return; - const { pending } = state; - const run = {}; - activeRun.current = run; - setState({ phase: "idle" }); - try { - await gateway.saveTeam(pending.updateData); - if (isCurrent(run)) toast.success("Team settings updated successfully"); - } catch (error) { - console.error("Error updating team:", error); - } - if (isCurrent(run)) await gateway.refreshTeamData(); }; const dismiss = useCallback(() => { @@ -130,5 +56,5 @@ export const useMemberBudgetReset = (gateway: MemberBudgetResetGateway) => { setState({ phase: "idle" }); }, []); - return { state, prompt, reset, retry, keepCustom, dismiss }; + return { state, prompt, save, dismiss }; }; diff --git a/ui/litellm-dashboard/src/lib/http/schema.d.ts b/ui/litellm-dashboard/src/lib/http/schema.d.ts index f3821a2bb46..4d7d0219d0f 100644 --- a/ui/litellm-dashboard/src/lib/http/schema.d.ts +++ b/ui/litellm-dashboard/src/lib/http/schema.d.ts @@ -40584,6 +40584,11 @@ export interface components { team_id?: string | null; /** Team Member Budget */ team_member_budget?: number | null; + /** + * Team Member Budget Backfill + * @description Which members with their own budget move onto the team_member_budget sent in the same request: 'raise_to_default' moves those below it, 'lower_to_default' those above it, 'all_to_default' both. Members whose budget resets on a different schedule than the default are left alone + */ + team_member_budget_backfill?: ("none" | "raise_to_default" | "lower_to_default" | "all_to_default") | null; /** Team Member Budget Duration */ team_member_budget_duration?: string | null; /** Team Member Key Duration */ @@ -48770,6 +48775,11 @@ export interface components { team_id: string; /** Team Member Budget */ team_member_budget?: number | null; + /** + * Team Member Budget Backfill + * @description Which members with their own budget move onto the team_member_budget sent in the same request: 'raise_to_default' moves those below it, 'lower_to_default' those above it, 'all_to_default' both. Members whose budget resets on a different schedule than the default are left alone + */ + team_member_budget_backfill?: ("none" | "raise_to_default" | "lower_to_default" | "all_to_default") | null; /** Team Member Budget Duration */ team_member_budget_duration?: string | null; /** Team Member Key Duration */ From 0e82841157f2fdeed88c7babb44ea69992ddfb93 Mon Sep 17 00:00:00 2001 From: shrey kharbanda Date: Fri, 23 Oct 2026 15:31:46 -0700 Subject: [PATCH 2/6] refactor(teams): keep the backfill SQL static and its writes fully typed Pass the backfill direction to a CASE as a bound parameter instead of formatting it into the query, write per-model member budgets through prisma.Json, and validate the request through a TypeAdapter so no Any leaks in. Also regenerates the dashboard API types after merging main. --- .../management_endpoints/team_endpoints.py | 16 +- .../team_member_default_budget.py | 85 +- .../test_team_endpoints.py | 1340 +++++------------ .../test_team_member_default_budget.py | 6 +- ui/litellm-dashboard/src/lib/http/schema.d.ts | 1 + 5 files changed, 450 insertions(+), 998 deletions(-) diff --git a/litellm/proxy/management_endpoints/team_endpoints.py b/litellm/proxy/management_endpoints/team_endpoints.py index 11e83150d8c..1cec93f857b 100644 --- a/litellm/proxy/management_endpoints/team_endpoints.py +++ b/litellm/proxy/management_endpoints/team_endpoints.py @@ -650,7 +650,7 @@ class TeamMemberBudgetHandler: @staticmethod @with_service_target("team_member_budgets") - async def _evict_default_budget_cache( + async def evict_default_budget_cache( budget_id: str, user_api_key_cache: UserApiKeyCache | None, ) -> None: @@ -712,7 +712,7 @@ class TeamMemberBudgetHandler: budget_obj=budget_request, user_api_key_dict=user_api_key_dict, ) - await TeamMemberBudgetHandler._evict_default_budget_cache( + await TeamMemberBudgetHandler.evict_default_budget_cache( budget_id=team_member_budget_table.budget_id, user_api_key_cache=user_api_key_cache, ) @@ -2627,10 +2627,10 @@ async def update_team( verbose_proxy_logger.info("Successfully updated team - %s, info", team_row.team_id) if default_budget_write is not None: - await TeamMemberBudgetHandler._evict_default_budget_cache( + await TeamMemberBudgetHandler.evict_default_budget_cache( budget_id=default_budget_write.budget_id, user_api_key_cache=user_api_key_cache ) - await _evict_team_member_cache_keys( + await evict_team_member_cache_keys( team_id=team_row.team_id, member_user_ids=team_write.changed_member_user_ids(), cache_keys=tuple(team_membership_cache_keys(team_row.team_id, team_write.changed_member_user_ids())), @@ -2650,14 +2650,14 @@ async def update_team( if is_audit_logging_enabled(): await _create_team_update_audit_log( existing_team_row=existing_team_row, - updated_kv=updated_kv | team_write.backfill_audit(), + updated_kv={**updated_kv, **team_write.backfill_audit()}, team_id=data.team_id, litellm_changed_by=litellm_changed_by, user_api_key_dict=user_api_key_dict, litellm_proxy_admin_name=litellm_proxy_admin_name, ) - return {"team_id": team_row.team_id, "data": team_row} | team_write.backfill_response() + return {"team_id": team_row.team_id, "data": team_row, **team_write.backfill_response()} except Exception as e: raise handle_exception_on_proxy(e) @@ -4839,7 +4839,7 @@ async def _invalidate_deleted_team_member_cache( user_api_key_cache: UserApiKeyCache, ) -> None: for team_id, member_user_ids in member_ids_per_team: - await _evict_team_member_cache_keys( + await evict_team_member_cache_keys( team_id=team_id, member_user_ids=member_user_ids, cache_keys=tuple(member_cache_keys(team_id, member_user_ids)), @@ -4847,7 +4847,7 @@ async def _invalidate_deleted_team_member_cache( ) -async def _evict_team_member_cache_keys( +async def evict_team_member_cache_keys( team_id: str, member_user_ids: Sequence[str], cache_keys: Sequence[str], diff --git a/litellm/proxy/management_helpers/team_member_default_budget.py b/litellm/proxy/management_helpers/team_member_default_budget.py index a8d2721ae38..f49a38eb198 100644 --- a/litellm/proxy/management_helpers/team_member_default_budget.py +++ b/litellm/proxy/management_helpers/team_member_default_budget.py @@ -1,10 +1,9 @@ -import json import uuid from collections.abc import Mapping, Sequence from dataclasses import dataclass from datetime import datetime from types import MappingProxyType -from typing import TYPE_CHECKING, Final, assert_never +from typing import TYPE_CHECKING, Final from pydantic import BaseModel, ConfigDict, JsonValue, TypeAdapter, field_validator @@ -20,7 +19,6 @@ from litellm.proxy.management_endpoints.common_utils import ( has_meaningful_budget_limit, upsert_budget_and_membership, ) -from litellm.proxy.utils import jsonify_object if TYPE_CHECKING: from prisma import Prisma @@ -59,19 +57,24 @@ _SHARED_BUDGET_IDS_SQL: Final = """ SELECT budget_id FROM "LiteLLM_TeamMembership" WHERE budget_id = ANY($1::text[]) GROUP BY budget_id HAVING COUNT(*) > 1 """ -_CANDIDATES_BY_SCHEDULE_SQL: Final = """ -SELECT b.budget_duration AS duration, COUNT(*)::int AS members -FROM "LiteLLM_TeamMembership" m JOIN "LiteLLM_BudgetTable" b ON b.budget_id = m.budget_id -WHERE m.team_id = $1 AND m.budget_id <> $2 AND {direction} -GROUP BY b.budget_duration -""" -_CANDIDATES_SQL: Final = """ -SELECT m.user_id, b.budget_id, b.soft_budget, b.max_parallel_requests, b.tpm_limit, b.rpm_limit, - b.model_max_budget, b.budget_duration, b.allowed_models, b.temp_budget_increase, b.temp_budget_expiry -FROM "LiteLLM_TeamMembership" m JOIN "LiteLLM_BudgetTable" b ON b.budget_id = m.budget_id -WHERE m.team_id = $1 AND m.budget_id <> $2 AND {direction} - AND (b.budget_duration = ANY($4::text[]) OR ($5::boolean AND b.budget_duration IS NULL)) -""" +_ON_CHOSEN_SIDE_OF_DEFAULT: Final = """m.team_id = $1 AND m.budget_id <> $2 AND CASE $3::text + WHEN 'raise_to_default' THEN b.max_budget < $4::double precision + WHEN 'lower_to_default' THEN b.max_budget > $4::double precision + WHEN 'all_to_default' THEN b.max_budget <> $4::double precision + ELSE FALSE END""" +_CANDIDATES_BY_SCHEDULE_SQL: Final = ( + 'SELECT b.budget_duration AS duration, COUNT(*)::int AS members FROM "LiteLLM_TeamMembership" m ' + 'JOIN "LiteLLM_BudgetTable" b ON b.budget_id = m.budget_id WHERE ' + + _ON_CHOSEN_SIDE_OF_DEFAULT + + " GROUP BY b.budget_duration" +) +_CANDIDATES_SQL: Final = ( + "SELECT m.user_id, b.budget_id, b.soft_budget, b.max_parallel_requests, b.tpm_limit, b.rpm_limit, " + "b.model_max_budget, b.budget_duration, b.allowed_models, b.temp_budget_increase, b.temp_budget_expiry " + 'FROM "LiteLLM_TeamMembership" m JOIN "LiteLLM_BudgetTable" b ON b.budget_id = m.budget_id WHERE ' + + _ON_CHOSEN_SIDE_OF_DEFAULT + + " AND (b.budget_duration = ANY($5::text[]) OR ($6::boolean AND b.budget_duration IS NULL))" +) @dataclass(frozen=True, slots=True) @@ -121,12 +124,12 @@ class _BudgetLimits(BaseModel): @field_validator("model_max_budget", mode="before") @classmethod def _decode_json_column(cls, value: object) -> object: - return json.loads(value) if isinstance(value, str) else value + return _JSON_VALUE.validate_json(value) if isinstance(value, str) else value def has_own_limits_beyond(self, default: "_BudgetLimits") -> bool: - return has_meaningful_budget_limit( - {field: value for field, value in self.model_dump().items() if value != getattr(default, field)} - ) + own: Final = _JSON_OBJECT.validate_python(self.model_dump(mode="json")) + inherited: Final = _JSON_OBJECT.validate_python(default.model_dump(mode="json")) + return has_meaningful_budget_limit({field: value for field, value in own.items() if value != inherited[field]}) class _MemberBudgetRef(BaseModel): @@ -148,6 +151,8 @@ class _BudgetIdRow(BaseModel): budget_id: str +_JSON_VALUE: Final[TypeAdapter[JsonValue]] = TypeAdapter(JsonValue) +_JSON_OBJECT: Final = TypeAdapter(dict[str, JsonValue]) _SCHEDULE_COUNTS: Final = TypeAdapter(tuple[_ScheduleCount, ...]) _MEMBER_BUDGET_REFS: Final = TypeAdapter(tuple[_MemberBudgetRef, ...]) _MEMBER_BUDGET_LIMITS: Final = TypeAdapter(tuple[_BudgetLimits, ...]) @@ -160,12 +165,14 @@ def plan_team_member_default_budget_write( team_alias: str | None, team_budget_duration: str | None, ) -> TeamMemberDefaultBudgetWrite | None: - requested: Final = data.model_dump(include=frozenset(_DEFAULT_BUDGET_COLUMNS) & data.model_fields_set) + requested: Final = _JSON_OBJECT.validate_python( + data.model_dump(mode="json", include=data.model_fields_set & _DEFAULT_BUDGET_COLUMNS.keys()) + ) sent: Final = MappingProxyType({_DEFAULT_BUDGET_COLUMNS[field]: value for field, value in requested.items()}) links_members: Final = any(value is not None for value in sent.values()) if not sent or (existing_budget_id is None and not links_members): return None - create_duration: Final = sent["budget_duration"] if "budget_duration" in sent else team_budget_duration + create_duration: Final = sent.get("budget_duration", team_budget_duration) created: Final = {**sent, "budget_duration": create_duration} return TeamMemberDefaultBudgetWrite( budget_id=existing_budget_id or _new_default_budget_id(team_alias), @@ -190,10 +197,10 @@ async def write_team_member_default_budget( await _budget_tx_db(tx).upsert( where={"budget_id": write.budget_id}, data={ - "create": jsonify_object( + "create": _prisma_columns( {**write.create, **stamps, "budget_id": write.budget_id, "created_by": changed_by} ), - "update": jsonify_object({**write.update, **stamps}), + "update": _prisma_columns({**write.update, **stamps}), }, ) if not write.links_members: @@ -213,17 +220,14 @@ async def move_member_budgets_to_default( """Members compare on their permanent ``max_budget``, and only those resetting on the default's schedule move. A member whose other limits all match the default is linked to the default row, while one holding a limit of its own keeps its row with ``max_budget`` cleared.""" - direction: Final = _direction_sql(backfill) - if direction is None: + if backfill == "none": return MovedMemberBudgets(user_ids=(), skipped_other_reset_period=0) default: Final = await _budget_tx_db(tx).find_unique(where={"budget_id": default_budget_id}) if default is None or default.max_budget is None: return MovedMemberBudgets(user_ids=(), skipped_other_reset_period=0) schedule: Final = budget_reset_period_key(default.budget_duration) counts: Final = _SCHEDULE_COUNTS.validate_python( - await tx.query_raw( - _CANDIDATES_BY_SCHEDULE_SQL.format(direction=direction), team_id, default_budget_id, default.max_budget - ) + await tx.query_raw(_CANDIDATES_BY_SCHEDULE_SQL, team_id, default_budget_id, backfill, default.max_budget) ) matching: Final = tuple(count for count in counts if budget_reset_period_key(count.duration) == schedule) moving: Final = sum(count.members for count in matching) @@ -233,9 +237,10 @@ async def move_member_budgets_to_default( if moving == 0: return MovedMemberBudgets(user_ids=(), skipped_other_reset_period=skipped) rows: Final = await tx.query_raw( - _CANDIDATES_SQL.format(direction=direction), + _CANDIDATES_SQL, team_id, default_budget_id, + backfill, default.max_budget, [count.duration for count in matching if count.duration is not None], any(count.duration is None for count in matching), @@ -289,24 +294,16 @@ async def _move_to_default( ) +def _prisma_columns(columns: Mapping[str, object]) -> Mapping[str, object]: + from prisma import Json # noqa: PLC0415 # local import: prisma may be ungenerated at module load in some tools + + return {column: Json(value) if isinstance(value, dict) else value for column, value in columns.items()} + + def _budget_tx_db(tx: "Prisma") -> "TableActions[prisma_models.LiteLLM_BudgetTable]": return tx.litellm_budgettable # pyright: ignore[reportReturnType] # TableActions widens the generated inputs to Mapping, as the repositories do -def _direction_sql(backfill: TeamMemberBudgetBackfill) -> str | None: - match backfill: - case "none": - return None - case "raise_to_default": - return "b.max_budget < $3::double precision" - case "lower_to_default": - return "b.max_budget > $3::double precision" - case "all_to_default": - return "b.max_budget <> $3::double precision" - case _: - assert_never(backfill) - - def _with_reset_at(columns: Mapping[str, object]) -> Mapping[str, object]: if "budget_duration" not in columns: return MappingProxyType(dict(columns)) diff --git a/tests/unit/proxy/management_endpoints/test_team_endpoints.py b/tests/unit/proxy/management_endpoints/test_team_endpoints.py index 9e3946daaec..f99e20a02a7 100644 --- a/tests/unit/proxy/management_endpoints/test_team_endpoints.py +++ b/tests/unit/proxy/management_endpoints/test_team_endpoints.py @@ -121,7 +121,9 @@ def _team_admin_may_edit(*fields: str): "litellm.proxy.management_endpoints.team_endpoints.PROXY_CONTROLLED_TEAM_METADATA_KEYS", PROXY_CONTROLLED_TEAM_METADATA_KEYS - frozenset(fields), ), - patch("litellm.proxy.proxy_server.general_settings", {"team_admin_editable_team_fields": list(fields)}), # test-quality-ok: update_team reads general_settings as a proxy_server module global + patch( + "litellm.proxy.proxy_server.general_settings", {"team_admin_editable_team_fields": list(fields)} + ), # test-quality-ok: update_team reads general_settings as a proxy_server module global ): yield @@ -277,9 +279,7 @@ mock_prisma_client.db.litellm_auditlog.create = AsyncMock() # Fixture to provide the mock prisma client @pytest.fixture(autouse=True) def mock_db_client(): - with patch( - "litellm.proxy.proxy_server.prisma_client", mock_prisma_client - ): # Mock in both places if necessary + with patch("litellm.proxy.proxy_server.prisma_client", mock_prisma_client): # Mock in both places if necessary yield mock_prisma_client mock_prisma_client.reset_mock() @@ -322,27 +322,17 @@ async def test_validate_team_org_change_same_org_id(): organization.organization_id = org_id organization.models = [] organization.litellm_budget_table = MagicMock() - organization.litellm_budget_table.max_budget = ( - 50.0 # This would normally fail validation - ) - organization.litellm_budget_table.tpm_limit = ( - 500 # This would normally fail validation - ) - organization.litellm_budget_table.rpm_limit = ( - 50 # This would normally fail validation - ) + organization.litellm_budget_table.max_budget = 50.0 # This would normally fail validation + organization.litellm_budget_table.tpm_limit = 500 # This would normally fail validation + organization.litellm_budget_table.rpm_limit = 50 # This would normally fail validation organization.members = [] # Mock Router mock_router = MagicMock(spec=Router) # Use patch to ensure the model access check is never called - with patch( - "litellm.proxy.management_endpoints.team_endpoints.can_org_access_model" - ) as mock_access_check: - result = validate_team_org_change( - team=team, organization=organization, llm_router=mock_router - ) + with patch("litellm.proxy.management_endpoints.team_endpoints.can_org_access_model") as mock_access_check: + result = validate_team_org_change(team=team, organization=organization, llm_router=mock_router) # Assert the function returns True without checking anything assert result is True @@ -359,9 +349,7 @@ async def test_validate_team_org_change_same_org_id(): ], ) @pytest.mark.asyncio -async def test_validate_team_org_change_zero_org_budget_is_enforced( - org_max_budget, team_max_budget, expect_blocked -): +async def test_validate_team_org_change_zero_org_budget_is_enforced(org_max_budget, team_max_budget, expect_blocked): """An organization with an explicit max_budget of 0 must still block moving in a team with a larger budget, matching key/team/user zero-budget semantics. @@ -443,9 +431,7 @@ async def test_validate_team_org_change_members_in_org(): mock_router = MagicMock(spec=Router) # Test should pass - all team members are in org members - result = validate_team_org_change( - team=team, organization=organization, llm_router=mock_router - ) + result = validate_team_org_change(team=team, organization=organization, llm_router=mock_router) assert result is True @@ -497,9 +483,7 @@ async def test_validate_team_org_change_member_not_in_org(): # Test should fail - user_id_not_in_org is not in org members with pytest.raises(HTTPException) as exc_info: - validate_team_org_change( - team=team, organization=organization, llm_router=mock_router - ) + validate_team_org_change(team=team, organization=organization, llm_router=mock_router) assert exc_info.value.status_code == 403 assert "not a member of the organization" in str(exc_info.value.detail) @@ -543,10 +527,7 @@ async def test_get_team_permissions_list_success(mock_db_client, mock_admin_auth assert response.status_code == 200 response_data = response.json() assert response_data["team_id"] == test_team_id - assert ( - response_data["team_member_permissions"] - == mock_team_data["team_member_permissions"] - ) + assert response_data["team_member_permissions"] == mock_team_data["team_member_permissions"] assert ( response_data["all_available_permissions"] == TeamMemberPermissionChecks.get_all_available_team_member_permissions() @@ -609,9 +590,7 @@ async def test_update_team_permissions_success(mock_db_client, mock_admin_auth): return_value=mock_existing_team_row, ): # Mock the database update function - mock_db_client.db.litellm_teamtable.update = AsyncMock( - return_value=mock_updated_team_row - ) + mock_db_client.db.litellm_teamtable.update = AsyncMock(return_value=mock_updated_team_row) # Override the dependency for this test app.dependency_overrides[user_api_key_auth] = lambda: mock_admin_auth @@ -636,9 +615,7 @@ async def test_update_team_permissions_success(mock_db_client, mock_admin_auth): @pytest.mark.asyncio @pytest.mark.parametrize("field", ["budget_duration", "team_member_budget_duration"]) @pytest.mark.parametrize("bad_duration", ["0s", "-5m"]) -async def test_new_team_rejects_a_duration_that_never_advances( - mock_db_client, mock_admin_auth, field, bad_duration -): +async def test_new_team_rejects_a_duration_that_never_advances(mock_db_client, mock_admin_auth, field, bad_duration): """A zero-length window resets to "now", so the team row is due again the moment it is written. The reset job re-reads such rows on every tick, and a tenant with enough of them fills each batch and starves other tenants. @@ -668,9 +645,7 @@ async def test_new_team_rejects_a_duration_that_never_advances( @pytest.mark.asyncio @pytest.mark.parametrize("field", ["budget_duration", "team_member_budget_duration"]) -async def test_update_team_rejects_a_duration_that_never_advances( - mock_db_client, mock_admin_auth, field -): +async def test_update_team_rejects_a_duration_that_never_advances(mock_db_client, mock_admin_auth, field): """/team/update must reject the same never-advancing durations /team/new does.""" from fastapi import Request @@ -709,17 +684,13 @@ async def test_new_team_with_object_permission(mock_db_client, mock_admin_auth): mock_db_client.db = MagicMock() # Mock object permission table creation - mock_object_perm_create = AsyncMock( - return_value=MagicMock(object_permission_id="objperm123") - ) + mock_object_perm_create = AsyncMock(return_value=MagicMock(object_permission_id="objperm123")) mock_db_client.db.litellm_objectpermissiontable = MagicMock() mock_db_client.db.litellm_objectpermissiontable.create = mock_object_perm_create # Mock model table creation mock_db_client.db.litellm_modeltable = MagicMock() - mock_db_client.db.litellm_modeltable.create = AsyncMock( - return_value=MagicMock(id="model123") - ) + mock_db_client.db.litellm_modeltable.create = AsyncMock(return_value=MagicMock(id="model123")) # Capture team table creation team_create_result = MagicMock( @@ -736,9 +707,7 @@ async def test_new_team_with_object_permission(mock_db_client, mock_admin_auth): mock_db_client.db.litellm_teamtable.create = mock_team_create _wire_team_create_tx(mock_db_client) mock_db_client.db.litellm_teamtable.count = mock_team_count - mock_db_client.db.litellm_teamtable.update = AsyncMock( - return_value=team_create_result - ) + mock_db_client.db.litellm_teamtable.update = AsyncMock(return_value=team_create_result) # Mock user table mock_db_client.db.litellm_usertable = MagicMock() @@ -844,9 +813,7 @@ async def test_new_team_with_mcp_tool_permissions(mock_db_client, mock_admin_aut # Mock model table mock_db_client.db.litellm_modeltable = MagicMock() - mock_db_client.db.litellm_modeltable.create = AsyncMock( - return_value=MagicMock(id="model456") - ) + mock_db_client.db.litellm_modeltable.create = AsyncMock(return_value=MagicMock(id="model456")) # Mock team table team_create_result = MagicMock( @@ -858,14 +825,10 @@ async def test_new_team_with_mcp_tool_permissions(mock_db_client, mock_admin_aut "object_permission_id": "objperm_team_mcp_456", } mock_db_client.db.litellm_teamtable = MagicMock() - mock_db_client.db.litellm_teamtable.create = AsyncMock( - return_value=team_create_result - ) + mock_db_client.db.litellm_teamtable.create = AsyncMock(return_value=team_create_result) _wire_team_create_tx(mock_db_client) mock_db_client.db.litellm_teamtable.count = AsyncMock(return_value=0) - mock_db_client.db.litellm_teamtable.update = AsyncMock( - return_value=team_create_result - ) + mock_db_client.db.litellm_teamtable.update = AsyncMock(return_value=team_create_result) # Mock user table mock_db_client.db.litellm_usertable = MagicMock() @@ -924,20 +887,14 @@ def test_should_auto_add_team_creator(user_role, user_id, flag_value, expected): _should_auto_add_team_creator, ) - general_settings = ( - {} if flag_value is None else {"disable_auto_add_proxy_admin_to_teams": flag_value} - ) + general_settings = {} if flag_value is None else {"disable_auto_add_proxy_admin_to_teams": flag_value} auth = UserAPIKeyAuth(user_role=user_role, user_id=user_id) assert _should_auto_add_team_creator(auth, general_settings) is expected @pytest.mark.asyncio -@pytest.mark.parametrize( - "disable_flag,expect_creator_added", [(True, False), (False, True)] -) -async def test_new_team_disable_auto_add_proxy_admin_flag( - mock_db_client, disable_flag, expect_creator_added -): +@pytest.mark.parametrize("disable_flag,expect_creator_added", [(True, False), (False, True)]) +async def test_new_team_disable_auto_add_proxy_admin_flag(mock_db_client, disable_flag, expect_creator_added): """ When general_settings.disable_auto_add_proxy_admin_to_teams is True, a proxy admin calling /team/new must NOT be auto-added to the team's members. When @@ -952,9 +909,7 @@ async def test_new_team_disable_auto_add_proxy_admin_flag( team_create_result = MagicMock(team_id="team-789") team_create_result.model_dump.return_value = {"team_id": "team-789"} mock_db_client.db.litellm_teamtable = MagicMock() - mock_db_client.db.litellm_teamtable.create = AsyncMock( - return_value=team_create_result - ) + mock_db_client.db.litellm_teamtable.create = AsyncMock(return_value=team_create_result) _wire_team_create_tx(mock_db_client) mock_db_client.db.litellm_teamtable.count = AsyncMock(return_value=0) mock_db_client.db.litellm_usertable = MagicMock() @@ -965,17 +920,18 @@ async def test_new_team_disable_auto_add_proxy_admin_flag( from litellm.proxy._types import NewTeamRequest from litellm.proxy.management_endpoints.team_endpoints import new_team - admin_auth = UserAPIKeyAuth( - user_role=LitellmUserRoles.PROXY_ADMIN, user_id="admin-user-1" - ) + admin_auth = UserAPIKeyAuth(user_role=LitellmUserRoles.PROXY_ADMIN, user_id="admin-user-1") - with patch( - "litellm.proxy.proxy_server.general_settings", - {"disable_auto_add_proxy_admin_to_teams": disable_flag}, - ), patch( - "litellm.proxy.management_endpoints.team_endpoints._add_team_members_to_team", - new_callable=AsyncMock, - ) as mock_add_members: + with ( + patch( + "litellm.proxy.proxy_server.general_settings", + {"disable_auto_add_proxy_admin_to_teams": disable_flag}, + ), + patch( + "litellm.proxy.management_endpoints.team_endpoints._add_team_members_to_team", + new_callable=AsyncMock, + ) as mock_add_members, + ): await new_team( data=NewTeamRequest(team_alias="flag-test-team"), http_request=MagicMock(spec=Request), @@ -1024,16 +980,12 @@ async def test_team_update_object_permissions_existing_permission(monkeypatch): "vector_stores": ["old_store_1", "old_store_2"], } - mock_prisma_client.db.litellm_objectpermissiontable.find_unique = AsyncMock( - return_value=existing_object_permission - ) + mock_prisma_client.db.litellm_objectpermissiontable.find_unique = AsyncMock(return_value=existing_object_permission) # Mock upsert operation updated_permission = MagicMock() updated_permission.object_permission_id = "existing_perm_id_123" - mock_prisma_client.db.litellm_objectpermissiontable.upsert = AsyncMock( - return_value=updated_permission - ) + mock_prisma_client.db.litellm_objectpermissiontable.upsert = AsyncMock(return_value=updated_permission) # Test data with new object permission data_json = { @@ -1089,21 +1041,17 @@ async def test_team_update_object_permissions_no_existing_permission(monkeypatch ) # Mock find_unique to return None (no existing permission) - mock_prisma_client.db.litellm_objectpermissiontable.find_unique = AsyncMock( - return_value=None - ) + mock_prisma_client.db.litellm_objectpermissiontable.find_unique = AsyncMock(return_value=None) # Mock upsert to create new record new_permission = MagicMock() new_permission.object_permission_id = "new_perm_id_456" - mock_prisma_client.db.litellm_objectpermissiontable.upsert = AsyncMock( - return_value=new_permission - ) + mock_prisma_client.db.litellm_objectpermissiontable.upsert = AsyncMock(return_value=new_permission) data_json = { - "object_permission": LiteLLM_ObjectPermissionBase( - vector_stores=["brand_new_store"] - ).model_dump(exclude_unset=True, exclude_none=True), + "object_permission": LiteLLM_ObjectPermissionBase(vector_stores=["brand_new_store"]).model_dump( + exclude_unset=True, exclude_none=True + ), "team_alias": "updated_team_2", } @@ -1149,21 +1097,17 @@ async def test_team_update_object_permissions_missing_permission_record(monkeypa ) # Mock find_unique to return None (permission record not found) - mock_prisma_client.db.litellm_objectpermissiontable.find_unique = AsyncMock( - return_value=None - ) + mock_prisma_client.db.litellm_objectpermissiontable.find_unique = AsyncMock(return_value=None) # Mock upsert to create new record new_permission = MagicMock() new_permission.object_permission_id = "recreated_perm_id_789" - mock_prisma_client.db.litellm_objectpermissiontable.upsert = AsyncMock( - return_value=new_permission - ) + mock_prisma_client.db.litellm_objectpermissiontable.upsert = AsyncMock(return_value=new_permission) data_json = { - "object_permission": LiteLLM_ObjectPermissionBase( - vector_stores=["recreated_store"] - ).model_dump(exclude_unset=True, exclude_none=True), + "object_permission": LiteLLM_ObjectPermissionBase(vector_stores=["recreated_store"]).model_dump( + exclude_unset=True, exclude_none=True + ), "team_alias": "updated_team_3", } @@ -1269,14 +1213,10 @@ async def test_add_team_member_budget_table_success(): mock_budget_record.budget_id = "budget-123" mock_budget_record.max_budget = 1000.0 - mock_prisma_client.db.litellm_budgettable.find_unique = AsyncMock( - return_value=mock_budget_record - ) + mock_prisma_client.db.litellm_budgettable.find_unique = AsyncMock(return_value=mock_budget_record) # Create team info response object - team_info_response = TeamInfoResponseObjectTeamTable( - team_id="test-team-123", team_alias="Test Team" - ) + team_info_response = TeamInfoResponseObjectTeamTable(team_id="test-team-123", team_alias="Test Team") # Call the function result = await _add_team_member_budget_table( @@ -1287,15 +1227,11 @@ async def test_add_team_member_budget_table_success(): # Verify the result assert result.team_member_budget_table == mock_budget_record - assert result == team_info_response.model_copy( - update={"team_member_budget_table": mock_budget_record} - ) + assert result == team_info_response.model_copy(update={"team_member_budget_table": mock_budget_record}) assert team_info_response.team_member_budget_table is None # Verify database call was made correctly - mock_prisma_client.db.litellm_budgettable.find_unique.assert_called_once_with( - where={"budget_id": "budget-123"} - ) + mock_prisma_client.db.litellm_budgettable.find_unique.assert_called_once_with(where={"budget_id": "budget-123"}) @pytest.mark.asyncio @@ -1315,14 +1251,10 @@ async def test_add_team_member_budget_table_exception_handling(): ) # Create team info response object - team_info_response = TeamInfoResponseObjectTeamTable( - team_id="test-team-456", team_alias="Test Team 2" - ) + team_info_response = TeamInfoResponseObjectTeamTable(team_id="test-team-456", team_alias="Test Team 2") # Mock the verbose_proxy_logger to capture log calls - with patch( - "litellm.proxy.management_endpoints.team_endpoints.verbose_proxy_logger" - ) as mock_logger: + with patch("litellm.proxy.management_endpoints.team_endpoints.verbose_proxy_logger") as mock_logger: # Call the function result = await _add_team_member_budget_table( team_member_budget_id="nonexistent-budget-456", @@ -1334,10 +1266,7 @@ async def test_add_team_member_budget_table_exception_handling(): assert result == team_info_response # Verify team_member_budget_table is not set when exception occurs - assert ( - not hasattr(result, "team_member_budget_table") - or result.team_member_budget_table is None - ) + assert not hasattr(result, "team_member_budget_table") or result.team_member_budget_table is None # Verify the error was logged mock_logger.info.assert_called_once_with( @@ -1366,9 +1295,7 @@ async def test_add_team_member_budget_table_budget_not_found(): mock_prisma_client.db.litellm_budgettable.find_unique = AsyncMock(return_value=None) # Create team info response object - team_info_response = TeamInfoResponseObjectTeamTable( - team_id="test-team-789", team_alias="Test Team 3" - ) + team_info_response = TeamInfoResponseObjectTeamTable(team_id="test-team-789", team_alias="Test Team 3") # Call the function result = await _add_team_member_budget_table( @@ -1569,9 +1496,7 @@ async def test_available_team_self_join_blocks_other_user_id(): await _validate_team_member_add_permissions( user_api_key_dict=user, complete_team_data=team, - data=_make_team_member_add_request( - member_user_id="bob-victim", role="user" - ), + data=_make_team_member_add_request(member_user_id="bob-victim", role="user"), ) assert exc_info.value.status_code == 403 @@ -1988,9 +1913,7 @@ async def test_update_team_members_list_duplicate_prevention(): # Create mock team with existing members mock_team = MagicMock(spec=LiteLLM_TeamTable) - mock_team.members_with_roles = [ - Member(user_id="existing-user", user_email="existing@example.com", role="admin") - ] + mock_team.members_with_roles = [Member(user_id="existing-user", user_email="existing@example.com", role="admin")] # Try to add the same member again duplicate_member = Member(user_id="existing-user", role="user") @@ -2121,9 +2044,7 @@ async def test_add_team_members_runs_member_writes_on_the_lock_holding_transacti tx = MagicMock() tx.query_raw = AsyncMock(return_value=[{"members_with_roles": []}]) - tx.litellm_teamtable.update = AsyncMock( - return_value=LiteLLM_TeamTable(team_id="team-pool", members_with_roles=[]) - ) + tx.litellm_teamtable.update = AsyncMock(return_value=LiteLLM_TeamTable(team_id="team-pool", members_with_roles=[])) tx.litellm_usertable.upsert = AsyncMock(return_value=added_user) tx.litellm_usertable.update_many = AsyncMock() tx.litellm_budgettable.create = AsyncMock(return_value=created_budget) @@ -2178,9 +2099,7 @@ async def test_add_team_members_locks_every_named_user_row_in_id_order_before_th tx = MagicMock() tx.query_raw = AsyncMock(side_effect=query_raw) tx.litellm_usertable.find_many = AsyncMock(return_value=[email_match]) - tx.litellm_teamtable.update = AsyncMock( - return_value=LiteLLM_TeamTable(team_id="team-order", members_with_roles=[]) - ) + tx.litellm_teamtable.update = AsyncMock(return_value=LiteLLM_TeamTable(team_id="team-order", members_with_roles=[])) tx_cm = MagicMock() tx_cm.__aenter__ = AsyncMock(return_value=tx) tx_cm.__aexit__ = AsyncMock(return_value=None) @@ -2241,9 +2160,7 @@ async def test_add_team_members_skips_budget_and_membership_writes_for_members_a tx.query_raw = AsyncMock( return_value=[{"members_with_roles": [{"user_id": "alice", "user_email": None, "role": "user"}]}] ) - tx.litellm_teamtable.update = AsyncMock( - return_value=LiteLLM_TeamTable(team_id="team-mixed", members_with_roles=[]) - ) + tx.litellm_teamtable.update = AsyncMock(return_value=LiteLLM_TeamTable(team_id="team-mixed", members_with_roles=[])) tx.litellm_usertable.upsert = AsyncMock(return_value=added_user) tx.litellm_usertable.update_many = AsyncMock() tx.litellm_budgettable.create = AsyncMock(return_value=created_budget) @@ -2275,7 +2192,9 @@ async def test_add_team_members_skips_budget_and_membership_writes_for_members_a } assert [user.user_id for user in updated_users] == ["bob"] assert [tm.user_id for tm in updated_team_memberships] == ["bob"] - written_ids = [m["user_id"] for m in json.loads(tx.litellm_teamtable.update.call_args.kwargs["data"]["members_with_roles"])] + written_ids = [ + m["user_id"] for m in json.loads(tx.litellm_teamtable.update.call_args.kwargs["data"]["members_with_roles"]) + ] assert written_ids == ["alice", "bob"] @@ -2383,9 +2302,7 @@ async def test_team_model_add_delete_refresh_team_cache(endpoint_name): ) mock_request = Mock(spec=Request) - mock_user_api_key_dict = UserAPIKeyAuth( - user_role=LitellmUserRoles.PROXY_ADMIN, user_id="test_user_id" - ) + mock_user_api_key_dict = UserAPIKeyAuth(user_role=LitellmUserRoles.PROXY_ADMIN, user_id="test_user_id") existing_team = MagicMock() existing_team.model_dump.return_value = { @@ -2422,12 +2339,8 @@ async def test_team_model_add_delete_refresh_team_cache(endpoint_name): new_callable=AsyncMock, ) as mock_cache_team, ): - mock_prisma_client.db.litellm_teamtable.find_unique = AsyncMock( - return_value=existing_team - ) - mock_prisma_client.db.litellm_teamtable.update = AsyncMock( - return_value=updated_team - ) + mock_prisma_client.db.litellm_teamtable.find_unique = AsyncMock(return_value=existing_team) + mock_prisma_client.db.litellm_teamtable.update = AsyncMock(return_value=updated_team) mock_prisma_client.db.execute_raw = AsyncMock(return_value=None) if endpoint_name == "team_model_add": @@ -2469,15 +2382,11 @@ async def test_team_model_add_delete_refresh_team_cache(endpoint_name): # "no team-level restriction" and stop enforcing the team's # search-tool allowlist on key issuance. assert call_kwargs["team_table"].object_permission is not None - assert call_kwargs["team_table"].object_permission.search_tools == [ - "allowed-tool-A" - ] + assert call_kwargs["team_table"].object_permission.search_tools == ["allowed-tool-A"] # Pin the Prisma call shape too — the regression is in *what the # update returns*, so the contract that the update asks for # `object_permission` belongs in this test. - update_call_kwargs = ( - mock_prisma_client.db.litellm_teamtable.update.call_args.kwargs - ) + update_call_kwargs = mock_prisma_client.db.litellm_teamtable.update.call_args.kwargs assert update_call_kwargs.get("include", {}).get("object_permission") is True @@ -2796,9 +2705,7 @@ async def test_team_write_404s_when_row_vanishes_before_update(endpoint_name): ) mock_request = Mock(spec=Request) - mock_user_api_key_dict = UserAPIKeyAuth( - user_role=LitellmUserRoles.PROXY_ADMIN, user_id="test_user_id" - ) + mock_user_api_key_dict = UserAPIKeyAuth(user_role=LitellmUserRoles.PROXY_ADMIN, user_id="test_user_id") existing_team = MagicMock() existing_team.team_id = "team-1234" @@ -2841,9 +2748,15 @@ async def test_team_write_404s_when_row_vanishes_before_update(endpoint_name): }[endpoint_name] with ( - patch("litellm.proxy.proxy_server.prisma_client") as mock_prisma_client, # test-quality-ok: proxy_server module global is the endpoint's only injection point - patch("litellm.proxy.proxy_server.user_api_key_cache"), # test-quality-ok: proxy_server module global is the endpoint's only injection point - patch("litellm.proxy.proxy_server.proxy_logging_obj"), # test-quality-ok: proxy_server module global is the endpoint's only injection point + patch( + "litellm.proxy.proxy_server.prisma_client" + ) as mock_prisma_client, # test-quality-ok: proxy_server module global is the endpoint's only injection point + patch( + "litellm.proxy.proxy_server.user_api_key_cache" + ), # test-quality-ok: proxy_server module global is the endpoint's only injection point + patch( + "litellm.proxy.proxy_server.proxy_logging_obj" + ), # test-quality-ok: proxy_server module global is the endpoint's only injection point patch( # test-quality-ok: stubs the cache write so the test observes only the DB result handling "litellm.proxy.management_endpoints.team_endpoints.cache_team_object", new_callable=AsyncMock, @@ -2854,9 +2767,7 @@ async def test_team_write_404s_when_row_vanishes_before_update(endpoint_name): return_value=existing_team, ), ): - mock_prisma_client.db.litellm_teamtable.find_unique = AsyncMock( - return_value=existing_team - ) + mock_prisma_client.db.litellm_teamtable.find_unique = AsyncMock(return_value=existing_team) mock_prisma_client.db.litellm_teamtable.update = AsyncMock(return_value=None) mock_prisma_client.db.execute_raw = AsyncMock(return_value=None) @@ -2867,8 +2778,6 @@ async def test_team_write_404s_when_row_vanishes_before_update(endpoint_name): assert exc_info.value.detail == {"error": "Team not found, passed team_id=team-1234"} - - def test_clean_team_member_fields(): """ Test that _clean_team_member_fields removes all team member fields from a dictionary. @@ -2929,9 +2838,7 @@ async def test_create_team_member_budget_table(): TeamMemberBudgetHandler, ) - mock_user_api_key_dict = UserAPIKeyAuth( - user_role=LitellmUserRoles.PROXY_ADMIN, user_id="test_user_id" - ) + mock_user_api_key_dict = UserAPIKeyAuth(user_role=LitellmUserRoles.PROXY_ADMIN, user_id="test_user_id") data = NewTeamRequest( team_id="test_team_id", @@ -2998,9 +2905,7 @@ async def test_create_team_member_budget_table_without_team_alias(): TeamMemberBudgetHandler, ) - mock_user_api_key_dict = UserAPIKeyAuth( - user_role=LitellmUserRoles.PROXY_ADMIN, user_id="test_user_id" - ) + mock_user_api_key_dict = UserAPIKeyAuth(user_role=LitellmUserRoles.PROXY_ADMIN, user_id="test_user_id") data = NewTeamRequest(team_id="test_team_id") new_team_data_json = { @@ -3032,12 +2937,6 @@ async def test_create_team_member_budget_table_without_team_alias(): assert budget_request.budget_id.startswith("team-budget-") - - - - - - @pytest.mark.asyncio async def test_create_team_member_budget_table_explicit_null_duration_does_not_inherit_team_duration( mock_db_client, @@ -3050,18 +2949,14 @@ async def test_create_team_member_budget_table_explicit_null_duration_does_not_i TeamMemberBudgetHandler, ) - mock_user_api_key_dict = UserAPIKeyAuth( - user_role=LitellmUserRoles.PROXY_ADMIN, user_id="test_user_id" - ) + mock_user_api_key_dict = UserAPIKeyAuth(user_role=LitellmUserRoles.PROXY_ADMIN, user_id="test_user_id") team_table = MagicMock(spec=LiteLLM_TeamTable) team_table.metadata = {} team_table.team_alias = "Test Team" team_table.budget_duration = "30d" - mock_db_client.db.litellm_budgettable.create = AsyncMock( - side_effect=lambda data: SimpleNamespace(**data) - ) + mock_db_client.db.litellm_budgettable.create = AsyncMock(side_effect=lambda data: SimpleNamespace(**data)) result = await TeamMemberBudgetHandler.create_team_member_budget_table( data=team_table, @@ -3095,18 +2990,14 @@ async def test_create_team_member_budget_table_inherits_team_duration_when_durat TeamMemberBudgetHandler, ) - mock_user_api_key_dict = UserAPIKeyAuth( - user_role=LitellmUserRoles.PROXY_ADMIN, user_id="test_user_id" - ) + mock_user_api_key_dict = UserAPIKeyAuth(user_role=LitellmUserRoles.PROXY_ADMIN, user_id="test_user_id") team_table = MagicMock(spec=LiteLLM_TeamTable) team_table.metadata = {} team_table.team_alias = "Test Team" team_table.budget_duration = "30d" - mock_db_client.db.litellm_budgettable.create = AsyncMock( - side_effect=lambda data: SimpleNamespace(**data) - ) + mock_db_client.db.litellm_budgettable.create = AsyncMock(side_effect=lambda data: SimpleNamespace(**data)) result = await TeamMemberBudgetHandler.create_team_member_budget_table( data=team_table, @@ -3122,16 +3013,6 @@ async def test_create_team_member_budget_table_inherits_team_duration_when_durat assert result["metadata"]["team_member_budget_id"] == written["budget_id"] - - - - - - - - - - @pytest.mark.asyncio async def test_bulk_team_member_add_success(): """ @@ -3273,9 +3154,7 @@ async def test_bulk_team_member_add_batch_size_limit(): from litellm.proxy.management_endpoints.team_endpoints import bulk_team_member_add # Create more than 500 members (the max batch size) - large_member_list = [ - Member(user_email=f"user{i}@example.com", role="user") for i in range(501) - ] + large_member_list = [Member(user_email=f"user{i}@example.com", role="user") for i in range(501)] bulk_request = BulkTeamMemberAddRequest( team_id="test-team-123", @@ -3330,9 +3209,7 @@ async def test_bulk_team_member_add_all_users_flag(): ) as mock_team_member_add, ): # Mock the database find_many call - mock_prisma.db.litellm_usertable.find_many = AsyncMock( - return_value=mock_db_users - ) + mock_prisma.db.litellm_usertable.find_many = AsyncMock(return_value=mock_db_users) mock_auth = UserAPIKeyAuth(user_role=LitellmUserRoles.PROXY_ADMIN) @@ -3342,9 +3219,7 @@ async def test_bulk_team_member_add_all_users_flag(): ) # Verify that find_many was called to get all users - mock_prisma.db.litellm_usertable.find_many.assert_called_once_with( - order={"created_at": "desc"} - ) + mock_prisma.db.litellm_usertable.find_many.assert_called_once_with(order={"created_at": "desc"}) # Verify team_member_add was called with users from database mock_team_member_add.assert_called_once() @@ -3467,9 +3342,7 @@ async def test_list_team_v2_security_check_non_admin_user(): ) assert exc_info.value.status_code == 401 - assert "Only admin users can query all teams/other teams" in str( - exc_info.value.detail - ) + assert "Only admin users can query all teams/other teams" in str(exc_info.value.detail) assert LitellmUserRoles.INTERNAL_USER.value in str(exc_info.value.detail) @@ -3517,9 +3390,7 @@ async def test_list_team_v2_security_check_non_admin_user_other_user(): ) assert exc_info.value.status_code == 401 - assert "Only admin users can query all teams/other teams" in str( - exc_info.value.detail - ) + assert "Only admin users can query all teams/other teams" in str(exc_info.value.detail) @pytest.mark.asyncio @@ -3669,17 +3540,11 @@ async def test_list_team_v2_with_status_deleted(): mock_prisma_client.db = mock_db # Mock deleted teams - mock_deleted_team1 = Mock( - model_dump=lambda: {"team_id": "team_1", "team_alias": "Deleted Team 1"} - ) - mock_deleted_team2 = Mock( - model_dump=lambda: {"team_id": "team_2", "team_alias": "Deleted Team 2"} - ) + mock_deleted_team1 = Mock(model_dump=lambda: {"team_id": "team_1", "team_alias": "Deleted Team 1"}) + mock_deleted_team2 = Mock(model_dump=lambda: {"team_id": "team_2", "team_alias": "Deleted Team 2"}) # Mock deleted teams table (should be called) - mock_db.litellm_deletedteamtable.find_many = AsyncMock( - return_value=[mock_deleted_team1, mock_deleted_team2] - ) + mock_db.litellm_deletedteamtable.find_many = AsyncMock(return_value=[mock_deleted_team1, mock_deleted_team2]) mock_db.litellm_deletedteamtable.count = AsyncMock(return_value=2) # Mock regular teams table (should NOT be called) @@ -3759,7 +3624,9 @@ async def test_list_team_v2_includes_litellm_model_table(): }, ) - with patch("litellm.proxy.proxy_server.prisma_client") as mock_prisma_client: # test-quality-ok: this file's DB-mock convention + with patch( + "litellm.proxy.proxy_server.prisma_client" + ) as mock_prisma_client: # test-quality-ok: this file's DB-mock convention mock_db = Mock() mock_prisma_client.db = mock_db @@ -3956,9 +3823,7 @@ async def test_list_team_v2_org_admin_own_user_id_sees_all_org_teams(): "organization_id": "org_A", "members_with_roles": [{"user_id": "other_user", "role": "user"}], } - mock_db.litellm_teamtable.find_many = AsyncMock( - return_value=[mock_team_1, mock_team_2] - ) + mock_db.litellm_teamtable.find_many = AsyncMock(return_value=[mock_team_1, mock_team_2]) mock_db.litellm_teamtable.count = AsyncMock(return_value=2) mock_db.litellm_verificationtoken.group_by = AsyncMock(return_value=[]) mock_db.litellm_usertable.find_unique = AsyncMock(return_value=mock_user) @@ -3984,9 +3849,7 @@ async def test_list_team_v2_org_admin_own_user_id_sees_all_org_teams(): # Verify the where clause scopes by org OR own membership — no # top-level team_id filter that would hide org teams they aren't in where = mock_db.litellm_teamtable.find_many.call_args.kwargs["where"] - assert where["AND"] == [ - {"OR": [{"organization_id": {"in": ["org_A"]}}, {"team_id": {"in": ["team_1"]}}]} - ] + assert where["AND"] == [{"OR": [{"organization_id": {"in": ["org_A"]}}, {"team_id": {"in": ["team_1"]}}]}] assert "team_id" not in where assert "organization_id" not in where @@ -4262,10 +4125,7 @@ async def test_list_team_v2_org_admin_cannot_view_other_orgs(): ) assert exc_info.value.status_code == 403 - assert ( - "only view teams within your organizations" - in str(exc_info.value.detail).lower() - ) + assert "only view teams within your organizations" in str(exc_info.value.detail).lower() @pytest.mark.asyncio @@ -4425,9 +4285,7 @@ async def test_list_team_v2_search_builds_or_clause(): from litellm.proxy.management_endpoints.team_endpoints import list_team_v2 mock_request = Mock(spec=Request) - mock_admin = UserAPIKeyAuth( - user_role=LitellmUserRoles.PROXY_ADMIN, user_id="admin_user" - ) + mock_admin = UserAPIKeyAuth(user_role=LitellmUserRoles.PROXY_ADMIN, user_id="admin_user") with patch("litellm.proxy.proxy_server.prisma_client") as mock_prisma_client: mock_db = Mock() @@ -4472,9 +4330,7 @@ async def test_list_team_v2_search_team_id_match_prefix(): from litellm.proxy.management_endpoints.team_endpoints import list_team_v2 mock_request = Mock(spec=Request) - mock_admin = UserAPIKeyAuth( - user_role=LitellmUserRoles.PROXY_ADMIN, user_id="admin_user" - ) + mock_admin = UserAPIKeyAuth(user_role=LitellmUserRoles.PROXY_ADMIN, user_id="admin_user") with patch("litellm.proxy.proxy_server.prisma_client") as mock_prisma_client: mock_db = Mock() @@ -4525,9 +4381,7 @@ async def test_list_team_v2_search_composes_with_user_id_filter(): from litellm.proxy.management_endpoints.team_endpoints import list_team_v2 mock_request = Mock(spec=Request) - mock_user_api_key_dict = UserAPIKeyAuth( - user_role=LitellmUserRoles.INTERNAL_USER, user_id="member_user" - ) + mock_user_api_key_dict = UserAPIKeyAuth(user_role=LitellmUserRoles.INTERNAL_USER, user_id="member_user") mock_user = LiteLLM_UserTable( user_id="member_user", @@ -4712,9 +4566,7 @@ async def test_list_team_v2_keys_count_skipped_for_deleted_status(): "team_alias": "Deleted Team", } - mock_db.litellm_deletedteamtable.find_many = AsyncMock( - return_value=[mock_deleted] - ) + mock_db.litellm_deletedteamtable.find_many = AsyncMock(return_value=[mock_deleted]) mock_db.litellm_deletedteamtable.count = AsyncMock(return_value=1) mock_db.litellm_verificationtoken.group_by = AsyncMock(return_value=[]) @@ -4747,9 +4599,7 @@ async def test_team_member_delete_cleans_membership(mock_db_client, mock_admin_a mock_team_row = MagicMock() mock_team_row.model_dump.return_value = { "team_id": test_team_id, - "members_with_roles": [ - {"user_id": test_user_id, "user_email": None, "role": "user"} - ], + "members_with_roles": [{"user_id": test_user_id, "user_email": None, "role": "user"}], "team_member_permissions": [], "metadata": {}, "models": [], @@ -4757,32 +4607,24 @@ async def test_team_member_delete_cleans_membership(mock_db_client, mock_admin_a } # Configure DB mocks used by team_member_delete - mock_db_client.db.litellm_teamtable.find_unique = AsyncMock( - return_value=mock_team_row - ) + mock_db_client.db.litellm_teamtable.find_unique = AsyncMock(return_value=mock_team_row) mock_db_client.db.litellm_teamtable.update = AsyncMock(return_value=mock_team_row) # User row to allow removal from user's teams list mock_user_row = MagicMock() mock_user_row.user_id = test_user_id mock_user_row.teams = [test_team_id] - mock_db_client.db.litellm_usertable.find_many = AsyncMock( - return_value=[mock_user_row] - ) + mock_db_client.db.litellm_usertable.find_many = AsyncMock(return_value=[mock_user_row]) mock_db_client.db.litellm_usertable.update = AsyncMock(return_value=MagicMock()) # Membership deletion should be called mock_db_client.db.litellm_teammembership = MagicMock() - mock_db_client.db.litellm_teammembership.delete_many = AsyncMock( - return_value=MagicMock() - ) + mock_db_client.db.litellm_teammembership.delete_many = AsyncMock(return_value=MagicMock()) # Verification token deletion should be called mock_db_client.db.litellm_verificationtoken = MagicMock() mock_db_client.db.litellm_verificationtoken.find_many = AsyncMock(return_value=[]) - mock_db_client.db.litellm_verificationtoken.delete_many = AsyncMock( - return_value=MagicMock() - ) + mock_db_client.db.litellm_verificationtoken.delete_many = AsyncMock(return_value=MagicMock()) _wire_member_delete_tx(mock_db_client) @@ -4799,9 +4641,7 @@ async def test_team_member_delete_cleans_membership(mock_db_client, mock_admin_a @pytest.mark.asyncio -async def test_team_member_delete_cleans_verification_tokens( - mock_db_client, mock_admin_auth -): +async def test_team_member_delete_cleans_verification_tokens(mock_db_client, mock_admin_auth): from litellm.proxy._types import TeamMemberDeleteRequest from litellm.proxy.management_endpoints.team_endpoints import team_member_delete @@ -4811,38 +4651,28 @@ async def test_team_member_delete_cleans_verification_tokens( mock_team_row = MagicMock() mock_team_row.model_dump.return_value = { "team_id": test_team_id, - "members_with_roles": [ - {"user_id": test_user_id, "user_email": None, "role": "user"} - ], + "members_with_roles": [{"user_id": test_user_id, "user_email": None, "role": "user"}], "team_member_permissions": [], "metadata": {}, "models": [], "spend": 0.0, } - mock_db_client.db.litellm_teamtable.find_unique = AsyncMock( - return_value=mock_team_row - ) + mock_db_client.db.litellm_teamtable.find_unique = AsyncMock(return_value=mock_team_row) mock_db_client.db.litellm_teamtable.update = AsyncMock(return_value=mock_team_row) mock_user_row = MagicMock() mock_user_row.user_id = test_user_id mock_user_row.teams = [test_team_id] - mock_db_client.db.litellm_usertable.find_many = AsyncMock( - return_value=[mock_user_row] - ) + mock_db_client.db.litellm_usertable.find_many = AsyncMock(return_value=[mock_user_row]) mock_db_client.db.litellm_usertable.update = AsyncMock(return_value=MagicMock()) mock_db_client.db.litellm_teammembership = MagicMock() - mock_db_client.db.litellm_teammembership.delete_many = AsyncMock( - return_value=MagicMock() - ) + mock_db_client.db.litellm_teammembership.delete_many = AsyncMock(return_value=MagicMock()) mock_db_client.db.litellm_verificationtoken = MagicMock() mock_db_client.db.litellm_verificationtoken.find_many = AsyncMock(return_value=[]) - mock_db_client.db.litellm_verificationtoken.delete_many = AsyncMock( - return_value=MagicMock() - ) + mock_db_client.db.litellm_verificationtoken.delete_many = AsyncMock(return_value=MagicMock()) _wire_member_delete_tx(mock_db_client) @@ -4860,9 +4690,7 @@ async def test_team_member_delete_cleans_verification_tokens( @pytest.mark.asyncio -async def test_team_member_delete_writes_deleted_audit_log_for_member_keys( - mock_db_client, mock_admin_auth -): +async def test_team_member_delete_writes_deleted_audit_log_for_member_keys(mock_db_client, mock_admin_auth): from litellm.proxy._types import ( LiteLLM_VerificationToken, LitellmTableNames, @@ -4877,38 +4705,28 @@ async def test_team_member_delete_writes_deleted_audit_log_for_member_keys( mock_team_row = MagicMock() mock_team_row.model_dump.return_value = { "team_id": test_team_id, - "members_with_roles": [ - {"user_id": test_user_id, "user_email": None, "role": "user"} - ], + "members_with_roles": [{"user_id": test_user_id, "user_email": None, "role": "user"}], "team_member_permissions": [], "metadata": {}, "models": [], "spend": 0.0, } - mock_db_client.db.litellm_teamtable.find_unique = AsyncMock( - return_value=mock_team_row - ) + mock_db_client.db.litellm_teamtable.find_unique = AsyncMock(return_value=mock_team_row) mock_db_client.db.litellm_teamtable.update = AsyncMock(return_value=mock_team_row) mock_user_row = MagicMock() mock_user_row.user_id = test_user_id mock_user_row.teams = [test_team_id] - mock_db_client.db.litellm_usertable.find_many = AsyncMock( - return_value=[mock_user_row] - ) + mock_db_client.db.litellm_usertable.find_many = AsyncMock(return_value=[mock_user_row]) mock_db_client.db.litellm_usertable.update = AsyncMock(return_value=MagicMock()) mock_db_client.db.litellm_teammembership = MagicMock() - mock_db_client.db.litellm_teammembership.delete_many = AsyncMock( - return_value=MagicMock() - ) + mock_db_client.db.litellm_teammembership.delete_many = AsyncMock(return_value=MagicMock()) mock_db_client.db.litellm_verificationtoken = MagicMock() mock_db_client.db.litellm_verificationtoken.find_many = AsyncMock(return_value=[member_key]) - mock_db_client.db.litellm_verificationtoken.delete_many = AsyncMock( - return_value=MagicMock() - ) + mock_db_client.db.litellm_verificationtoken.delete_many = AsyncMock(return_value=MagicMock()) mock_db_client.db.litellm_jwtkeymapping = MagicMock() mock_db_client.db.litellm_jwtkeymapping.find_many = AsyncMock(return_value=[]) mock_db_client.db.litellm_deletedverificationtoken = MagicMock() @@ -5022,9 +4840,7 @@ async def test_delete_team_writes_deleted_audit_log_for_team_keys( @pytest.mark.asyncio -async def test_team_member_delete_reads_on_the_lock_holding_transaction( - mock_db_client, mock_admin_auth -): +async def test_team_member_delete_reads_on_the_lock_holding_transaction(mock_db_client, mock_admin_auth): """ Regression pin against exhausting the connection pool with advisory-lock waiters. @@ -5050,9 +4866,7 @@ async def test_team_member_delete_reads_on_the_lock_holding_transaction( "models": [], "spend": 0.0, } - mock_db_client.db.litellm_teamtable.find_unique = AsyncMock( - return_value=mock_team_row - ) + mock_db_client.db.litellm_teamtable.find_unique = AsyncMock(return_value=mock_team_row) user_row = MagicMock() user_row.user_id = test_user_id @@ -5084,18 +4898,14 @@ async def test_team_member_delete_reads_on_the_lock_holding_transaction( user_api_key_dict=mock_admin_auth, ) - tx.litellm_usertable.find_many.assert_awaited_once_with( - where={"user_id": {"in": [test_user_id]}} - ) + tx.litellm_usertable.find_many.assert_awaited_once_with(where={"user_id": {"in": [test_user_id]}}) tx.litellm_verificationtoken.find_many.assert_awaited_once_with( where={"user_id": {"in": [test_user_id]}, "team_id": test_team_id} ) pooled_user_read.assert_not_awaited() pooled_token_read.assert_not_awaited() - tx.litellm_usertable.update.assert_awaited_once_with( - where={"user_id": test_user_id}, data={"teams": {"set": []}} - ) + tx.litellm_usertable.update.assert_awaited_once_with(where={"user_id": test_user_id}, data={"teams": {"set": []}}) tx.litellm_teammembership.delete_many.assert_awaited_once_with( where={"team_id": test_team_id, "user_id": test_user_id} ) @@ -5136,18 +4946,14 @@ async def test_team_member_delete_by_email_the_user_row_does_not_carry( mock_team_row = MagicMock() mock_team_row.model_dump.return_value = { "team_id": test_team_id, - "members_with_roles": [ - {"user_id": test_user_id, "user_email": roster_email, "role": "user"} - ], + "members_with_roles": [{"user_id": test_user_id, "user_email": roster_email, "role": "user"}], "team_member_permissions": [], "metadata": {}, "models": [], "spend": 0.0, } - mock_db_client.db.litellm_teamtable.find_unique = AsyncMock( - return_value=mock_team_row - ) + mock_db_client.db.litellm_teamtable.find_unique = AsyncMock(return_value=mock_team_row) mock_db_client.db.litellm_teamtable.update = AsyncMock(return_value=mock_team_row) mock_user_row = MagicMock() @@ -5159,29 +4965,21 @@ async def test_team_member_delete_by_email_the_user_row_does_not_carry( if not user_row_exists: return [] user_id_filter = where.get("user_id") - if isinstance(user_id_filter, dict) and test_user_id in user_id_filter.get( - "in", [] - ): + if isinstance(user_id_filter, dict) and test_user_id in user_id_filter.get("in", []): return [mock_user_row] if where.get("user_email") == user_row_email: return [mock_user_row] return [] - mock_db_client.db.litellm_usertable.find_many = AsyncMock( - side_effect=find_user_rows - ) + mock_db_client.db.litellm_usertable.find_many = AsyncMock(side_effect=find_user_rows) mock_db_client.db.litellm_usertable.update = AsyncMock(return_value=MagicMock()) mock_db_client.db.litellm_teammembership = MagicMock() - mock_db_client.db.litellm_teammembership.delete_many = AsyncMock( - return_value=MagicMock() - ) + mock_db_client.db.litellm_teammembership.delete_many = AsyncMock(return_value=MagicMock()) mock_db_client.db.litellm_verificationtoken = MagicMock() mock_db_client.db.litellm_verificationtoken.find_many = AsyncMock(return_value=[]) - mock_db_client.db.litellm_verificationtoken.delete_many = AsyncMock( - return_value=MagicMock() - ) + mock_db_client.db.litellm_verificationtoken.delete_many = AsyncMock(return_value=MagicMock()) _wire_member_delete_tx(mock_db_client) @@ -5228,30 +5026,22 @@ async def test_team_member_delete_clears_team_left_on_the_user_row_without_a_ros "models": [], "spend": 0.0, } - mock_db_client.db.litellm_teamtable.find_unique = AsyncMock( - return_value=mock_team_row - ) + mock_db_client.db.litellm_teamtable.find_unique = AsyncMock(return_value=mock_team_row) mock_db_client.db.litellm_teamtable.update = AsyncMock(return_value=mock_team_row) mock_user_row = MagicMock() mock_user_row.user_id = test_user_id mock_user_row.user_email = None mock_user_row.teams = [test_team_id, "other-team", test_team_id] - mock_db_client.db.litellm_usertable.find_many = AsyncMock( - return_value=[mock_user_row] - ) + mock_db_client.db.litellm_usertable.find_many = AsyncMock(return_value=[mock_user_row]) mock_db_client.db.litellm_usertable.update = AsyncMock(return_value=MagicMock()) mock_db_client.db.litellm_teammembership = MagicMock() - mock_db_client.db.litellm_teammembership.delete_many = AsyncMock( - return_value=MagicMock() - ) + mock_db_client.db.litellm_teammembership.delete_many = AsyncMock(return_value=MagicMock()) mock_db_client.db.litellm_verificationtoken = MagicMock() mock_db_client.db.litellm_verificationtoken.find_many = AsyncMock(return_value=[]) - mock_db_client.db.litellm_verificationtoken.delete_many = AsyncMock( - return_value=MagicMock() - ) + mock_db_client.db.litellm_verificationtoken.delete_many = AsyncMock(return_value=MagicMock()) _wire_member_delete_tx(mock_db_client) @@ -5270,9 +5060,7 @@ async def test_team_member_delete_clears_team_left_on_the_user_row_without_a_ros @pytest.mark.asyncio -async def test_team_member_delete_still_rejects_a_user_the_team_has_no_trace_of( - mock_db_client, mock_admin_auth -): +async def test_team_member_delete_still_rejects_a_user_the_team_has_no_trace_of(mock_db_client, mock_admin_auth): from litellm.proxy._types import TeamMemberDeleteRequest from litellm.proxy.management_endpoints.team_endpoints import team_member_delete @@ -5288,24 +5076,18 @@ async def test_team_member_delete_still_rejects_a_user_the_team_has_no_trace_of( "models": [], "spend": 0.0, } - mock_db_client.db.litellm_teamtable.find_unique = AsyncMock( - return_value=mock_team_row - ) + mock_db_client.db.litellm_teamtable.find_unique = AsyncMock(return_value=mock_team_row) mock_db_client.db.litellm_teamtable.update = AsyncMock(return_value=mock_team_row) mock_user_row = MagicMock() mock_user_row.user_id = test_user_id mock_user_row.user_email = None mock_user_row.teams = ["other-team"] - mock_db_client.db.litellm_usertable.find_many = AsyncMock( - return_value=[mock_user_row] - ) + mock_db_client.db.litellm_usertable.find_many = AsyncMock(return_value=[mock_user_row]) mock_db_client.db.litellm_usertable.update = AsyncMock(return_value=MagicMock()) mock_db_client.db.litellm_teammembership = MagicMock() - mock_db_client.db.litellm_teammembership.delete_many = AsyncMock( - return_value=MagicMock() - ) + mock_db_client.db.litellm_teammembership.delete_many = AsyncMock(return_value=MagicMock()) _wire_member_delete_tx(mock_db_client) @@ -5342,17 +5124,13 @@ async def test_team_member_delete_leaves_a_bystander_named_by_a_conflicting_user mock_team_row = MagicMock() mock_team_row.model_dump.return_value = { "team_id": test_team_id, - "members_with_roles": [ - {"user_id": roster_user_id, "user_email": roster_email, "role": "user"} - ], + "members_with_roles": [{"user_id": roster_user_id, "user_email": roster_email, "role": "user"}], "team_member_permissions": [], "metadata": {}, "models": [], "spend": 0.0, } - mock_db_client.db.litellm_teamtable.find_unique = AsyncMock( - return_value=mock_team_row - ) + mock_db_client.db.litellm_teamtable.find_unique = AsyncMock(return_value=mock_team_row) mock_db_client.db.litellm_teamtable.update = AsyncMock(return_value=mock_team_row) roster_user_row = MagicMock() @@ -5373,32 +5151,18 @@ async def test_team_member_delete_leaves_a_bystander_named_by_a_conflicting_user async def find_user_rows(where): user_id_filter = where.get("user_id") if isinstance(user_id_filter, dict): - return [ - rows_by_user_id[uid] - for uid in user_id_filter.get("in", []) - if uid in rows_by_user_id - ] - return [ - row - for row in rows_by_user_id.values() - if row.user_email == where.get("user_email") - ] + return [rows_by_user_id[uid] for uid in user_id_filter.get("in", []) if uid in rows_by_user_id] + return [row for row in rows_by_user_id.values() if row.user_email == where.get("user_email")] - mock_db_client.db.litellm_usertable.find_many = AsyncMock( - side_effect=find_user_rows - ) + mock_db_client.db.litellm_usertable.find_many = AsyncMock(side_effect=find_user_rows) mock_db_client.db.litellm_usertable.update = AsyncMock(return_value=MagicMock()) mock_db_client.db.litellm_teammembership = MagicMock() - mock_db_client.db.litellm_teammembership.delete_many = AsyncMock( - return_value=MagicMock() - ) + mock_db_client.db.litellm_teammembership.delete_many = AsyncMock(return_value=MagicMock()) mock_db_client.db.litellm_verificationtoken = MagicMock() mock_db_client.db.litellm_verificationtoken.find_many = AsyncMock(return_value=[]) - mock_db_client.db.litellm_verificationtoken.delete_many = AsyncMock( - return_value=MagicMock() - ) + mock_db_client.db.litellm_verificationtoken.delete_many = AsyncMock(return_value=MagicMock()) _wire_member_delete_tx(mock_db_client) @@ -5449,9 +5213,7 @@ async def test_team_member_delete_by_email_only_touches_the_row_carrying_the_sta "models": [], "spend": 0.0, } - mock_db_client.db.litellm_teamtable.find_unique = AsyncMock( - return_value=mock_team_row - ) + mock_db_client.db.litellm_teamtable.find_unique = AsyncMock(return_value=mock_team_row) mock_db_client.db.litellm_teamtable.update = AsyncMock(return_value=mock_team_row) stale_user_row = MagicMock() @@ -5464,21 +5226,15 @@ async def test_team_member_delete_by_email_only_touches_the_row_carrying_the_sta namesake_user_row.user_email = shared_email namesake_user_row.teams = ["other-team"] - mock_db_client.db.litellm_usertable.find_many = AsyncMock( - return_value=[stale_user_row, namesake_user_row] - ) + mock_db_client.db.litellm_usertable.find_many = AsyncMock(return_value=[stale_user_row, namesake_user_row]) mock_db_client.db.litellm_usertable.update = AsyncMock(return_value=MagicMock()) mock_db_client.db.litellm_teammembership = MagicMock() - mock_db_client.db.litellm_teammembership.delete_many = AsyncMock( - return_value=MagicMock() - ) + mock_db_client.db.litellm_teammembership.delete_many = AsyncMock(return_value=MagicMock()) mock_db_client.db.litellm_verificationtoken = MagicMock() mock_db_client.db.litellm_verificationtoken.find_many = AsyncMock(return_value=[]) - mock_db_client.db.litellm_verificationtoken.delete_many = AsyncMock( - return_value=MagicMock() - ) + mock_db_client.db.litellm_verificationtoken.delete_many = AsyncMock(return_value=MagicMock()) _wire_member_delete_tx(mock_db_client) @@ -5504,9 +5260,7 @@ class _InjectedMemberDeleteFailure(Exception): @pytest.mark.asyncio -async def test_team_member_delete_is_atomic_across_its_four_writes( - mock_db_client, mock_admin_auth -): +async def test_team_member_delete_is_atomic_across_its_four_writes(mock_db_client, mock_admin_auth): """ /team/member_delete's four cleanups (team roster, user.teams, team membership, verification tokens) run as one transaction, so a failure @@ -5527,25 +5281,19 @@ async def test_team_member_delete_is_atomic_across_its_four_writes( mock_team_row = MagicMock() mock_team_row.model_dump.return_value = { "team_id": test_team_id, - "members_with_roles": [ - {"user_id": test_user_id, "user_email": None, "role": "user"} - ], + "members_with_roles": [{"user_id": test_user_id, "user_email": None, "role": "user"}], "team_member_permissions": [], "metadata": {}, "models": [], "spend": 0.0, } - mock_db_client.db.litellm_teamtable.find_unique = AsyncMock( - return_value=mock_team_row - ) + mock_db_client.db.litellm_teamtable.find_unique = AsyncMock(return_value=mock_team_row) mock_db_client.db.litellm_teamtable.update = AsyncMock(return_value=mock_team_row) mock_user_row = MagicMock() mock_user_row.user_id = test_user_id mock_user_row.teams = [test_team_id] - mock_db_client.db.litellm_usertable.find_many = AsyncMock( - return_value=[mock_user_row] - ) + mock_db_client.db.litellm_usertable.find_many = AsyncMock(return_value=[mock_user_row]) mock_db_client.db.litellm_usertable.update = AsyncMock( side_effect=_InjectedMemberDeleteFailure("boom between writes 1 and 2") ) @@ -5609,9 +5357,7 @@ async def test_new_team_max_budget_exceeds_user_max_budget(): patch("litellm.proxy.proxy_server._license_check") as mock_license, patch("litellm.proxy.proxy_server.user_api_key_cache") as mock_cache, patch("litellm.proxy.proxy_server.litellm_proxy_admin_name", "admin"), - patch( - "litellm.proxy.proxy_server.create_audit_log_for_update", new=AsyncMock() - ) as mock_audit, + patch("litellm.proxy.proxy_server.create_audit_log_for_update", new=AsyncMock()) as mock_audit, ): # Setup basic mocks mock_prisma.db.litellm_teamtable.count = AsyncMock(return_value=0) @@ -5639,9 +5385,7 @@ async def test_new_team_max_budget_exceeds_user_max_budget(): # ProxyException stores status_code in 'code' attribute assert exc_info.value.code == "400" assert "max budget higher than user max" in str(exc_info.value.message) - assert "100.0" in str( - exc_info.value.message - ) # User's user_max_budget should be mentioned + assert "100.0" in str(exc_info.value.message) # User's user_max_budget should be mentioned assert LitellmUserRoles.INTERNAL_USER.value in str(exc_info.value.message) @@ -5678,9 +5422,7 @@ async def test_new_team_max_budget_within_user_limit(): patch("litellm.proxy.proxy_server.user_api_key_cache") as mock_cache, patch("litellm.proxy.proxy_server._license_check") as mock_license, patch("litellm.proxy.proxy_server.litellm_proxy_admin_name", "admin"), - patch( - "litellm.proxy.proxy_server.create_audit_log_for_update", new=AsyncMock() - ) as mock_audit, + patch("litellm.proxy.proxy_server.create_audit_log_for_update", new=AsyncMock()) as mock_audit, ): # Setup mocks mock_prisma.db.litellm_teamtable.count = AsyncMock(return_value=0) @@ -5712,19 +5454,13 @@ async def test_new_team_max_budget_within_user_limit(): "max_budget": 50.0, "members_with_roles": [], } - mock_prisma.db.litellm_teamtable.create = AsyncMock( - return_value=mock_created_team - ) + mock_prisma.db.litellm_teamtable.create = AsyncMock(return_value=mock_created_team) _wire_team_create_tx(mock_prisma) - mock_prisma.db.litellm_teamtable.update = AsyncMock( - return_value=mock_created_team - ) + mock_prisma.db.litellm_teamtable.update = AsyncMock(return_value=mock_created_team) # Mock model table mock_prisma.db.litellm_modeltable = MagicMock() - mock_prisma.db.litellm_modeltable.create = AsyncMock( - return_value=MagicMock(id="model123") - ) + mock_prisma.db.litellm_modeltable.create = AsyncMock(return_value=MagicMock(id="model123")) # Mock user table operations for adding the creator as a member mock_user = MagicMock() @@ -5747,9 +5483,7 @@ async def test_new_team_max_budget_within_user_limit(): "budget_id": None, } mock_prisma.db.litellm_teammembership = MagicMock() - mock_prisma.db.litellm_teammembership.upsert = AsyncMock( - return_value=mock_membership - ) + mock_prisma.db.litellm_teammembership.upsert = AsyncMock(return_value=mock_membership) # Should NOT raise an exception result = await new_team( @@ -5810,12 +5544,8 @@ async def test_new_team_org_scoped_budget_bypasses_user_limit(): patch("litellm.proxy.proxy_server.user_api_key_cache") as mock_cache, patch("litellm.proxy.proxy_server._license_check") as mock_license, patch("litellm.proxy.proxy_server.litellm_proxy_admin_name", "admin"), - patch( - "litellm.proxy.proxy_server.create_audit_log_for_update", new=AsyncMock() - ) as mock_audit, - patch( - "litellm.proxy.management_endpoints.team_endpoints.get_org_object" - ) as mock_get_org, + patch("litellm.proxy.proxy_server.create_audit_log_for_update", new=AsyncMock()) as mock_audit, + patch("litellm.proxy.management_endpoints.team_endpoints.get_org_object") as mock_get_org, ): # Setup mocks mock_prisma.db.litellm_teamtable.count = AsyncMock(return_value=0) @@ -5855,19 +5585,13 @@ async def test_new_team_org_scoped_budget_bypasses_user_limit(): "organization_id": "test-org-123", "members_with_roles": [], } - mock_prisma.db.litellm_teamtable.create = AsyncMock( - return_value=mock_created_team - ) + mock_prisma.db.litellm_teamtable.create = AsyncMock(return_value=mock_created_team) _wire_team_create_tx(mock_prisma) - mock_prisma.db.litellm_teamtable.update = AsyncMock( - return_value=mock_created_team - ) + mock_prisma.db.litellm_teamtable.update = AsyncMock(return_value=mock_created_team) # Mock model table mock_prisma.db.litellm_modeltable = MagicMock() - mock_prisma.db.litellm_modeltable.create = AsyncMock( - return_value=MagicMock(id="model123") - ) + mock_prisma.db.litellm_modeltable.create = AsyncMock(return_value=MagicMock(id="model123")) # Mock user table operations mock_user = MagicMock() @@ -5890,9 +5614,7 @@ async def test_new_team_org_scoped_budget_bypasses_user_limit(): "budget_id": None, } mock_prisma.db.litellm_teammembership = MagicMock() - mock_prisma.db.litellm_teammembership.upsert = AsyncMock( - return_value=mock_membership - ) + mock_prisma.db.litellm_teammembership.upsert = AsyncMock(return_value=mock_membership) # Should NOT raise an exception - the fix should bypass user budget validation for org-scoped teams result = await new_team( @@ -5943,9 +5665,7 @@ async def test_new_team_org_scoped_models_bypasses_user_limit(): # Create team request with models that are within org's allowed models but not user's team_request = NewTeamRequest( team_alias="org-scoped-models-team", - models=[ - "gpt-4" - ], # Within org's allowed models, but not in user's personal models + models=["gpt-4"], # Within org's allowed models, but not in user's personal models organization_id="test-org-456", # This makes it an org-scoped team ) @@ -5956,12 +5676,8 @@ async def test_new_team_org_scoped_models_bypasses_user_limit(): patch("litellm.proxy.proxy_server.user_api_key_cache") as mock_cache, patch("litellm.proxy.proxy_server._license_check") as mock_license, patch("litellm.proxy.proxy_server.litellm_proxy_admin_name", "admin"), - patch( - "litellm.proxy.proxy_server.create_audit_log_for_update", new=AsyncMock() - ) as mock_audit, - patch( - "litellm.proxy.management_endpoints.team_endpoints.get_org_object" - ) as mock_get_org, + patch("litellm.proxy.proxy_server.create_audit_log_for_update", new=AsyncMock()) as mock_audit, + patch("litellm.proxy.management_endpoints.team_endpoints.get_org_object") as mock_get_org, ): # Setup mocks mock_prisma.db.litellm_teamtable.count = AsyncMock(return_value=0) @@ -6003,19 +5719,13 @@ async def test_new_team_org_scoped_models_bypasses_user_limit(): "models": ["gpt-4"], "members_with_roles": [], } - mock_prisma.db.litellm_teamtable.create = AsyncMock( - return_value=mock_created_team - ) + mock_prisma.db.litellm_teamtable.create = AsyncMock(return_value=mock_created_team) _wire_team_create_tx(mock_prisma) - mock_prisma.db.litellm_teamtable.update = AsyncMock( - return_value=mock_created_team - ) + mock_prisma.db.litellm_teamtable.update = AsyncMock(return_value=mock_created_team) # Mock model table mock_prisma.db.litellm_modeltable = MagicMock() - mock_prisma.db.litellm_modeltable.create = AsyncMock( - return_value=MagicMock(id="model123") - ) + mock_prisma.db.litellm_modeltable.create = AsyncMock(return_value=MagicMock(id="model123")) # Mock user table operations mock_user = MagicMock() @@ -6038,9 +5748,7 @@ async def test_new_team_org_scoped_models_bypasses_user_limit(): "budget_id": None, } mock_prisma.db.litellm_teammembership = MagicMock() - mock_prisma.db.litellm_teammembership.upsert = AsyncMock( - return_value=mock_membership - ) + mock_prisma.db.litellm_teammembership.upsert = AsyncMock(return_value=mock_membership) # Should NOT raise an exception - the fix should bypass user model validation for org-scoped teams result = await new_team( @@ -6100,9 +5808,7 @@ async def test_new_team_standalone_validates_against_user_models(monkeypatch): patch("litellm.proxy.proxy_server.prisma_client") as mock_prisma, patch("litellm.proxy.proxy_server._license_check") as mock_license, patch("litellm.proxy.proxy_server.litellm_proxy_admin_name", "admin"), - patch( - "litellm.proxy.proxy_server.create_audit_log_for_update", new=AsyncMock() - ) as mock_audit, + patch("litellm.proxy.proxy_server.create_audit_log_for_update", new=AsyncMock()) as mock_audit, ): # Setup basic mocks mock_prisma.db.litellm_teamtable.count = AsyncMock(return_value=0) @@ -6169,9 +5875,7 @@ async def test_new_team_standalone_validates_against_user_budget(): patch("litellm.proxy.proxy_server._license_check") as mock_license, patch("litellm.proxy.proxy_server.user_api_key_cache") as mock_cache, patch("litellm.proxy.proxy_server.litellm_proxy_admin_name", "admin"), - patch( - "litellm.proxy.proxy_server.create_audit_log_for_update", new=AsyncMock() - ) as mock_audit, + patch("litellm.proxy.proxy_server.create_audit_log_for_update", new=AsyncMock()) as mock_audit, ): # Setup basic mocks mock_prisma.db.litellm_teamtable.count = AsyncMock(return_value=0) @@ -6196,9 +5900,7 @@ async def test_new_team_standalone_validates_against_user_budget(): # Verify exception details assert exc_info.value.code == "400" assert "max budget higher than user max" in str(exc_info.value.message) - assert "3.0" in str( - exc_info.value.message - ) # User's max_budget should be mentioned + assert "3.0" in str(exc_info.value.message) # User's max_budget should be mentioned @pytest.mark.asyncio @@ -6242,12 +5944,8 @@ async def test_new_team_org_scoped_budget_exceeds_org_limit(): patch("litellm.proxy.proxy_server.user_api_key_cache") as mock_cache, patch("litellm.proxy.proxy_server._license_check") as mock_license, patch("litellm.proxy.proxy_server.litellm_proxy_admin_name", "admin"), - patch( - "litellm.proxy.proxy_server.create_audit_log_for_update", new=AsyncMock() - ) as mock_audit, - patch( - "litellm.proxy.management_endpoints.team_endpoints.get_org_object" - ) as mock_get_org, + patch("litellm.proxy.proxy_server.create_audit_log_for_update", new=AsyncMock()) as mock_audit, + patch("litellm.proxy.management_endpoints.team_endpoints.get_org_object") as mock_get_org, ): # Setup mocks mock_prisma.db.litellm_teamtable.count = AsyncMock(return_value=0) @@ -6321,12 +6019,8 @@ async def test_new_team_org_scoped_models_not_in_org_models(): patch("litellm.proxy.proxy_server.user_api_key_cache") as mock_cache, patch("litellm.proxy.proxy_server._license_check") as mock_license, patch("litellm.proxy.proxy_server.litellm_proxy_admin_name", "admin"), - patch( - "litellm.proxy.proxy_server.create_audit_log_for_update", new=AsyncMock() - ) as mock_audit, - patch( - "litellm.proxy.management_endpoints.team_endpoints.get_org_object" - ) as mock_get_org, + patch("litellm.proxy.proxy_server.create_audit_log_for_update", new=AsyncMock()) as mock_audit, + patch("litellm.proxy.management_endpoints.team_endpoints.get_org_object") as mock_get_org, ): # Setup mocks mock_prisma.db.litellm_teamtable.count = AsyncMock(return_value=0) @@ -6350,10 +6044,7 @@ async def test_new_team_org_scoped_models_not_in_org_models(): # Verify exception details assert exc_info.value.code == "400" - assert ( - "claude-3-opus" in str(exc_info.value.message) - or "organization" in str(exc_info.value.message).lower() - ) + assert "claude-3-opus" in str(exc_info.value.message) or "organization" in str(exc_info.value.message).lower() @pytest.mark.asyncio @@ -6398,9 +6089,7 @@ async def test_update_team_standalone_budget_raise_blocked_for_team_admin(): patch("litellm.proxy.proxy_server.prisma_client") as mock_prisma, patch("litellm.proxy.proxy_server.user_api_key_cache") as mock_cache, patch("litellm.proxy.proxy_server.litellm_proxy_admin_name", "admin"), - patch( - "litellm.proxy.proxy_server.create_audit_log_for_update", new=AsyncMock() - ), + patch("litellm.proxy.proxy_server.create_audit_log_for_update", new=AsyncMock()), ): mock_existing_team = MagicMock() mock_existing_team.team_id = "standalone-team-123" @@ -6411,13 +6100,9 @@ async def test_update_team_standalone_budget_raise_blocked_for_team_admin(): "team_id": "standalone-team-123", "organization_id": None, "max_budget": 30.0, - "members_with_roles": [ - {"user_id": "non-admin-update-test", "role": "admin"} - ], + "members_with_roles": [{"user_id": "non-admin-update-test", "role": "admin"}], } - mock_prisma.db.litellm_teamtable.find_unique = AsyncMock( - return_value=mock_existing_team - ) + mock_prisma.db.litellm_teamtable.find_unique = AsyncMock(return_value=mock_existing_team) mock_cache.async_get_cache = AsyncMock(return_value=None) with pytest.raises(ProxyException) as exc_info: @@ -6466,9 +6151,7 @@ async def test_update_team_standalone_budget_raise_allowed_for_proxy_admin( patch("litellm.proxy.proxy_server.prisma_client") as mock_prisma, patch("litellm.proxy.proxy_server.user_api_key_cache") as mock_cache, patch("litellm.proxy.proxy_server.litellm_proxy_admin_name", "admin"), - patch( - "litellm.proxy.proxy_server.create_audit_log_for_update", new=AsyncMock() - ), + patch("litellm.proxy.proxy_server.create_audit_log_for_update", new=AsyncMock()), ): mock_existing_team = MagicMock() mock_existing_team.team_id = "standalone-team-123" @@ -6479,13 +6162,9 @@ async def test_update_team_standalone_budget_raise_allowed_for_proxy_admin( "team_id": "standalone-team-123", "organization_id": None, "max_budget": 30.0, - "members_with_roles": [ - {"user_id": "proxy-admin-update-test", "role": "admin"} - ], + "members_with_roles": [{"user_id": "proxy-admin-update-test", "role": "admin"}], } - mock_prisma.db.litellm_teamtable.find_unique = AsyncMock( - return_value=mock_existing_team - ) + mock_prisma.db.litellm_teamtable.find_unique = AsyncMock(return_value=mock_existing_team) mock_prisma.jsonify_team_object = lambda db_data: db_data mock_cache.async_get_cache = AsyncMock(return_value=None) mock_cache.async_set_cache = AsyncMock() @@ -6500,9 +6179,7 @@ async def test_update_team_standalone_budget_raise_allowed_for_proxy_admin( "organization_id": None, "max_budget": 100.0, } - mock_prisma.db.litellm_teamtable.update = AsyncMock( - return_value=mock_updated_team - ) + mock_prisma.db.litellm_teamtable.update = AsyncMock(return_value=mock_updated_team) result = await update_team( data=update_request, @@ -6555,9 +6232,7 @@ async def test_update_team_standalone_budget_removal_blocked_for_team_admin(): patch("litellm.proxy.proxy_server.prisma_client") as mock_prisma, patch("litellm.proxy.proxy_server.user_api_key_cache") as mock_cache, patch("litellm.proxy.proxy_server.litellm_proxy_admin_name", "admin"), - patch( - "litellm.proxy.proxy_server.create_audit_log_for_update", new=AsyncMock() - ), + patch("litellm.proxy.proxy_server.create_audit_log_for_update", new=AsyncMock()), ): mock_existing_team = MagicMock() mock_existing_team.team_id = "standalone-team-123" @@ -6568,13 +6243,9 @@ async def test_update_team_standalone_budget_removal_blocked_for_team_admin(): "team_id": "standalone-team-123", "organization_id": None, "max_budget": 500.0, - "members_with_roles": [ - {"user_id": "budget-removal-admin", "role": "admin"} - ], + "members_with_roles": [{"user_id": "budget-removal-admin", "role": "admin"}], } - mock_prisma.db.litellm_teamtable.find_unique = AsyncMock( - return_value=mock_existing_team - ) + mock_prisma.db.litellm_teamtable.find_unique = AsyncMock(return_value=mock_existing_team) mock_cache.async_get_cache = AsyncMock(return_value=None) with pytest.raises(ProxyException) as exc_info: @@ -6625,9 +6296,7 @@ async def test_update_team_standalone_uncapped_team_admin_sets_finite_allowed( patch("litellm.proxy.proxy_server.prisma_client") as mock_prisma, patch("litellm.proxy.proxy_server.user_api_key_cache") as mock_cache, patch("litellm.proxy.proxy_server.litellm_proxy_admin_name", "admin"), - patch( - "litellm.proxy.proxy_server.create_audit_log_for_update", new=AsyncMock() - ), + patch("litellm.proxy.proxy_server.create_audit_log_for_update", new=AsyncMock()), ): _TeamRowStore( mock_prisma.db.litellm_teamtable, @@ -6698,9 +6367,7 @@ async def test_update_team_standalone_unchanged_budget_allowed( patch("litellm.proxy.proxy_server.prisma_client") as mock_prisma, patch("litellm.proxy.proxy_server.user_api_key_cache") as mock_cache, patch("litellm.proxy.proxy_server.litellm_proxy_admin_name", "admin"), - patch( - "litellm.proxy.proxy_server.create_audit_log_for_update", new=AsyncMock() - ) as mock_audit, + patch("litellm.proxy.proxy_server.create_audit_log_for_update", new=AsyncMock()) as mock_audit, ): # Mock existing standalone team (no organization_id) with budget=$500 mock_existing_team = MagicMock() @@ -6712,13 +6379,9 @@ async def test_update_team_standalone_unchanged_budget_allowed( "team_id": "standalone-unchanged-budget-123", "organization_id": None, "max_budget": 500.0, - "members_with_roles": [ - {"user_id": "standalone-unchanged-budget-admin", "role": "admin"} - ], + "members_with_roles": [{"user_id": "standalone-unchanged-budget-admin", "role": "admin"}], } - mock_prisma.db.litellm_teamtable.find_unique = AsyncMock( - return_value=mock_existing_team - ) + mock_prisma.db.litellm_teamtable.find_unique = AsyncMock(return_value=mock_existing_team) mock_prisma.jsonify_team_object = lambda db_data: db_data # User has a restrictive personal budget that is lower than the team's. @@ -6740,9 +6403,7 @@ async def test_update_team_standalone_unchanged_budget_allowed( "max_budget": 500.0, "tpm_limit": 50000, } - mock_prisma.db.litellm_teamtable.update = AsyncMock( - return_value=mock_updated_team - ) + mock_prisma.db.litellm_teamtable.update = AsyncMock(return_value=mock_updated_team) # Should NOT raise - unchanged budget skips the personal-budget check. result = await update_team( @@ -6797,9 +6458,7 @@ async def test_update_team_standalone_lower_budget_allowed( patch("litellm.proxy.proxy_server.prisma_client") as mock_prisma, patch("litellm.proxy.proxy_server.user_api_key_cache") as mock_cache, patch("litellm.proxy.proxy_server.litellm_proxy_admin_name", "admin"), - patch( - "litellm.proxy.proxy_server.create_audit_log_for_update", new=AsyncMock() - ) as mock_audit, + patch("litellm.proxy.proxy_server.create_audit_log_for_update", new=AsyncMock()) as mock_audit, ): _TeamRowStore( mock_prisma.db.litellm_teamtable, @@ -6879,9 +6538,7 @@ async def test_update_team_org_scoped_budget_exceeds_org_limit(): patch("litellm.proxy.proxy_server.prisma_client") as mock_prisma, patch("litellm.proxy.proxy_server.user_api_key_cache") as mock_cache, patch("litellm.proxy.proxy_server.litellm_proxy_admin_name", "admin"), - patch( - "litellm.proxy.proxy_server.create_audit_log_for_update", new=AsyncMock() - ) as mock_audit, + patch("litellm.proxy.proxy_server.create_audit_log_for_update", new=AsyncMock()) as mock_audit, patch( "litellm.proxy.management_endpoints.team_endpoints.get_org_object", new=AsyncMock(return_value=mock_org), @@ -6896,13 +6553,9 @@ async def test_update_team_org_scoped_budget_exceeds_org_limit(): "team_id": "org-team-456", "organization_id": "test-org-update", "max_budget": 80.0, - "members_with_roles": [ - {"user_id": "org-admin-update-test", "role": "admin"} - ], + "members_with_roles": [{"user_id": "org-admin-update-test", "role": "admin"}], } - mock_prisma.db.litellm_teamtable.find_unique = AsyncMock( - return_value=mock_existing_team - ) + mock_prisma.db.litellm_teamtable.find_unique = AsyncMock(return_value=mock_existing_team) # Should raise ProxyException because new budget exceeds org's max_budget with pytest.raises(ProxyException) as exc_info: @@ -6914,10 +6567,7 @@ async def test_update_team_org_scoped_budget_exceeds_org_limit(): # Verify exception details assert exc_info.value.code == "400" - assert ( - "organization" in str(exc_info.value.message).lower() - or "budget" in str(exc_info.value.message).lower() - ) + assert "organization" in str(exc_info.value.message).lower() or "budget" in str(exc_info.value.message).lower() @pytest.mark.asyncio @@ -6960,9 +6610,7 @@ async def test_update_team_standalone_models_not_gated_by_user_limit( patch("litellm.proxy.proxy_server.prisma_client") as mock_prisma, patch("litellm.proxy.proxy_server.user_api_key_cache") as mock_cache, patch("litellm.proxy.proxy_server.litellm_proxy_admin_name", "admin"), - patch( - "litellm.proxy.proxy_server.create_audit_log_for_update", new=AsyncMock() - ) as mock_audit, + patch("litellm.proxy.proxy_server.create_audit_log_for_update", new=AsyncMock()) as mock_audit, ): # Mock existing standalone team (no organization_id) mock_existing_team = MagicMock() @@ -6974,13 +6622,9 @@ async def test_update_team_standalone_models_not_gated_by_user_limit( "team_id": "standalone-team-models-123", "organization_id": None, "models": ["gpt-3.5-turbo"], - "members_with_roles": [ - {"user_id": "non-admin-update-models-test", "role": "admin"} - ], + "members_with_roles": [{"user_id": "non-admin-update-models-test", "role": "admin"}], } - mock_prisma.db.litellm_teamtable.find_unique = AsyncMock( - return_value=mock_existing_team - ) + mock_prisma.db.litellm_teamtable.find_unique = AsyncMock(return_value=mock_existing_team) mock_prisma.jsonify_team_object = lambda db_data: db_data mock_cache.async_get_cache = AsyncMock(return_value=None) mock_cache.async_set_cache = AsyncMock() @@ -6994,9 +6638,7 @@ async def test_update_team_standalone_models_not_gated_by_user_limit( "organization_id": None, "models": ["gpt-4"], } - mock_prisma.db.litellm_teamtable.update = AsyncMock( - return_value=mock_updated_team - ) + mock_prisma.db.litellm_teamtable.update = AsyncMock(return_value=mock_updated_team) result = await update_team( data=update_request, @@ -7060,9 +6702,7 @@ async def test_update_team_org_scoped_budget_bypasses_user_limit( patch("litellm.proxy.proxy_server.prisma_client") as mock_prisma, patch("litellm.proxy.proxy_server.user_api_key_cache") as mock_cache, patch("litellm.proxy.proxy_server.litellm_proxy_admin_name", "admin"), - patch( - "litellm.proxy.proxy_server.create_audit_log_for_update", new=AsyncMock() - ) as mock_audit, + patch("litellm.proxy.proxy_server.create_audit_log_for_update", new=AsyncMock()) as mock_audit, patch( "litellm.proxy.management_endpoints.team_endpoints.get_org_object", new=AsyncMock(return_value=mock_org), @@ -7080,9 +6720,7 @@ async def test_update_team_org_scoped_budget_bypasses_user_limit( "max_budget": 30.0, "members_with_roles": [], } - mock_prisma.db.litellm_teamtable.find_unique = AsyncMock( - return_value=mock_existing_team - ) + mock_prisma.db.litellm_teamtable.find_unique = AsyncMock(return_value=mock_existing_team) mock_prisma.jsonify_team_object = lambda db_data: db_data # Mock user cache to return user with restrictive budget @@ -7091,9 +6729,7 @@ async def test_update_team_org_scoped_budget_bypasses_user_limit( max_budget=3.0, # Restrictive personal budget ) mock_cache.async_get_cache = AsyncMock(return_value=mock_user_obj) - mock_cache.async_set_cache = ( - AsyncMock() - ) # Mock cache set for _cache_team_object + mock_cache.async_set_cache = AsyncMock() # Mock cache set for _cache_team_object # Mock team update mock_updated_team = MagicMock() @@ -7106,9 +6742,7 @@ async def test_update_team_org_scoped_budget_bypasses_user_limit( "organization_id": "test-org-update-budget", "max_budget": 50.0, } - mock_prisma.db.litellm_teamtable.update = AsyncMock( - return_value=mock_updated_team - ) + mock_prisma.db.litellm_teamtable.update = AsyncMock(return_value=mock_updated_team) # Should NOT raise an exception - bypass user budget validation for org-scoped teams result = await update_team( @@ -7171,9 +6805,7 @@ async def test_update_team_org_scoped_models_bypasses_user_limit( patch("litellm.proxy.proxy_server.prisma_client") as mock_prisma, patch("litellm.proxy.proxy_server.user_api_key_cache") as mock_cache, patch("litellm.proxy.proxy_server.litellm_proxy_admin_name", "admin"), - patch( - "litellm.proxy.proxy_server.create_audit_log_for_update", new=AsyncMock() - ) as mock_audit, + patch("litellm.proxy.proxy_server.create_audit_log_for_update", new=AsyncMock()) as mock_audit, patch( "litellm.proxy.management_endpoints.team_endpoints.get_org_object", new=AsyncMock(return_value=mock_org), @@ -7189,17 +6821,11 @@ async def test_update_team_org_scoped_models_bypasses_user_limit( "team_id": "org-team-update-models-123", "organization_id": "test-org-update-models", "models": ["gpt-3.5-turbo"], - "members_with_roles": [ - {"user_id": "org-admin-update-models-test", "role": "admin"} - ], + "members_with_roles": [{"user_id": "org-admin-update-models-test", "role": "admin"}], } - mock_prisma.db.litellm_teamtable.find_unique = AsyncMock( - return_value=mock_existing_team - ) + mock_prisma.db.litellm_teamtable.find_unique = AsyncMock(return_value=mock_existing_team) mock_prisma.jsonify_team_object = lambda db_data: db_data - mock_cache.async_set_cache = ( - AsyncMock() - ) # Mock cache set for _cache_team_object + mock_cache.async_set_cache = AsyncMock() # Mock cache set for _cache_team_object # Mock team update mock_updated_team = MagicMock() @@ -7212,9 +6838,7 @@ async def test_update_team_org_scoped_models_bypasses_user_limit( "organization_id": "test-org-update-models", "models": ["gpt-4"], } - mock_prisma.db.litellm_teamtable.update = AsyncMock( - return_value=mock_updated_team - ) + mock_prisma.db.litellm_teamtable.update = AsyncMock(return_value=mock_updated_team) # Should NOT raise an exception - bypass user models validation for org-scoped teams result = await update_team( @@ -7275,9 +6899,7 @@ async def test_update_team_org_scoped_models_not_in_org_models(): patch("litellm.proxy.proxy_server.prisma_client") as mock_prisma, patch("litellm.proxy.proxy_server.user_api_key_cache") as mock_cache, patch("litellm.proxy.proxy_server.litellm_proxy_admin_name", "admin"), - patch( - "litellm.proxy.proxy_server.create_audit_log_for_update", new=AsyncMock() - ) as mock_audit, + patch("litellm.proxy.proxy_server.create_audit_log_for_update", new=AsyncMock()) as mock_audit, patch( "litellm.proxy.management_endpoints.team_endpoints.get_org_object", new=AsyncMock(return_value=mock_org), @@ -7292,13 +6914,9 @@ async def test_update_team_org_scoped_models_not_in_org_models(): "team_id": "org-team-update-models-fail-123", "organization_id": "test-org-update-models-fail", "models": ["gpt-4"], - "members_with_roles": [ - {"user_id": "org-admin-update-models-fail-test", "role": "admin"} - ], + "members_with_roles": [{"user_id": "org-admin-update-models-fail-test", "role": "admin"}], } - mock_prisma.db.litellm_teamtable.find_unique = AsyncMock( - return_value=mock_existing_team - ) + mock_prisma.db.litellm_teamtable.find_unique = AsyncMock(return_value=mock_existing_team) # Should raise ProxyException because claude-3-opus is not in org's allowed models with pytest.raises(ProxyException) as exc_info: @@ -7310,10 +6928,7 @@ async def test_update_team_org_scoped_models_not_in_org_models(): # Verify exception details assert exc_info.value.code == "400" - assert ( - "claude-3-opus" in str(exc_info.value.message) - or "organization" in str(exc_info.value.message).lower() - ) + assert "claude-3-opus" in str(exc_info.value.message) or "organization" in str(exc_info.value.message).lower() @pytest.mark.asyncio @@ -7366,9 +6981,7 @@ async def test_update_team_org_scoped_models_with_all_proxy_models( patch("litellm.proxy.proxy_server.prisma_client") as mock_prisma, patch("litellm.proxy.proxy_server.user_api_key_cache") as mock_cache, patch("litellm.proxy.proxy_server.litellm_proxy_admin_name", "admin"), - patch( - "litellm.proxy.proxy_server.create_audit_log_for_update", new=AsyncMock() - ) as mock_audit, + patch("litellm.proxy.proxy_server.create_audit_log_for_update", new=AsyncMock()) as mock_audit, patch( "litellm.proxy.management_endpoints.team_endpoints.get_org_object", new=AsyncMock(return_value=mock_org), @@ -7384,17 +6997,11 @@ async def test_update_team_org_scoped_models_with_all_proxy_models( "team_id": "org-team-all-proxy-models-123", "organization_id": "test-org-all-proxy-models", "models": ["gpt-4"], - "members_with_roles": [ - {"user_id": "org-admin-all-proxy-models-test", "role": "admin"} - ], + "members_with_roles": [{"user_id": "org-admin-all-proxy-models-test", "role": "admin"}], } - mock_prisma.db.litellm_teamtable.find_unique = AsyncMock( - return_value=mock_existing_team - ) + mock_prisma.db.litellm_teamtable.find_unique = AsyncMock(return_value=mock_existing_team) mock_prisma.jsonify_team_object = lambda db_data: db_data - mock_cache.async_set_cache = ( - AsyncMock() - ) # Mock cache set for _cache_team_object + mock_cache.async_set_cache = AsyncMock() # Mock cache set for _cache_team_object # Mock team update mock_updated_team = MagicMock() @@ -7415,9 +7022,7 @@ async def test_update_team_org_scoped_models_with_all_proxy_models( "gpt-4o-mini-test", ], } - mock_prisma.db.litellm_teamtable.update = AsyncMock( - return_value=mock_updated_team - ) + mock_prisma.db.litellm_teamtable.update = AsyncMock(return_value=mock_updated_team) # Should NOT raise an exception - 'all-proxy-models' allows all models result = await update_team( @@ -7476,9 +7081,7 @@ async def test_update_team_tpm_limit_not_gated_by_user_limit( patch("litellm.proxy.proxy_server.prisma_client") as mock_prisma, patch("litellm.proxy.proxy_server.user_api_key_cache") as mock_cache, patch("litellm.proxy.proxy_server.litellm_proxy_admin_name", "admin"), - patch( - "litellm.proxy.proxy_server.create_audit_log_for_update", new=AsyncMock() - ), + patch("litellm.proxy.proxy_server.create_audit_log_for_update", new=AsyncMock()), ): # Mock existing standalone team mock_existing_team = MagicMock() @@ -7492,9 +7095,7 @@ async def test_update_team_tpm_limit_not_gated_by_user_limit( "tpm_limit": 500, "members_with_roles": [{"user_id": "tpm-limit-user", "role": "admin"}], } - mock_prisma.db.litellm_teamtable.find_unique = AsyncMock( - return_value=mock_existing_team - ) + mock_prisma.db.litellm_teamtable.find_unique = AsyncMock(return_value=mock_existing_team) mock_prisma.jsonify_team_object = lambda db_data: db_data mock_cache.async_get_cache = AsyncMock(return_value=None) mock_cache.async_set_cache = AsyncMock() @@ -7508,9 +7109,7 @@ async def test_update_team_tpm_limit_not_gated_by_user_limit( "organization_id": None, "tpm_limit": 5000, } - mock_prisma.db.litellm_teamtable.update = AsyncMock( - return_value=mock_updated_team - ) + mock_prisma.db.litellm_teamtable.update = AsyncMock(return_value=mock_updated_team) result = await update_team( data=update_request, @@ -7559,9 +7158,7 @@ async def test_update_team_rpm_limit_not_gated_by_user_limit( patch("litellm.proxy.proxy_server.prisma_client") as mock_prisma, patch("litellm.proxy.proxy_server.user_api_key_cache") as mock_cache, patch("litellm.proxy.proxy_server.litellm_proxy_admin_name", "admin"), - patch( - "litellm.proxy.proxy_server.create_audit_log_for_update", new=AsyncMock() - ), + patch("litellm.proxy.proxy_server.create_audit_log_for_update", new=AsyncMock()), ): # Mock existing standalone team mock_existing_team = MagicMock() @@ -7575,9 +7172,7 @@ async def test_update_team_rpm_limit_not_gated_by_user_limit( "rpm_limit": 50, "members_with_roles": [{"user_id": "rpm-limit-user", "role": "admin"}], } - mock_prisma.db.litellm_teamtable.find_unique = AsyncMock( - return_value=mock_existing_team - ) + mock_prisma.db.litellm_teamtable.find_unique = AsyncMock(return_value=mock_existing_team) mock_prisma.jsonify_team_object = lambda db_data: db_data mock_cache.async_get_cache = AsyncMock(return_value=None) mock_cache.async_set_cache = AsyncMock() @@ -7591,9 +7186,7 @@ async def test_update_team_rpm_limit_not_gated_by_user_limit( "organization_id": None, "rpm_limit": 500, } - mock_prisma.db.litellm_teamtable.update = AsyncMock( - return_value=mock_updated_team - ) + mock_prisma.db.litellm_teamtable.update = AsyncMock(return_value=mock_updated_team) result = await update_team( data=update_request, @@ -7852,9 +7445,7 @@ async def test_new_team_org_scoped_tpm_rpm_bypasses_user_limit(): patch("litellm.proxy.proxy_server.user_api_key_cache") as mock_cache, patch("litellm.proxy.proxy_server.litellm_proxy_admin_name", "admin"), patch("litellm.proxy.proxy_server._license_check") as mock_license, - patch( - "litellm.proxy.proxy_server.create_audit_log_for_update", new=AsyncMock() - ), + patch("litellm.proxy.proxy_server.create_audit_log_for_update", new=AsyncMock()), patch( "litellm.proxy.management_endpoints.team_endpoints.get_org_object", new=AsyncMock(return_value=mock_org), @@ -7885,13 +7476,9 @@ async def test_new_team_org_scoped_tpm_rpm_bypasses_user_limit(): "metadata": None, "members_with_roles": [], } - mock_prisma.db.litellm_teamtable.create = AsyncMock( - return_value=mock_created_team - ) + mock_prisma.db.litellm_teamtable.create = AsyncMock(return_value=mock_created_team) _wire_team_create_tx(mock_prisma) - mock_prisma.db.litellm_teamtable.update = AsyncMock( - return_value=mock_created_team - ) + mock_prisma.db.litellm_teamtable.update = AsyncMock(return_value=mock_created_team) mock_prisma.jsonify_team_object = MagicMock(side_effect=lambda db_data: db_data) # Should succeed - bypasses user limits since org-scoped @@ -7972,13 +7559,9 @@ async def test_update_team_org_scoped_tpm_exceeds_org_limit(): "team_id": "org-team-update-tpm-123", "organization_id": "test-org-update-tpm", "tpm_limit": 5000, - "members_with_roles": [ - {"user_id": "org-admin-update-tpm-test", "role": "admin"} - ], + "members_with_roles": [{"user_id": "org-admin-update-tpm-test", "role": "admin"}], } - mock_prisma.db.litellm_teamtable.find_unique = AsyncMock( - return_value=mock_existing_team - ) + mock_prisma.db.litellm_teamtable.find_unique = AsyncMock(return_value=mock_existing_team) # Should raise ProxyException because TPM exceeds org limit with pytest.raises(ProxyException) as exc_info: @@ -8060,13 +7643,9 @@ async def test_update_team_org_scoped_rpm_exceeds_org_limit(): "team_id": "org-team-update-rpm-123", "organization_id": "test-org-update-rpm", "rpm_limit": 500, - "members_with_roles": [ - {"user_id": "org-admin-update-rpm-test", "role": "admin"} - ], + "members_with_roles": [{"user_id": "org-admin-update-rpm-test", "role": "admin"}], } - mock_prisma.db.litellm_teamtable.find_unique = AsyncMock( - return_value=mock_existing_team - ) + mock_prisma.db.litellm_teamtable.find_unique = AsyncMock(return_value=mock_existing_team) # Should raise ProxyException because RPM exceeds org limit with pytest.raises(ProxyException) as exc_info: @@ -8157,13 +7736,9 @@ async def test_update_team_org_scoped_tpm_rpm_bypasses_user_limit( "organization_id": "test-org-update-bypass", "tpm_limit": 5000, "rpm_limit": 500, - "members_with_roles": [ - {"user_id": "org-admin-update-bypass-test", "role": "admin"} - ], + "members_with_roles": [{"user_id": "org-admin-update-bypass-test", "role": "admin"}], } - mock_prisma.db.litellm_teamtable.find_unique = AsyncMock( - return_value=mock_existing_team - ) + mock_prisma.db.litellm_teamtable.find_unique = AsyncMock(return_value=mock_existing_team) mock_cache.async_set_cache = AsyncMock() mock_logging.internal_usage_cache.dual_cache.async_delete_cache = AsyncMock() @@ -8179,9 +7754,7 @@ async def test_update_team_org_scoped_tpm_rpm_bypasses_user_limit( "tpm_limit": 10000, "rpm_limit": 1000, } - mock_prisma.db.litellm_teamtable.update = AsyncMock( - return_value=mock_updated_team - ) + mock_prisma.db.litellm_teamtable.update = AsyncMock(return_value=mock_updated_team) mock_prisma.jsonify_team_object = MagicMock(side_effect=lambda db_data: db_data) # Should succeed - bypasses user limits since org-scoped @@ -8269,9 +7842,7 @@ async def test_update_team_guardrails_with_org_id( patch("litellm.proxy.proxy_server.prisma_client") as mock_prisma, patch("litellm.proxy.proxy_server.user_api_key_cache") as mock_cache, patch("litellm.proxy.proxy_server.litellm_proxy_admin_name", "admin"), - patch( - "litellm.proxy.proxy_server.create_audit_log_for_update", new=AsyncMock() - ), + patch("litellm.proxy.proxy_server.create_audit_log_for_update", new=AsyncMock()), patch( "litellm.proxy.proxy_server.premium_user", True, # Required for guardrails feature @@ -8296,20 +7867,14 @@ async def test_update_team_guardrails_with_org_id( "max_budget": None, "tpm_limit": None, "rpm_limit": None, - "members_with_roles": [ - {"user_id": "org-admin-guardrails-test", "role": "admin"} - ], + "members_with_roles": [{"user_id": "org-admin-guardrails-test", "role": "admin"}], } - mock_prisma.db.litellm_teamtable.find_unique = AsyncMock( - return_value=mock_existing_team - ) + mock_prisma.db.litellm_teamtable.find_unique = AsyncMock(return_value=mock_existing_team) mock_cache.async_set_cache = AsyncMock() # Mock organization fetch - this is where the bug occurred # The fix ensures 'teams: True' is in the include clause - mock_prisma.db.litellm_organizationtable.find_unique = AsyncMock( - return_value=mock_org - ) + mock_prisma.db.litellm_organizationtable.find_unique = AsyncMock(return_value=mock_org) # Destination-org guard in update_team queries for the caller's # ORG_ADMIN membership on the destination org. Return a match so @@ -8317,18 +7882,14 @@ async def test_update_team_guardrails_with_org_id( mock_org_admin_membership = MagicMock() mock_org_admin_membership.user_id = "org-admin-guardrails-test" mock_org_admin_membership.organization_id = "test-org-guardrails" - mock_prisma.db.litellm_organizationmembership.find_many = AsyncMock( - return_value=[mock_org_admin_membership] - ) + mock_prisma.db.litellm_organizationmembership.find_many = AsyncMock(return_value=[mock_org_admin_membership]) # Mock team update mock_updated_team = MagicMock(spec=LiteLLM_TeamTable) mock_updated_team.team_id = "team-guardrails-123" mock_updated_team.object_permission_id = None mock_updated_team.organization_id = "test-org-guardrails" - mock_updated_team.metadata = { - "guardrails": ["aporia-pre-call", "aporia-post-call"] - } + mock_updated_team.metadata = {"guardrails": ["aporia-pre-call", "aporia-post-call"]} mock_updated_team.litellm_model_table = None mock_updated_team.access_group_ids = None mock_updated_team.model_dump.return_value = { @@ -8336,9 +7897,7 @@ async def test_update_team_guardrails_with_org_id( "organization_id": "test-org-guardrails", "metadata": {"guardrails": ["aporia-pre-call", "aporia-post-call"]}, } - mock_prisma.db.litellm_teamtable.update = AsyncMock( - return_value=mock_updated_team - ) + mock_prisma.db.litellm_teamtable.update = AsyncMock(return_value=mock_updated_team) mock_prisma.jsonify_team_object = MagicMock(side_effect=lambda db_data: db_data) # async_get_cache must be an AsyncMock so `await` in get_org_object works mock_cache.async_get_cache = AsyncMock(return_value=None) @@ -8368,11 +7927,7 @@ async def test_update_team_guardrails_with_org_id( assert mock_prisma.db.litellm_organizationtable.find_unique.call_count >= 1 # Get the first call (from fetch_and_validate_organization) - first_call_kwargs = ( - mock_prisma.db.litellm_organizationtable.find_unique.call_args_list[ - 0 - ].kwargs - ) + first_call_kwargs = mock_prisma.db.litellm_organizationtable.find_unique.call_args_list[0].kwargs # Verify that 'teams' is included in the fetch assert "include" in first_call_kwargs @@ -8423,9 +7978,7 @@ def test_transform_teams_to_deleted_records(): assert all("litellm_changed_by" in record for record in records) assert all(record["deleted_by"] == "user-123" for record in records) # UserAPIKeyAuth hashes the api_key, so we check against the hashed value - assert all( - record["deleted_by_api_key"] == user_api_key_dict.api_key for record in records - ) + assert all(record["deleted_by_api_key"] == user_api_key_dict.api_key for record in records) assert all(record["litellm_changed_by"] == "admin-user" for record in records) record1 = records[0] @@ -8570,9 +8123,7 @@ async def test_delete_team_persists_deleted_teams( mock_prisma_client.db.litellm_deletedteamtable.create_many = mock_create_many_teams mock_create_many_keys = AsyncMock() - mock_prisma_client.db.litellm_deletedverificationtoken.create_many = ( - mock_create_many_keys - ) + mock_prisma_client.db.litellm_deletedverificationtoken.create_many = mock_create_many_keys mock_find_many_keys = AsyncMock(return_value=[]) mock_prisma_client.db.litellm_verificationtoken.find_many = mock_find_many_keys @@ -8732,9 +8283,7 @@ async def test_delete_team_sweeps_references_outside_members_with_roles( ("team-doomed", "doomed-team"), ("team-kept", "kept-team"), ): - cached_obj = LiteLLM_TeamTableCachedObj( - team_id=cached_team_id, team_alias=cached_alias - ) + cached_obj = LiteLLM_TeamTableCachedObj(team_id=cached_team_id, team_alias=cached_alias) fresh_cache.set_cache(key=f"team_id:{cached_team_id}", value=cached_obj) fresh_cache.set_cache(key=f"team_alias:{cached_alias}", value=cached_obj) @@ -8999,7 +8548,11 @@ async def test_delete_validated_team_rows_deletes_only_the_keys_its_rostered_mem ) team_keys = tuple( LiteLLM_VerificationToken(token=token, team_id="team-doomed", user_id=user_id) - for token, user_id in (("hashed-member", "member-1"), ("hashed-service-account", None), ("hashed-outsider", "admin-made")) + for token, user_id in ( + ("hashed-member", "member-1"), + ("hashed-service-account", None), + ("hashed-outsider", "admin-made"), + ) ) mock_prisma_client = AsyncMock() mock_prisma_client.db.litellm_teammembership.delete_many = AsyncMock() @@ -9159,7 +8712,9 @@ async def test_delete_team_evicts_the_auth_cache_of_the_keys_it_deletes( _wire_team_delete_tx(mock_prisma_client) fresh_cache = UserApiKeyCache() - fresh_cache.set_cache(key="hashed-doomed-key", value=UserAPIKeyAuth(token="hashed-doomed-key", team_id="team-doomed")) + fresh_cache.set_cache( + key="hashed-doomed-key", value=UserAPIKeyAuth(token="hashed-doomed-key", team_id="team-doomed") + ) fresh_cache.set_cache(key="hashed-unrelated-key", value=UserAPIKeyAuth(token="hashed-unrelated-key")) monkeypatch.setattr("litellm.proxy.proxy_server.prisma_client", mock_prisma_client) @@ -9373,7 +8928,7 @@ async def test_deleting_a_500_member_team_reaches_every_member_cache_on_other_wo team_membership_auth_cache_key, team_membership_reservation_cache_key, ) - from litellm.proxy.management_endpoints.team_endpoints import _evict_team_member_cache_keys, member_cache_keys + from litellm.proxy.management_endpoints.team_endpoints import evict_team_member_cache_keys, member_cache_keys redis: Final = _BroadcastRecordingRedis(round_trip_seconds=0.001) monkeypatch.setattr(pubsub_module, "coordination_redis_cache", lambda: redis) @@ -9381,7 +8936,7 @@ async def test_deleting_a_500_member_team_reaches_every_member_cache_on_other_wo monkeypatch.setattr(pubsub_module, "_in_flight_publishes", asyncio.Semaphore(16)) members: Final = tuple(f"member-{index:03d}" for index in range(500)) - await _evict_team_member_cache_keys( + await evict_team_member_cache_keys( team_id="team-large", member_user_ids=members, cache_keys=tuple(member_cache_keys("team-large", members)), @@ -9563,9 +9118,7 @@ async def test_team_member_delete_persists_deleted_keys(monkeypatch): mock_prisma_client.db.litellm_verificationtoken.delete_many = mock_delete_keys mock_create_many_keys = AsyncMock() - mock_prisma_client.db.litellm_deletedverificationtoken.create_many = ( - mock_create_many_keys - ) + mock_prisma_client.db.litellm_deletedverificationtoken.create_many = mock_create_many_keys _wire_member_delete_tx(mock_prisma_client) @@ -9576,7 +9129,11 @@ async def test_team_member_delete_persists_deleted_keys(monkeypatch): cache: Final = UserApiKeyCache() revoked_cache_keys: Final = ( - "team_id:team-1", "team_alias:test-team", "user-123", "hashed-token-1", "hashed-token-2", + "team_id:team-1", + "team_alias:test-team", + "user-123", + "hashed-token-1", + "hashed-token-2", team_membership_auth_cache_key(user_id="user-123", team_id="team-1"), team_membership_reservation_cache_key(user_id="user-123", team_id="team-1"), ) @@ -9877,9 +9434,7 @@ async def test_new_team_soft_budget_validation( patch("litellm.proxy.proxy_server.user_api_key_cache") as mock_cache, patch("litellm.proxy.proxy_server._license_check") as mock_license, patch("litellm.proxy.proxy_server.litellm_proxy_admin_name", "admin"), - patch( - "litellm.proxy.proxy_server.create_audit_log_for_update", new=AsyncMock() - ) as mock_audit, + patch("litellm.proxy.proxy_server.create_audit_log_for_update", new=AsyncMock()) as mock_audit, ): # Setup mocks mock_prisma.db.litellm_teamtable.count = AsyncMock(return_value=0) @@ -9913,19 +9468,13 @@ async def test_new_team_soft_budget_validation( "max_budget": expected_max_budget, "members_with_roles": [], } - mock_prisma.db.litellm_teamtable.create = AsyncMock( - return_value=mock_created_team - ) + mock_prisma.db.litellm_teamtable.create = AsyncMock(return_value=mock_created_team) _wire_team_create_tx(mock_prisma) - mock_prisma.db.litellm_teamtable.update = AsyncMock( - return_value=mock_created_team - ) + mock_prisma.db.litellm_teamtable.update = AsyncMock(return_value=mock_created_team) # Mock model table mock_prisma.db.litellm_modeltable = MagicMock() - mock_prisma.db.litellm_modeltable.create = AsyncMock( - return_value=MagicMock(id="model123") - ) + mock_prisma.db.litellm_modeltable.create = AsyncMock(return_value=MagicMock(id="model123")) # Mock user table operations mock_user = MagicMock() @@ -9948,9 +9497,7 @@ async def test_new_team_soft_budget_validation( "budget_id": None, } mock_prisma.db.litellm_teammembership = MagicMock() - mock_prisma.db.litellm_teammembership.upsert = AsyncMock( - return_value=mock_membership - ) + mock_prisma.db.litellm_teammembership.upsert = AsyncMock(return_value=mock_membership) if should_succeed: # Should NOT raise an exception @@ -10079,9 +9626,7 @@ async def test_update_team_soft_budget_validation( patch("litellm.proxy.proxy_server.prisma_client") as mock_prisma, patch("litellm.proxy.proxy_server.user_api_key_cache") as mock_cache, patch("litellm.proxy.proxy_server.litellm_proxy_admin_name", "admin"), - patch( - "litellm.proxy.proxy_server.create_audit_log_for_update", new=AsyncMock() - ) as mock_audit, + patch("litellm.proxy.proxy_server.create_audit_log_for_update", new=AsyncMock()) as mock_audit, ): # Mock existing team with existing budgets mock_existing_team = MagicMock() @@ -10095,9 +9640,7 @@ async def test_update_team_soft_budget_validation( "soft_budget": existing_soft_budget, "max_budget": existing_max_budget, } - mock_prisma.db.litellm_teamtable.find_unique = AsyncMock( - return_value=mock_existing_team - ) + mock_prisma.db.litellm_teamtable.find_unique = AsyncMock(return_value=mock_existing_team) # Mock user cache mock_user_obj = LiteLLM_UserTable( @@ -10107,14 +9650,8 @@ async def test_update_team_soft_budget_validation( mock_cache.async_get_cache = AsyncMock(return_value=mock_user_obj) # Mock updated team - preserve existing values if not being updated - final_soft_budget = ( - update_soft_budget - if update_soft_budget is not None - else existing_soft_budget - ) - final_max_budget = ( - update_max_budget if update_max_budget is not None else existing_max_budget - ) + final_soft_budget = update_soft_budget if update_soft_budget is not None else existing_soft_budget + final_max_budget = update_max_budget if update_max_budget is not None else existing_max_budget mock_updated_team = MagicMock() mock_updated_team.team_id = "test-team-123" @@ -10127,13 +9664,9 @@ async def test_update_team_soft_budget_validation( "soft_budget": final_soft_budget, "max_budget": final_max_budget, } - mock_prisma.db.litellm_teamtable.update = AsyncMock( - return_value=mock_updated_team - ) + mock_prisma.db.litellm_teamtable.update = AsyncMock(return_value=mock_updated_team) mock_prisma.jsonify_team_object = lambda db_data: db_data - mock_cache.async_set_cache = ( - AsyncMock() - ) # Mock cache set for _cache_team_object + mock_cache.async_set_cache = AsyncMock() # Mock cache set for _cache_team_object if should_succeed: # Should NOT raise an exception @@ -10179,9 +9712,7 @@ async def test_new_team_positive_budgets_accepted(): from litellm.proxy._types import NewTeamRequest # Should not raise any errors - request = NewTeamRequest( - team_alias="test-team", max_budget=100.0, team_member_budget=50.0 - ) + request = NewTeamRequest(team_alias="test-team", max_budget=100.0, team_member_budget=50.0) assert request.max_budget == 100.0 assert request.team_member_budget == 50.0 @@ -10199,15 +9730,13 @@ async def test_new_team_with_router_settings(mock_db_client, mock_admin_auth): mock_db_client.get_data = AsyncMock(return_value=None) mock_db_client.update_data = AsyncMock(return_value=MagicMock()) mock_db_client.db = MagicMock() - mock_db_client.db.litellm_proxymodeltable.find_many = AsyncMock(return_value=[ - SimpleNamespace(model_id="weighted-id", model_name="group", model_info={}) - ]) + mock_db_client.db.litellm_proxymodeltable.find_many = AsyncMock( + return_value=[SimpleNamespace(model_id="weighted-id", model_name="group", model_info={})] + ) # Mock model table creation mock_db_client.db.litellm_modeltable = MagicMock() - mock_db_client.db.litellm_modeltable.create = AsyncMock( - return_value=MagicMock(id="model123") - ) + mock_db_client.db.litellm_modeltable.create = AsyncMock(return_value=MagicMock(id="model123")) # Capture team table creation team_create_result = MagicMock( @@ -10222,9 +9751,7 @@ async def test_new_team_with_router_settings(mock_db_client, mock_admin_auth): mock_db_client.db.litellm_teamtable.create = mock_team_create _wire_team_create_tx(mock_db_client) mock_db_client.db.litellm_teamtable.count = mock_team_count - mock_db_client.db.litellm_teamtable.update = AsyncMock( - return_value=team_create_result - ) + mock_db_client.db.litellm_teamtable.update = AsyncMock(return_value=team_create_result) # Mock user table mock_db_client.db.litellm_usertable = MagicMock() @@ -10293,9 +9820,7 @@ async def test_get_team_daily_activity_member_with_permission_sees_all_spend( # Create a non-admin user user_id = "test_user_with_perm_123" team_id = "test_team_789" - user_api_key_dict = UserAPIKeyAuth( - user_id=user_id, user_role=LitellmUserRoles.INTERNAL_USER - ) + user_api_key_dict = UserAPIKeyAuth(user_id=user_id, user_role=LitellmUserRoles.INTERNAL_USER) # Mock user info mock_user_info = LiteLLM_UserTable( @@ -10380,9 +9905,7 @@ async def test_get_team_daily_activity_member_without_permission_filters_by_keys # Create a non-admin user user_id = "test_user_no_perm_123" team_id = "test_team_789" - user_api_key_dict = UserAPIKeyAuth( - user_id=user_id, user_role=LitellmUserRoles.INTERNAL_USER - ) + user_api_key_dict = UserAPIKeyAuth(user_id=user_id, user_role=LitellmUserRoles.INTERNAL_USER) # Mock user info mock_user_info = LiteLLM_UserTable( @@ -10416,9 +9939,7 @@ async def test_get_team_daily_activity_member_without_permission_filters_by_keys # Setup mocks mock_db_client.db.litellm_teamtable.find_many = AsyncMock(return_value=[mock_team]) - mock_db_client.db.litellm_verificationtoken.find_many = AsyncMock( - return_value=[user_api_key_1, user_api_key_2] - ) + mock_db_client.db.litellm_verificationtoken.find_many = AsyncMock(return_value=[user_api_key_1, user_api_key_2]) # Mock get_user_object with patch( @@ -10472,9 +9993,9 @@ async def test_update_team_with_router_settings( # Configure mocked prisma client mock_db_client.jsonify_team_object = lambda db_data: db_data mock_db_client.db = MagicMock() - mock_db_client.db.litellm_proxymodeltable.find_many = AsyncMock(return_value=[ - SimpleNamespace(model_id="weighted-id", model_name="group", model_info={}) - ]) + mock_db_client.db.litellm_proxymodeltable.find_many = AsyncMock( + return_value=[SimpleNamespace(model_id="weighted-id", model_name="group", model_info={})] + ) # Mock existing team row existing_team_mock = MagicMock() @@ -10564,9 +10085,7 @@ async def test_get_team_daily_activity_non_admin_filters_by_user_api_keys( # Create a non-admin user user_id = "test_user_123" team_id = "test_team_456" - user_api_key_dict = UserAPIKeyAuth( - user_id=user_id, user_role=LitellmUserRoles.INTERNAL_USER - ) + user_api_key_dict = UserAPIKeyAuth(user_id=user_id, user_role=LitellmUserRoles.INTERNAL_USER) # Mock user info mock_user_info = LiteLLM_UserTable( @@ -10598,9 +10117,7 @@ async def test_get_team_daily_activity_non_admin_filters_by_user_api_keys( # Setup mocks mock_db_client.db.litellm_teamtable.find_many = AsyncMock(return_value=[mock_team]) - mock_db_client.db.litellm_verificationtoken.find_many = AsyncMock( - return_value=[user_api_key_1, user_api_key_2] - ) + mock_db_client.db.litellm_verificationtoken.find_many = AsyncMock(return_value=[user_api_key_1, user_api_key_2]) # Mock get_user_object with patch( @@ -10637,9 +10154,7 @@ async def test_get_team_daily_activity_non_admin_filters_by_user_api_keys( # Verify user's API keys were fetched mock_db_client.db.litellm_verificationtoken.find_many.assert_called_once() - api_key_call_kwargs = ( - mock_db_client.db.litellm_verificationtoken.find_many.call_args[1] - ) + api_key_call_kwargs = mock_db_client.db.litellm_verificationtoken.find_many.call_args[1] assert api_key_call_kwargs["where"] == {"user_id": user_id} @@ -10656,9 +10171,7 @@ async def test_get_team_daily_activity_team_admin_sees_all_spend(mock_db_client) # Create a team admin user user_id = "test_admin_123" team_id = "test_team_456" - user_api_key_dict = UserAPIKeyAuth( - user_id=user_id, user_role=LitellmUserRoles.INTERNAL_USER - ) + user_api_key_dict = UserAPIKeyAuth(user_id=user_id, user_role=LitellmUserRoles.INTERNAL_USER) # Mock user info mock_user_info = LiteLLM_UserTable( @@ -10783,9 +10296,7 @@ async def test_validate_and_populate_member_user_info_only_email_provided(): mock_user_find_first.user_email = "test@example.com" # Mock find_first to return the user - mock_prisma_client.db.litellm_usertable.find_first = AsyncMock( - return_value=mock_user_find_first - ) + mock_prisma_client.db.litellm_usertable.find_first = AsyncMock(return_value=mock_user_find_first) # Mock get_data to return single user (no duplicates) mock_prisma_client.get_data = AsyncMock(return_value=[mock_user_find_first]) @@ -10841,9 +10352,7 @@ async def test_validate_and_populate_member_user_info_only_user_id_not_found(): assert result.role == "user" # Verify find_unique was called with correct parameters - mock_prisma_client.db.litellm_usertable.find_unique.assert_called_once_with( - where={"user_id": "nonexistent-user"} - ) + mock_prisma_client.db.litellm_usertable.find_unique.assert_called_once_with(where={"user_id": "nonexistent-user"}) @pytest.mark.asyncio @@ -10939,9 +10448,7 @@ async def test_list_team_v1_batches_key_queries(): return [key3] return [key1, key2, key3] - mock_prisma_client.db.litellm_verificationtoken.find_many = AsyncMock( - side_effect=filtered_find_many - ) + mock_prisma_client.db.litellm_verificationtoken.find_many = AsyncMock(side_effect=filtered_find_many) result = await list_team( http_request=mock_request, @@ -11010,8 +10517,6 @@ async def test_create_team_member_budget_table_with_duration(): assert result["metadata"]["team_member_budget_id"] == "budget-abc" - - @pytest.mark.asyncio async def test_update_team_clears_explicitly_null_member_model_budget_and_evicts_cache( disable_audit_logging_for_mocked_team, @@ -11056,7 +10561,7 @@ async def test_update_team_clears_explicitly_null_member_model_budget_and_evicts budget_upsert: Final = prisma.db.litellm_budgettable.upsert.call_args.kwargs assert budget_upsert["where"]["budget_id"] == "member-budget-1" - assert budget_upsert["data"]["update"]["model_max_budget"] == "{}" + assert budget_upsert["data"]["update"]["model_max_budget"].data == {} assert cache.async_delete_cache.await_args_list == [call(key="team_member_default_budget:member-budget-1")] @@ -11104,7 +10609,7 @@ async def test_update_team_persists_member_model_budget_to_default_budget_row( budget_upsert: Final = prisma.db.litellm_budgettable.upsert.call_args.kwargs assert budget_upsert["where"]["budget_id"] == "member-budget-1" - stored_member_model_caps: Final = json.loads(budget_upsert["data"]["update"]["model_max_budget"]) + stored_member_model_caps: Final = budget_upsert["data"]["update"]["model_max_budget"].data assert { model: { **budget, @@ -11154,9 +10659,7 @@ class TestBatchResolveAccessGroupResources: fake_row.access_agent_ids = ["agent-1", "agent-2"] fake_prisma = MagicMock() - fake_prisma.db.litellm_accessgrouptable.find_many = AsyncMock( - return_value=[fake_row] - ) + fake_prisma.db.litellm_accessgrouptable.find_many = AsyncMock(return_value=[fake_row]) with patch("litellm.proxy.proxy_server.prisma_client", fake_prisma): result = await _batch_resolve_access_group_resources(["ag-1"]) @@ -11185,9 +10688,7 @@ class TestBatchResolveAccessGroupResources: row2.access_agent_ids = ["agent-2"] fake_prisma = MagicMock() - fake_prisma.db.litellm_accessgrouptable.find_many = AsyncMock( - return_value=[row1, row2] - ) + fake_prisma.db.litellm_accessgrouptable.find_many = AsyncMock(return_value=[row1, row2]) with patch("litellm.proxy.proxy_server.prisma_client", fake_prisma): result = await _batch_resolve_access_group_resources(["ag-1", "ag-2"]) @@ -11209,9 +10710,7 @@ class TestBatchResolveAccessGroupResources: row1.access_agent_ids = [] fake_prisma = MagicMock() - fake_prisma.db.litellm_accessgrouptable.find_many = AsyncMock( - return_value=[row1] - ) + fake_prisma.db.litellm_accessgrouptable.find_many = AsyncMock(return_value=[row1]) with patch("litellm.proxy.proxy_server.prisma_client", fake_prisma): result = await _batch_resolve_access_group_resources(["ag-1", "ag-missing"]) @@ -11249,9 +10748,7 @@ class TestBatchResolveAccessGroupResources: fake_prisma.db.litellm_accessgrouptable.find_many = fake_find_many with patch("litellm.proxy.proxy_server.prisma_client", fake_prisma): - result = await _batch_resolve_access_group_resources( - ["ag-1", "ag-1", "ag-1"] - ) + result = await _batch_resolve_access_group_resources(["ag-1", "ag-1", "ag-1"]) # Should have been called with deduplicated list call_args = fake_find_many.call_args @@ -11290,9 +10787,7 @@ class TestResolveTeamAccessGroupResources: row2.access_skill_names = ["shared-plugin"] fake_prisma = MagicMock() - fake_prisma.db.litellm_accessgrouptable.find_many = AsyncMock( - return_value=[row1, row2] - ) + fake_prisma.db.litellm_accessgrouptable.find_many = AsyncMock(return_value=[row1, row2]) team_info = TeamInfoResponseObjectTeamTable( team_id="team-1", access_group_ids=["ag-1", "ag-2", "ag-1", "ag-missing"] @@ -11396,9 +10891,7 @@ async def test_update_team_rejects_unauthorized_caller(): ], "organization_id": "org-456", } - mock_prisma_client.db.litellm_teamtable.find_unique = AsyncMock( - return_value=mock_existing_team - ) + mock_prisma_client.db.litellm_teamtable.find_unique = AsyncMock(return_value=mock_existing_team) update_request = UpdateTeamRequest( team_id="team-123", @@ -11480,9 +10973,7 @@ async def test_team_member_me_returns_caller_membership(mock_db_client): team_id = "team-me-1" caller_id = "alice@example.com" other_id = "bob@example.com" - caller_auth = UserAPIKeyAuth( - user_role=LitellmUserRoles.INTERNAL_USER, user_id=caller_id - ) + caller_auth = UserAPIKeyAuth(user_role=LitellmUserRoles.INTERNAL_USER, user_id=caller_id) team = _build_team_for_me( team_id, @@ -11494,9 +10985,7 @@ async def test_team_member_me_returns_caller_membership(mock_db_client): membership = _build_membership_for_me(caller_id, team_id, spend=42.0) user = LiteLLM_UserTable(user_id=caller_id, user_email=caller_id, max_budget=None) - p_team, p_membership, p_user = _patch_member_me_helpers( - team=team, membership=membership, user=user - ) + p_team, p_membership, p_user = _patch_member_me_helpers(team=team, membership=membership, user=user) with p_team, p_membership as mock_get_membership, p_user: response = await team_member_me( http_request=MagicMock(spec=Request), @@ -11514,9 +11003,7 @@ async def test_team_member_me_returns_caller_membership(mock_db_client): # budget_reset_at must survive end-to-end — proves the BudgetTableFull # variant of the Union is selected (created_at is present), not the base # LiteLLM_BudgetTable which would silently strip this field. - assert response.litellm_budget_table.budget_reset_at == datetime( - 2026, 5, 1, tzinfo=timezone.utc - ) + assert response.litellm_budget_table.budget_reset_at == datetime(2026, 5, 1, tzinfo=timezone.utc) # Membership lookup must scope to caller_id, not just team_id — proves the # endpoint cannot return another member's row. @@ -11551,13 +11038,9 @@ async def test_team_member_me_matches_email_only_member(mock_db_client): [{"user_id": None, "user_email": caller_email, "role": "user"}], ) membership = _build_membership_for_me(caller_id, team_id, spend=7.0) - user = LiteLLM_UserTable( - user_id=caller_id, user_email=caller_email, max_budget=None - ) + user = LiteLLM_UserTable(user_id=caller_id, user_email=caller_email, max_budget=None) - p_team, p_membership, p_user = _patch_member_me_helpers( - team=team, membership=membership, user=user - ) + p_team, p_membership, p_user = _patch_member_me_helpers(team=team, membership=membership, user=user) with p_team, p_membership, p_user: response = await team_member_me( http_request=MagicMock(spec=Request), @@ -11579,9 +11062,7 @@ async def test_team_member_me_returns_404_for_non_member(mock_db_client): team_id = "team-me-2" caller_id = "outsider@example.com" - caller_auth = UserAPIKeyAuth( - user_role=LitellmUserRoles.INTERNAL_USER, user_id=caller_id - ) + caller_auth = UserAPIKeyAuth(user_role=LitellmUserRoles.INTERNAL_USER, user_id=caller_id) team = _build_team_for_me( team_id, @@ -11600,9 +11081,7 @@ async def test_team_member_me_returns_404_for_non_member(mock_db_client): @pytest.mark.asyncio -async def test_team_member_me_returns_404_for_proxy_admin_not_in_team( - mock_db_client, mock_admin_auth -): +async def test_team_member_me_returns_404_for_proxy_admin_not_in_team(mock_db_client, mock_admin_auth): """ Proxy admins get 404 if they are not actually a member of the team. `me` only resolves for actual team members; admins use /team/info instead. @@ -11642,9 +11121,7 @@ async def test_team_member_me_returns_defaults_when_no_membership_row(mock_db_cl team_id = "team-me-4" caller_id = "newmember@example.com" - caller_auth = UserAPIKeyAuth( - user_role=LitellmUserRoles.INTERNAL_USER, user_id=caller_id - ) + caller_auth = UserAPIKeyAuth(user_role=LitellmUserRoles.INTERNAL_USER, user_id=caller_id) team = _build_team_for_me( team_id, @@ -11690,18 +11167,12 @@ async def test_team_member_me_returns_404_for_unknown_team(mock_db_client): from litellm.proxy.management_endpoints.team_endpoints import team_member_me - caller_auth = UserAPIKeyAuth( - user_role=LitellmUserRoles.INTERNAL_USER, user_id="alice@example.com" - ) + caller_auth = UserAPIKeyAuth(user_role=LitellmUserRoles.INTERNAL_USER, user_id="alice@example.com") # get_team_object raises 404 directly when the team is missing. with patch( "litellm.proxy.management_endpoints.team_endpoints.get_team_object", - AsyncMock( - side_effect=HTTPException( - status_code=404, detail={"error": "Team doesn't exist in db."} - ) - ), + AsyncMock(side_effect=HTTPException(status_code=404, detail={"error": "Team doesn't exist in db."})), ): with pytest.raises(HTTPException) as exc_info: await team_member_me( @@ -11713,9 +11184,7 @@ async def test_team_member_me_returns_404_for_unknown_team(mock_db_client): @pytest.mark.asyncio -async def test_new_team_encrypts_callback_vars( - mock_db_client, mock_admin_auth, monkeypatch -): +async def test_new_team_encrypts_callback_vars(mock_db_client, mock_admin_auth, monkeypatch): """/team/new must encrypt callback_vars values before they reach the DB.""" from fastapi import Request @@ -11730,9 +11199,7 @@ async def test_new_team_encrypts_callback_vars( # actual JSON serialization production uses (catches non-serializable # ciphertext, missing fields, etc.). mock_db_client.jsonify_object = PrismaClient.jsonify_object.__get__(mock_db_client) - mock_db_client.jsonify_team_object = PrismaClient.jsonify_team_object.__get__( - mock_db_client - ) + mock_db_client.jsonify_team_object = PrismaClient.jsonify_team_object.__get__(mock_db_client) mock_db_client.get_data = AsyncMock(return_value=None) mock_db_client.db = MagicMock() mock_db_client.db.litellm_teamtable = MagicMock() @@ -11742,9 +11209,7 @@ async def test_new_team_encrypts_callback_vars( mock_db_client.db.litellm_teamtable.create = mock_team_create _wire_team_create_tx(mock_db_client) mock_db_client.db.litellm_teamtable.count = AsyncMock(return_value=0) - mock_db_client.db.litellm_teamtable.update = AsyncMock( - return_value=team_create_result - ) + mock_db_client.db.litellm_teamtable.update = AsyncMock(return_value=team_create_result) mock_db_client.db.litellm_usertable = MagicMock() mock_db_client.db.litellm_usertable.update = AsyncMock(return_value=MagicMock()) @@ -11781,9 +11246,7 @@ async def test_new_team_encrypts_callback_vars( def _non_admin_auth(): - return UserAPIKeyAuth( - user_id="u-team-admin", user_role=LitellmUserRoles.INTERNAL_USER - ) + return UserAPIKeyAuth(user_id="u-team-admin", user_role=LitellmUserRoles.INTERNAL_USER) def test_check_passthrough_routes_caller_permission_team(): @@ -11799,12 +11262,8 @@ def test_check_passthrough_routes_caller_permission_team(): NewTeamRequest(allowed_passthrough_routes=["/foo/*"]), admin, entity="team" ) - check_passthrough_routes_caller_permission( - NewTeamRequest(), non_admin, entity="team" - ) - check_passthrough_routes_caller_permission( - NewTeamRequest(allowed_passthrough_routes=[]), non_admin, entity="team" - ) + check_passthrough_routes_caller_permission(NewTeamRequest(), non_admin, entity="team") + check_passthrough_routes_caller_permission(NewTeamRequest(allowed_passthrough_routes=[]), non_admin, entity="team") with pytest.raises(HTTPException) as exc: check_passthrough_routes_caller_permission( @@ -11841,9 +11300,7 @@ async def test_new_team_blocks_non_admin_passthrough_routes(mock_db_client): ): with pytest.raises(ProxyException) as exc: await new_team( - data=NewTeamRequest( - team_alias="t", allowed_passthrough_routes=["/admin/*"] - ), + data=NewTeamRequest(team_alias="t", allowed_passthrough_routes=["/admin/*"]), http_request=MagicMock(spec=Request), user_api_key_dict=_non_admin_auth(), ) @@ -11867,9 +11324,7 @@ async def test_update_team_blocks_non_admin_passthrough_routes(mock_db_client): with _org_admins(("u-team-admin", "org-1")): with pytest.raises(ProxyException) as exc: await update_team( - data=UpdateTeamRequest( - team_id="t1", allowed_passthrough_routes=["/admin/*"] - ), + data=UpdateTeamRequest(team_id="t1", allowed_passthrough_routes=["/admin/*"]), http_request=MagicMock(spec=Request), user_api_key_dict=_non_admin_auth(), ) @@ -12142,14 +11597,6 @@ def test_set_budget_reset_at_sets_value_when_budget_duration_provided(): assert updated_kv["budget_reset_at"] is not None - - - - - - - - @pytest.mark.asyncio async def test_team_member_budget_duration_not_sent_does_not_update(): """ @@ -12181,8 +11628,6 @@ async def test_team_member_budget_duration_not_sent_does_not_update(): assert "team_member_budget" not in updated_kv - - @pytest.mark.asyncio async def test_team_info_forwards_key_limit_to_get_data(): """/team/info must thread its ``key_limit`` query param into the key @@ -12193,16 +11638,12 @@ async def test_team_info_forwards_key_limit_to_get_data(): from litellm.proxy.management_endpoints import team_endpoints mock_prisma = MagicMock() - mock_prisma.db.litellm_teamtable.find_unique = AsyncMock( - return_value=LiteLLM_TeamTable(team_id="team-1") - ) + mock_prisma.db.litellm_teamtable.find_unique = AsyncMock(return_value=LiteLLM_TeamTable(team_id="team-1")) mock_prisma.get_data = AsyncMock(return_value=[]) with ( patch("litellm.proxy.proxy_server.prisma_client", mock_prisma), - patch.object( - team_endpoints, "get_all_team_memberships", AsyncMock(return_value=[]) - ), + patch.object(team_endpoints, "get_all_team_memberships", AsyncMock(return_value=[])), ): await team_endpoints.team_info( http_request=MagicMock(spec=Request), @@ -12240,9 +11681,7 @@ async def test_team_info_returns_model_aliases(): with ( patch("litellm.proxy.proxy_server.prisma_client", mock_prisma), - patch.object( - team_endpoints, "get_all_team_memberships", AsyncMock(return_value=[]) - ), + patch.object(team_endpoints, "get_all_team_memberships", AsyncMock(return_value=[])), ): response = await team_endpoints.team_info( http_request=MagicMock(spec=Request), @@ -12321,12 +11760,8 @@ async def test_update_model_table_clears_aliases_with_empty_map(): """ mock_prisma = MagicMock() mock_prisma.db.litellm_modeltable.create = AsyncMock() - mock_prisma.db.litellm_modeltable.upsert = AsyncMock( - return_value=MagicMock(id="model-123") - ) - user_api_key_dict = UserAPIKeyAuth( - user_role=LitellmUserRoles.PROXY_ADMIN, user_id="admin" - ) + mock_prisma.db.litellm_modeltable.upsert = AsyncMock(return_value=MagicMock(id="model-123")) + user_api_key_dict = UserAPIKeyAuth(user_role=LitellmUserRoles.PROXY_ADMIN, user_id="admin") returned_model_id = await _update_model_table( data=UpdateTeamRequest(team_id="team-1", model_aliases={}), @@ -12374,9 +11809,7 @@ class TestEmitTeamMembersMetric: return LiteLLM_TeamTable( team_id="team-x", team_alias="X", - members_with_roles=[ - Member(user_id=f"u{i}", role="user") for i in range(member_count) - ], + members_with_roles=[Member(user_id=f"u{i}", role="user") for i in range(member_count)], ) def test_emits_with_team_when_logger_registered(self, restore_callbacks): @@ -12450,9 +11883,7 @@ async def test_new_team_rejects_reserved_ui_session_team_id(): await new_team( data=team_request, http_request=dummy_request, - user_api_key_dict=UserAPIKeyAuth( - user_role=LitellmUserRoles.PROXY_ADMIN - ), + user_api_key_dict=UserAPIKeyAuth(user_role=LitellmUserRoles.PROXY_ADMIN), ) assert exc_info.value.code == "400" @@ -12540,9 +11971,7 @@ async def _drive_team_write( new=AsyncMock(), ), ): - pc.db.litellm_teamtable.find_unique = AsyncMock( - return_value=None if find_returns_none else existing - ) + pc.db.litellm_teamtable.find_unique = AsyncMock(return_value=None if find_returns_none else existing) pc.db.litellm_teamtable.update = AsyncMock( return_value=LiteLLM_TeamTable(team_id=_PATCH_TEAM_ID, team_alias="t") ) @@ -12644,9 +12073,7 @@ _METADATA_MAPPING = [ _METADATA_MAPPING, ids=[row[0] for row in _METADATA_MAPPING], ) -async def test_post_vs_patch_metadata_write_mapping( - label, existing_metadata, body, expected_post, expected_patch -): +async def test_post_vs_patch_metadata_write_mapping(label, existing_metadata, body, expected_post, expected_patch): """Exhaustive map: POST replaces metadata wholesale, PATCH merges per RFC 7386.""" post_meta = await _written_metadata("post", existing_metadata, body) patch_meta = await _written_metadata("patch", existing_metadata, body) @@ -12838,9 +12265,7 @@ async def test_patch_team_not_found_returns_404(): # metadata present -> patch_team does its own existence check with pytest.raises(ProxyException) as exc: - await _drive_team_write( - "patch", raw_body={"metadata": {"cost_center": "1"}}, find_returns_none=True - ) + await _drive_team_write("patch", raw_body={"metadata": {"cost_center": "1"}}, find_returns_none=True) assert exc.value.code == "404" or exc.value.code == 404 # metadata absent -> existence check happens in the delegated update_team @@ -12857,9 +12282,7 @@ async def test_patch_enforces_team_access_via_delegation(): outsider = UserAPIKeyAuth(user_role=LitellmUserRoles.INTERNAL_USER, user_id="outsider") with pytest.raises(ProxyException) as exc: - await _drive_team_write( - "patch", raw_body={"tpm_limit": 5}, user=outsider - ) + await _drive_team_write("patch", raw_body={"tpm_limit": 5}, user=outsider) assert exc.value.code == "403" or exc.value.code == 403 @@ -12869,9 +12292,7 @@ async def test_patch_returns_full_team_object_not_wrapper(): {"team_id", "data"} envelope.""" from litellm.proxy._types import LiteLLM_TeamTable - result, _ = await _drive_team_write( - "patch", existing_metadata={"a": 1}, raw_body={"metadata": {"b": 2}} - ) + result, _ = await _drive_team_write("patch", existing_metadata={"a": 1}, raw_body={"metadata": {"b": 2}}) assert isinstance(result, LiteLLM_TeamTable) assert result.team_id == _PATCH_TEAM_ID @@ -13188,9 +12609,7 @@ def test_patch_body_reshaping_adds_no_keys_the_caller_did_not_send(body): @pytest.mark.asyncio async def test_patch_ignores_unknown_body_keys(): """Unknown keys were silently dropped by the previous construction; keep that.""" - _, update_mock = await _drive_team_write( - "patch", raw_body={"tpm_limit": 5, "not_a_team_field": "x"} - ) + _, update_mock = await _drive_team_write("patch", raw_body={"tpm_limit": 5, "not_a_team_field": "x"}) written = update_mock.call_args.kwargs["data"] assert written["tpm_limit"] == 5 @@ -14927,16 +14346,12 @@ class _FakeMirrorDb: if "array_append" in sql: self.transactions[-1].append("attach") - changed = [ - g for g in desired if g in self._access_groups and team_id not in self._team_ids(g) - ] + changed = [g for g in desired if g in self._access_groups and team_id not in self._team_ids(g)] for group_id in changed: self._team_ids(group_id).append(team_id) else: self.transactions[-1].append("detach") - changed = [ - g for g in self._access_groups if team_id in self._team_ids(g) and g not in desired - ] + changed = [g for g in self._access_groups if team_id in self._team_ids(g) and g not in desired] for group_id in changed: self._team_ids(group_id).remove(team_id) return [{"access_group_id": group_id} for group_id in changed] @@ -15186,7 +14601,9 @@ async def test_new_team_and_delete_team_both_drive_the_mirror( patch("litellm.proxy.proxy_server.prisma_client") as prisma, patch("litellm.proxy.proxy_server.litellm_proxy_admin_name", "admin"), patch("litellm.proxy.proxy_server.llm_router", None), - patch("litellm.proxy.management_endpoints.team_endpoints._persist_deleted_team_records", new_callable=AsyncMock), + patch( + "litellm.proxy.management_endpoints.team_endpoints._persist_deleted_team_records", new_callable=AsyncMock + ), patch( "litellm.proxy.management_endpoints.team_endpoints.sync_team_access_group_membership", new_callable=AsyncMock, @@ -16128,7 +15545,9 @@ async def test_team_info_reports_parent_organization_models_only_to_team_manager with ( patch("litellm.proxy.proxy_server.prisma_client", mock_prisma), # test-quality-ok: no seam on team_info - patch.object(team_endpoints, "get_all_team_memberships", AsyncMock(return_value=[])), # test-quality-ok: no seam on team_info + patch.object( + team_endpoints, "get_all_team_memberships", AsyncMock(return_value=[]) + ), # test-quality-ok: no seam on team_info _not_org_admin(), ): response = await team_endpoints.team_info( @@ -16368,7 +15787,10 @@ async def test_new_team_rejects_unenforceable_model_max_budget(mock_db_client, m mock_db_client.db.litellm_teamtable.create = AsyncMock() - with patch("litellm.proxy.proxy_server.premium_user", True), pytest.raises(ProxyException) as exc: # test-quality-ok: proxy_server module global is the endpoint's only injection point + with ( + patch("litellm.proxy.proxy_server.premium_user", True), + pytest.raises(ProxyException) as exc, + ): # test-quality-ok: proxy_server module global is the endpoint's only injection point await new_team( data=NewTeamRequest(team_alias="model-caps", model_max_budget={"gpt-4o": {"max_budget": 10.0}}), http_request=MagicMock(spec=Request), @@ -16423,10 +15845,18 @@ async def test_update_team_clearing_model_max_budget_writes_an_empty_mapping( from litellm.proxy.management_endpoints.team_endpoints import update_team with ( - patch("litellm.proxy.proxy_server.prisma_client") as mock_prisma, # test-quality-ok: proxy_server module global is the endpoint's only injection point - patch("litellm.proxy.proxy_server.user_api_key_cache") as mock_cache, # test-quality-ok: proxy_server module global is the endpoint's only injection point - patch("litellm.proxy.proxy_server.litellm_proxy_admin_name", "admin"), # test-quality-ok: proxy_server module global is the endpoint's only injection point - patch("litellm.proxy.proxy_server.premium_user", True), # test-quality-ok: proxy_server module global is the endpoint's only injection point + patch( + "litellm.proxy.proxy_server.prisma_client" + ) as mock_prisma, # test-quality-ok: proxy_server module global is the endpoint's only injection point + patch( + "litellm.proxy.proxy_server.user_api_key_cache" + ) as mock_cache, # test-quality-ok: proxy_server module global is the endpoint's only injection point + patch( + "litellm.proxy.proxy_server.litellm_proxy_admin_name", "admin" + ), # test-quality-ok: proxy_server module global is the endpoint's only injection point + patch( + "litellm.proxy.proxy_server.premium_user", True + ), # test-quality-ok: proxy_server module global is the endpoint's only injection point ): mock_prisma.db.litellm_teamtable.find_unique = AsyncMock( return_value=_existing_team_with_model_caps(_EXISTING_TEAM_MODEL_CAPS) @@ -16455,11 +15885,21 @@ async def test_update_team_model_max_budget_raise_blocked_for_team_admin(): from litellm.proxy.management_endpoints.team_endpoints import update_team with ( - patch("litellm.proxy.proxy_server.prisma_client") as mock_prisma, # test-quality-ok: proxy_server module global is the endpoint's only injection point - patch("litellm.proxy.proxy_server.user_api_key_cache") as mock_cache, # test-quality-ok: proxy_server module global is the endpoint's only injection point - patch("litellm.proxy.proxy_server.litellm_proxy_admin_name", "admin"), # test-quality-ok: proxy_server module global is the endpoint's only injection point - patch("litellm.proxy.proxy_server.premium_user", True), # test-quality-ok: proxy_server module global is the endpoint's only injection point - patch("litellm.proxy.proxy_server.create_audit_log_for_update", new=AsyncMock()), # test-quality-ok: stubs the audit write so the test observes only the team update result + patch( + "litellm.proxy.proxy_server.prisma_client" + ) as mock_prisma, # test-quality-ok: proxy_server module global is the endpoint's only injection point + patch( + "litellm.proxy.proxy_server.user_api_key_cache" + ) as mock_cache, # test-quality-ok: proxy_server module global is the endpoint's only injection point + patch( + "litellm.proxy.proxy_server.litellm_proxy_admin_name", "admin" + ), # test-quality-ok: proxy_server module global is the endpoint's only injection point + patch( + "litellm.proxy.proxy_server.premium_user", True + ), # test-quality-ok: proxy_server module global is the endpoint's only injection point + patch( + "litellm.proxy.proxy_server.create_audit_log_for_update", new=AsyncMock() + ), # test-quality-ok: stubs the audit write so the test observes only the team update result ): mock_prisma.db.litellm_teamtable.find_unique = AsyncMock( return_value=_existing_team_with_model_caps(_EXISTING_TEAM_MODEL_CAPS) @@ -16582,7 +16022,9 @@ async def test_update_team_configured_but_unsupported_field_does_not_open_editin with contextlib.ExitStack() as stack: prisma = _wire_update_team(stack, {}) stack.enter_context( - patch("litellm.proxy.proxy_server.general_settings", {"team_admin_editable_team_fields": ["team_alias"]}) # test-quality-ok: update_team reads general_settings as a proxy_server module global + patch( + "litellm.proxy.proxy_server.general_settings", {"team_admin_editable_team_fields": ["team_alias"]} + ) # test-quality-ok: update_team reads general_settings as a proxy_server module global ) with pytest.raises(ProxyException) as exc: await update_team( @@ -16726,7 +16168,9 @@ async def test_update_team_team_admin_resending_stored_member_defaults_is_not_an ) ) stack.enter_context( - patch("litellm.proxy.proxy_server.general_settings", {"team_admin_editable_team_fields": ["tpm_limit"]}) # test-quality-ok: update_team reads general_settings as a proxy_server module global + patch( + "litellm.proxy.proxy_server.general_settings", {"team_admin_editable_team_fields": ["tpm_limit"]} + ) # test-quality-ok: update_team reads general_settings as a proxy_server module global ) result = await update_team( data=UpdateTeamRequest( @@ -16756,7 +16200,9 @@ async def test_update_team_team_admin_changes_tpm_limit_once_a_proxy_admin_enabl with contextlib.ExitStack() as stack: prisma = _wire_update_team(stack, {}) stack.enter_context( - patch("litellm.proxy.proxy_server.general_settings", {"team_admin_editable_team_fields": ["tpm_limit"]}) # test-quality-ok: update_team reads general_settings as a proxy_server module global + patch( + "litellm.proxy.proxy_server.general_settings", {"team_admin_editable_team_fields": ["tpm_limit"]} + ) # test-quality-ok: update_team reads general_settings as a proxy_server module global ) await update_team( data=UpdateTeamRequest(team_id="test_team_id", tpm_limit=5000), @@ -16826,8 +16272,10 @@ async def test_update_team_holds_a_team_admin_to_the_org_tpm_limit(disable_audit ) async def org_lookup(**kwargs): - return capped_org if kwargs.get("include_budget_table") else capped_org.model_copy( - update={"litellm_budget_table": None} + return ( + capped_org + if kwargs.get("include_budget_table") + else capped_org.model_copy(update={"litellm_budget_table": None}) ) org_team = MagicMock() @@ -17291,7 +16739,9 @@ async def test_team_info_reports_what_the_caller_may_edit(caller, org_admin, ena with ( patch("litellm.proxy.proxy_server.prisma_client", mock_prisma), # test-quality-ok: no seam on team_info - patch.object(team_endpoints, "get_all_team_memberships", AsyncMock(return_value=[])), # test-quality-ok: no seam on team_info + patch.object( + team_endpoints, "get_all_team_memberships", AsyncMock(return_value=[]) + ), # test-quality-ok: no seam on team_info _org_admins(("admin-1", "org-1")) if org_admin else _not_org_admin(), _team_admin_may_edit(*enabled_fields), ): @@ -17362,7 +16812,9 @@ def test_member_budget_patch_stores_model_max_budget_as_json_and_clears_on_empty user_id="user-1", model_max_budget={"gpt-4o": {"budget_limit": 5, "time_period": "30d"}}, ) - assert member_budget_patch(request) == {"model_max_budget": {"gpt-4o": {"max_budget": 5.0, "budget_duration": "30d"}}} + assert member_budget_patch(request) == { + "model_max_budget": {"gpt-4o": {"max_budget": 5.0, "budget_duration": "30d"}} + } cleared: Final = TeamMemberUpdateRequest(team_id="team-1", user_id="user-1", model_max_budget={}) assert member_budget_patch(cleared) == {"model_max_budget": {}} @@ -17728,7 +17180,7 @@ async def test_default_budget_cache_eviction_does_not_fail_after_redis_error() - user_api_key_cache = MagicMock() user_api_key_cache.async_delete_cache = AsyncMock(side_effect=RuntimeError("redis unavailable")) - await TeamMemberBudgetHandler._evict_default_budget_cache( + await TeamMemberBudgetHandler.evict_default_budget_cache( budget_id="budget_456", user_api_key_cache=user_api_key_cache, ) diff --git a/tests/unit/proxy/management_helpers/test_team_member_default_budget.py b/tests/unit/proxy/management_helpers/test_team_member_default_budget.py index a3a7fa5dcce..3fd741429a5 100644 --- a/tests/unit/proxy/management_helpers/test_team_member_default_budget.py +++ b/tests/unit/proxy/management_helpers/test_team_member_default_budget.py @@ -43,7 +43,8 @@ def test_a_first_default_gets_a_new_row_that_inherits_the_team_reset_period(): assert write.budget_id.startswith("team-My-Team-budget-") assert write.create["max_budget"] == 25.0 assert write.create["budget_duration"] == "30d" - assert write.create["budget_reset_at"] > before + reset_at = write.create["budget_reset_at"] + assert isinstance(reset_at, datetime) and reset_at > before assert write.links_members is True @@ -63,7 +64,8 @@ def test_changing_the_reset_period_restarts_the_window(): assert write is not None assert write.update["budget_duration"] == "7d" - assert write.update["budget_reset_at"] > before + reset_at = write.update["budget_reset_at"] + assert isinstance(reset_at, datetime) and reset_at > before @pytest.mark.parametrize("team_member_budget", [None, 0.0]) diff --git a/ui/litellm-dashboard/src/lib/http/schema.d.ts b/ui/litellm-dashboard/src/lib/http/schema.d.ts index ae1b8fab924..7a3804d18fb 100644 --- a/ui/litellm-dashboard/src/lib/http/schema.d.ts +++ b/ui/litellm-dashboard/src/lib/http/schema.d.ts @@ -17314,6 +17314,7 @@ export interface paths { * - team_member_model_max_budget: Optional[dict] - Per-model budgets shared by team members without an override. * - team_member_rpm_limit: Optional[int] - The RPM (Requests Per Minute) limit for individual team members. * - team_member_tpm_limit: Optional[int] - The TPM (Tokens Per Minute) limit for individual team members. + * - team_member_budget_backfill: Optional[str] - Moves members with their own budget onto the team_member_budget sent in the same request: "raise_to_default" (those below it), "lower_to_default" (those above it), "all_to_default" (both) or "none". Members on a different reset schedule are skipped, and the response's team_member_budget_backfill_result counts who moved. * - team_member_key_duration: Optional[str] - The duration for a team member's key. e.g. "1d", "1w", "1mo" * - allowed_passthrough_routes: Optional[List[str]] - List of allowed pass through routes for the team. * - denied_passthrough_routes: Optional[List[str]] - List of pass through routes the team's keys may not call, even if allowed. Applies together with each key's `denied_passthrough_routes`. From 0270b6bc5c1d192fe2b06a725f605cd3dabe3107 Mon Sep 17 00:00:00 2001 From: shrey kharbanda Date: Fri, 23 Oct 2026 15:47:01 -0700 Subject: [PATCH 3/6] fix(ui): fit the member budget prompt title on one line --- .../src/components/team/ResetMemberBudgetsDialog.test.tsx | 2 +- .../src/components/team/ResetMemberBudgetsDialog.tsx | 4 +--- .../src/components/team/TeamInfo.integration.test.tsx | 4 ++-- 3 files changed, 4 insertions(+), 6 deletions(-) diff --git a/ui/litellm-dashboard/src/components/team/ResetMemberBudgetsDialog.test.tsx b/ui/litellm-dashboard/src/components/team/ResetMemberBudgetsDialog.test.tsx index 439c383255c..b80202568a2 100644 --- a/ui/litellm-dashboard/src/components/team/ResetMemberBudgetsDialog.test.tsx +++ b/ui/litellm-dashboard/src/components/team/ResetMemberBudgetsDialog.test.tsx @@ -45,7 +45,7 @@ describe("ResetMemberBudgetsDialog", () => { const user = userEvent.setup(); const { onSave } = renderDialog(state("prompting", preview(2, 1))); - expect(screen.getByText("Apply the new $1,250.00 default to members with a custom budget?")).toBeInTheDocument(); + expect(screen.getByText("Apply the $1,250.00 default to custom budgets?")).toBeInTheDocument(); expect(screen.getByRole("radio", { name: "Keep all custom budgets" })).toBeChecked(); await user.click(screen.getByRole("button", { name: "Save" })); diff --git a/ui/litellm-dashboard/src/components/team/ResetMemberBudgetsDialog.tsx b/ui/litellm-dashboard/src/components/team/ResetMemberBudgetsDialog.tsx index 045bb18e780..5edc148c072 100644 --- a/ui/litellm-dashboard/src/components/team/ResetMemberBudgetsDialog.tsx +++ b/ui/litellm-dashboard/src/components/team/ResetMemberBudgetsDialog.tsx @@ -52,9 +52,7 @@ function BackfillChoice({ pending, busy, onSave, onDismiss }: BackfillChoiceProp return ( <> - - Apply the new ${formatNumberWithCommas(pending.newBudget, 2)} default to members with a custom budget? - + Apply the ${formatNumberWithCommas(pending.newBudget, 2)} default to custom budgets? setChoice(value as MemberBudgetBackfill)}> {backfillOptions(pending.preview, pending.newBudget).map((option) => ( diff --git a/ui/litellm-dashboard/src/components/team/TeamInfo.integration.test.tsx b/ui/litellm-dashboard/src/components/team/TeamInfo.integration.test.tsx index 016b60338ee..fe028073ff3 100644 --- a/ui/litellm-dashboard/src/components/team/TeamInfo.integration.test.tsx +++ b/ui/litellm-dashboard/src/components/team/TeamInfo.integration.test.tsx @@ -413,7 +413,7 @@ describe("TeamInfoView - member budget reset prompt", () => { }; const savedBody = () => vi.mocked(networking.teamUpdateCall).mock.calls[0][1]; - const promptTitle = "Apply the new $20.00 default to members with a custom budget?"; + const promptTitle = "Apply the $20.00 default to custom budgets?"; beforeEach(() => { seedDefaultMocks(); @@ -514,7 +514,7 @@ describe("TeamInfoView - member budget reset prompt", () => { await waitFor(() => expect(networking.teamUpdateCall).toHaveBeenCalledTimes(1)); expect(savedBody().team_member_budget).toBe(Number(value)); expect(savedBody()).not.toHaveProperty("team_member_budget_backfill"); - expect(screen.queryByText(/default to members with a custom budget/)).not.toBeInTheDocument(); + expect(screen.queryByText(/default to custom budgets/)).not.toBeInTheDocument(); }); it("dismisses a pending prompt when the selected team changes", async () => { From ce4656155535268b46b26c2def683dbebdf4dc3d Mon Sep 17 00:00:00 2001 From: shrey kharbanda Date: Fri, 23 Oct 2026 16:13:58 -0700 Subject: [PATCH 4/6] fix(teams): keep backfilled members consistent with the default they join Members that keep their own row after a backfill now take the default's reset time, so their spend resets when the default's does. A model list always stays the member's own, even when it matches the default, so clearing the default later cannot widen what they may call. Writing the default member budget now evicts every roster member's cached membership, including when its cap is cleared, and /team/member_update reads the member's budget again once it holds the team lock, so an edit racing a backfill lands on the row the member actually uses. --- .../management_endpoints/team_endpoints.py | 24 +++++----- .../team_member_default_budget.py | 17 +++++-- .../test_team_member_budget_backfill.py | 45 ++++++++++++++++++ .../test_team_endpoints.py | 46 +++++++++++++++++++ tests/unit/proxy/test_team_member_update.py | 14 ++++++ 5 files changed, 131 insertions(+), 15 deletions(-) diff --git a/litellm/proxy/management_endpoints/team_endpoints.py b/litellm/proxy/management_endpoints/team_endpoints.py index 1cec93f857b..448c3e6fa82 100644 --- a/litellm/proxy/management_endpoints/team_endpoints.py +++ b/litellm/proxy/management_endpoints/team_endpoints.py @@ -501,6 +501,10 @@ def _team_membership_db(prisma_client: PrismaClient | None) -> "TableActions[pri return TeamMembershipRepository(prisma_client).table +def _team_membership_tx_db(tx: "Prisma") -> "TableActions[prisma_models.LiteLLM_TeamMembership]": + return tx.litellm_teammembership # pyright: ignore[reportReturnType] # TableActions widens the generated inputs to Mapping, as the repositories do + + def _user_db(prisma_client: PrismaClient | None) -> "TableActions[prisma_models.LiteLLM_UserTable]": return UserRepository(prisma_client).table @@ -1242,7 +1246,7 @@ async def _write_team_update( @dataclass(frozen=True, slots=True) class _TeamWrite: team_row: "prisma_models.LiteLLM_TeamTable | None" - linked_member_user_ids: tuple[str, ...] + roster_user_ids: tuple[str, ...] moved_member_budgets: MovedMemberBudgets | None def backfill_response(self) -> Mapping[str, TeamMemberBudgetBackfillResult]: @@ -1255,7 +1259,7 @@ class _TeamWrite: def changed_member_user_ids(self) -> tuple[str, ...]: moved: Final = () if self.moved_member_budgets is None else self.moved_member_budgets.user_ids - return tuple(dict.fromkeys((*self.linked_member_user_ids, *moved))) + return tuple(dict.fromkeys((*self.roster_user_ids, *moved))) async def _write_team_with_member_default_budget( @@ -1304,7 +1308,7 @@ async def _write_team_with_member_default_budget( team_row: Final = await _write_team_update(_team_tx_db(tx), team_id, team_update_data, max_budget_guard) return _TeamWrite( team_row=team_row, - linked_member_user_ids=member_user_ids if default_budget_write.links_members else (), + roster_user_ids=member_user_ids, moved_member_budgets=moved if backfill != "none" else None, ) @@ -2602,7 +2606,7 @@ async def update_team( team_row=await _write_team_update( _team_db(prisma_client), data.team_id, team_update_data, max_budget_guard ), - linked_member_user_ids=(), + roster_user_ids=(), moved_member_budgets=None, ) if default_budget_write is None @@ -3958,13 +3962,6 @@ async def team_member_update( status_code=400, detail={"error": f"User id doesn't exist in team table. Data={data}"}, ) - ## find the relevant team membership - identified_budget_id: str | None = None - for tm in returned_team_info["team_memberships"]: - if tm.user_id == received_user_id: - identified_budget_id = tm.budget_id - break - # If this membership still points at the team's shared default member # budget, _upsert_budget_and_membership will clone-on-write so that the # update only touches this user (not every member sharing the default). @@ -3990,11 +3987,14 @@ async def team_member_update( if data.role is not None else None ) + locked_membership: Final = await _team_membership_tx_db(tx).find_unique( + where={"user_id_team_id": {"user_id": received_user_id, "team_id": data.team_id}} + ) await upsert_budget_and_membership( tx=tx, team_id=data.team_id, user_id=received_user_id, - existing_budget_id=identified_budget_id, + existing_budget_id=locked_membership.budget_id if locked_membership is not None else None, user_api_key_dict=user_api_key_dict, budget_patch=budget_patch, team_default_budget_id=team_default_budget_id, diff --git a/litellm/proxy/management_helpers/team_member_default_budget.py b/litellm/proxy/management_helpers/team_member_default_budget.py index f49a38eb198..038fd5f2a9f 100644 --- a/litellm/proxy/management_helpers/team_member_default_budget.py +++ b/litellm/proxy/management_helpers/team_member_default_budget.py @@ -28,6 +28,8 @@ if TYPE_CHECKING: MAX_MEMBER_BUDGETS_MOVED_PER_UPDATE: Final = 50_000 +_ALWAYS_OWN_LIMITS: Final = frozenset({"allowed_models"}) + _DEFAULT_BUDGET_COLUMNS: Final = MappingProxyType( { "team_member_budget": "max_budget", @@ -53,6 +55,12 @@ _CLEAR_MAX_BUDGET_SQL: Final = """ UPDATE "LiteLLM_BudgetTable" SET max_budget = NULL, updated_by = $2, updated_at = (NOW() AT TIME ZONE 'UTC') WHERE budget_id = ANY($1::text[]) """ +_ALIGN_RESET_TO_DEFAULT_SQL: Final = """ +UPDATE "LiteLLM_BudgetTable" b +SET budget_reset_at = (SELECT d.budget_reset_at FROM "LiteLLM_BudgetTable" d WHERE d.budget_id = $2) +FROM "LiteLLM_TeamMembership" m +WHERE m.team_id = $1 AND m.user_id = ANY($3::text[]) AND m.budget_id = b.budget_id AND b.budget_id <> $2 +""" _SHARED_BUDGET_IDS_SQL: Final = """ SELECT budget_id FROM "LiteLLM_TeamMembership" WHERE budget_id = ANY($1::text[]) GROUP BY budget_id HAVING COUNT(*) > 1 @@ -129,7 +137,9 @@ class _BudgetLimits(BaseModel): def has_own_limits_beyond(self, default: "_BudgetLimits") -> bool: own: Final = _JSON_OBJECT.validate_python(self.model_dump(mode="json")) inherited: Final = _JSON_OBJECT.validate_python(default.model_dump(mode="json")) - return has_meaningful_budget_limit({field: value for field, value in own.items() if value != inherited[field]}) + return has_meaningful_budget_limit( + {field: value for field, value in own.items() if field in _ALWAYS_OWN_LIMITS or value != inherited[field]} + ) class _MemberBudgetRef(BaseModel): @@ -218,8 +228,8 @@ async def move_member_budgets_to_default( changed_by: UserAPIKeyAuth, ) -> MovedMemberBudgets | TooManyMemberBudgetsToMove: """Members compare on their permanent ``max_budget``, and only those resetting on the default's schedule move. - A member whose other limits all match the default is linked to the default row, while one holding a limit of its - own keeps its row with ``max_budget`` cleared.""" + A member whose other limits all match the default is linked to the default row. One holding a limit of its own, or + any model list, keeps its row with ``max_budget`` cleared and its reset moved onto the default's.""" if backfill == "none": return MovedMemberBudgets(user_ids=(), skipped_other_reset_period=0) default: Final = await _budget_tx_db(tx).find_unique(where={"budget_id": default_budget_id}) @@ -292,6 +302,7 @@ async def _move_to_default( team_default_budget_id=default_budget_id, shared_budget_ids=shared, ) + await tx.execute_raw(_ALIGN_RESET_TO_DEFAULT_SQL, team_id, default_budget_id, [ref.user_id for ref in keeping]) def _prisma_columns(columns: Mapping[str, object]) -> Mapping[str, object]: diff --git a/tests/integration/management/test_team_member_budget_backfill.py b/tests/integration/management/test_team_member_budget_backfill.py index fbf64f80b29..2da71a54ba6 100644 --- a/tests/integration/management/test_team_member_budget_backfill.py +++ b/tests/integration/management/test_team_member_budget_backfill.py @@ -1,5 +1,6 @@ from collections.abc import Mapping from dataclasses import dataclass +from datetime import datetime, timezone import pytest from prisma import Json @@ -188,6 +189,50 @@ async def test_backfill_links_members_sharing_a_plain_custom_budget_to_the_defau assert shared.max_budget == 20.0 +async def test_a_moved_member_keeping_their_own_limits_resets_with_the_default(db, resources): + default_budget_id = await _seed_team(db, resources, {"own_rpm": _Budget(20.0, rpm_limit=5)}) + default_reset = datetime(2030, 1, 1, tzinfo=timezone.utc) + await db.db.litellm_budgettable.update( + where={"budget_id": default_budget_id}, data={"budget_reset_at": default_reset} + ) + await db.db.litellm_budgettable.update( + where={"budget_id": resources.tag("own-own_rpm")}, + data={"budget_reset_at": datetime(2030, 1, 15, tzinfo=timezone.utc)}, + ) + + response = _update_team( + db, + resources.prefix, + {"team_member_budget": _NEW_DEFAULT, "team_member_budget_backfill": "raise_to_default"}, + ) + + assert response.status_code == 200, response.text + kept = (await _member_budget(db, resources, "own_rpm")).litellm_budget_table + assert (kept.max_budget, kept.rpm_limit, kept.budget_reset_at) == (None, 5, default_reset) + + +async def test_a_member_with_a_model_list_keeps_it_even_when_it_matches_the_default(db, resources): + default_budget_id = await _seed_team(db, resources, {"scoped": _Budget(20.0)}) + for budget_id in (default_budget_id, resources.tag("own-scoped")): + await db.db.litellm_budgettable.update( + where={"budget_id": budget_id}, data={"allowed_models": ["gpt-5.4-mini"]} + ) + + response = _update_team( + db, + resources.prefix, + {"team_member_budget": _NEW_DEFAULT, "team_member_budget_backfill": "raise_to_default"}, + ) + + assert response.status_code == 200, response.text + scoped = await _member_budget(db, resources, "scoped") + assert scoped.budget_id == resources.tag("own-scoped") + assert (scoped.litellm_budget_table.max_budget, scoped.litellm_budget_table.allowed_models) == ( + None, + ["gpt-5.4-mini"], + ) + + async def test_backfill_over_the_member_cap_rolls_back_the_new_default(db, resources): default_budget_id = await _seed_team(db, resources, {}) over_cap = MAX_MEMBER_BUDGETS_MOVED_PER_UPDATE + 1 diff --git a/tests/unit/proxy/management_endpoints/test_team_endpoints.py b/tests/unit/proxy/management_endpoints/test_team_endpoints.py index f99e20a02a7..8b0b5bda334 100644 --- a/tests/unit/proxy/management_endpoints/test_team_endpoints.py +++ b/tests/unit/proxy/management_endpoints/test_team_endpoints.py @@ -10565,6 +10565,50 @@ async def test_update_team_clears_explicitly_null_member_model_budget_and_evicts assert cache.async_delete_cache.await_args_list == [call(key="team_member_default_budget:member-budget-1")] +@pytest.mark.asyncio +async def test_clearing_the_member_default_evicts_every_roster_members_cached_membership( + disable_audit_logging_for_mocked_team, +): + """A member on the default caches the default row inside their membership, so clearing its cap must drop + that cached copy, or a member already at the old cap stays blocked until the cache expires.""" + from fastapi import Request + + from litellm.proxy._types import UpdateTeamRequest + from litellm.proxy.management_endpoints.team_endpoints import update_team + + existing: Final = _existing_team_with_model_caps({}) + existing.metadata = {"team_member_budget_id": "member-budget-1"} + existing.model_dump.return_value["metadata"] = existing.metadata + cache: Final = MagicMock() + cache.async_get_cache = AsyncMock(return_value=None) + cache.async_set_cache = AsyncMock() + cache.async_delete_cache = AsyncMock() + updated: Final = _existing_team_with_model_caps({}) + updated.metadata = existing.metadata + updated.litellm_model_table = None + prisma: Final = MagicMock() + + with ( + patch("litellm.proxy.proxy_server.prisma_client", prisma), + patch("litellm.proxy.proxy_server.user_api_key_cache", cache), + patch("litellm.proxy.proxy_server.litellm_proxy_admin_name", "admin"), + ): + prisma.db.litellm_teamtable.find_unique = AsyncMock(return_value=existing) + prisma.jsonify_team_object = lambda db_data: db_data + prisma.db.litellm_teamtable.update = AsyncMock(return_value=updated) + tx: Final = _transaction_over(prisma) + tx.query_raw = AsyncMock(return_value=[{"members_with_roles": [{"user_id": "at-old-cap", "role": "user"}]}]) + + await update_team( + data=UpdateTeamRequest(team_id="standalone-team-123", team_member_budget=None), + http_request=MagicMock(spec=Request), + user_api_key_dict=UserAPIKeyAuth(user_role=LitellmUserRoles.PROXY_ADMIN, user_id="admin"), + ) + + evicted: Final = {c.args[0] for c in cache.in_memory_cache_for.return_value.delete_cache.call_args_list} + assert "standalone-team-123_at-old-cap" in evicted + + @pytest.mark.asyncio async def test_update_team_persists_member_model_budget_to_default_budget_row( disable_audit_logging_for_mocked_team, @@ -13427,6 +13471,7 @@ async def test_team_member_update_role_change_emits_a_roster_audit_event(monkeyp mock_prisma_client.db.litellm_auditlog.create = AsyncMock() monkeypatch.setattr("litellm.proxy.proxy_server.prisma_client", mock_prisma_client) _wire_member_delete_tx(mock_prisma_client) + mock_prisma_client.db.litellm_teammembership.find_unique = AsyncMock(return_value=None) with ( patch( # test-quality-ok: no live DB here; matches this file's established convention for endpoint-logic unit tests @@ -13522,6 +13567,7 @@ async def test_team_member_update_role_change_rewrites_the_roster_it_read_under_ mock_prisma_client.db.litellm_auditlog.create = AsyncMock() monkeypatch.setattr("litellm.proxy.proxy_server.prisma_client", mock_prisma_client) tx = _wire_member_delete_tx(mock_prisma_client) + mock_prisma_client.db.litellm_teammembership.find_unique = AsyncMock(return_value=None) team_info_patch, upsert_patch = _member_update_patches(stale_snapshot) with team_info_patch, upsert_patch: diff --git a/tests/unit/proxy/test_team_member_update.py b/tests/unit/proxy/test_team_member_update.py index d77904fc05d..502fa3340a4 100644 --- a/tests/unit/proxy/test_team_member_update.py +++ b/tests/unit/proxy/test_team_member_update.py @@ -69,6 +69,9 @@ def happy_path_upsert(monkeypatch): class _FakeTx: litellm_teamtable = prisma_client.db.litellm_teamtable + litellm_teammembership = types.SimpleNamespace( + find_unique=AsyncMock(return_value=types.SimpleNamespace(user_id="user-1", budget_id="bud-under-lock")) + ) async def __aenter__(self): return self @@ -123,6 +126,17 @@ async def test_team_member_update_sends_provided_fields_as_patch(happy_path_upse assert response.budget_duration == "30d" +@pytest.mark.asyncio +async def test_team_member_update_writes_the_budget_the_member_has_once_the_team_lock_is_held(happy_path_upsert): + """A team default backfill that commits while this update waits for the lock can relink the member. The + update must then write the budget the member points at now, not the one read before the lock.""" + data, request, auth = _member_update_request(max_budget_in_team=30.0) + + await team_member_update(data, request, auth) + + assert happy_path_upsert.await_args.kwargs["existing_budget_id"] == "bud-under-lock" + + @pytest.mark.asyncio async def test_team_member_update_explicit_null_clears_field(happy_path_upsert): """An explicitly-null field must be forwarded as None so the column is From d06ee225a1071081152715db2388bb19265336bc Mon Sep 17 00:00:00 2001 From: shrey kharbanda Date: Fri, 23 Oct 2026 16:28:06 -0700 Subject: [PATCH 5/6] test(teams): cover the backfill's selection, shared copies and refusals in unit tests The real Postgres suite only runs on main, so pin the Python side of the backfill against an in-memory team as well: who moves, who is skipped for another reset schedule, shared budget copies, the member limit, a missing default, the reported counts and a team deleted while waiting for its lock. --- .../test_upsert_budget_membership.py | 21 ++ .../test_team_endpoints.py | 135 +++++++++ .../test_team_member_default_budget.py | 278 +++++++++++++++++- 3 files changed, 432 insertions(+), 2 deletions(-) diff --git a/tests/unit/proxy/common_utils/test_upsert_budget_membership.py b/tests/unit/proxy/common_utils/test_upsert_budget_membership.py index 9bd3217067a..b0680133325 100644 --- a/tests/unit/proxy/common_utils/test_upsert_budget_membership.py +++ b/tests/unit/proxy/common_utils/test_upsert_budget_membership.py @@ -105,6 +105,27 @@ async def test_clearing_all_limits_links_the_member_to_the_team_default(mock_tx, ) +@pytest.mark.asyncio +async def test_emptying_a_member_on_a_limitless_team_default_keeps_them_on_it(mock_tx, fake_user): + mock_tx.litellm_budgettable.find_unique = AsyncMock(return_value=budget_row(budget_id="team-default")) + + await upsert_budget_and_membership( + mock_tx, + team_id="team-1", + user_id="user-1", + existing_budget_id="team-default", + user_api_key_dict=fake_user, + budget_patch={"max_budget": None}, + team_default_budget_id="team-default", + ) + + mock_tx.litellm_teammembership.update.assert_awaited_once_with( + where={"user_id_team_id": {"user_id": "user-1", "team_id": "team-1"}}, + data={"litellm_budget_table": {"connect": {"budget_id": "team-default"}}}, + ) + mock_tx.litellm_budgettable.create.assert_not_called() + + # TEST: clearing every limit on a member's private budget disconnects it, so the # member falls back to the team default instead of keeping an empty private row. @pytest.mark.asyncio diff --git a/tests/unit/proxy/management_endpoints/test_team_endpoints.py b/tests/unit/proxy/management_endpoints/test_team_endpoints.py index 8b0b5bda334..a420e19e7fe 100644 --- a/tests/unit/proxy/management_endpoints/test_team_endpoints.py +++ b/tests/unit/proxy/management_endpoints/test_team_endpoints.py @@ -10609,6 +10609,141 @@ async def test_clearing_the_member_default_evicts_every_roster_members_cached_me assert "standalone-team-123_at-old-cap" in evicted +def _backfill_ready_prisma(answer): + from types import SimpleNamespace + + existing: Final = _existing_team_with_model_caps({}) + existing.metadata = {"team_member_budget_id": "member-budget-1"} + existing.model_dump.return_value["metadata"] = existing.metadata + updated: Final = _existing_team_with_model_caps({}) + updated.metadata = existing.metadata + updated.litellm_model_table = None + prisma: Final = MagicMock() + prisma.db.litellm_teamtable.find_unique = AsyncMock(return_value=existing) + prisma.jsonify_team_object = lambda db_data: db_data + prisma.db.litellm_teamtable.update = AsyncMock(return_value=updated) + tx: Final = _transaction_over(prisma) + tx.query_raw = AsyncMock(side_effect=answer) + default_row: Final = {"max_budget": 50.0, "budget_duration": "30d"} + prisma.db.litellm_budgettable.find_unique = AsyncMock( + return_value=SimpleNamespace(**default_row, model_dump=lambda: default_row) + ) + return prisma + + +async def _raise_to_default(prisma): + from fastapi import Request + + from litellm.proxy._types import UpdateTeamRequest + from litellm.proxy.management_endpoints.team_endpoints import update_team + + cache: Final = MagicMock() + cache.async_get_cache = AsyncMock(return_value=None) + cache.async_set_cache = AsyncMock() + cache.async_delete_cache = AsyncMock() + with ( + patch("litellm.proxy.proxy_server.prisma_client", prisma), + patch("litellm.proxy.proxy_server.user_api_key_cache", cache), + patch("litellm.proxy.proxy_server.litellm_proxy_admin_name", "admin"), + ): + return await update_team( + data=UpdateTeamRequest( + team_id="standalone-team-123", team_member_budget=50.0, team_member_budget_backfill="raise_to_default" + ), + http_request=MagicMock(spec=Request), + user_api_key_dict=UserAPIKeyAuth(user_role=LitellmUserRoles.PROXY_ADMIN, user_id="admin"), + ) + + +@pytest.mark.asyncio +async def test_a_backfill_reports_how_many_members_moved(disable_audit_logging_for_mocked_team): + from litellm.proxy._types import TeamMemberBudgetBackfillResult + + async def answer(sql: str, *args: object) -> list[dict[str, object]]: + if "GROUP BY b.budget_duration" in sql: + return [{"duration": "30d", "members": 1}, {"duration": "7d", "members": 2}] + if "b.budget_duration = ANY" in sql: + return [{"user_id": "below", "budget_id": "own-below", "budget_duration": "30d"}] + if "HAVING COUNT(*) > 1" in sql: + return [] + return [{"members_with_roles": [{"user_id": "below", "role": "user"}]}] + + response: Final = await _raise_to_default(_backfill_ready_prisma(answer)) + + assert response["team_member_budget_backfill_result"] == TeamMemberBudgetBackfillResult( + moved_to_default=1, skipped_other_reset_period=2 + ) + + +@pytest.mark.asyncio +async def test_a_team_deleted_while_its_update_waits_for_the_lock_is_not_written(disable_audit_logging_for_mocked_team): + from litellm.proxy._types import ProxyException + + async def answer(sql: str, *args: object) -> list[dict[str, object]]: + return [] + + prisma: Final = _backfill_ready_prisma(answer) + + with pytest.raises(ProxyException) as gone: + await _raise_to_default(prisma) + + assert gone.value.code == "404" + prisma.db.litellm_teamtable.update.assert_not_awaited() + + +@pytest.mark.asyncio +async def test_a_backfill_over_the_member_limit_is_refused_without_writing_the_team( + disable_audit_logging_for_mocked_team, +): + from types import SimpleNamespace + + from fastapi import Request + + from litellm.proxy._types import ProxyException, UpdateTeamRequest + from litellm.proxy.management_endpoints.team_endpoints import update_team + from litellm.proxy.management_helpers.team_member_default_budget import MAX_MEMBER_BUDGETS_MOVED_PER_UPDATE + + existing: Final = _existing_team_with_model_caps({}) + existing.metadata = {"team_member_budget_id": "member-budget-1"} + existing.model_dump.return_value["metadata"] = existing.metadata + prisma: Final = MagicMock() + over_limit: Final = MAX_MEMBER_BUDGETS_MOVED_PER_UPDATE + 1 + + async def answer(sql: str, *args: object) -> list[dict[str, object]]: + if "GROUP BY b.budget_duration" in sql: + return [{"duration": "30d", "members": over_limit}] + return [{"members_with_roles": []}] + + with ( + patch("litellm.proxy.proxy_server.prisma_client", prisma), + patch("litellm.proxy.proxy_server.user_api_key_cache", MagicMock()), + patch("litellm.proxy.proxy_server.litellm_proxy_admin_name", "admin"), + ): + prisma.db.litellm_teamtable.find_unique = AsyncMock(return_value=existing) + prisma.jsonify_team_object = lambda db_data: db_data + prisma.db.litellm_teamtable.update = AsyncMock() + tx: Final = _transaction_over(prisma) + tx.query_raw = AsyncMock(side_effect=answer) + prisma.db.litellm_budgettable.find_unique = AsyncMock( + return_value=SimpleNamespace(max_budget=50.0, budget_duration="30d") + ) + + with pytest.raises(ProxyException) as refused: + await update_team( + data=UpdateTeamRequest( + team_id="standalone-team-123", + team_member_budget=50.0, + team_member_budget_backfill="raise_to_default", + ), + http_request=MagicMock(spec=Request), + user_api_key_dict=UserAPIKeyAuth(user_role=LitellmUserRoles.PROXY_ADMIN, user_id="admin"), + ) + + assert refused.value.code == "422" + assert str(over_limit) in refused.value.message + prisma.db.litellm_teamtable.update.assert_not_awaited() + + @pytest.mark.asyncio async def test_update_team_persists_member_model_budget_to_default_budget_row( disable_audit_logging_for_mocked_team, diff --git a/tests/unit/proxy/management_helpers/test_team_member_default_budget.py b/tests/unit/proxy/management_helpers/test_team_member_default_budget.py index 3fd741429a5..c675f24e8aa 100644 --- a/tests/unit/proxy/management_helpers/test_team_member_default_budget.py +++ b/tests/unit/proxy/management_helpers/test_team_member_default_budget.py @@ -1,11 +1,19 @@ import json from datetime import datetime, timezone +from types import SimpleNamespace import pytest from pydantic import ValidationError -from litellm.proxy._types import UpdateTeamRequest -from litellm.proxy.management_helpers.team_member_default_budget import plan_team_member_default_budget_write +from litellm.proxy._types import TeamMemberBudgetBackfillResult, UpdateTeamRequest, UserAPIKeyAuth +from litellm.proxy.management_helpers.team_member_default_budget import ( + MAX_MEMBER_BUDGETS_MOVED_PER_UPDATE, + MovedMemberBudgets, + TooManyMemberBudgetsToMove, + move_member_budgets_to_default, + plan_team_member_default_budget_write, + write_team_member_default_budget, +) def _plan(existing_budget_id: str | None = None, team_budget_duration: str | None = None, **fields: object): @@ -88,3 +96,269 @@ def test_per_model_member_budgets_are_stored_as_plain_json(): assert write is not None assert json.loads(json.dumps(write.update["model_max_budget"]))["gpt-4o"]["max_budget"] == 5.0 + + +class _InMemoryTeam: + """One team's memberships and budget rows, changed the way the backfill's statements change Postgres.""" + + def __init__(self, default: dict[str, object], members: dict[str, dict[str, object] | None]) -> None: + self.budgets: dict[str, dict[str, object]] = {"default": {"budget_id": "default", **default}} + self.memberships: dict[str, str | None] = {} + for user_id, budget in members.items(): + if budget is None: + self.memberships[user_id] = "default" + continue + self.budgets[f"own-{user_id}"] = {"budget_id": f"own-{user_id}", **budget} + self.memberships[user_id] = f"own-{user_id}" + self.litellm_budgettable = SimpleNamespace( + find_unique=self._find_budget, upsert=self._upsert_budget, create=self._create_budget + ) + self.litellm_teammembership = SimpleNamespace(upsert=self._link_membership) + + def share(self, budget_id: str, *user_ids: str) -> None: + for user_id in user_ids: + self.memberships[user_id] = budget_id + + async def _create_budget(self, data: dict[str, object], include: dict[str, bool] | None = None): + budget_id = f"copy-{len(self.budgets)}" + self.budgets[budget_id] = {"budget_id": budget_id, **data} + return SimpleNamespace(budget_id=budget_id) + + async def _link_membership(self, where: dict[str, dict[str, str]], data: dict[str, dict[str, object]]) -> None: + self.memberships[where["user_id_team_id"]["user_id"]] = data["update"]["litellm_budget_table"]["connect"][ + "budget_id" + ] + + def budget_of(self, user_id: str) -> dict[str, object]: + return self.budgets[self.memberships[user_id]] + + async def _find_budget(self, where: dict[str, str]): + stored = self.budgets.get(where["budget_id"]) + if stored is None: + return None + row = {**_ROW_DEFAULTS, **stored} + return SimpleNamespace(**row, model_dump=lambda: row) + + async def _upsert_budget(self, where: dict[str, str], data: dict[str, dict[str, object]]) -> None: + current = self.budgets.get(where["budget_id"]) + self.budgets[where["budget_id"]] = {**(current or {}), **(data["update"] if current else data["create"])} + + def _on_chosen_side(self, budget: dict[str, object], direction: str, amount: float) -> bool: + own = budget.get("max_budget") + if budget["budget_id"] == "default" or own is None: + return False + return {"raise_to_default": own < amount, "lower_to_default": own > amount, "all_to_default": own != amount}[ + direction + ] + + async def query_raw(self, sql: str, *args: object) -> list[dict[str, object]]: + if "HAVING COUNT(*) > 1" in sql: + budget_ids = list(self.memberships.values()) + return [{"budget_id": b} for b in set(args[0]) if budget_ids.count(b) > 1] + _team, _default, direction, amount = args[:4] + chosen = [ + (u, self.budgets[b]) + for u, b in self.memberships.items() + if b and self._on_chosen_side(self.budgets[b], direction, amount) + ] + if "GROUP BY" in sql: + durations = [budget.get("budget_duration") for _, budget in chosen] + return [{"duration": d, "members": durations.count(d)} for d in set(durations)] + durations, include_none = args[4], args[5] + return [ + {**_ROW_DEFAULTS, **budget, "user_id": user_id} + for user_id, budget in chosen + if budget.get("budget_duration") in durations or (include_none and budget.get("budget_duration") is None) + ] + + async def execute_raw(self, sql: str, *args: object) -> int: + if "INSERT INTO" in sql: + for user_id in args[2]: + self.memberships.setdefault(user_id, args[1]) + elif "budget_id IS NULL" in sql: + self.memberships = {u: b or args[1] for u, b in self.memberships.items()} + elif "SET budget_reset_at" in sql: + for user_id in args[2]: + if self.memberships[user_id] != args[1]: + self.budget_of(user_id)["budget_reset_at"] = self.budgets[args[1]].get("budget_reset_at") + elif "SET max_budget = NULL" in sql: + for budget_id in args[0]: + self.budgets[budget_id]["max_budget"] = None + elif "SET budget_id = $2" in sql: + for user_id in args[2]: + self.memberships[user_id] = args[1] + return 0 + + +_ROW_DEFAULTS = { + "soft_budget": None, + "max_parallel_requests": None, + "tpm_limit": None, + "rpm_limit": None, + "model_max_budget": None, + "budget_duration": None, + "allowed_models": None, + "temp_budget_increase": None, + "temp_budget_expiry": None, +} +_DEFAULT_RESET = datetime(2030, 1, 1, tzinfo=timezone.utc) +_ADMIN = UserAPIKeyAuth(user_id="admin") + + +async def _backfill(team: _InMemoryTeam, backfill: str): + return await move_member_budgets_to_default( + team, team_id="team-1", default_budget_id="default", backfill=backfill, changed_by=_ADMIN + ) + + +def _team(**members: dict[str, object] | None) -> _InMemoryTeam: + return _InMemoryTeam({"max_budget": 50.0, "budget_duration": "30d", "budget_reset_at": _DEFAULT_RESET}, members) + + +@pytest.mark.asyncio +async def test_raise_moves_members_below_the_default_on_its_schedule_and_counts_the_rest(): + team = _team( + below={"max_budget": 10.0, "budget_duration": "30d"}, + own_rpm={"max_budget": 10.0, "budget_duration": "30d", "rpm_limit": 5, "budget_reset_at": "2030-02-01"}, + weekly={"max_budget": 10.0, "budget_duration": "7d"}, + above={"max_budget": 80.0, "budget_duration": "30d"}, + on_default=None, + ) + + moved = await _backfill(team, "raise_to_default") + + assert isinstance(moved, MovedMemberBudgets) + assert sorted(moved.user_ids) == ["below", "own_rpm"] + assert moved.result() == TeamMemberBudgetBackfillResult(moved_to_default=2, skipped_other_reset_period=1) + assert team.memberships["below"] == "default" + assert team.budget_of("own_rpm") == { + "budget_id": "own-own_rpm", + "max_budget": None, + "budget_duration": "30d", + "rpm_limit": 5, + "budget_reset_at": _DEFAULT_RESET, + } + assert team.budget_of("weekly")["max_budget"] == 10.0 + assert team.budget_of("above")["max_budget"] == 80.0 + + +@pytest.mark.asyncio +async def test_a_model_list_matching_the_default_still_keeps_the_members_own_row(): + team = _team(scoped={"max_budget": 10.0, "budget_duration": "30d", "allowed_models": ["gpt-5.4-mini"]}) + team.budgets["default"]["allowed_models"] = ["gpt-5.4-mini"] + + await _backfill(team, "raise_to_default") + + assert team.memberships["scoped"] == "own-scoped" + assert team.budget_of("scoped")["max_budget"] is None + + +@pytest.mark.asyncio +async def test_more_members_than_one_update_may_move_changes_nobody(): + members = { + f"m{i}": {"max_budget": 10.0, "budget_duration": "30d"} for i in range(MAX_MEMBER_BUDGETS_MOVED_PER_UPDATE + 1) + } + team = _team(**members) + + moved = await _backfill(team, "raise_to_default") + + assert moved == TooManyMemberBudgetsToMove(count=MAX_MEMBER_BUDGETS_MOVED_PER_UPDATE + 1) + assert all(budget_id != "default" for budget_id in team.memberships.values()) + + +@pytest.mark.asyncio +async def test_members_sharing_a_budget_with_their_own_limits_each_get_a_copy_on_the_default(): + team = _team() + team.budgets["shared"] = {"budget_id": "shared", "max_budget": 10.0, "budget_duration": "30d", "rpm_limit": 5} + team.share("shared", "first", "second") + + moved = await _backfill(team, "raise_to_default") + + assert isinstance(moved, MovedMemberBudgets) + assert sorted(moved.user_ids) == ["first", "second"] + copies = {team.memberships["first"], team.memberships["second"]} + assert len(copies) == 2 and "shared" not in copies + assert [(team.budgets[c]["max_budget"], team.budgets[c]["rpm_limit"]) for c in sorted(copies)] == [ + (None, 5), + (None, 5), + ] + assert team.budgets["shared"]["max_budget"] == 10.0 + + +@pytest.mark.asyncio +async def test_only_members_on_another_schedule_are_counted_and_left_alone(): + team = _team(weekly={"max_budget": 10.0, "budget_duration": "7d"}) + + moved = await _backfill(team, "raise_to_default") + + assert moved == MovedMemberBudgets(user_ids=(), skipped_other_reset_period=1) + assert team.memberships["weekly"] == "own-weekly" + + +@pytest.mark.asyncio +async def test_a_missing_default_row_moves_nobody(): + team = _team(below={"max_budget": 10.0, "budget_duration": "30d"}) + del team.budgets["default"] + + assert await _backfill(team, "raise_to_default") == MovedMemberBudgets(user_ids=(), skipped_other_reset_period=0) + + +def test_a_first_default_on_a_team_without_an_alias_gets_a_generic_id(): + write = plan_team_member_default_budget_write( + data=UpdateTeamRequest(team_id="team-1", team_member_budget=5.0), + existing_budget_id=None, + team_alias=None, + team_budget_duration=None, + ) + + assert write is not None + assert write.budget_id.startswith("team-budget-") + + +@pytest.mark.asyncio +async def test_keeping_custom_budgets_moves_nobody(): + team = _team(below={"max_budget": 10.0, "budget_duration": "30d"}) + + assert await _backfill(team, "none") == MovedMemberBudgets(user_ids=(), skipped_other_reset_period=0) + assert team.memberships["below"] == "own-below" + + +@pytest.mark.asyncio +async def test_writing_a_default_links_roster_members_without_a_budget_to_it(): + team = _team(own={"max_budget": 10.0, "budget_duration": "30d"}) + team.memberships["unbudgeted"] = None + write = _plan( + existing_budget_id="default", + team_member_budget=60.0, + team_member_model_max_budget={"gpt-4o": {"max_budget": 1.0}}, + ) + assert write is not None + + await write_team_member_default_budget( + team, write, team_id="team-1", member_user_ids=("own", "unbudgeted", "no-row"), changed_by="admin" + ) + + assert team.budgets["default"]["max_budget"] == 60.0 + assert team.budgets["default"]["model_max_budget"].data == { + "gpt-4o": {"max_budget": 1.0, "budget_duration": None, "tpm_limit": None, "rpm_limit": None} + } + assert (team.memberships["unbudgeted"], team.memberships["no-row"], team.memberships["own"]) == ( + "default", + "default", + "own-own", + ) + + +@pytest.mark.asyncio +async def test_clearing_the_default_does_not_link_members_without_a_budget_to_it(): + team = _team() + team.memberships["unbudgeted"] = None + write = _plan(existing_budget_id="default", team_member_budget=None) + assert write is not None + + await write_team_member_default_budget( + team, write, team_id="team-1", member_user_ids=("unbudgeted", "no-row"), changed_by="admin" + ) + + assert team.budgets["default"]["max_budget"] is None + assert team.memberships == {"unbudgeted": None} From edd697564b6e9edaac8e4e5f8525ea28e697b220 Mon Sep 17 00:00:00 2001 From: shrey kharbanda Date: Sat, 24 Oct 2026 11:22:03 -0700 Subject: [PATCH 6/6] refactor(proxy): simplify team member budget backfill --- litellm/proxy/auth/auth_checks.py | 3 +- .../proxy/common_utils/user_api_key_cache.py | 4 - .../budget_management_endpoints.py | 11 +- .../management_endpoints/common_utils.py | 6 +- .../management_endpoints/team_endpoints.py | 45 +- .../team_member_default_budget.py | 182 +-- .../spend_tracking/budget_reservation.py | 3 +- .../test_team_member_budget_backfill.py | 44 +- .../test_team_endpoints.py | 1296 ++++++++++++----- .../test_management_helpers_utils.py | 213 ++- .../test_team_member_default_budget.py | 288 +--- 11 files changed, 1183 insertions(+), 912 deletions(-) diff --git a/litellm/proxy/auth/auth_checks.py b/litellm/proxy/auth/auth_checks.py index 6c5385d5654..8887d86570a 100644 --- a/litellm/proxy/auth/auth_checks.py +++ b/litellm/proxy/auth/auth_checks.py @@ -128,7 +128,6 @@ from litellm.proxy.common_utils.user_api_key_cache import ( project_spend_counter_key, tag_cache_key, tag_registry_cache_key, - team_member_default_budget_cache_key, team_membership_auth_cache_key, team_membership_reservation_cache_key, ) @@ -1767,7 +1766,7 @@ async def get_team_member_default_budget( if prisma_client is None: return None - cache_key: Final = team_member_default_budget_cache_key(budget_id) + cache_key: Final = f"team_member_default_budget:{budget_id}" cached_budget: Final = await user_api_key_cache.async_get_cache( key=cache_key, diff --git a/litellm/proxy/common_utils/user_api_key_cache.py b/litellm/proxy/common_utils/user_api_key_cache.py index e5e217a067c..e64fd755ef9 100644 --- a/litellm/proxy/common_utils/user_api_key_cache.py +++ b/litellm/proxy/common_utils/user_api_key_cache.py @@ -392,10 +392,6 @@ def team_membership_reservation_cache_key(user_id: str, team_id: str) -> str: return f"team_membership:{user_id}:{team_id}" -def team_member_default_budget_cache_key(budget_id: str) -> str: - return f"team_member_default_budget:{budget_id}" - - #: Cached under ``team_membership_reservation_cache_key`` when a member has no ``LiteLLM_TeamMembership`` #: row, so a session-token member without a per-member budget costs no DB read per request. Lives beside #: the key builder because it is part of the same cache protocol: every reader of the key must know that diff --git a/litellm/proxy/management_endpoints/budget_management_endpoints.py b/litellm/proxy/management_endpoints/budget_management_endpoints.py index 4862435a8c7..b3f372327dc 100644 --- a/litellm/proxy/management_endpoints/budget_management_endpoints.py +++ b/litellm/proxy/management_endpoints/budget_management_endpoints.py @@ -20,11 +20,10 @@ from typing import Final from fastapi import APIRouter, Depends, HTTPException from litellm._internal_context import service_target +from litellm._logging import verbose_proxy_logger from litellm.proxy._types import * from litellm.proxy.auth.user_api_key_auth import user_api_key_auth -from litellm.proxy.common_utils.auth_cache_invalidation_pubsub import evict_and_broadcast from litellm.proxy.common_utils.timezone_utils import get_budget_reset_time -from litellm.proxy.common_utils.user_api_key_cache import team_member_default_budget_cache_key from litellm.proxy.management_endpoints.common_utils import ( # noqa: F401 # legacy module exports _user_has_admin_view, # pyright: ignore[reportPrivateUsage,reportUnusedImport] # backwards-compatible package export user_api_key_has_admin_view, @@ -203,10 +202,10 @@ async def update_budget( data=budget_obj_jsonified, ) with service_target("team_member_budgets"): - await evict_and_broadcast( - cache_keys=(team_member_default_budget_cache_key(budget_obj.budget_id),), - user_api_key_cache=user_api_key_cache, - ) + try: + await user_api_key_cache.async_delete_cache(key=f"team_member_default_budget:{budget_obj.budget_id}") + except Exception: # noqa: BLE001 # Cache failure must not fail a committed budget update. + verbose_proxy_logger.warning("Failed to evict the team member default budget cache", exc_info=True) return response diff --git a/litellm/proxy/management_endpoints/common_utils.py b/litellm/proxy/management_endpoints/common_utils.py index 0f05a14c519..aed6386c5d3 100644 --- a/litellm/proxy/management_endpoints/common_utils.py +++ b/litellm/proxy/management_endpoints/common_utils.py @@ -619,7 +619,7 @@ def _is_set_budget_value(value: object) -> bool: return True -def has_meaningful_budget_limit(budget_values: Mapping[str, object]) -> bool: +def _has_meaningful_budget_limit(budget_values: Mapping[str, object]) -> bool: """A budget is meaningful if at least one limit is actually set; an empty list (no model restriction) and None both count as unset.""" return any(_is_set_budget_value(budget_values.get(field)) for field in _TEAM_MEMBER_BUDGET_LIMIT_FIELDS) @@ -704,7 +704,7 @@ async def upsert_budget_and_membership( existing_budget: Final = await tx.litellm_budgettable.find_unique(where={"budget_id": existing_budget_id}) merged: Final = existing_budget.model_dump() if existing_budget is not None else {} merged.update(write_data) - if not has_meaningful_budget_limit(merged): + if not _has_meaningful_budget_limit(merged): await _fall_back_to_team_default() return await tx.litellm_budgettable.update( @@ -746,7 +746,7 @@ async def upsert_budget_and_membership( if create_data.get("budget_reset_at") is None: create_data.pop("budget_reset_at", None) - if not has_meaningful_budget_limit(create_data): + if not _has_meaningful_budget_limit(create_data): if existing_budget_id is not None and not temp_only: await _fall_back_to_team_default() return diff --git a/litellm/proxy/management_endpoints/team_endpoints.py b/litellm/proxy/management_endpoints/team_endpoints.py index 448c3e6fa82..ef83776f9c5 100644 --- a/litellm/proxy/management_endpoints/team_endpoints.py +++ b/litellm/proxy/management_endpoints/team_endpoints.py @@ -133,7 +133,6 @@ from litellm.proxy.common_utils.callback_utils import encrypt_callback_vars from litellm.proxy.common_utils.json_merge_patch import apply_json_merge_patch from litellm.proxy.common_utils.user_api_key_cache import ( UserApiKeyCache, - team_member_default_budget_cache_key, team_membership_auth_cache_key, team_membership_reservation_cache_key, ) @@ -207,7 +206,6 @@ from litellm.proxy.management_helpers.object_permission_utils import ( # noqa: from litellm.proxy.management_helpers.ptu_share_guard import raise_if_teams_hold_ptu_shares from litellm.proxy.management_helpers.team_member_default_budget import ( MAX_MEMBER_BUDGETS_MOVED_PER_UPDATE, - MovedMemberBudgets, TeamMemberDefaultBudgetWrite, TooManyMemberBudgetsToMove, move_member_budgets_to_default, @@ -660,7 +658,7 @@ class TeamMemberBudgetHandler: ) -> None: if user_api_key_cache is not None: await evict_and_broadcast( - cache_keys=(team_member_default_budget_cache_key(budget_id),), user_api_key_cache=user_api_key_cache + cache_keys=(f"team_member_default_budget:{budget_id}",), user_api_key_cache=user_api_key_cache ) @staticmethod @@ -1246,20 +1244,8 @@ async def _write_team_update( @dataclass(frozen=True, slots=True) class _TeamWrite: team_row: "prisma_models.LiteLLM_TeamTable | None" - roster_user_ids: tuple[str, ...] - moved_member_budgets: MovedMemberBudgets | None - - def backfill_response(self) -> Mapping[str, TeamMemberBudgetBackfillResult]: - if self.moved_member_budgets is None: - return MappingProxyType({}) - return MappingProxyType({"team_member_budget_backfill_result": self.moved_member_budgets.result()}) - - def backfill_audit(self) -> Mapping[str, object]: - return MappingProxyType({key: result.model_dump() for key, result in self.backfill_response().items()}) - - def changed_member_user_ids(self) -> tuple[str, ...]: - moved: Final = () if self.moved_member_budgets is None else self.moved_member_budgets.user_ids - return tuple(dict.fromkeys((*self.roster_user_ids, *moved))) + changed_member_user_ids: tuple[str, ...] + backfill_result: TeamMemberBudgetBackfillResult | None async def _write_team_with_member_default_budget( @@ -1270,7 +1256,6 @@ async def _write_team_with_member_default_budget( max_budget_guard: _MaxBudgetGuard | None, default_budget_write: TeamMemberDefaultBudgetWrite, backfill: TeamMemberBudgetBackfill, - user_api_key_dict: UserAPIKeyAuth, changed_by: str, ) -> _TeamWrite: """One transaction under the team lock, so the default, every member it reaches and the team row commit @@ -1291,7 +1276,7 @@ async def _write_team_with_member_default_budget( team_id=team_id, default_budget_id=default_budget_write.budget_id, backfill=backfill, - changed_by=user_api_key_dict, + changed_by=changed_by, ) if isinstance(moved, TooManyMemberBudgetsToMove): raise HTTPException( @@ -1308,8 +1293,8 @@ async def _write_team_with_member_default_budget( team_row: Final = await _write_team_update(_team_tx_db(tx), team_id, team_update_data, max_budget_guard) return _TeamWrite( team_row=team_row, - roster_user_ids=member_user_ids, - moved_member_budgets=moved if backfill != "none" else None, + changed_member_user_ids=tuple(dict.fromkeys((*member_user_ids, *moved.user_ids))), + backfill_result=moved.result() if backfill != "none" else None, ) @@ -2606,8 +2591,8 @@ async def update_team( team_row=await _write_team_update( _team_db(prisma_client), data.team_id, team_update_data, max_budget_guard ), - roster_user_ids=(), - moved_member_budgets=None, + changed_member_user_ids=(), + backfill_result=None, ) if default_budget_write is None else await _write_team_with_member_default_budget( @@ -2617,11 +2602,15 @@ async def update_team( max_budget_guard=max_budget_guard, default_budget_write=default_budget_write, backfill=data.team_member_budget_backfill or "none", - user_api_key_dict=user_api_key_dict, changed_by=user_api_key_dict.user_id or litellm_proxy_admin_name, ) ) team_row: Final = team_write.team_row + backfill_response: Final = ( + {"team_member_budget_backfill_result": team_write.backfill_result} + if team_write.backfill_result is not None + else {} + ) if team_row is None or team_row.team_id is None: raise HTTPException( @@ -2636,8 +2625,8 @@ async def update_team( ) await evict_team_member_cache_keys( team_id=team_row.team_id, - member_user_ids=team_write.changed_member_user_ids(), - cache_keys=tuple(team_membership_cache_keys(team_row.team_id, team_write.changed_member_user_ids())), + member_user_ids=team_write.changed_member_user_ids, + cache_keys=tuple(team_membership_cache_keys(team_row.team_id, team_write.changed_member_user_ids)), user_api_key_cache=user_api_key_cache, ) await sync_team_access_group_membership(prisma_client=prisma_client, team_id=team_row.team_id) @@ -2654,14 +2643,14 @@ async def update_team( if is_audit_logging_enabled(): await _create_team_update_audit_log( existing_team_row=existing_team_row, - updated_kv={**updated_kv, **team_write.backfill_audit()}, + updated_kv={**updated_kv, **{key: value.model_dump() for key, value in backfill_response.items()}}, team_id=data.team_id, litellm_changed_by=litellm_changed_by, user_api_key_dict=user_api_key_dict, litellm_proxy_admin_name=litellm_proxy_admin_name, ) - return {"team_id": team_row.team_id, "data": team_row, **team_write.backfill_response()} + return {"team_id": team_row.team_id, "data": team_row, **backfill_response} except Exception as e: raise handle_exception_on_proxy(e) diff --git a/litellm/proxy/management_helpers/team_member_default_budget.py b/litellm/proxy/management_helpers/team_member_default_budget.py index 038fd5f2a9f..bbac2b7781d 100644 --- a/litellm/proxy/management_helpers/team_member_default_budget.py +++ b/litellm/proxy/management_helpers/team_member_default_budget.py @@ -1,24 +1,18 @@ import uuid from collections.abc import Mapping, Sequence from dataclasses import dataclass -from datetime import datetime from types import MappingProxyType from typing import TYPE_CHECKING, Final -from pydantic import BaseModel, ConfigDict, JsonValue, TypeAdapter, field_validator +from pydantic import BaseModel, ConfigDict, JsonValue, TypeAdapter from litellm.litellm_core_utils.duration_parser import budget_reset_period_key from litellm.proxy._types import ( TeamMemberBudgetBackfill, TeamMemberBudgetBackfillResult, UpdateTeamRequest, - UserAPIKeyAuth, ) from litellm.proxy.common_utils.timezone_utils import get_budget_reset_time -from litellm.proxy.management_endpoints.common_utils import ( - has_meaningful_budget_limit, - upsert_budget_and_membership, -) if TYPE_CHECKING: from prisma import Prisma @@ -28,8 +22,6 @@ if TYPE_CHECKING: MAX_MEMBER_BUDGETS_MOVED_PER_UPDATE: Final = 50_000 -_ALWAYS_OWN_LIMITS: Final = frozenset({"allowed_models"}) - _DEFAULT_BUDGET_COLUMNS: Final = MappingProxyType( { "team_member_budget": "max_budget", @@ -48,23 +40,6 @@ ON CONFLICT (user_id, team_id) DO NOTHING _LINK_UNBUDGETED_MEMBERSHIPS_SQL: Final = ( 'UPDATE "LiteLLM_TeamMembership" SET budget_id = $2 WHERE team_id = $1 AND budget_id IS NULL' ) -_RELINK_TO_DEFAULT_SQL: Final = ( - 'UPDATE "LiteLLM_TeamMembership" SET budget_id = $2 WHERE team_id = $1 AND user_id = ANY($3::text[])' -) -_CLEAR_MAX_BUDGET_SQL: Final = """ -UPDATE "LiteLLM_BudgetTable" SET max_budget = NULL, updated_by = $2, updated_at = (NOW() AT TIME ZONE 'UTC') -WHERE budget_id = ANY($1::text[]) -""" -_ALIGN_RESET_TO_DEFAULT_SQL: Final = """ -UPDATE "LiteLLM_BudgetTable" b -SET budget_reset_at = (SELECT d.budget_reset_at FROM "LiteLLM_BudgetTable" d WHERE d.budget_id = $2) -FROM "LiteLLM_TeamMembership" m -WHERE m.team_id = $1 AND m.user_id = ANY($3::text[]) AND m.budget_id = b.budget_id AND b.budget_id <> $2 -""" -_SHARED_BUDGET_IDS_SQL: Final = """ -SELECT budget_id FROM "LiteLLM_TeamMembership" WHERE budget_id = ANY($1::text[]) -GROUP BY budget_id HAVING COUNT(*) > 1 -""" _ON_CHOSEN_SIDE_OF_DEFAULT: Final = """m.team_id = $1 AND m.budget_id <> $2 AND CASE $3::text WHEN 'raise_to_default' THEN b.max_budget < $4::double precision WHEN 'lower_to_default' THEN b.max_budget > $4::double precision @@ -76,12 +51,40 @@ _CANDIDATES_BY_SCHEDULE_SQL: Final = ( + _ON_CHOSEN_SIDE_OF_DEFAULT + " GROUP BY b.budget_duration" ) -_CANDIDATES_SQL: Final = ( - "SELECT m.user_id, b.budget_id, b.soft_budget, b.max_parallel_requests, b.tpm_limit, b.rpm_limit, " - "b.model_max_budget, b.budget_duration, b.allowed_models, b.temp_budget_increase, b.temp_budget_expiry " - 'FROM "LiteLLM_TeamMembership" m JOIN "LiteLLM_BudgetTable" b ON b.budget_id = m.budget_id WHERE ' +_MOVE_MEMBERS_SQL: Final = ( + """ +WITH candidates AS MATERIALIZED ( + SELECT m.user_id, b.*, CASE WHEN + b.soft_budget IS NOT NULL OR b.max_parallel_requests IS NOT NULL OR + b.tpm_limit IS NOT NULL OR b.rpm_limit IS NOT NULL OR b.tpd_limit IS NOT NULL OR + b.temp_budget_increase IS NOT NULL OR b.temp_budget_expiry IS NOT NULL OR + COALESCE(b.model_max_budget, '{}'::jsonb) NOT IN ('{}'::jsonb, 'null'::jsonb) OR + cardinality(b.allowed_models) > 0 + THEN gen_random_uuid()::text ELSE $2 END AS next_budget_id + FROM "LiteLLM_TeamMembership" m JOIN "LiteLLM_BudgetTable" b ON b.budget_id = m.budget_id + WHERE """ + _ON_CHOSEN_SIDE_OF_DEFAULT - + " AND (b.budget_duration = ANY($5::text[]) OR ($6::boolean AND b.budget_duration IS NULL))" + + """ AND (b.budget_duration = ANY($5::text[]) OR ($6::boolean AND b.budget_duration IS NULL)) +), copies AS ( + INSERT INTO "LiteLLM_BudgetTable" ( + budget_id, max_budget, soft_budget, max_parallel_requests, tpm_limit, rpm_limit, tpd_limit, + model_max_budget, budget_duration, budget_reset_at, allowed_models, temp_budget_increase, + temp_budget_expiry, created_by, updated_by, created_at, updated_at + ) + SELECT next_budget_id, NULL, soft_budget, max_parallel_requests, tpm_limit, rpm_limit, tpd_limit, + model_max_budget, budget_duration, + (SELECT budget_reset_at FROM "LiteLLM_BudgetTable" WHERE budget_id = $2), + allowed_models, temp_budget_increase, temp_budget_expiry, $7, $7, + NOW() AT TIME ZONE 'UTC', NOW() AT TIME ZONE 'UTC' + FROM candidates WHERE next_budget_id <> $2 + RETURNING budget_id +) +UPDATE "LiteLLM_TeamMembership" m SET budget_id = c.next_budget_id +FROM candidates c +WHERE m.team_id = $1 AND m.user_id = c.user_id + AND (c.next_budget_id = $2 OR c.next_budget_id IN (SELECT budget_id FROM copies)) +RETURNING m.user_id +""" ) @@ -116,57 +119,15 @@ class _ScheduleCount(BaseModel): members: int -class _BudgetLimits(BaseModel): - model_config = ConfigDict(frozen=True) - - soft_budget: float | None = None - max_parallel_requests: int | None = None - tpm_limit: int | None = None - rpm_limit: int | None = None - model_max_budget: JsonValue = None - budget_duration: str | None = None - allowed_models: tuple[str, ...] | None = None - temp_budget_increase: float | None = None - temp_budget_expiry: datetime | None = None - - @field_validator("model_max_budget", mode="before") - @classmethod - def _decode_json_column(cls, value: object) -> object: - return _JSON_VALUE.validate_json(value) if isinstance(value, str) else value - - def has_own_limits_beyond(self, default: "_BudgetLimits") -> bool: - own: Final = _JSON_OBJECT.validate_python(self.model_dump(mode="json")) - inherited: Final = _JSON_OBJECT.validate_python(default.model_dump(mode="json")) - return has_meaningful_budget_limit( - {field: value for field, value in own.items() if field in _ALWAYS_OWN_LIMITS or value != inherited[field]} - ) - - -class _MemberBudgetRef(BaseModel): +class _MovedMember(BaseModel): model_config = ConfigDict(frozen=True) user_id: str - budget_id: str -@dataclass(frozen=True, slots=True) -class _CustomMemberBudget: - ref: _MemberBudgetRef - keeps_own_limits: bool - - -class _BudgetIdRow(BaseModel): - model_config = ConfigDict(frozen=True) - - budget_id: str - - -_JSON_VALUE: Final[TypeAdapter[JsonValue]] = TypeAdapter(JsonValue) _JSON_OBJECT: Final = TypeAdapter(dict[str, JsonValue]) _SCHEDULE_COUNTS: Final = TypeAdapter(tuple[_ScheduleCount, ...]) -_MEMBER_BUDGET_REFS: Final = TypeAdapter(tuple[_MemberBudgetRef, ...]) -_MEMBER_BUDGET_LIMITS: Final = TypeAdapter(tuple[_BudgetLimits, ...]) -_BUDGET_IDS: Final = TypeAdapter(tuple[_BudgetIdRow, ...]) +_MOVED_MEMBERS: Final = TypeAdapter(tuple[_MovedMember, ...]) def plan_team_member_default_budget_write( @@ -225,11 +186,8 @@ async def move_member_budgets_to_default( team_id: str, default_budget_id: str, backfill: TeamMemberBudgetBackfill, - changed_by: UserAPIKeyAuth, + changed_by: str, ) -> MovedMemberBudgets | TooManyMemberBudgetsToMove: - """Members compare on their permanent ``max_budget``, and only those resetting on the default's schedule move. - A member whose other limits all match the default is linked to the default row. One holding a limit of its own, or - any model list, keeps its row with ``max_budget`` cleared and its reset moved onto the default's.""" if backfill == "none": return MovedMemberBudgets(user_ids=(), skipped_other_reset_period=0) default: Final = await _budget_tx_db(tx).find_unique(where={"budget_id": default_budget_id}) @@ -246,63 +204,19 @@ async def move_member_budgets_to_default( return TooManyMemberBudgetsToMove(count=moving) if moving == 0: return MovedMemberBudgets(user_ids=(), skipped_other_reset_period=skipped) - rows: Final = await tx.query_raw( - _CANDIDATES_SQL, - team_id, - default_budget_id, - backfill, - default.max_budget, - [count.duration for count in matching if count.duration is not None], - any(count.duration is None for count in matching), - ) - default_limits: Final = _BudgetLimits.model_validate(default.model_dump()) - candidates: Final = tuple( - _CustomMemberBudget(ref=ref, keeps_own_limits=limits.has_own_limits_beyond(default_limits)) - for ref, limits in zip( - _MEMBER_BUDGET_REFS.validate_python(rows), _MEMBER_BUDGET_LIMITS.validate_python(rows), strict=True + moved: Final = _MOVED_MEMBERS.validate_python( + await tx.query_raw( + _MOVE_MEMBERS_SQL, + team_id, + default_budget_id, + backfill, + default.max_budget, + [count.duration for count in matching if count.duration is not None], + any(count.duration is None for count in matching), + changed_by, ) ) - await _move_to_default(tx, candidates, team_id=team_id, default_budget_id=default_budget_id, changed_by=changed_by) - return MovedMemberBudgets( - user_ids=tuple(candidate.ref.user_id for candidate in candidates), skipped_other_reset_period=skipped - ) - - -async def _move_to_default( - tx: "Prisma", - candidates: Sequence[_CustomMemberBudget], - *, - team_id: str, - default_budget_id: str, - changed_by: UserAPIKeyAuth, -) -> None: - keeping: Final = tuple(candidate.ref for candidate in candidates if candidate.keeps_own_limits) - relinking: Final = tuple(candidate.ref.user_id for candidate in candidates if not candidate.keeps_own_limits) - shared: Final = frozenset( - row.budget_id - for row in _BUDGET_IDS.validate_python( - await tx.query_raw(_SHARED_BUDGET_IDS_SQL, list({ref.budget_id for ref in keeping})) - ) - ) - await tx.execute_raw(_RELINK_TO_DEFAULT_SQL, team_id, default_budget_id, list(relinking)) - await tx.execute_raw( - _CLEAR_MAX_BUDGET_SQL, - list({ref.budget_id for ref in keeping if ref.budget_id not in shared}), - changed_by.user_id or "", - ) - for ref in keeping: - if ref.budget_id in shared: - await upsert_budget_and_membership( - tx, - team_id=team_id, - user_id=ref.user_id, - existing_budget_id=ref.budget_id, - user_api_key_dict=changed_by, - budget_patch=MappingProxyType({"max_budget": None}), - team_default_budget_id=default_budget_id, - shared_budget_ids=shared, - ) - await tx.execute_raw(_ALIGN_RESET_TO_DEFAULT_SQL, team_id, default_budget_id, [ref.user_id for ref in keeping]) + return MovedMemberBudgets(user_ids=tuple(member.user_id for member in moved), skipped_other_reset_period=skipped) def _prisma_columns(columns: Mapping[str, object]) -> Mapping[str, object]: diff --git a/litellm/proxy/spend_tracking/budget_reservation.py b/litellm/proxy/spend_tracking/budget_reservation.py index 6e5322cdb32..803df9f83ca 100644 --- a/litellm/proxy/spend_tracking/budget_reservation.py +++ b/litellm/proxy/spend_tracking/budget_reservation.py @@ -37,7 +37,6 @@ from litellm.proxy.common_utils.user_api_key_cache import ( project_cache_key, project_spend_counter_key, tag_cache_key, - team_member_default_budget_cache_key, team_membership_reservation_cache_key, ) from litellm.proxy.spend_tracking.input_tokens import count_input_tokens, count_input_tokens_for_model @@ -745,7 +744,7 @@ async def _get_team_member_budget_counter( default_budget_id: Final = (team_object.metadata or {}).get("team_member_budget_id") if isinstance(default_budget_id, str): default_budget: Final = _CACHED_VALUE.validate_python( - await user_api_key_cache.async_get_cache(key=team_member_default_budget_cache_key(default_budget_id)) + await user_api_key_cache.async_get_cache(key=f"team_member_default_budget:{default_budget_id}") ) default_cap: Final = _to_float(_get_value(default_budget, "max_budget")) if default_cap is not None and default_cap > 0: diff --git a/tests/integration/management/test_team_member_budget_backfill.py b/tests/integration/management/test_team_member_budget_backfill.py index 2da71a54ba6..cea18c2e9a3 100644 --- a/tests/integration/management/test_team_member_budget_backfill.py +++ b/tests/integration/management/test_team_member_budget_backfill.py @@ -1,12 +1,13 @@ from collections.abc import Mapping from dataclasses import dataclass from datetime import datetime, timezone +from typing import Final import pytest from prisma import Json from litellm.proxy.management_helpers.team_member_default_budget import MAX_MEMBER_BUDGETS_MOVED_PER_UPDATE -from tests.integration._support.actors import create_scratch_team +from tests.integration._support.actors import ManagementDatabase, ScratchResources, create_scratch_team pytestmark = pytest.mark.asyncio(loop_scope="session") @@ -122,7 +123,6 @@ async def test_backfill_moves_only_members_on_the_chosen_side_of_the_new_default for name, budget in _ROSTER.items(): membership = await _member_budget(db, resources, name) if name == "own_rpm" and name in moved: - assert membership.budget_id == resources.tag("own-own_rpm") assert membership.litellm_budget_table.max_budget is None assert membership.litellm_budget_table.rpm_limit == 5 elif name in moved or budget is None: @@ -214,9 +214,7 @@ async def test_a_moved_member_keeping_their_own_limits_resets_with_the_default(d async def test_a_member_with_a_model_list_keeps_it_even_when_it_matches_the_default(db, resources): default_budget_id = await _seed_team(db, resources, {"scoped": _Budget(20.0)}) for budget_id in (default_budget_id, resources.tag("own-scoped")): - await db.db.litellm_budgettable.update( - where={"budget_id": budget_id}, data={"allowed_models": ["gpt-5.4-mini"]} - ) + await db.db.litellm_budgettable.update(where={"budget_id": budget_id}, data={"allowed_models": ["test-model"]}) response = _update_team( db, @@ -226,10 +224,9 @@ async def test_a_member_with_a_model_list_keeps_it_even_when_it_matches_the_defa assert response.status_code == 200, response.text scoped = await _member_budget(db, resources, "scoped") - assert scoped.budget_id == resources.tag("own-scoped") assert (scoped.litellm_budget_table.max_budget, scoped.litellm_budget_table.allowed_models) == ( None, - ["gpt-5.4-mini"], + ["test-model"], ) @@ -296,3 +293,36 @@ async def test_saving_a_default_links_every_roster_member_without_a_budget_to_it assert response.status_code == 200, response.text for name in ("no-row", "no-budget"): assert (await _member_budget(db, resources, name)).budget_id == default_budget_id, name + + +@pytest.mark.parametrize( + "limits", + [ + {"rpm_limit": 5}, + {"tpm_limit": 7}, + {"tpd_limit": 11}, + {"soft_budget": 0.0}, + {"max_parallel_requests": 0}, + {"model_max_budget": Json({"test-model": {"max_budget": 2.0}})}, + {"allowed_models": ["test-model"]}, + {"temp_budget_increase": 5.0, "temp_budget_expiry": datetime(2030, 1, 1, tzinfo=timezone.utc)}, + ], +) +async def test_moving_a_member_preserves_every_other_limit_even_when_it_matches_the_default( + limits: Mapping[str, object], db: ManagementDatabase, resources: ScratchResources +) -> None: + default_id: Final = await _seed_team(db, resources, {"custom": _Budget(20.0)}) + for budget_id in (default_id, resources.tag("own-custom")): + await db.db.litellm_budgettable.update(where={"budget_id": budget_id}, data=dict(limits)) + original: Final = (await _member_budget(db, resources, "custom")).litellm_budget_table + + response: Final = _update_team( + db, resources.prefix, {"team_member_budget": _NEW_DEFAULT, "team_member_budget_backfill": "raise_to_default"} + ) + + assert response.status_code == 200, response.text + moved: Final = (await _member_budget(db, resources, "custom")).litellm_budget_table + assert moved.max_budget is None + assert {field: getattr(moved, field) for field in limits} == {field: getattr(original, field) for field in limits} + untouched: Final = await db.db.litellm_budgettable.find_unique(where={"budget_id": original.budget_id}) + assert untouched == original diff --git a/tests/unit/proxy/management_endpoints/test_team_endpoints.py b/tests/unit/proxy/management_endpoints/test_team_endpoints.py index a420e19e7fe..bd200c62f39 100644 --- a/tests/unit/proxy/management_endpoints/test_team_endpoints.py +++ b/tests/unit/proxy/management_endpoints/test_team_endpoints.py @@ -121,9 +121,7 @@ def _team_admin_may_edit(*fields: str): "litellm.proxy.management_endpoints.team_endpoints.PROXY_CONTROLLED_TEAM_METADATA_KEYS", PROXY_CONTROLLED_TEAM_METADATA_KEYS - frozenset(fields), ), - patch( - "litellm.proxy.proxy_server.general_settings", {"team_admin_editable_team_fields": list(fields)} - ), # test-quality-ok: update_team reads general_settings as a proxy_server module global + patch("litellm.proxy.proxy_server.general_settings", {"team_admin_editable_team_fields": list(fields)}), # test-quality-ok: update_team reads general_settings as a proxy_server module global ): yield @@ -279,7 +277,9 @@ mock_prisma_client.db.litellm_auditlog.create = AsyncMock() # Fixture to provide the mock prisma client @pytest.fixture(autouse=True) def mock_db_client(): - with patch("litellm.proxy.proxy_server.prisma_client", mock_prisma_client): # Mock in both places if necessary + with patch( + "litellm.proxy.proxy_server.prisma_client", mock_prisma_client + ): # Mock in both places if necessary yield mock_prisma_client mock_prisma_client.reset_mock() @@ -322,17 +322,27 @@ async def test_validate_team_org_change_same_org_id(): organization.organization_id = org_id organization.models = [] organization.litellm_budget_table = MagicMock() - organization.litellm_budget_table.max_budget = 50.0 # This would normally fail validation - organization.litellm_budget_table.tpm_limit = 500 # This would normally fail validation - organization.litellm_budget_table.rpm_limit = 50 # This would normally fail validation + organization.litellm_budget_table.max_budget = ( + 50.0 # This would normally fail validation + ) + organization.litellm_budget_table.tpm_limit = ( + 500 # This would normally fail validation + ) + organization.litellm_budget_table.rpm_limit = ( + 50 # This would normally fail validation + ) organization.members = [] # Mock Router mock_router = MagicMock(spec=Router) # Use patch to ensure the model access check is never called - with patch("litellm.proxy.management_endpoints.team_endpoints.can_org_access_model") as mock_access_check: - result = validate_team_org_change(team=team, organization=organization, llm_router=mock_router) + with patch( + "litellm.proxy.management_endpoints.team_endpoints.can_org_access_model" + ) as mock_access_check: + result = validate_team_org_change( + team=team, organization=organization, llm_router=mock_router + ) # Assert the function returns True without checking anything assert result is True @@ -349,7 +359,9 @@ async def test_validate_team_org_change_same_org_id(): ], ) @pytest.mark.asyncio -async def test_validate_team_org_change_zero_org_budget_is_enforced(org_max_budget, team_max_budget, expect_blocked): +async def test_validate_team_org_change_zero_org_budget_is_enforced( + org_max_budget, team_max_budget, expect_blocked +): """An organization with an explicit max_budget of 0 must still block moving in a team with a larger budget, matching key/team/user zero-budget semantics. @@ -431,7 +443,9 @@ async def test_validate_team_org_change_members_in_org(): mock_router = MagicMock(spec=Router) # Test should pass - all team members are in org members - result = validate_team_org_change(team=team, organization=organization, llm_router=mock_router) + result = validate_team_org_change( + team=team, organization=organization, llm_router=mock_router + ) assert result is True @@ -483,7 +497,9 @@ async def test_validate_team_org_change_member_not_in_org(): # Test should fail - user_id_not_in_org is not in org members with pytest.raises(HTTPException) as exc_info: - validate_team_org_change(team=team, organization=organization, llm_router=mock_router) + validate_team_org_change( + team=team, organization=organization, llm_router=mock_router + ) assert exc_info.value.status_code == 403 assert "not a member of the organization" in str(exc_info.value.detail) @@ -527,7 +543,10 @@ async def test_get_team_permissions_list_success(mock_db_client, mock_admin_auth assert response.status_code == 200 response_data = response.json() assert response_data["team_id"] == test_team_id - assert response_data["team_member_permissions"] == mock_team_data["team_member_permissions"] + assert ( + response_data["team_member_permissions"] + == mock_team_data["team_member_permissions"] + ) assert ( response_data["all_available_permissions"] == TeamMemberPermissionChecks.get_all_available_team_member_permissions() @@ -590,7 +609,9 @@ async def test_update_team_permissions_success(mock_db_client, mock_admin_auth): return_value=mock_existing_team_row, ): # Mock the database update function - mock_db_client.db.litellm_teamtable.update = AsyncMock(return_value=mock_updated_team_row) + mock_db_client.db.litellm_teamtable.update = AsyncMock( + return_value=mock_updated_team_row + ) # Override the dependency for this test app.dependency_overrides[user_api_key_auth] = lambda: mock_admin_auth @@ -615,7 +636,9 @@ async def test_update_team_permissions_success(mock_db_client, mock_admin_auth): @pytest.mark.asyncio @pytest.mark.parametrize("field", ["budget_duration", "team_member_budget_duration"]) @pytest.mark.parametrize("bad_duration", ["0s", "-5m"]) -async def test_new_team_rejects_a_duration_that_never_advances(mock_db_client, mock_admin_auth, field, bad_duration): +async def test_new_team_rejects_a_duration_that_never_advances( + mock_db_client, mock_admin_auth, field, bad_duration +): """A zero-length window resets to "now", so the team row is due again the moment it is written. The reset job re-reads such rows on every tick, and a tenant with enough of them fills each batch and starves other tenants. @@ -645,7 +668,9 @@ async def test_new_team_rejects_a_duration_that_never_advances(mock_db_client, m @pytest.mark.asyncio @pytest.mark.parametrize("field", ["budget_duration", "team_member_budget_duration"]) -async def test_update_team_rejects_a_duration_that_never_advances(mock_db_client, mock_admin_auth, field): +async def test_update_team_rejects_a_duration_that_never_advances( + mock_db_client, mock_admin_auth, field +): """/team/update must reject the same never-advancing durations /team/new does.""" from fastapi import Request @@ -684,13 +709,17 @@ async def test_new_team_with_object_permission(mock_db_client, mock_admin_auth): mock_db_client.db = MagicMock() # Mock object permission table creation - mock_object_perm_create = AsyncMock(return_value=MagicMock(object_permission_id="objperm123")) + mock_object_perm_create = AsyncMock( + return_value=MagicMock(object_permission_id="objperm123") + ) mock_db_client.db.litellm_objectpermissiontable = MagicMock() mock_db_client.db.litellm_objectpermissiontable.create = mock_object_perm_create # Mock model table creation mock_db_client.db.litellm_modeltable = MagicMock() - mock_db_client.db.litellm_modeltable.create = AsyncMock(return_value=MagicMock(id="model123")) + mock_db_client.db.litellm_modeltable.create = AsyncMock( + return_value=MagicMock(id="model123") + ) # Capture team table creation team_create_result = MagicMock( @@ -707,7 +736,9 @@ async def test_new_team_with_object_permission(mock_db_client, mock_admin_auth): mock_db_client.db.litellm_teamtable.create = mock_team_create _wire_team_create_tx(mock_db_client) mock_db_client.db.litellm_teamtable.count = mock_team_count - mock_db_client.db.litellm_teamtable.update = AsyncMock(return_value=team_create_result) + mock_db_client.db.litellm_teamtable.update = AsyncMock( + return_value=team_create_result + ) # Mock user table mock_db_client.db.litellm_usertable = MagicMock() @@ -813,7 +844,9 @@ async def test_new_team_with_mcp_tool_permissions(mock_db_client, mock_admin_aut # Mock model table mock_db_client.db.litellm_modeltable = MagicMock() - mock_db_client.db.litellm_modeltable.create = AsyncMock(return_value=MagicMock(id="model456")) + mock_db_client.db.litellm_modeltable.create = AsyncMock( + return_value=MagicMock(id="model456") + ) # Mock team table team_create_result = MagicMock( @@ -825,10 +858,14 @@ async def test_new_team_with_mcp_tool_permissions(mock_db_client, mock_admin_aut "object_permission_id": "objperm_team_mcp_456", } mock_db_client.db.litellm_teamtable = MagicMock() - mock_db_client.db.litellm_teamtable.create = AsyncMock(return_value=team_create_result) + mock_db_client.db.litellm_teamtable.create = AsyncMock( + return_value=team_create_result + ) _wire_team_create_tx(mock_db_client) mock_db_client.db.litellm_teamtable.count = AsyncMock(return_value=0) - mock_db_client.db.litellm_teamtable.update = AsyncMock(return_value=team_create_result) + mock_db_client.db.litellm_teamtable.update = AsyncMock( + return_value=team_create_result + ) # Mock user table mock_db_client.db.litellm_usertable = MagicMock() @@ -887,14 +924,20 @@ def test_should_auto_add_team_creator(user_role, user_id, flag_value, expected): _should_auto_add_team_creator, ) - general_settings = {} if flag_value is None else {"disable_auto_add_proxy_admin_to_teams": flag_value} + general_settings = ( + {} if flag_value is None else {"disable_auto_add_proxy_admin_to_teams": flag_value} + ) auth = UserAPIKeyAuth(user_role=user_role, user_id=user_id) assert _should_auto_add_team_creator(auth, general_settings) is expected @pytest.mark.asyncio -@pytest.mark.parametrize("disable_flag,expect_creator_added", [(True, False), (False, True)]) -async def test_new_team_disable_auto_add_proxy_admin_flag(mock_db_client, disable_flag, expect_creator_added): +@pytest.mark.parametrize( + "disable_flag,expect_creator_added", [(True, False), (False, True)] +) +async def test_new_team_disable_auto_add_proxy_admin_flag( + mock_db_client, disable_flag, expect_creator_added +): """ When general_settings.disable_auto_add_proxy_admin_to_teams is True, a proxy admin calling /team/new must NOT be auto-added to the team's members. When @@ -909,7 +952,9 @@ async def test_new_team_disable_auto_add_proxy_admin_flag(mock_db_client, disabl team_create_result = MagicMock(team_id="team-789") team_create_result.model_dump.return_value = {"team_id": "team-789"} mock_db_client.db.litellm_teamtable = MagicMock() - mock_db_client.db.litellm_teamtable.create = AsyncMock(return_value=team_create_result) + mock_db_client.db.litellm_teamtable.create = AsyncMock( + return_value=team_create_result + ) _wire_team_create_tx(mock_db_client) mock_db_client.db.litellm_teamtable.count = AsyncMock(return_value=0) mock_db_client.db.litellm_usertable = MagicMock() @@ -920,18 +965,17 @@ async def test_new_team_disable_auto_add_proxy_admin_flag(mock_db_client, disabl from litellm.proxy._types import NewTeamRequest from litellm.proxy.management_endpoints.team_endpoints import new_team - admin_auth = UserAPIKeyAuth(user_role=LitellmUserRoles.PROXY_ADMIN, user_id="admin-user-1") + admin_auth = UserAPIKeyAuth( + user_role=LitellmUserRoles.PROXY_ADMIN, user_id="admin-user-1" + ) - with ( - patch( - "litellm.proxy.proxy_server.general_settings", - {"disable_auto_add_proxy_admin_to_teams": disable_flag}, - ), - patch( - "litellm.proxy.management_endpoints.team_endpoints._add_team_members_to_team", - new_callable=AsyncMock, - ) as mock_add_members, - ): + with patch( + "litellm.proxy.proxy_server.general_settings", + {"disable_auto_add_proxy_admin_to_teams": disable_flag}, + ), patch( + "litellm.proxy.management_endpoints.team_endpoints._add_team_members_to_team", + new_callable=AsyncMock, + ) as mock_add_members: await new_team( data=NewTeamRequest(team_alias="flag-test-team"), http_request=MagicMock(spec=Request), @@ -980,12 +1024,16 @@ async def test_team_update_object_permissions_existing_permission(monkeypatch): "vector_stores": ["old_store_1", "old_store_2"], } - mock_prisma_client.db.litellm_objectpermissiontable.find_unique = AsyncMock(return_value=existing_object_permission) + mock_prisma_client.db.litellm_objectpermissiontable.find_unique = AsyncMock( + return_value=existing_object_permission + ) # Mock upsert operation updated_permission = MagicMock() updated_permission.object_permission_id = "existing_perm_id_123" - mock_prisma_client.db.litellm_objectpermissiontable.upsert = AsyncMock(return_value=updated_permission) + mock_prisma_client.db.litellm_objectpermissiontable.upsert = AsyncMock( + return_value=updated_permission + ) # Test data with new object permission data_json = { @@ -1041,17 +1089,21 @@ async def test_team_update_object_permissions_no_existing_permission(monkeypatch ) # Mock find_unique to return None (no existing permission) - mock_prisma_client.db.litellm_objectpermissiontable.find_unique = AsyncMock(return_value=None) + mock_prisma_client.db.litellm_objectpermissiontable.find_unique = AsyncMock( + return_value=None + ) # Mock upsert to create new record new_permission = MagicMock() new_permission.object_permission_id = "new_perm_id_456" - mock_prisma_client.db.litellm_objectpermissiontable.upsert = AsyncMock(return_value=new_permission) + mock_prisma_client.db.litellm_objectpermissiontable.upsert = AsyncMock( + return_value=new_permission + ) data_json = { - "object_permission": LiteLLM_ObjectPermissionBase(vector_stores=["brand_new_store"]).model_dump( - exclude_unset=True, exclude_none=True - ), + "object_permission": LiteLLM_ObjectPermissionBase( + vector_stores=["brand_new_store"] + ).model_dump(exclude_unset=True, exclude_none=True), "team_alias": "updated_team_2", } @@ -1097,17 +1149,21 @@ async def test_team_update_object_permissions_missing_permission_record(monkeypa ) # Mock find_unique to return None (permission record not found) - mock_prisma_client.db.litellm_objectpermissiontable.find_unique = AsyncMock(return_value=None) + mock_prisma_client.db.litellm_objectpermissiontable.find_unique = AsyncMock( + return_value=None + ) # Mock upsert to create new record new_permission = MagicMock() new_permission.object_permission_id = "recreated_perm_id_789" - mock_prisma_client.db.litellm_objectpermissiontable.upsert = AsyncMock(return_value=new_permission) + mock_prisma_client.db.litellm_objectpermissiontable.upsert = AsyncMock( + return_value=new_permission + ) data_json = { - "object_permission": LiteLLM_ObjectPermissionBase(vector_stores=["recreated_store"]).model_dump( - exclude_unset=True, exclude_none=True - ), + "object_permission": LiteLLM_ObjectPermissionBase( + vector_stores=["recreated_store"] + ).model_dump(exclude_unset=True, exclude_none=True), "team_alias": "updated_team_3", } @@ -1213,10 +1269,14 @@ async def test_add_team_member_budget_table_success(): mock_budget_record.budget_id = "budget-123" mock_budget_record.max_budget = 1000.0 - mock_prisma_client.db.litellm_budgettable.find_unique = AsyncMock(return_value=mock_budget_record) + mock_prisma_client.db.litellm_budgettable.find_unique = AsyncMock( + return_value=mock_budget_record + ) # Create team info response object - team_info_response = TeamInfoResponseObjectTeamTable(team_id="test-team-123", team_alias="Test Team") + team_info_response = TeamInfoResponseObjectTeamTable( + team_id="test-team-123", team_alias="Test Team" + ) # Call the function result = await _add_team_member_budget_table( @@ -1227,11 +1287,15 @@ async def test_add_team_member_budget_table_success(): # Verify the result assert result.team_member_budget_table == mock_budget_record - assert result == team_info_response.model_copy(update={"team_member_budget_table": mock_budget_record}) + assert result == team_info_response.model_copy( + update={"team_member_budget_table": mock_budget_record} + ) assert team_info_response.team_member_budget_table is None # Verify database call was made correctly - mock_prisma_client.db.litellm_budgettable.find_unique.assert_called_once_with(where={"budget_id": "budget-123"}) + mock_prisma_client.db.litellm_budgettable.find_unique.assert_called_once_with( + where={"budget_id": "budget-123"} + ) @pytest.mark.asyncio @@ -1251,10 +1315,14 @@ async def test_add_team_member_budget_table_exception_handling(): ) # Create team info response object - team_info_response = TeamInfoResponseObjectTeamTable(team_id="test-team-456", team_alias="Test Team 2") + team_info_response = TeamInfoResponseObjectTeamTable( + team_id="test-team-456", team_alias="Test Team 2" + ) # Mock the verbose_proxy_logger to capture log calls - with patch("litellm.proxy.management_endpoints.team_endpoints.verbose_proxy_logger") as mock_logger: + with patch( + "litellm.proxy.management_endpoints.team_endpoints.verbose_proxy_logger" + ) as mock_logger: # Call the function result = await _add_team_member_budget_table( team_member_budget_id="nonexistent-budget-456", @@ -1266,7 +1334,10 @@ async def test_add_team_member_budget_table_exception_handling(): assert result == team_info_response # Verify team_member_budget_table is not set when exception occurs - assert not hasattr(result, "team_member_budget_table") or result.team_member_budget_table is None + assert ( + not hasattr(result, "team_member_budget_table") + or result.team_member_budget_table is None + ) # Verify the error was logged mock_logger.info.assert_called_once_with( @@ -1295,7 +1366,9 @@ async def test_add_team_member_budget_table_budget_not_found(): mock_prisma_client.db.litellm_budgettable.find_unique = AsyncMock(return_value=None) # Create team info response object - team_info_response = TeamInfoResponseObjectTeamTable(team_id="test-team-789", team_alias="Test Team 3") + team_info_response = TeamInfoResponseObjectTeamTable( + team_id="test-team-789", team_alias="Test Team 3" + ) # Call the function result = await _add_team_member_budget_table( @@ -1496,7 +1569,9 @@ async def test_available_team_self_join_blocks_other_user_id(): await _validate_team_member_add_permissions( user_api_key_dict=user, complete_team_data=team, - data=_make_team_member_add_request(member_user_id="bob-victim", role="user"), + data=_make_team_member_add_request( + member_user_id="bob-victim", role="user" + ), ) assert exc_info.value.status_code == 403 @@ -1913,7 +1988,9 @@ async def test_update_team_members_list_duplicate_prevention(): # Create mock team with existing members mock_team = MagicMock(spec=LiteLLM_TeamTable) - mock_team.members_with_roles = [Member(user_id="existing-user", user_email="existing@example.com", role="admin")] + mock_team.members_with_roles = [ + Member(user_id="existing-user", user_email="existing@example.com", role="admin") + ] # Try to add the same member again duplicate_member = Member(user_id="existing-user", role="user") @@ -2044,7 +2121,9 @@ async def test_add_team_members_runs_member_writes_on_the_lock_holding_transacti tx = MagicMock() tx.query_raw = AsyncMock(return_value=[{"members_with_roles": []}]) - tx.litellm_teamtable.update = AsyncMock(return_value=LiteLLM_TeamTable(team_id="team-pool", members_with_roles=[])) + tx.litellm_teamtable.update = AsyncMock( + return_value=LiteLLM_TeamTable(team_id="team-pool", members_with_roles=[]) + ) tx.litellm_usertable.upsert = AsyncMock(return_value=added_user) tx.litellm_usertable.update_many = AsyncMock() tx.litellm_budgettable.create = AsyncMock(return_value=created_budget) @@ -2099,7 +2178,9 @@ async def test_add_team_members_locks_every_named_user_row_in_id_order_before_th tx = MagicMock() tx.query_raw = AsyncMock(side_effect=query_raw) tx.litellm_usertable.find_many = AsyncMock(return_value=[email_match]) - tx.litellm_teamtable.update = AsyncMock(return_value=LiteLLM_TeamTable(team_id="team-order", members_with_roles=[])) + tx.litellm_teamtable.update = AsyncMock( + return_value=LiteLLM_TeamTable(team_id="team-order", members_with_roles=[]) + ) tx_cm = MagicMock() tx_cm.__aenter__ = AsyncMock(return_value=tx) tx_cm.__aexit__ = AsyncMock(return_value=None) @@ -2160,7 +2241,9 @@ async def test_add_team_members_skips_budget_and_membership_writes_for_members_a tx.query_raw = AsyncMock( return_value=[{"members_with_roles": [{"user_id": "alice", "user_email": None, "role": "user"}]}] ) - tx.litellm_teamtable.update = AsyncMock(return_value=LiteLLM_TeamTable(team_id="team-mixed", members_with_roles=[])) + tx.litellm_teamtable.update = AsyncMock( + return_value=LiteLLM_TeamTable(team_id="team-mixed", members_with_roles=[]) + ) tx.litellm_usertable.upsert = AsyncMock(return_value=added_user) tx.litellm_usertable.update_many = AsyncMock() tx.litellm_budgettable.create = AsyncMock(return_value=created_budget) @@ -2192,9 +2275,7 @@ async def test_add_team_members_skips_budget_and_membership_writes_for_members_a } assert [user.user_id for user in updated_users] == ["bob"] assert [tm.user_id for tm in updated_team_memberships] == ["bob"] - written_ids = [ - m["user_id"] for m in json.loads(tx.litellm_teamtable.update.call_args.kwargs["data"]["members_with_roles"]) - ] + written_ids = [m["user_id"] for m in json.loads(tx.litellm_teamtable.update.call_args.kwargs["data"]["members_with_roles"])] assert written_ids == ["alice", "bob"] @@ -2302,7 +2383,9 @@ async def test_team_model_add_delete_refresh_team_cache(endpoint_name): ) mock_request = Mock(spec=Request) - mock_user_api_key_dict = UserAPIKeyAuth(user_role=LitellmUserRoles.PROXY_ADMIN, user_id="test_user_id") + mock_user_api_key_dict = UserAPIKeyAuth( + user_role=LitellmUserRoles.PROXY_ADMIN, user_id="test_user_id" + ) existing_team = MagicMock() existing_team.model_dump.return_value = { @@ -2339,8 +2422,12 @@ async def test_team_model_add_delete_refresh_team_cache(endpoint_name): new_callable=AsyncMock, ) as mock_cache_team, ): - mock_prisma_client.db.litellm_teamtable.find_unique = AsyncMock(return_value=existing_team) - mock_prisma_client.db.litellm_teamtable.update = AsyncMock(return_value=updated_team) + mock_prisma_client.db.litellm_teamtable.find_unique = AsyncMock( + return_value=existing_team + ) + mock_prisma_client.db.litellm_teamtable.update = AsyncMock( + return_value=updated_team + ) mock_prisma_client.db.execute_raw = AsyncMock(return_value=None) if endpoint_name == "team_model_add": @@ -2382,11 +2469,15 @@ async def test_team_model_add_delete_refresh_team_cache(endpoint_name): # "no team-level restriction" and stop enforcing the team's # search-tool allowlist on key issuance. assert call_kwargs["team_table"].object_permission is not None - assert call_kwargs["team_table"].object_permission.search_tools == ["allowed-tool-A"] + assert call_kwargs["team_table"].object_permission.search_tools == [ + "allowed-tool-A" + ] # Pin the Prisma call shape too — the regression is in *what the # update returns*, so the contract that the update asks for # `object_permission` belongs in this test. - update_call_kwargs = mock_prisma_client.db.litellm_teamtable.update.call_args.kwargs + update_call_kwargs = ( + mock_prisma_client.db.litellm_teamtable.update.call_args.kwargs + ) assert update_call_kwargs.get("include", {}).get("object_permission") is True @@ -2705,7 +2796,9 @@ async def test_team_write_404s_when_row_vanishes_before_update(endpoint_name): ) mock_request = Mock(spec=Request) - mock_user_api_key_dict = UserAPIKeyAuth(user_role=LitellmUserRoles.PROXY_ADMIN, user_id="test_user_id") + mock_user_api_key_dict = UserAPIKeyAuth( + user_role=LitellmUserRoles.PROXY_ADMIN, user_id="test_user_id" + ) existing_team = MagicMock() existing_team.team_id = "team-1234" @@ -2748,15 +2841,9 @@ async def test_team_write_404s_when_row_vanishes_before_update(endpoint_name): }[endpoint_name] with ( - patch( - "litellm.proxy.proxy_server.prisma_client" - ) as mock_prisma_client, # test-quality-ok: proxy_server module global is the endpoint's only injection point - patch( - "litellm.proxy.proxy_server.user_api_key_cache" - ), # test-quality-ok: proxy_server module global is the endpoint's only injection point - patch( - "litellm.proxy.proxy_server.proxy_logging_obj" - ), # test-quality-ok: proxy_server module global is the endpoint's only injection point + patch("litellm.proxy.proxy_server.prisma_client") as mock_prisma_client, # test-quality-ok: proxy_server module global is the endpoint's only injection point + patch("litellm.proxy.proxy_server.user_api_key_cache"), # test-quality-ok: proxy_server module global is the endpoint's only injection point + patch("litellm.proxy.proxy_server.proxy_logging_obj"), # test-quality-ok: proxy_server module global is the endpoint's only injection point patch( # test-quality-ok: stubs the cache write so the test observes only the DB result handling "litellm.proxy.management_endpoints.team_endpoints.cache_team_object", new_callable=AsyncMock, @@ -2767,7 +2854,9 @@ async def test_team_write_404s_when_row_vanishes_before_update(endpoint_name): return_value=existing_team, ), ): - mock_prisma_client.db.litellm_teamtable.find_unique = AsyncMock(return_value=existing_team) + mock_prisma_client.db.litellm_teamtable.find_unique = AsyncMock( + return_value=existing_team + ) mock_prisma_client.db.litellm_teamtable.update = AsyncMock(return_value=None) mock_prisma_client.db.execute_raw = AsyncMock(return_value=None) @@ -2838,7 +2927,9 @@ async def test_create_team_member_budget_table(): TeamMemberBudgetHandler, ) - mock_user_api_key_dict = UserAPIKeyAuth(user_role=LitellmUserRoles.PROXY_ADMIN, user_id="test_user_id") + mock_user_api_key_dict = UserAPIKeyAuth( + user_role=LitellmUserRoles.PROXY_ADMIN, user_id="test_user_id" + ) data = NewTeamRequest( team_id="test_team_id", @@ -2905,7 +2996,9 @@ async def test_create_team_member_budget_table_without_team_alias(): TeamMemberBudgetHandler, ) - mock_user_api_key_dict = UserAPIKeyAuth(user_role=LitellmUserRoles.PROXY_ADMIN, user_id="test_user_id") + mock_user_api_key_dict = UserAPIKeyAuth( + user_role=LitellmUserRoles.PROXY_ADMIN, user_id="test_user_id" + ) data = NewTeamRequest(team_id="test_team_id") new_team_data_json = { @@ -2949,14 +3042,18 @@ async def test_create_team_member_budget_table_explicit_null_duration_does_not_i TeamMemberBudgetHandler, ) - mock_user_api_key_dict = UserAPIKeyAuth(user_role=LitellmUserRoles.PROXY_ADMIN, user_id="test_user_id") + mock_user_api_key_dict = UserAPIKeyAuth( + user_role=LitellmUserRoles.PROXY_ADMIN, user_id="test_user_id" + ) team_table = MagicMock(spec=LiteLLM_TeamTable) team_table.metadata = {} team_table.team_alias = "Test Team" team_table.budget_duration = "30d" - mock_db_client.db.litellm_budgettable.create = AsyncMock(side_effect=lambda data: SimpleNamespace(**data)) + mock_db_client.db.litellm_budgettable.create = AsyncMock( + side_effect=lambda data: SimpleNamespace(**data) + ) result = await TeamMemberBudgetHandler.create_team_member_budget_table( data=team_table, @@ -2990,14 +3087,18 @@ async def test_create_team_member_budget_table_inherits_team_duration_when_durat TeamMemberBudgetHandler, ) - mock_user_api_key_dict = UserAPIKeyAuth(user_role=LitellmUserRoles.PROXY_ADMIN, user_id="test_user_id") + mock_user_api_key_dict = UserAPIKeyAuth( + user_role=LitellmUserRoles.PROXY_ADMIN, user_id="test_user_id" + ) team_table = MagicMock(spec=LiteLLM_TeamTable) team_table.metadata = {} team_table.team_alias = "Test Team" team_table.budget_duration = "30d" - mock_db_client.db.litellm_budgettable.create = AsyncMock(side_effect=lambda data: SimpleNamespace(**data)) + mock_db_client.db.litellm_budgettable.create = AsyncMock( + side_effect=lambda data: SimpleNamespace(**data) + ) result = await TeamMemberBudgetHandler.create_team_member_budget_table( data=team_table, @@ -3154,7 +3255,9 @@ async def test_bulk_team_member_add_batch_size_limit(): from litellm.proxy.management_endpoints.team_endpoints import bulk_team_member_add # Create more than 500 members (the max batch size) - large_member_list = [Member(user_email=f"user{i}@example.com", role="user") for i in range(501)] + large_member_list = [ + Member(user_email=f"user{i}@example.com", role="user") for i in range(501) + ] bulk_request = BulkTeamMemberAddRequest( team_id="test-team-123", @@ -3209,7 +3312,9 @@ async def test_bulk_team_member_add_all_users_flag(): ) as mock_team_member_add, ): # Mock the database find_many call - mock_prisma.db.litellm_usertable.find_many = AsyncMock(return_value=mock_db_users) + mock_prisma.db.litellm_usertable.find_many = AsyncMock( + return_value=mock_db_users + ) mock_auth = UserAPIKeyAuth(user_role=LitellmUserRoles.PROXY_ADMIN) @@ -3219,7 +3324,9 @@ async def test_bulk_team_member_add_all_users_flag(): ) # Verify that find_many was called to get all users - mock_prisma.db.litellm_usertable.find_many.assert_called_once_with(order={"created_at": "desc"}) + mock_prisma.db.litellm_usertable.find_many.assert_called_once_with( + order={"created_at": "desc"} + ) # Verify team_member_add was called with users from database mock_team_member_add.assert_called_once() @@ -3342,7 +3449,9 @@ async def test_list_team_v2_security_check_non_admin_user(): ) assert exc_info.value.status_code == 401 - assert "Only admin users can query all teams/other teams" in str(exc_info.value.detail) + assert "Only admin users can query all teams/other teams" in str( + exc_info.value.detail + ) assert LitellmUserRoles.INTERNAL_USER.value in str(exc_info.value.detail) @@ -3390,7 +3499,9 @@ async def test_list_team_v2_security_check_non_admin_user_other_user(): ) assert exc_info.value.status_code == 401 - assert "Only admin users can query all teams/other teams" in str(exc_info.value.detail) + assert "Only admin users can query all teams/other teams" in str( + exc_info.value.detail + ) @pytest.mark.asyncio @@ -3540,11 +3651,17 @@ async def test_list_team_v2_with_status_deleted(): mock_prisma_client.db = mock_db # Mock deleted teams - mock_deleted_team1 = Mock(model_dump=lambda: {"team_id": "team_1", "team_alias": "Deleted Team 1"}) - mock_deleted_team2 = Mock(model_dump=lambda: {"team_id": "team_2", "team_alias": "Deleted Team 2"}) + mock_deleted_team1 = Mock( + model_dump=lambda: {"team_id": "team_1", "team_alias": "Deleted Team 1"} + ) + mock_deleted_team2 = Mock( + model_dump=lambda: {"team_id": "team_2", "team_alias": "Deleted Team 2"} + ) # Mock deleted teams table (should be called) - mock_db.litellm_deletedteamtable.find_many = AsyncMock(return_value=[mock_deleted_team1, mock_deleted_team2]) + mock_db.litellm_deletedteamtable.find_many = AsyncMock( + return_value=[mock_deleted_team1, mock_deleted_team2] + ) mock_db.litellm_deletedteamtable.count = AsyncMock(return_value=2) # Mock regular teams table (should NOT be called) @@ -3624,9 +3741,7 @@ async def test_list_team_v2_includes_litellm_model_table(): }, ) - with patch( - "litellm.proxy.proxy_server.prisma_client" - ) as mock_prisma_client: # test-quality-ok: this file's DB-mock convention + with patch("litellm.proxy.proxy_server.prisma_client") as mock_prisma_client: # test-quality-ok: this file's DB-mock convention mock_db = Mock() mock_prisma_client.db = mock_db @@ -3823,7 +3938,9 @@ async def test_list_team_v2_org_admin_own_user_id_sees_all_org_teams(): "organization_id": "org_A", "members_with_roles": [{"user_id": "other_user", "role": "user"}], } - mock_db.litellm_teamtable.find_many = AsyncMock(return_value=[mock_team_1, mock_team_2]) + mock_db.litellm_teamtable.find_many = AsyncMock( + return_value=[mock_team_1, mock_team_2] + ) mock_db.litellm_teamtable.count = AsyncMock(return_value=2) mock_db.litellm_verificationtoken.group_by = AsyncMock(return_value=[]) mock_db.litellm_usertable.find_unique = AsyncMock(return_value=mock_user) @@ -3849,7 +3966,9 @@ async def test_list_team_v2_org_admin_own_user_id_sees_all_org_teams(): # Verify the where clause scopes by org OR own membership — no # top-level team_id filter that would hide org teams they aren't in where = mock_db.litellm_teamtable.find_many.call_args.kwargs["where"] - assert where["AND"] == [{"OR": [{"organization_id": {"in": ["org_A"]}}, {"team_id": {"in": ["team_1"]}}]}] + assert where["AND"] == [ + {"OR": [{"organization_id": {"in": ["org_A"]}}, {"team_id": {"in": ["team_1"]}}]} + ] assert "team_id" not in where assert "organization_id" not in where @@ -4125,7 +4244,10 @@ async def test_list_team_v2_org_admin_cannot_view_other_orgs(): ) assert exc_info.value.status_code == 403 - assert "only view teams within your organizations" in str(exc_info.value.detail).lower() + assert ( + "only view teams within your organizations" + in str(exc_info.value.detail).lower() + ) @pytest.mark.asyncio @@ -4285,7 +4407,9 @@ async def test_list_team_v2_search_builds_or_clause(): from litellm.proxy.management_endpoints.team_endpoints import list_team_v2 mock_request = Mock(spec=Request) - mock_admin = UserAPIKeyAuth(user_role=LitellmUserRoles.PROXY_ADMIN, user_id="admin_user") + mock_admin = UserAPIKeyAuth( + user_role=LitellmUserRoles.PROXY_ADMIN, user_id="admin_user" + ) with patch("litellm.proxy.proxy_server.prisma_client") as mock_prisma_client: mock_db = Mock() @@ -4330,7 +4454,9 @@ async def test_list_team_v2_search_team_id_match_prefix(): from litellm.proxy.management_endpoints.team_endpoints import list_team_v2 mock_request = Mock(spec=Request) - mock_admin = UserAPIKeyAuth(user_role=LitellmUserRoles.PROXY_ADMIN, user_id="admin_user") + mock_admin = UserAPIKeyAuth( + user_role=LitellmUserRoles.PROXY_ADMIN, user_id="admin_user" + ) with patch("litellm.proxy.proxy_server.prisma_client") as mock_prisma_client: mock_db = Mock() @@ -4381,7 +4507,9 @@ async def test_list_team_v2_search_composes_with_user_id_filter(): from litellm.proxy.management_endpoints.team_endpoints import list_team_v2 mock_request = Mock(spec=Request) - mock_user_api_key_dict = UserAPIKeyAuth(user_role=LitellmUserRoles.INTERNAL_USER, user_id="member_user") + mock_user_api_key_dict = UserAPIKeyAuth( + user_role=LitellmUserRoles.INTERNAL_USER, user_id="member_user" + ) mock_user = LiteLLM_UserTable( user_id="member_user", @@ -4566,7 +4694,9 @@ async def test_list_team_v2_keys_count_skipped_for_deleted_status(): "team_alias": "Deleted Team", } - mock_db.litellm_deletedteamtable.find_many = AsyncMock(return_value=[mock_deleted]) + mock_db.litellm_deletedteamtable.find_many = AsyncMock( + return_value=[mock_deleted] + ) mock_db.litellm_deletedteamtable.count = AsyncMock(return_value=1) mock_db.litellm_verificationtoken.group_by = AsyncMock(return_value=[]) @@ -4599,7 +4729,9 @@ async def test_team_member_delete_cleans_membership(mock_db_client, mock_admin_a mock_team_row = MagicMock() mock_team_row.model_dump.return_value = { "team_id": test_team_id, - "members_with_roles": [{"user_id": test_user_id, "user_email": None, "role": "user"}], + "members_with_roles": [ + {"user_id": test_user_id, "user_email": None, "role": "user"} + ], "team_member_permissions": [], "metadata": {}, "models": [], @@ -4607,24 +4739,32 @@ async def test_team_member_delete_cleans_membership(mock_db_client, mock_admin_a } # Configure DB mocks used by team_member_delete - mock_db_client.db.litellm_teamtable.find_unique = AsyncMock(return_value=mock_team_row) + mock_db_client.db.litellm_teamtable.find_unique = AsyncMock( + return_value=mock_team_row + ) mock_db_client.db.litellm_teamtable.update = AsyncMock(return_value=mock_team_row) # User row to allow removal from user's teams list mock_user_row = MagicMock() mock_user_row.user_id = test_user_id mock_user_row.teams = [test_team_id] - mock_db_client.db.litellm_usertable.find_many = AsyncMock(return_value=[mock_user_row]) + mock_db_client.db.litellm_usertable.find_many = AsyncMock( + return_value=[mock_user_row] + ) mock_db_client.db.litellm_usertable.update = AsyncMock(return_value=MagicMock()) # Membership deletion should be called mock_db_client.db.litellm_teammembership = MagicMock() - mock_db_client.db.litellm_teammembership.delete_many = AsyncMock(return_value=MagicMock()) + mock_db_client.db.litellm_teammembership.delete_many = AsyncMock( + return_value=MagicMock() + ) # Verification token deletion should be called mock_db_client.db.litellm_verificationtoken = MagicMock() mock_db_client.db.litellm_verificationtoken.find_many = AsyncMock(return_value=[]) - mock_db_client.db.litellm_verificationtoken.delete_many = AsyncMock(return_value=MagicMock()) + mock_db_client.db.litellm_verificationtoken.delete_many = AsyncMock( + return_value=MagicMock() + ) _wire_member_delete_tx(mock_db_client) @@ -4641,7 +4781,9 @@ async def test_team_member_delete_cleans_membership(mock_db_client, mock_admin_a @pytest.mark.asyncio -async def test_team_member_delete_cleans_verification_tokens(mock_db_client, mock_admin_auth): +async def test_team_member_delete_cleans_verification_tokens( + mock_db_client, mock_admin_auth +): from litellm.proxy._types import TeamMemberDeleteRequest from litellm.proxy.management_endpoints.team_endpoints import team_member_delete @@ -4651,28 +4793,38 @@ async def test_team_member_delete_cleans_verification_tokens(mock_db_client, moc mock_team_row = MagicMock() mock_team_row.model_dump.return_value = { "team_id": test_team_id, - "members_with_roles": [{"user_id": test_user_id, "user_email": None, "role": "user"}], + "members_with_roles": [ + {"user_id": test_user_id, "user_email": None, "role": "user"} + ], "team_member_permissions": [], "metadata": {}, "models": [], "spend": 0.0, } - mock_db_client.db.litellm_teamtable.find_unique = AsyncMock(return_value=mock_team_row) + mock_db_client.db.litellm_teamtable.find_unique = AsyncMock( + return_value=mock_team_row + ) mock_db_client.db.litellm_teamtable.update = AsyncMock(return_value=mock_team_row) mock_user_row = MagicMock() mock_user_row.user_id = test_user_id mock_user_row.teams = [test_team_id] - mock_db_client.db.litellm_usertable.find_many = AsyncMock(return_value=[mock_user_row]) + mock_db_client.db.litellm_usertable.find_many = AsyncMock( + return_value=[mock_user_row] + ) mock_db_client.db.litellm_usertable.update = AsyncMock(return_value=MagicMock()) mock_db_client.db.litellm_teammembership = MagicMock() - mock_db_client.db.litellm_teammembership.delete_many = AsyncMock(return_value=MagicMock()) + mock_db_client.db.litellm_teammembership.delete_many = AsyncMock( + return_value=MagicMock() + ) mock_db_client.db.litellm_verificationtoken = MagicMock() mock_db_client.db.litellm_verificationtoken.find_many = AsyncMock(return_value=[]) - mock_db_client.db.litellm_verificationtoken.delete_many = AsyncMock(return_value=MagicMock()) + mock_db_client.db.litellm_verificationtoken.delete_many = AsyncMock( + return_value=MagicMock() + ) _wire_member_delete_tx(mock_db_client) @@ -4690,7 +4842,9 @@ async def test_team_member_delete_cleans_verification_tokens(mock_db_client, moc @pytest.mark.asyncio -async def test_team_member_delete_writes_deleted_audit_log_for_member_keys(mock_db_client, mock_admin_auth): +async def test_team_member_delete_writes_deleted_audit_log_for_member_keys( + mock_db_client, mock_admin_auth +): from litellm.proxy._types import ( LiteLLM_VerificationToken, LitellmTableNames, @@ -4705,28 +4859,38 @@ async def test_team_member_delete_writes_deleted_audit_log_for_member_keys(mock_ mock_team_row = MagicMock() mock_team_row.model_dump.return_value = { "team_id": test_team_id, - "members_with_roles": [{"user_id": test_user_id, "user_email": None, "role": "user"}], + "members_with_roles": [ + {"user_id": test_user_id, "user_email": None, "role": "user"} + ], "team_member_permissions": [], "metadata": {}, "models": [], "spend": 0.0, } - mock_db_client.db.litellm_teamtable.find_unique = AsyncMock(return_value=mock_team_row) + mock_db_client.db.litellm_teamtable.find_unique = AsyncMock( + return_value=mock_team_row + ) mock_db_client.db.litellm_teamtable.update = AsyncMock(return_value=mock_team_row) mock_user_row = MagicMock() mock_user_row.user_id = test_user_id mock_user_row.teams = [test_team_id] - mock_db_client.db.litellm_usertable.find_many = AsyncMock(return_value=[mock_user_row]) + mock_db_client.db.litellm_usertable.find_many = AsyncMock( + return_value=[mock_user_row] + ) mock_db_client.db.litellm_usertable.update = AsyncMock(return_value=MagicMock()) mock_db_client.db.litellm_teammembership = MagicMock() - mock_db_client.db.litellm_teammembership.delete_many = AsyncMock(return_value=MagicMock()) + mock_db_client.db.litellm_teammembership.delete_many = AsyncMock( + return_value=MagicMock() + ) mock_db_client.db.litellm_verificationtoken = MagicMock() mock_db_client.db.litellm_verificationtoken.find_many = AsyncMock(return_value=[member_key]) - mock_db_client.db.litellm_verificationtoken.delete_many = AsyncMock(return_value=MagicMock()) + mock_db_client.db.litellm_verificationtoken.delete_many = AsyncMock( + return_value=MagicMock() + ) mock_db_client.db.litellm_jwtkeymapping = MagicMock() mock_db_client.db.litellm_jwtkeymapping.find_many = AsyncMock(return_value=[]) mock_db_client.db.litellm_deletedverificationtoken = MagicMock() @@ -4840,7 +5004,9 @@ async def test_delete_team_writes_deleted_audit_log_for_team_keys( @pytest.mark.asyncio -async def test_team_member_delete_reads_on_the_lock_holding_transaction(mock_db_client, mock_admin_auth): +async def test_team_member_delete_reads_on_the_lock_holding_transaction( + mock_db_client, mock_admin_auth +): """ Regression pin against exhausting the connection pool with advisory-lock waiters. @@ -4866,7 +5032,9 @@ async def test_team_member_delete_reads_on_the_lock_holding_transaction(mock_db_ "models": [], "spend": 0.0, } - mock_db_client.db.litellm_teamtable.find_unique = AsyncMock(return_value=mock_team_row) + mock_db_client.db.litellm_teamtable.find_unique = AsyncMock( + return_value=mock_team_row + ) user_row = MagicMock() user_row.user_id = test_user_id @@ -4898,14 +5066,18 @@ async def test_team_member_delete_reads_on_the_lock_holding_transaction(mock_db_ user_api_key_dict=mock_admin_auth, ) - tx.litellm_usertable.find_many.assert_awaited_once_with(where={"user_id": {"in": [test_user_id]}}) + tx.litellm_usertable.find_many.assert_awaited_once_with( + where={"user_id": {"in": [test_user_id]}} + ) tx.litellm_verificationtoken.find_many.assert_awaited_once_with( where={"user_id": {"in": [test_user_id]}, "team_id": test_team_id} ) pooled_user_read.assert_not_awaited() pooled_token_read.assert_not_awaited() - tx.litellm_usertable.update.assert_awaited_once_with(where={"user_id": test_user_id}, data={"teams": {"set": []}}) + tx.litellm_usertable.update.assert_awaited_once_with( + where={"user_id": test_user_id}, data={"teams": {"set": []}} + ) tx.litellm_teammembership.delete_many.assert_awaited_once_with( where={"team_id": test_team_id, "user_id": test_user_id} ) @@ -4946,14 +5118,18 @@ async def test_team_member_delete_by_email_the_user_row_does_not_carry( mock_team_row = MagicMock() mock_team_row.model_dump.return_value = { "team_id": test_team_id, - "members_with_roles": [{"user_id": test_user_id, "user_email": roster_email, "role": "user"}], + "members_with_roles": [ + {"user_id": test_user_id, "user_email": roster_email, "role": "user"} + ], "team_member_permissions": [], "metadata": {}, "models": [], "spend": 0.0, } - mock_db_client.db.litellm_teamtable.find_unique = AsyncMock(return_value=mock_team_row) + mock_db_client.db.litellm_teamtable.find_unique = AsyncMock( + return_value=mock_team_row + ) mock_db_client.db.litellm_teamtable.update = AsyncMock(return_value=mock_team_row) mock_user_row = MagicMock() @@ -4965,21 +5141,29 @@ async def test_team_member_delete_by_email_the_user_row_does_not_carry( if not user_row_exists: return [] user_id_filter = where.get("user_id") - if isinstance(user_id_filter, dict) and test_user_id in user_id_filter.get("in", []): + if isinstance(user_id_filter, dict) and test_user_id in user_id_filter.get( + "in", [] + ): return [mock_user_row] if where.get("user_email") == user_row_email: return [mock_user_row] return [] - mock_db_client.db.litellm_usertable.find_many = AsyncMock(side_effect=find_user_rows) + mock_db_client.db.litellm_usertable.find_many = AsyncMock( + side_effect=find_user_rows + ) mock_db_client.db.litellm_usertable.update = AsyncMock(return_value=MagicMock()) mock_db_client.db.litellm_teammembership = MagicMock() - mock_db_client.db.litellm_teammembership.delete_many = AsyncMock(return_value=MagicMock()) + mock_db_client.db.litellm_teammembership.delete_many = AsyncMock( + return_value=MagicMock() + ) mock_db_client.db.litellm_verificationtoken = MagicMock() mock_db_client.db.litellm_verificationtoken.find_many = AsyncMock(return_value=[]) - mock_db_client.db.litellm_verificationtoken.delete_many = AsyncMock(return_value=MagicMock()) + mock_db_client.db.litellm_verificationtoken.delete_many = AsyncMock( + return_value=MagicMock() + ) _wire_member_delete_tx(mock_db_client) @@ -5026,22 +5210,30 @@ async def test_team_member_delete_clears_team_left_on_the_user_row_without_a_ros "models": [], "spend": 0.0, } - mock_db_client.db.litellm_teamtable.find_unique = AsyncMock(return_value=mock_team_row) + mock_db_client.db.litellm_teamtable.find_unique = AsyncMock( + return_value=mock_team_row + ) mock_db_client.db.litellm_teamtable.update = AsyncMock(return_value=mock_team_row) mock_user_row = MagicMock() mock_user_row.user_id = test_user_id mock_user_row.user_email = None mock_user_row.teams = [test_team_id, "other-team", test_team_id] - mock_db_client.db.litellm_usertable.find_many = AsyncMock(return_value=[mock_user_row]) + mock_db_client.db.litellm_usertable.find_many = AsyncMock( + return_value=[mock_user_row] + ) mock_db_client.db.litellm_usertable.update = AsyncMock(return_value=MagicMock()) mock_db_client.db.litellm_teammembership = MagicMock() - mock_db_client.db.litellm_teammembership.delete_many = AsyncMock(return_value=MagicMock()) + mock_db_client.db.litellm_teammembership.delete_many = AsyncMock( + return_value=MagicMock() + ) mock_db_client.db.litellm_verificationtoken = MagicMock() mock_db_client.db.litellm_verificationtoken.find_many = AsyncMock(return_value=[]) - mock_db_client.db.litellm_verificationtoken.delete_many = AsyncMock(return_value=MagicMock()) + mock_db_client.db.litellm_verificationtoken.delete_many = AsyncMock( + return_value=MagicMock() + ) _wire_member_delete_tx(mock_db_client) @@ -5060,7 +5252,9 @@ async def test_team_member_delete_clears_team_left_on_the_user_row_without_a_ros @pytest.mark.asyncio -async def test_team_member_delete_still_rejects_a_user_the_team_has_no_trace_of(mock_db_client, mock_admin_auth): +async def test_team_member_delete_still_rejects_a_user_the_team_has_no_trace_of( + mock_db_client, mock_admin_auth +): from litellm.proxy._types import TeamMemberDeleteRequest from litellm.proxy.management_endpoints.team_endpoints import team_member_delete @@ -5076,18 +5270,24 @@ async def test_team_member_delete_still_rejects_a_user_the_team_has_no_trace_of( "models": [], "spend": 0.0, } - mock_db_client.db.litellm_teamtable.find_unique = AsyncMock(return_value=mock_team_row) + mock_db_client.db.litellm_teamtable.find_unique = AsyncMock( + return_value=mock_team_row + ) mock_db_client.db.litellm_teamtable.update = AsyncMock(return_value=mock_team_row) mock_user_row = MagicMock() mock_user_row.user_id = test_user_id mock_user_row.user_email = None mock_user_row.teams = ["other-team"] - mock_db_client.db.litellm_usertable.find_many = AsyncMock(return_value=[mock_user_row]) + mock_db_client.db.litellm_usertable.find_many = AsyncMock( + return_value=[mock_user_row] + ) mock_db_client.db.litellm_usertable.update = AsyncMock(return_value=MagicMock()) mock_db_client.db.litellm_teammembership = MagicMock() - mock_db_client.db.litellm_teammembership.delete_many = AsyncMock(return_value=MagicMock()) + mock_db_client.db.litellm_teammembership.delete_many = AsyncMock( + return_value=MagicMock() + ) _wire_member_delete_tx(mock_db_client) @@ -5124,13 +5324,17 @@ async def test_team_member_delete_leaves_a_bystander_named_by_a_conflicting_user mock_team_row = MagicMock() mock_team_row.model_dump.return_value = { "team_id": test_team_id, - "members_with_roles": [{"user_id": roster_user_id, "user_email": roster_email, "role": "user"}], + "members_with_roles": [ + {"user_id": roster_user_id, "user_email": roster_email, "role": "user"} + ], "team_member_permissions": [], "metadata": {}, "models": [], "spend": 0.0, } - mock_db_client.db.litellm_teamtable.find_unique = AsyncMock(return_value=mock_team_row) + mock_db_client.db.litellm_teamtable.find_unique = AsyncMock( + return_value=mock_team_row + ) mock_db_client.db.litellm_teamtable.update = AsyncMock(return_value=mock_team_row) roster_user_row = MagicMock() @@ -5151,18 +5355,32 @@ async def test_team_member_delete_leaves_a_bystander_named_by_a_conflicting_user async def find_user_rows(where): user_id_filter = where.get("user_id") if isinstance(user_id_filter, dict): - return [rows_by_user_id[uid] for uid in user_id_filter.get("in", []) if uid in rows_by_user_id] - return [row for row in rows_by_user_id.values() if row.user_email == where.get("user_email")] + return [ + rows_by_user_id[uid] + for uid in user_id_filter.get("in", []) + if uid in rows_by_user_id + ] + return [ + row + for row in rows_by_user_id.values() + if row.user_email == where.get("user_email") + ] - mock_db_client.db.litellm_usertable.find_many = AsyncMock(side_effect=find_user_rows) + mock_db_client.db.litellm_usertable.find_many = AsyncMock( + side_effect=find_user_rows + ) mock_db_client.db.litellm_usertable.update = AsyncMock(return_value=MagicMock()) mock_db_client.db.litellm_teammembership = MagicMock() - mock_db_client.db.litellm_teammembership.delete_many = AsyncMock(return_value=MagicMock()) + mock_db_client.db.litellm_teammembership.delete_many = AsyncMock( + return_value=MagicMock() + ) mock_db_client.db.litellm_verificationtoken = MagicMock() mock_db_client.db.litellm_verificationtoken.find_many = AsyncMock(return_value=[]) - mock_db_client.db.litellm_verificationtoken.delete_many = AsyncMock(return_value=MagicMock()) + mock_db_client.db.litellm_verificationtoken.delete_many = AsyncMock( + return_value=MagicMock() + ) _wire_member_delete_tx(mock_db_client) @@ -5213,7 +5431,9 @@ async def test_team_member_delete_by_email_only_touches_the_row_carrying_the_sta "models": [], "spend": 0.0, } - mock_db_client.db.litellm_teamtable.find_unique = AsyncMock(return_value=mock_team_row) + mock_db_client.db.litellm_teamtable.find_unique = AsyncMock( + return_value=mock_team_row + ) mock_db_client.db.litellm_teamtable.update = AsyncMock(return_value=mock_team_row) stale_user_row = MagicMock() @@ -5226,15 +5446,21 @@ async def test_team_member_delete_by_email_only_touches_the_row_carrying_the_sta namesake_user_row.user_email = shared_email namesake_user_row.teams = ["other-team"] - mock_db_client.db.litellm_usertable.find_many = AsyncMock(return_value=[stale_user_row, namesake_user_row]) + mock_db_client.db.litellm_usertable.find_many = AsyncMock( + return_value=[stale_user_row, namesake_user_row] + ) mock_db_client.db.litellm_usertable.update = AsyncMock(return_value=MagicMock()) mock_db_client.db.litellm_teammembership = MagicMock() - mock_db_client.db.litellm_teammembership.delete_many = AsyncMock(return_value=MagicMock()) + mock_db_client.db.litellm_teammembership.delete_many = AsyncMock( + return_value=MagicMock() + ) mock_db_client.db.litellm_verificationtoken = MagicMock() mock_db_client.db.litellm_verificationtoken.find_many = AsyncMock(return_value=[]) - mock_db_client.db.litellm_verificationtoken.delete_many = AsyncMock(return_value=MagicMock()) + mock_db_client.db.litellm_verificationtoken.delete_many = AsyncMock( + return_value=MagicMock() + ) _wire_member_delete_tx(mock_db_client) @@ -5260,7 +5486,9 @@ class _InjectedMemberDeleteFailure(Exception): @pytest.mark.asyncio -async def test_team_member_delete_is_atomic_across_its_four_writes(mock_db_client, mock_admin_auth): +async def test_team_member_delete_is_atomic_across_its_four_writes( + mock_db_client, mock_admin_auth +): """ /team/member_delete's four cleanups (team roster, user.teams, team membership, verification tokens) run as one transaction, so a failure @@ -5281,19 +5509,25 @@ async def test_team_member_delete_is_atomic_across_its_four_writes(mock_db_clien mock_team_row = MagicMock() mock_team_row.model_dump.return_value = { "team_id": test_team_id, - "members_with_roles": [{"user_id": test_user_id, "user_email": None, "role": "user"}], + "members_with_roles": [ + {"user_id": test_user_id, "user_email": None, "role": "user"} + ], "team_member_permissions": [], "metadata": {}, "models": [], "spend": 0.0, } - mock_db_client.db.litellm_teamtable.find_unique = AsyncMock(return_value=mock_team_row) + mock_db_client.db.litellm_teamtable.find_unique = AsyncMock( + return_value=mock_team_row + ) mock_db_client.db.litellm_teamtable.update = AsyncMock(return_value=mock_team_row) mock_user_row = MagicMock() mock_user_row.user_id = test_user_id mock_user_row.teams = [test_team_id] - mock_db_client.db.litellm_usertable.find_many = AsyncMock(return_value=[mock_user_row]) + mock_db_client.db.litellm_usertable.find_many = AsyncMock( + return_value=[mock_user_row] + ) mock_db_client.db.litellm_usertable.update = AsyncMock( side_effect=_InjectedMemberDeleteFailure("boom between writes 1 and 2") ) @@ -5357,7 +5591,9 @@ async def test_new_team_max_budget_exceeds_user_max_budget(): patch("litellm.proxy.proxy_server._license_check") as mock_license, patch("litellm.proxy.proxy_server.user_api_key_cache") as mock_cache, patch("litellm.proxy.proxy_server.litellm_proxy_admin_name", "admin"), - patch("litellm.proxy.proxy_server.create_audit_log_for_update", new=AsyncMock()) as mock_audit, + patch( + "litellm.proxy.proxy_server.create_audit_log_for_update", new=AsyncMock() + ) as mock_audit, ): # Setup basic mocks mock_prisma.db.litellm_teamtable.count = AsyncMock(return_value=0) @@ -5385,7 +5621,9 @@ async def test_new_team_max_budget_exceeds_user_max_budget(): # ProxyException stores status_code in 'code' attribute assert exc_info.value.code == "400" assert "max budget higher than user max" in str(exc_info.value.message) - assert "100.0" in str(exc_info.value.message) # User's user_max_budget should be mentioned + assert "100.0" in str( + exc_info.value.message + ) # User's user_max_budget should be mentioned assert LitellmUserRoles.INTERNAL_USER.value in str(exc_info.value.message) @@ -5422,7 +5660,9 @@ async def test_new_team_max_budget_within_user_limit(): patch("litellm.proxy.proxy_server.user_api_key_cache") as mock_cache, patch("litellm.proxy.proxy_server._license_check") as mock_license, patch("litellm.proxy.proxy_server.litellm_proxy_admin_name", "admin"), - patch("litellm.proxy.proxy_server.create_audit_log_for_update", new=AsyncMock()) as mock_audit, + patch( + "litellm.proxy.proxy_server.create_audit_log_for_update", new=AsyncMock() + ) as mock_audit, ): # Setup mocks mock_prisma.db.litellm_teamtable.count = AsyncMock(return_value=0) @@ -5454,13 +5694,19 @@ async def test_new_team_max_budget_within_user_limit(): "max_budget": 50.0, "members_with_roles": [], } - mock_prisma.db.litellm_teamtable.create = AsyncMock(return_value=mock_created_team) + mock_prisma.db.litellm_teamtable.create = AsyncMock( + return_value=mock_created_team + ) _wire_team_create_tx(mock_prisma) - mock_prisma.db.litellm_teamtable.update = AsyncMock(return_value=mock_created_team) + mock_prisma.db.litellm_teamtable.update = AsyncMock( + return_value=mock_created_team + ) # Mock model table mock_prisma.db.litellm_modeltable = MagicMock() - mock_prisma.db.litellm_modeltable.create = AsyncMock(return_value=MagicMock(id="model123")) + mock_prisma.db.litellm_modeltable.create = AsyncMock( + return_value=MagicMock(id="model123") + ) # Mock user table operations for adding the creator as a member mock_user = MagicMock() @@ -5483,7 +5729,9 @@ async def test_new_team_max_budget_within_user_limit(): "budget_id": None, } mock_prisma.db.litellm_teammembership = MagicMock() - mock_prisma.db.litellm_teammembership.upsert = AsyncMock(return_value=mock_membership) + mock_prisma.db.litellm_teammembership.upsert = AsyncMock( + return_value=mock_membership + ) # Should NOT raise an exception result = await new_team( @@ -5544,8 +5792,12 @@ async def test_new_team_org_scoped_budget_bypasses_user_limit(): patch("litellm.proxy.proxy_server.user_api_key_cache") as mock_cache, patch("litellm.proxy.proxy_server._license_check") as mock_license, patch("litellm.proxy.proxy_server.litellm_proxy_admin_name", "admin"), - patch("litellm.proxy.proxy_server.create_audit_log_for_update", new=AsyncMock()) as mock_audit, - patch("litellm.proxy.management_endpoints.team_endpoints.get_org_object") as mock_get_org, + patch( + "litellm.proxy.proxy_server.create_audit_log_for_update", new=AsyncMock() + ) as mock_audit, + patch( + "litellm.proxy.management_endpoints.team_endpoints.get_org_object" + ) as mock_get_org, ): # Setup mocks mock_prisma.db.litellm_teamtable.count = AsyncMock(return_value=0) @@ -5585,13 +5837,19 @@ async def test_new_team_org_scoped_budget_bypasses_user_limit(): "organization_id": "test-org-123", "members_with_roles": [], } - mock_prisma.db.litellm_teamtable.create = AsyncMock(return_value=mock_created_team) + mock_prisma.db.litellm_teamtable.create = AsyncMock( + return_value=mock_created_team + ) _wire_team_create_tx(mock_prisma) - mock_prisma.db.litellm_teamtable.update = AsyncMock(return_value=mock_created_team) + mock_prisma.db.litellm_teamtable.update = AsyncMock( + return_value=mock_created_team + ) # Mock model table mock_prisma.db.litellm_modeltable = MagicMock() - mock_prisma.db.litellm_modeltable.create = AsyncMock(return_value=MagicMock(id="model123")) + mock_prisma.db.litellm_modeltable.create = AsyncMock( + return_value=MagicMock(id="model123") + ) # Mock user table operations mock_user = MagicMock() @@ -5614,7 +5872,9 @@ async def test_new_team_org_scoped_budget_bypasses_user_limit(): "budget_id": None, } mock_prisma.db.litellm_teammembership = MagicMock() - mock_prisma.db.litellm_teammembership.upsert = AsyncMock(return_value=mock_membership) + mock_prisma.db.litellm_teammembership.upsert = AsyncMock( + return_value=mock_membership + ) # Should NOT raise an exception - the fix should bypass user budget validation for org-scoped teams result = await new_team( @@ -5665,7 +5925,9 @@ async def test_new_team_org_scoped_models_bypasses_user_limit(): # Create team request with models that are within org's allowed models but not user's team_request = NewTeamRequest( team_alias="org-scoped-models-team", - models=["gpt-4"], # Within org's allowed models, but not in user's personal models + models=[ + "gpt-4" + ], # Within org's allowed models, but not in user's personal models organization_id="test-org-456", # This makes it an org-scoped team ) @@ -5676,8 +5938,12 @@ async def test_new_team_org_scoped_models_bypasses_user_limit(): patch("litellm.proxy.proxy_server.user_api_key_cache") as mock_cache, patch("litellm.proxy.proxy_server._license_check") as mock_license, patch("litellm.proxy.proxy_server.litellm_proxy_admin_name", "admin"), - patch("litellm.proxy.proxy_server.create_audit_log_for_update", new=AsyncMock()) as mock_audit, - patch("litellm.proxy.management_endpoints.team_endpoints.get_org_object") as mock_get_org, + patch( + "litellm.proxy.proxy_server.create_audit_log_for_update", new=AsyncMock() + ) as mock_audit, + patch( + "litellm.proxy.management_endpoints.team_endpoints.get_org_object" + ) as mock_get_org, ): # Setup mocks mock_prisma.db.litellm_teamtable.count = AsyncMock(return_value=0) @@ -5719,13 +5985,19 @@ async def test_new_team_org_scoped_models_bypasses_user_limit(): "models": ["gpt-4"], "members_with_roles": [], } - mock_prisma.db.litellm_teamtable.create = AsyncMock(return_value=mock_created_team) + mock_prisma.db.litellm_teamtable.create = AsyncMock( + return_value=mock_created_team + ) _wire_team_create_tx(mock_prisma) - mock_prisma.db.litellm_teamtable.update = AsyncMock(return_value=mock_created_team) + mock_prisma.db.litellm_teamtable.update = AsyncMock( + return_value=mock_created_team + ) # Mock model table mock_prisma.db.litellm_modeltable = MagicMock() - mock_prisma.db.litellm_modeltable.create = AsyncMock(return_value=MagicMock(id="model123")) + mock_prisma.db.litellm_modeltable.create = AsyncMock( + return_value=MagicMock(id="model123") + ) # Mock user table operations mock_user = MagicMock() @@ -5748,7 +6020,9 @@ async def test_new_team_org_scoped_models_bypasses_user_limit(): "budget_id": None, } mock_prisma.db.litellm_teammembership = MagicMock() - mock_prisma.db.litellm_teammembership.upsert = AsyncMock(return_value=mock_membership) + mock_prisma.db.litellm_teammembership.upsert = AsyncMock( + return_value=mock_membership + ) # Should NOT raise an exception - the fix should bypass user model validation for org-scoped teams result = await new_team( @@ -5808,7 +6082,9 @@ async def test_new_team_standalone_validates_against_user_models(monkeypatch): patch("litellm.proxy.proxy_server.prisma_client") as mock_prisma, patch("litellm.proxy.proxy_server._license_check") as mock_license, patch("litellm.proxy.proxy_server.litellm_proxy_admin_name", "admin"), - patch("litellm.proxy.proxy_server.create_audit_log_for_update", new=AsyncMock()) as mock_audit, + patch( + "litellm.proxy.proxy_server.create_audit_log_for_update", new=AsyncMock() + ) as mock_audit, ): # Setup basic mocks mock_prisma.db.litellm_teamtable.count = AsyncMock(return_value=0) @@ -5875,7 +6151,9 @@ async def test_new_team_standalone_validates_against_user_budget(): patch("litellm.proxy.proxy_server._license_check") as mock_license, patch("litellm.proxy.proxy_server.user_api_key_cache") as mock_cache, patch("litellm.proxy.proxy_server.litellm_proxy_admin_name", "admin"), - patch("litellm.proxy.proxy_server.create_audit_log_for_update", new=AsyncMock()) as mock_audit, + patch( + "litellm.proxy.proxy_server.create_audit_log_for_update", new=AsyncMock() + ) as mock_audit, ): # Setup basic mocks mock_prisma.db.litellm_teamtable.count = AsyncMock(return_value=0) @@ -5900,7 +6178,9 @@ async def test_new_team_standalone_validates_against_user_budget(): # Verify exception details assert exc_info.value.code == "400" assert "max budget higher than user max" in str(exc_info.value.message) - assert "3.0" in str(exc_info.value.message) # User's max_budget should be mentioned + assert "3.0" in str( + exc_info.value.message + ) # User's max_budget should be mentioned @pytest.mark.asyncio @@ -5944,8 +6224,12 @@ async def test_new_team_org_scoped_budget_exceeds_org_limit(): patch("litellm.proxy.proxy_server.user_api_key_cache") as mock_cache, patch("litellm.proxy.proxy_server._license_check") as mock_license, patch("litellm.proxy.proxy_server.litellm_proxy_admin_name", "admin"), - patch("litellm.proxy.proxy_server.create_audit_log_for_update", new=AsyncMock()) as mock_audit, - patch("litellm.proxy.management_endpoints.team_endpoints.get_org_object") as mock_get_org, + patch( + "litellm.proxy.proxy_server.create_audit_log_for_update", new=AsyncMock() + ) as mock_audit, + patch( + "litellm.proxy.management_endpoints.team_endpoints.get_org_object" + ) as mock_get_org, ): # Setup mocks mock_prisma.db.litellm_teamtable.count = AsyncMock(return_value=0) @@ -6019,8 +6303,12 @@ async def test_new_team_org_scoped_models_not_in_org_models(): patch("litellm.proxy.proxy_server.user_api_key_cache") as mock_cache, patch("litellm.proxy.proxy_server._license_check") as mock_license, patch("litellm.proxy.proxy_server.litellm_proxy_admin_name", "admin"), - patch("litellm.proxy.proxy_server.create_audit_log_for_update", new=AsyncMock()) as mock_audit, - patch("litellm.proxy.management_endpoints.team_endpoints.get_org_object") as mock_get_org, + patch( + "litellm.proxy.proxy_server.create_audit_log_for_update", new=AsyncMock() + ) as mock_audit, + patch( + "litellm.proxy.management_endpoints.team_endpoints.get_org_object" + ) as mock_get_org, ): # Setup mocks mock_prisma.db.litellm_teamtable.count = AsyncMock(return_value=0) @@ -6044,7 +6332,10 @@ async def test_new_team_org_scoped_models_not_in_org_models(): # Verify exception details assert exc_info.value.code == "400" - assert "claude-3-opus" in str(exc_info.value.message) or "organization" in str(exc_info.value.message).lower() + assert ( + "claude-3-opus" in str(exc_info.value.message) + or "organization" in str(exc_info.value.message).lower() + ) @pytest.mark.asyncio @@ -6089,7 +6380,9 @@ async def test_update_team_standalone_budget_raise_blocked_for_team_admin(): patch("litellm.proxy.proxy_server.prisma_client") as mock_prisma, patch("litellm.proxy.proxy_server.user_api_key_cache") as mock_cache, patch("litellm.proxy.proxy_server.litellm_proxy_admin_name", "admin"), - patch("litellm.proxy.proxy_server.create_audit_log_for_update", new=AsyncMock()), + patch( + "litellm.proxy.proxy_server.create_audit_log_for_update", new=AsyncMock() + ), ): mock_existing_team = MagicMock() mock_existing_team.team_id = "standalone-team-123" @@ -6100,9 +6393,13 @@ async def test_update_team_standalone_budget_raise_blocked_for_team_admin(): "team_id": "standalone-team-123", "organization_id": None, "max_budget": 30.0, - "members_with_roles": [{"user_id": "non-admin-update-test", "role": "admin"}], + "members_with_roles": [ + {"user_id": "non-admin-update-test", "role": "admin"} + ], } - mock_prisma.db.litellm_teamtable.find_unique = AsyncMock(return_value=mock_existing_team) + mock_prisma.db.litellm_teamtable.find_unique = AsyncMock( + return_value=mock_existing_team + ) mock_cache.async_get_cache = AsyncMock(return_value=None) with pytest.raises(ProxyException) as exc_info: @@ -6151,7 +6448,9 @@ async def test_update_team_standalone_budget_raise_allowed_for_proxy_admin( patch("litellm.proxy.proxy_server.prisma_client") as mock_prisma, patch("litellm.proxy.proxy_server.user_api_key_cache") as mock_cache, patch("litellm.proxy.proxy_server.litellm_proxy_admin_name", "admin"), - patch("litellm.proxy.proxy_server.create_audit_log_for_update", new=AsyncMock()), + patch( + "litellm.proxy.proxy_server.create_audit_log_for_update", new=AsyncMock() + ), ): mock_existing_team = MagicMock() mock_existing_team.team_id = "standalone-team-123" @@ -6162,9 +6461,13 @@ async def test_update_team_standalone_budget_raise_allowed_for_proxy_admin( "team_id": "standalone-team-123", "organization_id": None, "max_budget": 30.0, - "members_with_roles": [{"user_id": "proxy-admin-update-test", "role": "admin"}], + "members_with_roles": [ + {"user_id": "proxy-admin-update-test", "role": "admin"} + ], } - mock_prisma.db.litellm_teamtable.find_unique = AsyncMock(return_value=mock_existing_team) + mock_prisma.db.litellm_teamtable.find_unique = AsyncMock( + return_value=mock_existing_team + ) mock_prisma.jsonify_team_object = lambda db_data: db_data mock_cache.async_get_cache = AsyncMock(return_value=None) mock_cache.async_set_cache = AsyncMock() @@ -6179,7 +6482,9 @@ async def test_update_team_standalone_budget_raise_allowed_for_proxy_admin( "organization_id": None, "max_budget": 100.0, } - mock_prisma.db.litellm_teamtable.update = AsyncMock(return_value=mock_updated_team) + mock_prisma.db.litellm_teamtable.update = AsyncMock( + return_value=mock_updated_team + ) result = await update_team( data=update_request, @@ -6232,7 +6537,9 @@ async def test_update_team_standalone_budget_removal_blocked_for_team_admin(): patch("litellm.proxy.proxy_server.prisma_client") as mock_prisma, patch("litellm.proxy.proxy_server.user_api_key_cache") as mock_cache, patch("litellm.proxy.proxy_server.litellm_proxy_admin_name", "admin"), - patch("litellm.proxy.proxy_server.create_audit_log_for_update", new=AsyncMock()), + patch( + "litellm.proxy.proxy_server.create_audit_log_for_update", new=AsyncMock() + ), ): mock_existing_team = MagicMock() mock_existing_team.team_id = "standalone-team-123" @@ -6243,9 +6550,13 @@ async def test_update_team_standalone_budget_removal_blocked_for_team_admin(): "team_id": "standalone-team-123", "organization_id": None, "max_budget": 500.0, - "members_with_roles": [{"user_id": "budget-removal-admin", "role": "admin"}], + "members_with_roles": [ + {"user_id": "budget-removal-admin", "role": "admin"} + ], } - mock_prisma.db.litellm_teamtable.find_unique = AsyncMock(return_value=mock_existing_team) + mock_prisma.db.litellm_teamtable.find_unique = AsyncMock( + return_value=mock_existing_team + ) mock_cache.async_get_cache = AsyncMock(return_value=None) with pytest.raises(ProxyException) as exc_info: @@ -6296,7 +6607,9 @@ async def test_update_team_standalone_uncapped_team_admin_sets_finite_allowed( patch("litellm.proxy.proxy_server.prisma_client") as mock_prisma, patch("litellm.proxy.proxy_server.user_api_key_cache") as mock_cache, patch("litellm.proxy.proxy_server.litellm_proxy_admin_name", "admin"), - patch("litellm.proxy.proxy_server.create_audit_log_for_update", new=AsyncMock()), + patch( + "litellm.proxy.proxy_server.create_audit_log_for_update", new=AsyncMock() + ), ): _TeamRowStore( mock_prisma.db.litellm_teamtable, @@ -6367,7 +6680,9 @@ async def test_update_team_standalone_unchanged_budget_allowed( patch("litellm.proxy.proxy_server.prisma_client") as mock_prisma, patch("litellm.proxy.proxy_server.user_api_key_cache") as mock_cache, patch("litellm.proxy.proxy_server.litellm_proxy_admin_name", "admin"), - patch("litellm.proxy.proxy_server.create_audit_log_for_update", new=AsyncMock()) as mock_audit, + patch( + "litellm.proxy.proxy_server.create_audit_log_for_update", new=AsyncMock() + ) as mock_audit, ): # Mock existing standalone team (no organization_id) with budget=$500 mock_existing_team = MagicMock() @@ -6379,9 +6694,13 @@ async def test_update_team_standalone_unchanged_budget_allowed( "team_id": "standalone-unchanged-budget-123", "organization_id": None, "max_budget": 500.0, - "members_with_roles": [{"user_id": "standalone-unchanged-budget-admin", "role": "admin"}], + "members_with_roles": [ + {"user_id": "standalone-unchanged-budget-admin", "role": "admin"} + ], } - mock_prisma.db.litellm_teamtable.find_unique = AsyncMock(return_value=mock_existing_team) + mock_prisma.db.litellm_teamtable.find_unique = AsyncMock( + return_value=mock_existing_team + ) mock_prisma.jsonify_team_object = lambda db_data: db_data # User has a restrictive personal budget that is lower than the team's. @@ -6403,7 +6722,9 @@ async def test_update_team_standalone_unchanged_budget_allowed( "max_budget": 500.0, "tpm_limit": 50000, } - mock_prisma.db.litellm_teamtable.update = AsyncMock(return_value=mock_updated_team) + mock_prisma.db.litellm_teamtable.update = AsyncMock( + return_value=mock_updated_team + ) # Should NOT raise - unchanged budget skips the personal-budget check. result = await update_team( @@ -6458,7 +6779,9 @@ async def test_update_team_standalone_lower_budget_allowed( patch("litellm.proxy.proxy_server.prisma_client") as mock_prisma, patch("litellm.proxy.proxy_server.user_api_key_cache") as mock_cache, patch("litellm.proxy.proxy_server.litellm_proxy_admin_name", "admin"), - patch("litellm.proxy.proxy_server.create_audit_log_for_update", new=AsyncMock()) as mock_audit, + patch( + "litellm.proxy.proxy_server.create_audit_log_for_update", new=AsyncMock() + ) as mock_audit, ): _TeamRowStore( mock_prisma.db.litellm_teamtable, @@ -6538,7 +6861,9 @@ async def test_update_team_org_scoped_budget_exceeds_org_limit(): patch("litellm.proxy.proxy_server.prisma_client") as mock_prisma, patch("litellm.proxy.proxy_server.user_api_key_cache") as mock_cache, patch("litellm.proxy.proxy_server.litellm_proxy_admin_name", "admin"), - patch("litellm.proxy.proxy_server.create_audit_log_for_update", new=AsyncMock()) as mock_audit, + patch( + "litellm.proxy.proxy_server.create_audit_log_for_update", new=AsyncMock() + ) as mock_audit, patch( "litellm.proxy.management_endpoints.team_endpoints.get_org_object", new=AsyncMock(return_value=mock_org), @@ -6553,9 +6878,13 @@ async def test_update_team_org_scoped_budget_exceeds_org_limit(): "team_id": "org-team-456", "organization_id": "test-org-update", "max_budget": 80.0, - "members_with_roles": [{"user_id": "org-admin-update-test", "role": "admin"}], + "members_with_roles": [ + {"user_id": "org-admin-update-test", "role": "admin"} + ], } - mock_prisma.db.litellm_teamtable.find_unique = AsyncMock(return_value=mock_existing_team) + mock_prisma.db.litellm_teamtable.find_unique = AsyncMock( + return_value=mock_existing_team + ) # Should raise ProxyException because new budget exceeds org's max_budget with pytest.raises(ProxyException) as exc_info: @@ -6567,7 +6896,10 @@ async def test_update_team_org_scoped_budget_exceeds_org_limit(): # Verify exception details assert exc_info.value.code == "400" - assert "organization" in str(exc_info.value.message).lower() or "budget" in str(exc_info.value.message).lower() + assert ( + "organization" in str(exc_info.value.message).lower() + or "budget" in str(exc_info.value.message).lower() + ) @pytest.mark.asyncio @@ -6610,7 +6942,9 @@ async def test_update_team_standalone_models_not_gated_by_user_limit( patch("litellm.proxy.proxy_server.prisma_client") as mock_prisma, patch("litellm.proxy.proxy_server.user_api_key_cache") as mock_cache, patch("litellm.proxy.proxy_server.litellm_proxy_admin_name", "admin"), - patch("litellm.proxy.proxy_server.create_audit_log_for_update", new=AsyncMock()) as mock_audit, + patch( + "litellm.proxy.proxy_server.create_audit_log_for_update", new=AsyncMock() + ) as mock_audit, ): # Mock existing standalone team (no organization_id) mock_existing_team = MagicMock() @@ -6622,9 +6956,13 @@ async def test_update_team_standalone_models_not_gated_by_user_limit( "team_id": "standalone-team-models-123", "organization_id": None, "models": ["gpt-3.5-turbo"], - "members_with_roles": [{"user_id": "non-admin-update-models-test", "role": "admin"}], + "members_with_roles": [ + {"user_id": "non-admin-update-models-test", "role": "admin"} + ], } - mock_prisma.db.litellm_teamtable.find_unique = AsyncMock(return_value=mock_existing_team) + mock_prisma.db.litellm_teamtable.find_unique = AsyncMock( + return_value=mock_existing_team + ) mock_prisma.jsonify_team_object = lambda db_data: db_data mock_cache.async_get_cache = AsyncMock(return_value=None) mock_cache.async_set_cache = AsyncMock() @@ -6638,7 +6976,9 @@ async def test_update_team_standalone_models_not_gated_by_user_limit( "organization_id": None, "models": ["gpt-4"], } - mock_prisma.db.litellm_teamtable.update = AsyncMock(return_value=mock_updated_team) + mock_prisma.db.litellm_teamtable.update = AsyncMock( + return_value=mock_updated_team + ) result = await update_team( data=update_request, @@ -6702,7 +7042,9 @@ async def test_update_team_org_scoped_budget_bypasses_user_limit( patch("litellm.proxy.proxy_server.prisma_client") as mock_prisma, patch("litellm.proxy.proxy_server.user_api_key_cache") as mock_cache, patch("litellm.proxy.proxy_server.litellm_proxy_admin_name", "admin"), - patch("litellm.proxy.proxy_server.create_audit_log_for_update", new=AsyncMock()) as mock_audit, + patch( + "litellm.proxy.proxy_server.create_audit_log_for_update", new=AsyncMock() + ) as mock_audit, patch( "litellm.proxy.management_endpoints.team_endpoints.get_org_object", new=AsyncMock(return_value=mock_org), @@ -6720,7 +7062,9 @@ async def test_update_team_org_scoped_budget_bypasses_user_limit( "max_budget": 30.0, "members_with_roles": [], } - mock_prisma.db.litellm_teamtable.find_unique = AsyncMock(return_value=mock_existing_team) + mock_prisma.db.litellm_teamtable.find_unique = AsyncMock( + return_value=mock_existing_team + ) mock_prisma.jsonify_team_object = lambda db_data: db_data # Mock user cache to return user with restrictive budget @@ -6729,7 +7073,9 @@ async def test_update_team_org_scoped_budget_bypasses_user_limit( max_budget=3.0, # Restrictive personal budget ) mock_cache.async_get_cache = AsyncMock(return_value=mock_user_obj) - mock_cache.async_set_cache = AsyncMock() # Mock cache set for _cache_team_object + mock_cache.async_set_cache = ( + AsyncMock() + ) # Mock cache set for _cache_team_object # Mock team update mock_updated_team = MagicMock() @@ -6742,7 +7088,9 @@ async def test_update_team_org_scoped_budget_bypasses_user_limit( "organization_id": "test-org-update-budget", "max_budget": 50.0, } - mock_prisma.db.litellm_teamtable.update = AsyncMock(return_value=mock_updated_team) + mock_prisma.db.litellm_teamtable.update = AsyncMock( + return_value=mock_updated_team + ) # Should NOT raise an exception - bypass user budget validation for org-scoped teams result = await update_team( @@ -6805,7 +7153,9 @@ async def test_update_team_org_scoped_models_bypasses_user_limit( patch("litellm.proxy.proxy_server.prisma_client") as mock_prisma, patch("litellm.proxy.proxy_server.user_api_key_cache") as mock_cache, patch("litellm.proxy.proxy_server.litellm_proxy_admin_name", "admin"), - patch("litellm.proxy.proxy_server.create_audit_log_for_update", new=AsyncMock()) as mock_audit, + patch( + "litellm.proxy.proxy_server.create_audit_log_for_update", new=AsyncMock() + ) as mock_audit, patch( "litellm.proxy.management_endpoints.team_endpoints.get_org_object", new=AsyncMock(return_value=mock_org), @@ -6821,11 +7171,17 @@ async def test_update_team_org_scoped_models_bypasses_user_limit( "team_id": "org-team-update-models-123", "organization_id": "test-org-update-models", "models": ["gpt-3.5-turbo"], - "members_with_roles": [{"user_id": "org-admin-update-models-test", "role": "admin"}], + "members_with_roles": [ + {"user_id": "org-admin-update-models-test", "role": "admin"} + ], } - mock_prisma.db.litellm_teamtable.find_unique = AsyncMock(return_value=mock_existing_team) + mock_prisma.db.litellm_teamtable.find_unique = AsyncMock( + return_value=mock_existing_team + ) mock_prisma.jsonify_team_object = lambda db_data: db_data - mock_cache.async_set_cache = AsyncMock() # Mock cache set for _cache_team_object + mock_cache.async_set_cache = ( + AsyncMock() + ) # Mock cache set for _cache_team_object # Mock team update mock_updated_team = MagicMock() @@ -6838,7 +7194,9 @@ async def test_update_team_org_scoped_models_bypasses_user_limit( "organization_id": "test-org-update-models", "models": ["gpt-4"], } - mock_prisma.db.litellm_teamtable.update = AsyncMock(return_value=mock_updated_team) + mock_prisma.db.litellm_teamtable.update = AsyncMock( + return_value=mock_updated_team + ) # Should NOT raise an exception - bypass user models validation for org-scoped teams result = await update_team( @@ -6899,7 +7257,9 @@ async def test_update_team_org_scoped_models_not_in_org_models(): patch("litellm.proxy.proxy_server.prisma_client") as mock_prisma, patch("litellm.proxy.proxy_server.user_api_key_cache") as mock_cache, patch("litellm.proxy.proxy_server.litellm_proxy_admin_name", "admin"), - patch("litellm.proxy.proxy_server.create_audit_log_for_update", new=AsyncMock()) as mock_audit, + patch( + "litellm.proxy.proxy_server.create_audit_log_for_update", new=AsyncMock() + ) as mock_audit, patch( "litellm.proxy.management_endpoints.team_endpoints.get_org_object", new=AsyncMock(return_value=mock_org), @@ -6914,9 +7274,13 @@ async def test_update_team_org_scoped_models_not_in_org_models(): "team_id": "org-team-update-models-fail-123", "organization_id": "test-org-update-models-fail", "models": ["gpt-4"], - "members_with_roles": [{"user_id": "org-admin-update-models-fail-test", "role": "admin"}], + "members_with_roles": [ + {"user_id": "org-admin-update-models-fail-test", "role": "admin"} + ], } - mock_prisma.db.litellm_teamtable.find_unique = AsyncMock(return_value=mock_existing_team) + mock_prisma.db.litellm_teamtable.find_unique = AsyncMock( + return_value=mock_existing_team + ) # Should raise ProxyException because claude-3-opus is not in org's allowed models with pytest.raises(ProxyException) as exc_info: @@ -6928,7 +7292,10 @@ async def test_update_team_org_scoped_models_not_in_org_models(): # Verify exception details assert exc_info.value.code == "400" - assert "claude-3-opus" in str(exc_info.value.message) or "organization" in str(exc_info.value.message).lower() + assert ( + "claude-3-opus" in str(exc_info.value.message) + or "organization" in str(exc_info.value.message).lower() + ) @pytest.mark.asyncio @@ -6981,7 +7348,9 @@ async def test_update_team_org_scoped_models_with_all_proxy_models( patch("litellm.proxy.proxy_server.prisma_client") as mock_prisma, patch("litellm.proxy.proxy_server.user_api_key_cache") as mock_cache, patch("litellm.proxy.proxy_server.litellm_proxy_admin_name", "admin"), - patch("litellm.proxy.proxy_server.create_audit_log_for_update", new=AsyncMock()) as mock_audit, + patch( + "litellm.proxy.proxy_server.create_audit_log_for_update", new=AsyncMock() + ) as mock_audit, patch( "litellm.proxy.management_endpoints.team_endpoints.get_org_object", new=AsyncMock(return_value=mock_org), @@ -6997,11 +7366,17 @@ async def test_update_team_org_scoped_models_with_all_proxy_models( "team_id": "org-team-all-proxy-models-123", "organization_id": "test-org-all-proxy-models", "models": ["gpt-4"], - "members_with_roles": [{"user_id": "org-admin-all-proxy-models-test", "role": "admin"}], + "members_with_roles": [ + {"user_id": "org-admin-all-proxy-models-test", "role": "admin"} + ], } - mock_prisma.db.litellm_teamtable.find_unique = AsyncMock(return_value=mock_existing_team) + mock_prisma.db.litellm_teamtable.find_unique = AsyncMock( + return_value=mock_existing_team + ) mock_prisma.jsonify_team_object = lambda db_data: db_data - mock_cache.async_set_cache = AsyncMock() # Mock cache set for _cache_team_object + mock_cache.async_set_cache = ( + AsyncMock() + ) # Mock cache set for _cache_team_object # Mock team update mock_updated_team = MagicMock() @@ -7022,7 +7397,9 @@ async def test_update_team_org_scoped_models_with_all_proxy_models( "gpt-4o-mini-test", ], } - mock_prisma.db.litellm_teamtable.update = AsyncMock(return_value=mock_updated_team) + mock_prisma.db.litellm_teamtable.update = AsyncMock( + return_value=mock_updated_team + ) # Should NOT raise an exception - 'all-proxy-models' allows all models result = await update_team( @@ -7081,7 +7458,9 @@ async def test_update_team_tpm_limit_not_gated_by_user_limit( patch("litellm.proxy.proxy_server.prisma_client") as mock_prisma, patch("litellm.proxy.proxy_server.user_api_key_cache") as mock_cache, patch("litellm.proxy.proxy_server.litellm_proxy_admin_name", "admin"), - patch("litellm.proxy.proxy_server.create_audit_log_for_update", new=AsyncMock()), + patch( + "litellm.proxy.proxy_server.create_audit_log_for_update", new=AsyncMock() + ), ): # Mock existing standalone team mock_existing_team = MagicMock() @@ -7095,7 +7474,9 @@ async def test_update_team_tpm_limit_not_gated_by_user_limit( "tpm_limit": 500, "members_with_roles": [{"user_id": "tpm-limit-user", "role": "admin"}], } - mock_prisma.db.litellm_teamtable.find_unique = AsyncMock(return_value=mock_existing_team) + mock_prisma.db.litellm_teamtable.find_unique = AsyncMock( + return_value=mock_existing_team + ) mock_prisma.jsonify_team_object = lambda db_data: db_data mock_cache.async_get_cache = AsyncMock(return_value=None) mock_cache.async_set_cache = AsyncMock() @@ -7109,7 +7490,9 @@ async def test_update_team_tpm_limit_not_gated_by_user_limit( "organization_id": None, "tpm_limit": 5000, } - mock_prisma.db.litellm_teamtable.update = AsyncMock(return_value=mock_updated_team) + mock_prisma.db.litellm_teamtable.update = AsyncMock( + return_value=mock_updated_team + ) result = await update_team( data=update_request, @@ -7158,7 +7541,9 @@ async def test_update_team_rpm_limit_not_gated_by_user_limit( patch("litellm.proxy.proxy_server.prisma_client") as mock_prisma, patch("litellm.proxy.proxy_server.user_api_key_cache") as mock_cache, patch("litellm.proxy.proxy_server.litellm_proxy_admin_name", "admin"), - patch("litellm.proxy.proxy_server.create_audit_log_for_update", new=AsyncMock()), + patch( + "litellm.proxy.proxy_server.create_audit_log_for_update", new=AsyncMock() + ), ): # Mock existing standalone team mock_existing_team = MagicMock() @@ -7172,7 +7557,9 @@ async def test_update_team_rpm_limit_not_gated_by_user_limit( "rpm_limit": 50, "members_with_roles": [{"user_id": "rpm-limit-user", "role": "admin"}], } - mock_prisma.db.litellm_teamtable.find_unique = AsyncMock(return_value=mock_existing_team) + mock_prisma.db.litellm_teamtable.find_unique = AsyncMock( + return_value=mock_existing_team + ) mock_prisma.jsonify_team_object = lambda db_data: db_data mock_cache.async_get_cache = AsyncMock(return_value=None) mock_cache.async_set_cache = AsyncMock() @@ -7186,7 +7573,9 @@ async def test_update_team_rpm_limit_not_gated_by_user_limit( "organization_id": None, "rpm_limit": 500, } - mock_prisma.db.litellm_teamtable.update = AsyncMock(return_value=mock_updated_team) + mock_prisma.db.litellm_teamtable.update = AsyncMock( + return_value=mock_updated_team + ) result = await update_team( data=update_request, @@ -7445,7 +7834,9 @@ async def test_new_team_org_scoped_tpm_rpm_bypasses_user_limit(): patch("litellm.proxy.proxy_server.user_api_key_cache") as mock_cache, patch("litellm.proxy.proxy_server.litellm_proxy_admin_name", "admin"), patch("litellm.proxy.proxy_server._license_check") as mock_license, - patch("litellm.proxy.proxy_server.create_audit_log_for_update", new=AsyncMock()), + patch( + "litellm.proxy.proxy_server.create_audit_log_for_update", new=AsyncMock() + ), patch( "litellm.proxy.management_endpoints.team_endpoints.get_org_object", new=AsyncMock(return_value=mock_org), @@ -7476,9 +7867,13 @@ async def test_new_team_org_scoped_tpm_rpm_bypasses_user_limit(): "metadata": None, "members_with_roles": [], } - mock_prisma.db.litellm_teamtable.create = AsyncMock(return_value=mock_created_team) + mock_prisma.db.litellm_teamtable.create = AsyncMock( + return_value=mock_created_team + ) _wire_team_create_tx(mock_prisma) - mock_prisma.db.litellm_teamtable.update = AsyncMock(return_value=mock_created_team) + mock_prisma.db.litellm_teamtable.update = AsyncMock( + return_value=mock_created_team + ) mock_prisma.jsonify_team_object = MagicMock(side_effect=lambda db_data: db_data) # Should succeed - bypasses user limits since org-scoped @@ -7559,9 +7954,13 @@ async def test_update_team_org_scoped_tpm_exceeds_org_limit(): "team_id": "org-team-update-tpm-123", "organization_id": "test-org-update-tpm", "tpm_limit": 5000, - "members_with_roles": [{"user_id": "org-admin-update-tpm-test", "role": "admin"}], + "members_with_roles": [ + {"user_id": "org-admin-update-tpm-test", "role": "admin"} + ], } - mock_prisma.db.litellm_teamtable.find_unique = AsyncMock(return_value=mock_existing_team) + mock_prisma.db.litellm_teamtable.find_unique = AsyncMock( + return_value=mock_existing_team + ) # Should raise ProxyException because TPM exceeds org limit with pytest.raises(ProxyException) as exc_info: @@ -7643,9 +8042,13 @@ async def test_update_team_org_scoped_rpm_exceeds_org_limit(): "team_id": "org-team-update-rpm-123", "organization_id": "test-org-update-rpm", "rpm_limit": 500, - "members_with_roles": [{"user_id": "org-admin-update-rpm-test", "role": "admin"}], + "members_with_roles": [ + {"user_id": "org-admin-update-rpm-test", "role": "admin"} + ], } - mock_prisma.db.litellm_teamtable.find_unique = AsyncMock(return_value=mock_existing_team) + mock_prisma.db.litellm_teamtable.find_unique = AsyncMock( + return_value=mock_existing_team + ) # Should raise ProxyException because RPM exceeds org limit with pytest.raises(ProxyException) as exc_info: @@ -7736,9 +8139,13 @@ async def test_update_team_org_scoped_tpm_rpm_bypasses_user_limit( "organization_id": "test-org-update-bypass", "tpm_limit": 5000, "rpm_limit": 500, - "members_with_roles": [{"user_id": "org-admin-update-bypass-test", "role": "admin"}], + "members_with_roles": [ + {"user_id": "org-admin-update-bypass-test", "role": "admin"} + ], } - mock_prisma.db.litellm_teamtable.find_unique = AsyncMock(return_value=mock_existing_team) + mock_prisma.db.litellm_teamtable.find_unique = AsyncMock( + return_value=mock_existing_team + ) mock_cache.async_set_cache = AsyncMock() mock_logging.internal_usage_cache.dual_cache.async_delete_cache = AsyncMock() @@ -7754,7 +8161,9 @@ async def test_update_team_org_scoped_tpm_rpm_bypasses_user_limit( "tpm_limit": 10000, "rpm_limit": 1000, } - mock_prisma.db.litellm_teamtable.update = AsyncMock(return_value=mock_updated_team) + mock_prisma.db.litellm_teamtable.update = AsyncMock( + return_value=mock_updated_team + ) mock_prisma.jsonify_team_object = MagicMock(side_effect=lambda db_data: db_data) # Should succeed - bypasses user limits since org-scoped @@ -7842,7 +8251,9 @@ async def test_update_team_guardrails_with_org_id( patch("litellm.proxy.proxy_server.prisma_client") as mock_prisma, patch("litellm.proxy.proxy_server.user_api_key_cache") as mock_cache, patch("litellm.proxy.proxy_server.litellm_proxy_admin_name", "admin"), - patch("litellm.proxy.proxy_server.create_audit_log_for_update", new=AsyncMock()), + patch( + "litellm.proxy.proxy_server.create_audit_log_for_update", new=AsyncMock() + ), patch( "litellm.proxy.proxy_server.premium_user", True, # Required for guardrails feature @@ -7867,14 +8278,20 @@ async def test_update_team_guardrails_with_org_id( "max_budget": None, "tpm_limit": None, "rpm_limit": None, - "members_with_roles": [{"user_id": "org-admin-guardrails-test", "role": "admin"}], + "members_with_roles": [ + {"user_id": "org-admin-guardrails-test", "role": "admin"} + ], } - mock_prisma.db.litellm_teamtable.find_unique = AsyncMock(return_value=mock_existing_team) + mock_prisma.db.litellm_teamtable.find_unique = AsyncMock( + return_value=mock_existing_team + ) mock_cache.async_set_cache = AsyncMock() # Mock organization fetch - this is where the bug occurred # The fix ensures 'teams: True' is in the include clause - mock_prisma.db.litellm_organizationtable.find_unique = AsyncMock(return_value=mock_org) + mock_prisma.db.litellm_organizationtable.find_unique = AsyncMock( + return_value=mock_org + ) # Destination-org guard in update_team queries for the caller's # ORG_ADMIN membership on the destination org. Return a match so @@ -7882,14 +8299,18 @@ async def test_update_team_guardrails_with_org_id( mock_org_admin_membership = MagicMock() mock_org_admin_membership.user_id = "org-admin-guardrails-test" mock_org_admin_membership.organization_id = "test-org-guardrails" - mock_prisma.db.litellm_organizationmembership.find_many = AsyncMock(return_value=[mock_org_admin_membership]) + mock_prisma.db.litellm_organizationmembership.find_many = AsyncMock( + return_value=[mock_org_admin_membership] + ) # Mock team update mock_updated_team = MagicMock(spec=LiteLLM_TeamTable) mock_updated_team.team_id = "team-guardrails-123" mock_updated_team.object_permission_id = None mock_updated_team.organization_id = "test-org-guardrails" - mock_updated_team.metadata = {"guardrails": ["aporia-pre-call", "aporia-post-call"]} + mock_updated_team.metadata = { + "guardrails": ["aporia-pre-call", "aporia-post-call"] + } mock_updated_team.litellm_model_table = None mock_updated_team.access_group_ids = None mock_updated_team.model_dump.return_value = { @@ -7897,7 +8318,9 @@ async def test_update_team_guardrails_with_org_id( "organization_id": "test-org-guardrails", "metadata": {"guardrails": ["aporia-pre-call", "aporia-post-call"]}, } - mock_prisma.db.litellm_teamtable.update = AsyncMock(return_value=mock_updated_team) + mock_prisma.db.litellm_teamtable.update = AsyncMock( + return_value=mock_updated_team + ) mock_prisma.jsonify_team_object = MagicMock(side_effect=lambda db_data: db_data) # async_get_cache must be an AsyncMock so `await` in get_org_object works mock_cache.async_get_cache = AsyncMock(return_value=None) @@ -7927,7 +8350,11 @@ async def test_update_team_guardrails_with_org_id( assert mock_prisma.db.litellm_organizationtable.find_unique.call_count >= 1 # Get the first call (from fetch_and_validate_organization) - first_call_kwargs = mock_prisma.db.litellm_organizationtable.find_unique.call_args_list[0].kwargs + first_call_kwargs = ( + mock_prisma.db.litellm_organizationtable.find_unique.call_args_list[ + 0 + ].kwargs + ) # Verify that 'teams' is included in the fetch assert "include" in first_call_kwargs @@ -7978,7 +8405,9 @@ def test_transform_teams_to_deleted_records(): assert all("litellm_changed_by" in record for record in records) assert all(record["deleted_by"] == "user-123" for record in records) # UserAPIKeyAuth hashes the api_key, so we check against the hashed value - assert all(record["deleted_by_api_key"] == user_api_key_dict.api_key for record in records) + assert all( + record["deleted_by_api_key"] == user_api_key_dict.api_key for record in records + ) assert all(record["litellm_changed_by"] == "admin-user" for record in records) record1 = records[0] @@ -8123,7 +8552,9 @@ async def test_delete_team_persists_deleted_teams( mock_prisma_client.db.litellm_deletedteamtable.create_many = mock_create_many_teams mock_create_many_keys = AsyncMock() - mock_prisma_client.db.litellm_deletedverificationtoken.create_many = mock_create_many_keys + mock_prisma_client.db.litellm_deletedverificationtoken.create_many = ( + mock_create_many_keys + ) mock_find_many_keys = AsyncMock(return_value=[]) mock_prisma_client.db.litellm_verificationtoken.find_many = mock_find_many_keys @@ -8283,7 +8714,9 @@ async def test_delete_team_sweeps_references_outside_members_with_roles( ("team-doomed", "doomed-team"), ("team-kept", "kept-team"), ): - cached_obj = LiteLLM_TeamTableCachedObj(team_id=cached_team_id, team_alias=cached_alias) + cached_obj = LiteLLM_TeamTableCachedObj( + team_id=cached_team_id, team_alias=cached_alias + ) fresh_cache.set_cache(key=f"team_id:{cached_team_id}", value=cached_obj) fresh_cache.set_cache(key=f"team_alias:{cached_alias}", value=cached_obj) @@ -8548,11 +8981,7 @@ async def test_delete_validated_team_rows_deletes_only_the_keys_its_rostered_mem ) team_keys = tuple( LiteLLM_VerificationToken(token=token, team_id="team-doomed", user_id=user_id) - for token, user_id in ( - ("hashed-member", "member-1"), - ("hashed-service-account", None), - ("hashed-outsider", "admin-made"), - ) + for token, user_id in (("hashed-member", "member-1"), ("hashed-service-account", None), ("hashed-outsider", "admin-made")) ) mock_prisma_client = AsyncMock() mock_prisma_client.db.litellm_teammembership.delete_many = AsyncMock() @@ -8712,9 +9141,7 @@ async def test_delete_team_evicts_the_auth_cache_of_the_keys_it_deletes( _wire_team_delete_tx(mock_prisma_client) fresh_cache = UserApiKeyCache() - fresh_cache.set_cache( - key="hashed-doomed-key", value=UserAPIKeyAuth(token="hashed-doomed-key", team_id="team-doomed") - ) + fresh_cache.set_cache(key="hashed-doomed-key", value=UserAPIKeyAuth(token="hashed-doomed-key", team_id="team-doomed")) fresh_cache.set_cache(key="hashed-unrelated-key", value=UserAPIKeyAuth(token="hashed-unrelated-key")) monkeypatch.setattr("litellm.proxy.proxy_server.prisma_client", mock_prisma_client) @@ -9118,7 +9545,9 @@ async def test_team_member_delete_persists_deleted_keys(monkeypatch): mock_prisma_client.db.litellm_verificationtoken.delete_many = mock_delete_keys mock_create_many_keys = AsyncMock() - mock_prisma_client.db.litellm_deletedverificationtoken.create_many = mock_create_many_keys + mock_prisma_client.db.litellm_deletedverificationtoken.create_many = ( + mock_create_many_keys + ) _wire_member_delete_tx(mock_prisma_client) @@ -9129,11 +9558,7 @@ async def test_team_member_delete_persists_deleted_keys(monkeypatch): cache: Final = UserApiKeyCache() revoked_cache_keys: Final = ( - "team_id:team-1", - "team_alias:test-team", - "user-123", - "hashed-token-1", - "hashed-token-2", + "team_id:team-1", "team_alias:test-team", "user-123", "hashed-token-1", "hashed-token-2", team_membership_auth_cache_key(user_id="user-123", team_id="team-1"), team_membership_reservation_cache_key(user_id="user-123", team_id="team-1"), ) @@ -9434,7 +9859,9 @@ async def test_new_team_soft_budget_validation( patch("litellm.proxy.proxy_server.user_api_key_cache") as mock_cache, patch("litellm.proxy.proxy_server._license_check") as mock_license, patch("litellm.proxy.proxy_server.litellm_proxy_admin_name", "admin"), - patch("litellm.proxy.proxy_server.create_audit_log_for_update", new=AsyncMock()) as mock_audit, + patch( + "litellm.proxy.proxy_server.create_audit_log_for_update", new=AsyncMock() + ) as mock_audit, ): # Setup mocks mock_prisma.db.litellm_teamtable.count = AsyncMock(return_value=0) @@ -9468,13 +9895,19 @@ async def test_new_team_soft_budget_validation( "max_budget": expected_max_budget, "members_with_roles": [], } - mock_prisma.db.litellm_teamtable.create = AsyncMock(return_value=mock_created_team) + mock_prisma.db.litellm_teamtable.create = AsyncMock( + return_value=mock_created_team + ) _wire_team_create_tx(mock_prisma) - mock_prisma.db.litellm_teamtable.update = AsyncMock(return_value=mock_created_team) + mock_prisma.db.litellm_teamtable.update = AsyncMock( + return_value=mock_created_team + ) # Mock model table mock_prisma.db.litellm_modeltable = MagicMock() - mock_prisma.db.litellm_modeltable.create = AsyncMock(return_value=MagicMock(id="model123")) + mock_prisma.db.litellm_modeltable.create = AsyncMock( + return_value=MagicMock(id="model123") + ) # Mock user table operations mock_user = MagicMock() @@ -9497,7 +9930,9 @@ async def test_new_team_soft_budget_validation( "budget_id": None, } mock_prisma.db.litellm_teammembership = MagicMock() - mock_prisma.db.litellm_teammembership.upsert = AsyncMock(return_value=mock_membership) + mock_prisma.db.litellm_teammembership.upsert = AsyncMock( + return_value=mock_membership + ) if should_succeed: # Should NOT raise an exception @@ -9626,7 +10061,9 @@ async def test_update_team_soft_budget_validation( patch("litellm.proxy.proxy_server.prisma_client") as mock_prisma, patch("litellm.proxy.proxy_server.user_api_key_cache") as mock_cache, patch("litellm.proxy.proxy_server.litellm_proxy_admin_name", "admin"), - patch("litellm.proxy.proxy_server.create_audit_log_for_update", new=AsyncMock()) as mock_audit, + patch( + "litellm.proxy.proxy_server.create_audit_log_for_update", new=AsyncMock() + ) as mock_audit, ): # Mock existing team with existing budgets mock_existing_team = MagicMock() @@ -9640,7 +10077,9 @@ async def test_update_team_soft_budget_validation( "soft_budget": existing_soft_budget, "max_budget": existing_max_budget, } - mock_prisma.db.litellm_teamtable.find_unique = AsyncMock(return_value=mock_existing_team) + mock_prisma.db.litellm_teamtable.find_unique = AsyncMock( + return_value=mock_existing_team + ) # Mock user cache mock_user_obj = LiteLLM_UserTable( @@ -9650,8 +10089,14 @@ async def test_update_team_soft_budget_validation( mock_cache.async_get_cache = AsyncMock(return_value=mock_user_obj) # Mock updated team - preserve existing values if not being updated - final_soft_budget = update_soft_budget if update_soft_budget is not None else existing_soft_budget - final_max_budget = update_max_budget if update_max_budget is not None else existing_max_budget + final_soft_budget = ( + update_soft_budget + if update_soft_budget is not None + else existing_soft_budget + ) + final_max_budget = ( + update_max_budget if update_max_budget is not None else existing_max_budget + ) mock_updated_team = MagicMock() mock_updated_team.team_id = "test-team-123" @@ -9664,9 +10109,13 @@ async def test_update_team_soft_budget_validation( "soft_budget": final_soft_budget, "max_budget": final_max_budget, } - mock_prisma.db.litellm_teamtable.update = AsyncMock(return_value=mock_updated_team) + mock_prisma.db.litellm_teamtable.update = AsyncMock( + return_value=mock_updated_team + ) mock_prisma.jsonify_team_object = lambda db_data: db_data - mock_cache.async_set_cache = AsyncMock() # Mock cache set for _cache_team_object + mock_cache.async_set_cache = ( + AsyncMock() + ) # Mock cache set for _cache_team_object if should_succeed: # Should NOT raise an exception @@ -9712,7 +10161,9 @@ async def test_new_team_positive_budgets_accepted(): from litellm.proxy._types import NewTeamRequest # Should not raise any errors - request = NewTeamRequest(team_alias="test-team", max_budget=100.0, team_member_budget=50.0) + request = NewTeamRequest( + team_alias="test-team", max_budget=100.0, team_member_budget=50.0 + ) assert request.max_budget == 100.0 assert request.team_member_budget == 50.0 @@ -9730,13 +10181,15 @@ async def test_new_team_with_router_settings(mock_db_client, mock_admin_auth): mock_db_client.get_data = AsyncMock(return_value=None) mock_db_client.update_data = AsyncMock(return_value=MagicMock()) mock_db_client.db = MagicMock() - mock_db_client.db.litellm_proxymodeltable.find_many = AsyncMock( - return_value=[SimpleNamespace(model_id="weighted-id", model_name="group", model_info={})] - ) + mock_db_client.db.litellm_proxymodeltable.find_many = AsyncMock(return_value=[ + SimpleNamespace(model_id="weighted-id", model_name="group", model_info={}) + ]) # Mock model table creation mock_db_client.db.litellm_modeltable = MagicMock() - mock_db_client.db.litellm_modeltable.create = AsyncMock(return_value=MagicMock(id="model123")) + mock_db_client.db.litellm_modeltable.create = AsyncMock( + return_value=MagicMock(id="model123") + ) # Capture team table creation team_create_result = MagicMock( @@ -9751,7 +10204,9 @@ async def test_new_team_with_router_settings(mock_db_client, mock_admin_auth): mock_db_client.db.litellm_teamtable.create = mock_team_create _wire_team_create_tx(mock_db_client) mock_db_client.db.litellm_teamtable.count = mock_team_count - mock_db_client.db.litellm_teamtable.update = AsyncMock(return_value=team_create_result) + mock_db_client.db.litellm_teamtable.update = AsyncMock( + return_value=team_create_result + ) # Mock user table mock_db_client.db.litellm_usertable = MagicMock() @@ -9820,7 +10275,9 @@ async def test_get_team_daily_activity_member_with_permission_sees_all_spend( # Create a non-admin user user_id = "test_user_with_perm_123" team_id = "test_team_789" - user_api_key_dict = UserAPIKeyAuth(user_id=user_id, user_role=LitellmUserRoles.INTERNAL_USER) + user_api_key_dict = UserAPIKeyAuth( + user_id=user_id, user_role=LitellmUserRoles.INTERNAL_USER + ) # Mock user info mock_user_info = LiteLLM_UserTable( @@ -9905,7 +10362,9 @@ async def test_get_team_daily_activity_member_without_permission_filters_by_keys # Create a non-admin user user_id = "test_user_no_perm_123" team_id = "test_team_789" - user_api_key_dict = UserAPIKeyAuth(user_id=user_id, user_role=LitellmUserRoles.INTERNAL_USER) + user_api_key_dict = UserAPIKeyAuth( + user_id=user_id, user_role=LitellmUserRoles.INTERNAL_USER + ) # Mock user info mock_user_info = LiteLLM_UserTable( @@ -9939,7 +10398,9 @@ async def test_get_team_daily_activity_member_without_permission_filters_by_keys # Setup mocks mock_db_client.db.litellm_teamtable.find_many = AsyncMock(return_value=[mock_team]) - mock_db_client.db.litellm_verificationtoken.find_many = AsyncMock(return_value=[user_api_key_1, user_api_key_2]) + mock_db_client.db.litellm_verificationtoken.find_many = AsyncMock( + return_value=[user_api_key_1, user_api_key_2] + ) # Mock get_user_object with patch( @@ -9993,9 +10454,9 @@ async def test_update_team_with_router_settings( # Configure mocked prisma client mock_db_client.jsonify_team_object = lambda db_data: db_data mock_db_client.db = MagicMock() - mock_db_client.db.litellm_proxymodeltable.find_many = AsyncMock( - return_value=[SimpleNamespace(model_id="weighted-id", model_name="group", model_info={})] - ) + mock_db_client.db.litellm_proxymodeltable.find_many = AsyncMock(return_value=[ + SimpleNamespace(model_id="weighted-id", model_name="group", model_info={}) + ]) # Mock existing team row existing_team_mock = MagicMock() @@ -10085,7 +10546,9 @@ async def test_get_team_daily_activity_non_admin_filters_by_user_api_keys( # Create a non-admin user user_id = "test_user_123" team_id = "test_team_456" - user_api_key_dict = UserAPIKeyAuth(user_id=user_id, user_role=LitellmUserRoles.INTERNAL_USER) + user_api_key_dict = UserAPIKeyAuth( + user_id=user_id, user_role=LitellmUserRoles.INTERNAL_USER + ) # Mock user info mock_user_info = LiteLLM_UserTable( @@ -10117,7 +10580,9 @@ async def test_get_team_daily_activity_non_admin_filters_by_user_api_keys( # Setup mocks mock_db_client.db.litellm_teamtable.find_many = AsyncMock(return_value=[mock_team]) - mock_db_client.db.litellm_verificationtoken.find_many = AsyncMock(return_value=[user_api_key_1, user_api_key_2]) + mock_db_client.db.litellm_verificationtoken.find_many = AsyncMock( + return_value=[user_api_key_1, user_api_key_2] + ) # Mock get_user_object with patch( @@ -10154,7 +10619,9 @@ async def test_get_team_daily_activity_non_admin_filters_by_user_api_keys( # Verify user's API keys were fetched mock_db_client.db.litellm_verificationtoken.find_many.assert_called_once() - api_key_call_kwargs = mock_db_client.db.litellm_verificationtoken.find_many.call_args[1] + api_key_call_kwargs = ( + mock_db_client.db.litellm_verificationtoken.find_many.call_args[1] + ) assert api_key_call_kwargs["where"] == {"user_id": user_id} @@ -10171,7 +10638,9 @@ async def test_get_team_daily_activity_team_admin_sees_all_spend(mock_db_client) # Create a team admin user user_id = "test_admin_123" team_id = "test_team_456" - user_api_key_dict = UserAPIKeyAuth(user_id=user_id, user_role=LitellmUserRoles.INTERNAL_USER) + user_api_key_dict = UserAPIKeyAuth( + user_id=user_id, user_role=LitellmUserRoles.INTERNAL_USER + ) # Mock user info mock_user_info = LiteLLM_UserTable( @@ -10296,7 +10765,9 @@ async def test_validate_and_populate_member_user_info_only_email_provided(): mock_user_find_first.user_email = "test@example.com" # Mock find_first to return the user - mock_prisma_client.db.litellm_usertable.find_first = AsyncMock(return_value=mock_user_find_first) + mock_prisma_client.db.litellm_usertable.find_first = AsyncMock( + return_value=mock_user_find_first + ) # Mock get_data to return single user (no duplicates) mock_prisma_client.get_data = AsyncMock(return_value=[mock_user_find_first]) @@ -10352,7 +10823,9 @@ async def test_validate_and_populate_member_user_info_only_user_id_not_found(): assert result.role == "user" # Verify find_unique was called with correct parameters - mock_prisma_client.db.litellm_usertable.find_unique.assert_called_once_with(where={"user_id": "nonexistent-user"}) + mock_prisma_client.db.litellm_usertable.find_unique.assert_called_once_with( + where={"user_id": "nonexistent-user"} + ) @pytest.mark.asyncio @@ -10448,7 +10921,9 @@ async def test_list_team_v1_batches_key_queries(): return [key3] return [key1, key2, key3] - mock_prisma_client.db.litellm_verificationtoken.find_many = AsyncMock(side_effect=filtered_find_many) + mock_prisma_client.db.litellm_verificationtoken.find_many = AsyncMock( + side_effect=filtered_find_many + ) result = await list_team( http_request=mock_request, @@ -10838,7 +11313,9 @@ class TestBatchResolveAccessGroupResources: fake_row.access_agent_ids = ["agent-1", "agent-2"] fake_prisma = MagicMock() - fake_prisma.db.litellm_accessgrouptable.find_many = AsyncMock(return_value=[fake_row]) + fake_prisma.db.litellm_accessgrouptable.find_many = AsyncMock( + return_value=[fake_row] + ) with patch("litellm.proxy.proxy_server.prisma_client", fake_prisma): result = await _batch_resolve_access_group_resources(["ag-1"]) @@ -10867,7 +11344,9 @@ class TestBatchResolveAccessGroupResources: row2.access_agent_ids = ["agent-2"] fake_prisma = MagicMock() - fake_prisma.db.litellm_accessgrouptable.find_many = AsyncMock(return_value=[row1, row2]) + fake_prisma.db.litellm_accessgrouptable.find_many = AsyncMock( + return_value=[row1, row2] + ) with patch("litellm.proxy.proxy_server.prisma_client", fake_prisma): result = await _batch_resolve_access_group_resources(["ag-1", "ag-2"]) @@ -10889,7 +11368,9 @@ class TestBatchResolveAccessGroupResources: row1.access_agent_ids = [] fake_prisma = MagicMock() - fake_prisma.db.litellm_accessgrouptable.find_many = AsyncMock(return_value=[row1]) + fake_prisma.db.litellm_accessgrouptable.find_many = AsyncMock( + return_value=[row1] + ) with patch("litellm.proxy.proxy_server.prisma_client", fake_prisma): result = await _batch_resolve_access_group_resources(["ag-1", "ag-missing"]) @@ -10927,7 +11408,9 @@ class TestBatchResolveAccessGroupResources: fake_prisma.db.litellm_accessgrouptable.find_many = fake_find_many with patch("litellm.proxy.proxy_server.prisma_client", fake_prisma): - result = await _batch_resolve_access_group_resources(["ag-1", "ag-1", "ag-1"]) + result = await _batch_resolve_access_group_resources( + ["ag-1", "ag-1", "ag-1"] + ) # Should have been called with deduplicated list call_args = fake_find_many.call_args @@ -10966,7 +11449,9 @@ class TestResolveTeamAccessGroupResources: row2.access_skill_names = ["shared-plugin"] fake_prisma = MagicMock() - fake_prisma.db.litellm_accessgrouptable.find_many = AsyncMock(return_value=[row1, row2]) + fake_prisma.db.litellm_accessgrouptable.find_many = AsyncMock( + return_value=[row1, row2] + ) team_info = TeamInfoResponseObjectTeamTable( team_id="team-1", access_group_ids=["ag-1", "ag-2", "ag-1", "ag-missing"] @@ -11070,7 +11555,9 @@ async def test_update_team_rejects_unauthorized_caller(): ], "organization_id": "org-456", } - mock_prisma_client.db.litellm_teamtable.find_unique = AsyncMock(return_value=mock_existing_team) + mock_prisma_client.db.litellm_teamtable.find_unique = AsyncMock( + return_value=mock_existing_team + ) update_request = UpdateTeamRequest( team_id="team-123", @@ -11152,7 +11639,9 @@ async def test_team_member_me_returns_caller_membership(mock_db_client): team_id = "team-me-1" caller_id = "alice@example.com" other_id = "bob@example.com" - caller_auth = UserAPIKeyAuth(user_role=LitellmUserRoles.INTERNAL_USER, user_id=caller_id) + caller_auth = UserAPIKeyAuth( + user_role=LitellmUserRoles.INTERNAL_USER, user_id=caller_id + ) team = _build_team_for_me( team_id, @@ -11164,7 +11653,9 @@ async def test_team_member_me_returns_caller_membership(mock_db_client): membership = _build_membership_for_me(caller_id, team_id, spend=42.0) user = LiteLLM_UserTable(user_id=caller_id, user_email=caller_id, max_budget=None) - p_team, p_membership, p_user = _patch_member_me_helpers(team=team, membership=membership, user=user) + p_team, p_membership, p_user = _patch_member_me_helpers( + team=team, membership=membership, user=user + ) with p_team, p_membership as mock_get_membership, p_user: response = await team_member_me( http_request=MagicMock(spec=Request), @@ -11182,7 +11673,9 @@ async def test_team_member_me_returns_caller_membership(mock_db_client): # budget_reset_at must survive end-to-end — proves the BudgetTableFull # variant of the Union is selected (created_at is present), not the base # LiteLLM_BudgetTable which would silently strip this field. - assert response.litellm_budget_table.budget_reset_at == datetime(2026, 5, 1, tzinfo=timezone.utc) + assert response.litellm_budget_table.budget_reset_at == datetime( + 2026, 5, 1, tzinfo=timezone.utc + ) # Membership lookup must scope to caller_id, not just team_id — proves the # endpoint cannot return another member's row. @@ -11217,9 +11710,13 @@ async def test_team_member_me_matches_email_only_member(mock_db_client): [{"user_id": None, "user_email": caller_email, "role": "user"}], ) membership = _build_membership_for_me(caller_id, team_id, spend=7.0) - user = LiteLLM_UserTable(user_id=caller_id, user_email=caller_email, max_budget=None) + user = LiteLLM_UserTable( + user_id=caller_id, user_email=caller_email, max_budget=None + ) - p_team, p_membership, p_user = _patch_member_me_helpers(team=team, membership=membership, user=user) + p_team, p_membership, p_user = _patch_member_me_helpers( + team=team, membership=membership, user=user + ) with p_team, p_membership, p_user: response = await team_member_me( http_request=MagicMock(spec=Request), @@ -11241,7 +11738,9 @@ async def test_team_member_me_returns_404_for_non_member(mock_db_client): team_id = "team-me-2" caller_id = "outsider@example.com" - caller_auth = UserAPIKeyAuth(user_role=LitellmUserRoles.INTERNAL_USER, user_id=caller_id) + caller_auth = UserAPIKeyAuth( + user_role=LitellmUserRoles.INTERNAL_USER, user_id=caller_id + ) team = _build_team_for_me( team_id, @@ -11260,7 +11759,9 @@ async def test_team_member_me_returns_404_for_non_member(mock_db_client): @pytest.mark.asyncio -async def test_team_member_me_returns_404_for_proxy_admin_not_in_team(mock_db_client, mock_admin_auth): +async def test_team_member_me_returns_404_for_proxy_admin_not_in_team( + mock_db_client, mock_admin_auth +): """ Proxy admins get 404 if they are not actually a member of the team. `me` only resolves for actual team members; admins use /team/info instead. @@ -11300,7 +11801,9 @@ async def test_team_member_me_returns_defaults_when_no_membership_row(mock_db_cl team_id = "team-me-4" caller_id = "newmember@example.com" - caller_auth = UserAPIKeyAuth(user_role=LitellmUserRoles.INTERNAL_USER, user_id=caller_id) + caller_auth = UserAPIKeyAuth( + user_role=LitellmUserRoles.INTERNAL_USER, user_id=caller_id + ) team = _build_team_for_me( team_id, @@ -11346,12 +11849,18 @@ async def test_team_member_me_returns_404_for_unknown_team(mock_db_client): from litellm.proxy.management_endpoints.team_endpoints import team_member_me - caller_auth = UserAPIKeyAuth(user_role=LitellmUserRoles.INTERNAL_USER, user_id="alice@example.com") + caller_auth = UserAPIKeyAuth( + user_role=LitellmUserRoles.INTERNAL_USER, user_id="alice@example.com" + ) # get_team_object raises 404 directly when the team is missing. with patch( "litellm.proxy.management_endpoints.team_endpoints.get_team_object", - AsyncMock(side_effect=HTTPException(status_code=404, detail={"error": "Team doesn't exist in db."})), + AsyncMock( + side_effect=HTTPException( + status_code=404, detail={"error": "Team doesn't exist in db."} + ) + ), ): with pytest.raises(HTTPException) as exc_info: await team_member_me( @@ -11363,7 +11872,9 @@ async def test_team_member_me_returns_404_for_unknown_team(mock_db_client): @pytest.mark.asyncio -async def test_new_team_encrypts_callback_vars(mock_db_client, mock_admin_auth, monkeypatch): +async def test_new_team_encrypts_callback_vars( + mock_db_client, mock_admin_auth, monkeypatch +): """/team/new must encrypt callback_vars values before they reach the DB.""" from fastapi import Request @@ -11378,7 +11889,9 @@ async def test_new_team_encrypts_callback_vars(mock_db_client, mock_admin_auth, # actual JSON serialization production uses (catches non-serializable # ciphertext, missing fields, etc.). mock_db_client.jsonify_object = PrismaClient.jsonify_object.__get__(mock_db_client) - mock_db_client.jsonify_team_object = PrismaClient.jsonify_team_object.__get__(mock_db_client) + mock_db_client.jsonify_team_object = PrismaClient.jsonify_team_object.__get__( + mock_db_client + ) mock_db_client.get_data = AsyncMock(return_value=None) mock_db_client.db = MagicMock() mock_db_client.db.litellm_teamtable = MagicMock() @@ -11388,7 +11901,9 @@ async def test_new_team_encrypts_callback_vars(mock_db_client, mock_admin_auth, mock_db_client.db.litellm_teamtable.create = mock_team_create _wire_team_create_tx(mock_db_client) mock_db_client.db.litellm_teamtable.count = AsyncMock(return_value=0) - mock_db_client.db.litellm_teamtable.update = AsyncMock(return_value=team_create_result) + mock_db_client.db.litellm_teamtable.update = AsyncMock( + return_value=team_create_result + ) mock_db_client.db.litellm_usertable = MagicMock() mock_db_client.db.litellm_usertable.update = AsyncMock(return_value=MagicMock()) @@ -11425,7 +11940,9 @@ async def test_new_team_encrypts_callback_vars(mock_db_client, mock_admin_auth, def _non_admin_auth(): - return UserAPIKeyAuth(user_id="u-team-admin", user_role=LitellmUserRoles.INTERNAL_USER) + return UserAPIKeyAuth( + user_id="u-team-admin", user_role=LitellmUserRoles.INTERNAL_USER + ) def test_check_passthrough_routes_caller_permission_team(): @@ -11441,8 +11958,12 @@ def test_check_passthrough_routes_caller_permission_team(): NewTeamRequest(allowed_passthrough_routes=["/foo/*"]), admin, entity="team" ) - check_passthrough_routes_caller_permission(NewTeamRequest(), non_admin, entity="team") - check_passthrough_routes_caller_permission(NewTeamRequest(allowed_passthrough_routes=[]), non_admin, entity="team") + check_passthrough_routes_caller_permission( + NewTeamRequest(), non_admin, entity="team" + ) + check_passthrough_routes_caller_permission( + NewTeamRequest(allowed_passthrough_routes=[]), non_admin, entity="team" + ) with pytest.raises(HTTPException) as exc: check_passthrough_routes_caller_permission( @@ -11479,7 +12000,9 @@ async def test_new_team_blocks_non_admin_passthrough_routes(mock_db_client): ): with pytest.raises(ProxyException) as exc: await new_team( - data=NewTeamRequest(team_alias="t", allowed_passthrough_routes=["/admin/*"]), + data=NewTeamRequest( + team_alias="t", allowed_passthrough_routes=["/admin/*"] + ), http_request=MagicMock(spec=Request), user_api_key_dict=_non_admin_auth(), ) @@ -11503,7 +12026,9 @@ async def test_update_team_blocks_non_admin_passthrough_routes(mock_db_client): with _org_admins(("u-team-admin", "org-1")): with pytest.raises(ProxyException) as exc: await update_team( - data=UpdateTeamRequest(team_id="t1", allowed_passthrough_routes=["/admin/*"]), + data=UpdateTeamRequest( + team_id="t1", allowed_passthrough_routes=["/admin/*"] + ), http_request=MagicMock(spec=Request), user_api_key_dict=_non_admin_auth(), ) @@ -11817,12 +12342,16 @@ async def test_team_info_forwards_key_limit_to_get_data(): from litellm.proxy.management_endpoints import team_endpoints mock_prisma = MagicMock() - mock_prisma.db.litellm_teamtable.find_unique = AsyncMock(return_value=LiteLLM_TeamTable(team_id="team-1")) + mock_prisma.db.litellm_teamtable.find_unique = AsyncMock( + return_value=LiteLLM_TeamTable(team_id="team-1") + ) mock_prisma.get_data = AsyncMock(return_value=[]) with ( patch("litellm.proxy.proxy_server.prisma_client", mock_prisma), - patch.object(team_endpoints, "get_all_team_memberships", AsyncMock(return_value=[])), + patch.object( + team_endpoints, "get_all_team_memberships", AsyncMock(return_value=[]) + ), ): await team_endpoints.team_info( http_request=MagicMock(spec=Request), @@ -11860,7 +12389,9 @@ async def test_team_info_returns_model_aliases(): with ( patch("litellm.proxy.proxy_server.prisma_client", mock_prisma), - patch.object(team_endpoints, "get_all_team_memberships", AsyncMock(return_value=[])), + patch.object( + team_endpoints, "get_all_team_memberships", AsyncMock(return_value=[]) + ), ): response = await team_endpoints.team_info( http_request=MagicMock(spec=Request), @@ -11939,8 +12470,12 @@ async def test_update_model_table_clears_aliases_with_empty_map(): """ mock_prisma = MagicMock() mock_prisma.db.litellm_modeltable.create = AsyncMock() - mock_prisma.db.litellm_modeltable.upsert = AsyncMock(return_value=MagicMock(id="model-123")) - user_api_key_dict = UserAPIKeyAuth(user_role=LitellmUserRoles.PROXY_ADMIN, user_id="admin") + mock_prisma.db.litellm_modeltable.upsert = AsyncMock( + return_value=MagicMock(id="model-123") + ) + user_api_key_dict = UserAPIKeyAuth( + user_role=LitellmUserRoles.PROXY_ADMIN, user_id="admin" + ) returned_model_id = await _update_model_table( data=UpdateTeamRequest(team_id="team-1", model_aliases={}), @@ -11988,7 +12523,9 @@ class TestEmitTeamMembersMetric: return LiteLLM_TeamTable( team_id="team-x", team_alias="X", - members_with_roles=[Member(user_id=f"u{i}", role="user") for i in range(member_count)], + members_with_roles=[ + Member(user_id=f"u{i}", role="user") for i in range(member_count) + ], ) def test_emits_with_team_when_logger_registered(self, restore_callbacks): @@ -12062,7 +12599,9 @@ async def test_new_team_rejects_reserved_ui_session_team_id(): await new_team( data=team_request, http_request=dummy_request, - user_api_key_dict=UserAPIKeyAuth(user_role=LitellmUserRoles.PROXY_ADMIN), + user_api_key_dict=UserAPIKeyAuth( + user_role=LitellmUserRoles.PROXY_ADMIN + ), ) assert exc_info.value.code == "400" @@ -12252,7 +12791,9 @@ _METADATA_MAPPING = [ _METADATA_MAPPING, ids=[row[0] for row in _METADATA_MAPPING], ) -async def test_post_vs_patch_metadata_write_mapping(label, existing_metadata, body, expected_post, expected_patch): +async def test_post_vs_patch_metadata_write_mapping( + label, existing_metadata, body, expected_post, expected_patch +): """Exhaustive map: POST replaces metadata wholesale, PATCH merges per RFC 7386.""" post_meta = await _written_metadata("post", existing_metadata, body) patch_meta = await _written_metadata("patch", existing_metadata, body) @@ -12444,7 +12985,9 @@ async def test_patch_team_not_found_returns_404(): # metadata present -> patch_team does its own existence check with pytest.raises(ProxyException) as exc: - await _drive_team_write("patch", raw_body={"metadata": {"cost_center": "1"}}, find_returns_none=True) + await _drive_team_write( + "patch", raw_body={"metadata": {"cost_center": "1"}}, find_returns_none=True + ) assert exc.value.code == "404" or exc.value.code == 404 # metadata absent -> existence check happens in the delegated update_team @@ -12461,7 +13004,9 @@ async def test_patch_enforces_team_access_via_delegation(): outsider = UserAPIKeyAuth(user_role=LitellmUserRoles.INTERNAL_USER, user_id="outsider") with pytest.raises(ProxyException) as exc: - await _drive_team_write("patch", raw_body={"tpm_limit": 5}, user=outsider) + await _drive_team_write( + "patch", raw_body={"tpm_limit": 5}, user=outsider + ) assert exc.value.code == "403" or exc.value.code == 403 @@ -12471,7 +13016,9 @@ async def test_patch_returns_full_team_object_not_wrapper(): {"team_id", "data"} envelope.""" from litellm.proxy._types import LiteLLM_TeamTable - result, _ = await _drive_team_write("patch", existing_metadata={"a": 1}, raw_body={"metadata": {"b": 2}}) + result, _ = await _drive_team_write( + "patch", existing_metadata={"a": 1}, raw_body={"metadata": {"b": 2}} + ) assert isinstance(result, LiteLLM_TeamTable) assert result.team_id == _PATCH_TEAM_ID @@ -12788,7 +13335,9 @@ def test_patch_body_reshaping_adds_no_keys_the_caller_did_not_send(body): @pytest.mark.asyncio async def test_patch_ignores_unknown_body_keys(): """Unknown keys were silently dropped by the previous construction; keep that.""" - _, update_mock = await _drive_team_write("patch", raw_body={"tpm_limit": 5, "not_a_team_field": "x"}) + _, update_mock = await _drive_team_write( + "patch", raw_body={"tpm_limit": 5, "not_a_team_field": "x"} + ) written = update_mock.call_args.kwargs["data"] assert written["tpm_limit"] == 5 @@ -14527,12 +15076,16 @@ class _FakeMirrorDb: if "array_append" in sql: self.transactions[-1].append("attach") - changed = [g for g in desired if g in self._access_groups and team_id not in self._team_ids(g)] + changed = [ + g for g in desired if g in self._access_groups and team_id not in self._team_ids(g) + ] for group_id in changed: self._team_ids(group_id).append(team_id) else: self.transactions[-1].append("detach") - changed = [g for g in self._access_groups if team_id in self._team_ids(g) and g not in desired] + changed = [ + g for g in self._access_groups if team_id in self._team_ids(g) and g not in desired + ] for group_id in changed: self._team_ids(group_id).remove(team_id) return [{"access_group_id": group_id} for group_id in changed] @@ -14782,9 +15335,7 @@ async def test_new_team_and_delete_team_both_drive_the_mirror( patch("litellm.proxy.proxy_server.prisma_client") as prisma, patch("litellm.proxy.proxy_server.litellm_proxy_admin_name", "admin"), patch("litellm.proxy.proxy_server.llm_router", None), - patch( - "litellm.proxy.management_endpoints.team_endpoints._persist_deleted_team_records", new_callable=AsyncMock - ), + patch("litellm.proxy.management_endpoints.team_endpoints._persist_deleted_team_records", new_callable=AsyncMock), patch( "litellm.proxy.management_endpoints.team_endpoints.sync_team_access_group_membership", new_callable=AsyncMock, @@ -15726,9 +16277,7 @@ async def test_team_info_reports_parent_organization_models_only_to_team_manager with ( patch("litellm.proxy.proxy_server.prisma_client", mock_prisma), # test-quality-ok: no seam on team_info - patch.object( - team_endpoints, "get_all_team_memberships", AsyncMock(return_value=[]) - ), # test-quality-ok: no seam on team_info + patch.object(team_endpoints, "get_all_team_memberships", AsyncMock(return_value=[])), # test-quality-ok: no seam on team_info _not_org_admin(), ): response = await team_endpoints.team_info( @@ -15968,10 +16517,7 @@ async def test_new_team_rejects_unenforceable_model_max_budget(mock_db_client, m mock_db_client.db.litellm_teamtable.create = AsyncMock() - with ( - patch("litellm.proxy.proxy_server.premium_user", True), - pytest.raises(ProxyException) as exc, - ): # test-quality-ok: proxy_server module global is the endpoint's only injection point + with patch("litellm.proxy.proxy_server.premium_user", True), pytest.raises(ProxyException) as exc: # test-quality-ok: proxy_server module global is the endpoint's only injection point await new_team( data=NewTeamRequest(team_alias="model-caps", model_max_budget={"gpt-4o": {"max_budget": 10.0}}), http_request=MagicMock(spec=Request), @@ -16026,18 +16572,10 @@ async def test_update_team_clearing_model_max_budget_writes_an_empty_mapping( from litellm.proxy.management_endpoints.team_endpoints import update_team with ( - patch( - "litellm.proxy.proxy_server.prisma_client" - ) as mock_prisma, # test-quality-ok: proxy_server module global is the endpoint's only injection point - patch( - "litellm.proxy.proxy_server.user_api_key_cache" - ) as mock_cache, # test-quality-ok: proxy_server module global is the endpoint's only injection point - patch( - "litellm.proxy.proxy_server.litellm_proxy_admin_name", "admin" - ), # test-quality-ok: proxy_server module global is the endpoint's only injection point - patch( - "litellm.proxy.proxy_server.premium_user", True - ), # test-quality-ok: proxy_server module global is the endpoint's only injection point + patch("litellm.proxy.proxy_server.prisma_client") as mock_prisma, # test-quality-ok: proxy_server module global is the endpoint's only injection point + patch("litellm.proxy.proxy_server.user_api_key_cache") as mock_cache, # test-quality-ok: proxy_server module global is the endpoint's only injection point + patch("litellm.proxy.proxy_server.litellm_proxy_admin_name", "admin"), # test-quality-ok: proxy_server module global is the endpoint's only injection point + patch("litellm.proxy.proxy_server.premium_user", True), # test-quality-ok: proxy_server module global is the endpoint's only injection point ): mock_prisma.db.litellm_teamtable.find_unique = AsyncMock( return_value=_existing_team_with_model_caps(_EXISTING_TEAM_MODEL_CAPS) @@ -16066,21 +16604,11 @@ async def test_update_team_model_max_budget_raise_blocked_for_team_admin(): from litellm.proxy.management_endpoints.team_endpoints import update_team with ( - patch( - "litellm.proxy.proxy_server.prisma_client" - ) as mock_prisma, # test-quality-ok: proxy_server module global is the endpoint's only injection point - patch( - "litellm.proxy.proxy_server.user_api_key_cache" - ) as mock_cache, # test-quality-ok: proxy_server module global is the endpoint's only injection point - patch( - "litellm.proxy.proxy_server.litellm_proxy_admin_name", "admin" - ), # test-quality-ok: proxy_server module global is the endpoint's only injection point - patch( - "litellm.proxy.proxy_server.premium_user", True - ), # test-quality-ok: proxy_server module global is the endpoint's only injection point - patch( - "litellm.proxy.proxy_server.create_audit_log_for_update", new=AsyncMock() - ), # test-quality-ok: stubs the audit write so the test observes only the team update result + patch("litellm.proxy.proxy_server.prisma_client") as mock_prisma, # test-quality-ok: proxy_server module global is the endpoint's only injection point + patch("litellm.proxy.proxy_server.user_api_key_cache") as mock_cache, # test-quality-ok: proxy_server module global is the endpoint's only injection point + patch("litellm.proxy.proxy_server.litellm_proxy_admin_name", "admin"), # test-quality-ok: proxy_server module global is the endpoint's only injection point + patch("litellm.proxy.proxy_server.premium_user", True), # test-quality-ok: proxy_server module global is the endpoint's only injection point + patch("litellm.proxy.proxy_server.create_audit_log_for_update", new=AsyncMock()), # test-quality-ok: stubs the audit write so the test observes only the team update result ): mock_prisma.db.litellm_teamtable.find_unique = AsyncMock( return_value=_existing_team_with_model_caps(_EXISTING_TEAM_MODEL_CAPS) @@ -16203,9 +16731,7 @@ async def test_update_team_configured_but_unsupported_field_does_not_open_editin with contextlib.ExitStack() as stack: prisma = _wire_update_team(stack, {}) stack.enter_context( - patch( - "litellm.proxy.proxy_server.general_settings", {"team_admin_editable_team_fields": ["team_alias"]} - ) # test-quality-ok: update_team reads general_settings as a proxy_server module global + patch("litellm.proxy.proxy_server.general_settings", {"team_admin_editable_team_fields": ["team_alias"]}) # test-quality-ok: update_team reads general_settings as a proxy_server module global ) with pytest.raises(ProxyException) as exc: await update_team( @@ -16349,9 +16875,7 @@ async def test_update_team_team_admin_resending_stored_member_defaults_is_not_an ) ) stack.enter_context( - patch( - "litellm.proxy.proxy_server.general_settings", {"team_admin_editable_team_fields": ["tpm_limit"]} - ) # test-quality-ok: update_team reads general_settings as a proxy_server module global + patch("litellm.proxy.proxy_server.general_settings", {"team_admin_editable_team_fields": ["tpm_limit"]}) # test-quality-ok: update_team reads general_settings as a proxy_server module global ) result = await update_team( data=UpdateTeamRequest( @@ -16381,9 +16905,7 @@ async def test_update_team_team_admin_changes_tpm_limit_once_a_proxy_admin_enabl with contextlib.ExitStack() as stack: prisma = _wire_update_team(stack, {}) stack.enter_context( - patch( - "litellm.proxy.proxy_server.general_settings", {"team_admin_editable_team_fields": ["tpm_limit"]} - ) # test-quality-ok: update_team reads general_settings as a proxy_server module global + patch("litellm.proxy.proxy_server.general_settings", {"team_admin_editable_team_fields": ["tpm_limit"]}) # test-quality-ok: update_team reads general_settings as a proxy_server module global ) await update_team( data=UpdateTeamRequest(team_id="test_team_id", tpm_limit=5000), @@ -16453,10 +16975,8 @@ async def test_update_team_holds_a_team_admin_to_the_org_tpm_limit(disable_audit ) async def org_lookup(**kwargs): - return ( - capped_org - if kwargs.get("include_budget_table") - else capped_org.model_copy(update={"litellm_budget_table": None}) + return capped_org if kwargs.get("include_budget_table") else capped_org.model_copy( + update={"litellm_budget_table": None} ) org_team = MagicMock() @@ -16920,9 +17440,7 @@ async def test_team_info_reports_what_the_caller_may_edit(caller, org_admin, ena with ( patch("litellm.proxy.proxy_server.prisma_client", mock_prisma), # test-quality-ok: no seam on team_info - patch.object( - team_endpoints, "get_all_team_memberships", AsyncMock(return_value=[]) - ), # test-quality-ok: no seam on team_info + patch.object(team_endpoints, "get_all_team_memberships", AsyncMock(return_value=[])), # test-quality-ok: no seam on team_info _org_admins(("admin-1", "org-1")) if org_admin else _not_org_admin(), _team_admin_may_edit(*enabled_fields), ): @@ -16993,9 +17511,7 @@ def test_member_budget_patch_stores_model_max_budget_as_json_and_clears_on_empty user_id="user-1", model_max_budget={"gpt-4o": {"budget_limit": 5, "time_period": "30d"}}, ) - assert member_budget_patch(request) == { - "model_max_budget": {"gpt-4o": {"max_budget": 5.0, "budget_duration": "30d"}} - } + assert member_budget_patch(request) == {"model_max_budget": {"gpt-4o": {"max_budget": 5.0, "budget_duration": "30d"}}} cleared: Final = TeamMemberUpdateRequest(team_id="team-1", user_id="user-1", model_max_budget={}) assert member_budget_patch(cleared) == {"model_max_budget": {}} diff --git a/tests/unit/proxy/management_helpers/test_management_helpers_utils.py b/tests/unit/proxy/management_helpers/test_management_helpers_utils.py index d16ec9921a2..3d13c73e98c 100644 --- a/tests/unit/proxy/management_helpers/test_management_helpers_utils.py +++ b/tests/unit/proxy/management_helpers/test_management_helpers_utils.py @@ -44,7 +44,9 @@ async def test_management_otel_span_redacts_mcp_global_env_var_secrets(monkeypat captured = {} class _FakeOtelLogger: - async def async_management_endpoint_success_hook(self, logging_payload, parent_otel_span): + async def async_management_endpoint_success_hook( + self, logging_payload, parent_otel_span + ): captured["response"] = logging_payload.response from litellm.proxy import proxy_server @@ -117,7 +119,9 @@ async def test_management_otel_span_redacts_nested_submission_env_var_secrets( captured = {} class _FakeOtelLogger: - async def async_management_endpoint_success_hook(self, logging_payload, parent_otel_span): + async def async_management_endpoint_success_hook( + self, logging_payload, parent_otel_span + ): captured["response"] = logging_payload.response from litellm.proxy import proxy_server @@ -137,7 +141,9 @@ async def test_management_otel_span_redacts_nested_submission_env_var_secrets( created_at=datetime.datetime.now(), updated_at=datetime.datetime.now(), ) - result = MCPSubmissionsSummary(total=1, pending_review=1, active=0, rejected=0, items=[server]) + result = MCPSubmissionsSummary( + total=1, pending_review=1, active=0, rejected=0, items=[server] + ) await mgmt_utils._emit_management_endpoint_otel_span( func=lambda: None, @@ -152,7 +158,11 @@ async def test_management_otel_span_redacts_nested_submission_env_var_secrets( assert secret not in str(captured["response"]) redacted_item = captured["response"]["items"][0] - redacted_env_vars = redacted_item["env_vars"] if isinstance(redacted_item, dict) else redacted_item.env_vars + redacted_env_vars = ( + redacted_item["env_vars"] + if isinstance(redacted_item, dict) + else redacted_item.env_vars + ) assert [entry["value"] for entry in redacted_env_vars] == [""] assert redacted_env_vars[0]["name"] == "DB_PASSWORD" # The endpoint's own return value is untouched for the admin UI. @@ -170,7 +180,9 @@ async def test_add_new_member_links_default_team_budget_id(): new_member = Member(user_id=test_user_id, role="user") - user_api_key_dict = UserAPIKeyAuth(user_id="admin_user", user_role=LitellmUserRoles.PROXY_ADMIN) + user_api_key_dict = UserAPIKeyAuth( + user_id="admin_user", user_role=LitellmUserRoles.PROXY_ADMIN + ) mock_prisma_client = AsyncMock() @@ -183,11 +195,15 @@ async def test_add_new_member_links_default_team_budget_id(): "user_role": "internal_user", } mock_prisma_client.db.litellm_usertable.upsert = AsyncMock(return_value=mock_user_response) - mock_prisma_client.db.litellm_usertable.find_unique = AsyncMock(return_value=mock_user_response) + mock_prisma_client.db.litellm_usertable.find_unique = AsyncMock( + return_value=mock_user_response + ) mock_default_budget_row = MagicMock() mock_default_budget_row.budget_id = test_default_budget_id - mock_prisma_client.db.litellm_budgettable.find_unique = AsyncMock(return_value=mock_default_budget_row) + mock_prisma_client.db.litellm_budgettable.find_unique = AsyncMock( + return_value=mock_default_budget_row + ) mock_prisma_client.db.litellm_budgettable.create = AsyncMock() # Mock the team membership creation @@ -198,7 +214,9 @@ async def test_add_new_member_links_default_team_budget_id(): "budget_id": test_default_budget_id, "litellm_budget_table": None, } - mock_prisma_client.db.litellm_teammembership.upsert = AsyncMock(return_value=mock_team_membership_response) + mock_prisma_client.db.litellm_teammembership.upsert = AsyncMock( + return_value=mock_team_membership_response + ) result_user, result_team_membership = await add_new_member( new_member=new_member, @@ -224,7 +242,9 @@ async def test_add_new_member_links_default_team_budget_id(): ) mock_prisma_client.db.litellm_budgettable.create.assert_not_called() - team_membership_call_args = mock_prisma_client.db.litellm_teammembership.upsert.call_args + team_membership_call_args = ( + mock_prisma_client.db.litellm_teammembership.upsert.call_args + ) create_data = team_membership_call_args.kwargs["data"]["create"] assert create_data["budget_id"] == test_default_budget_id @@ -294,7 +314,9 @@ async def test_add_new_member_no_budget_when_default_budget_row_is_missing(): from litellm.proxy._types import LitellmUserRoles new_member = Member(user_id="missing-default-user", role="user") - user_api_key_dict = UserAPIKeyAuth(user_id="admin_user", user_role=LitellmUserRoles.PROXY_ADMIN) + user_api_key_dict = UserAPIKeyAuth( + user_id="admin_user", user_role=LitellmUserRoles.PROXY_ADMIN + ) mock_prisma_client = AsyncMock() mock_user_response = MagicMock() @@ -305,7 +327,9 @@ async def test_add_new_member_no_budget_when_default_budget_row_is_missing(): "user_role": "internal_user", } mock_prisma_client.db.litellm_usertable.upsert = AsyncMock(return_value=mock_user_response) - mock_prisma_client.db.litellm_usertable.find_unique = AsyncMock(return_value=mock_user_response) + mock_prisma_client.db.litellm_usertable.find_unique = AsyncMock( + return_value=mock_user_response + ) mock_prisma_client.db.litellm_budgettable.find_unique = AsyncMock(return_value=None) mock_prisma_client.db.litellm_budgettable.create = AsyncMock() mock_membership = MagicMock() @@ -343,7 +367,9 @@ async def test_add_new_member_budget_duration_only_clones_default_max_budget(): from litellm.proxy._types import LitellmUserRoles new_member = Member(user_id="dur-clone-user", role="user") - user_api_key_dict = UserAPIKeyAuth(user_id="admin_user", user_role=LitellmUserRoles.PROXY_ADMIN) + user_api_key_dict = UserAPIKeyAuth( + user_id="admin_user", user_role=LitellmUserRoles.PROXY_ADMIN + ) mock_prisma_client = AsyncMock() mock_user_response = MagicMock() @@ -354,7 +380,9 @@ async def test_add_new_member_budget_duration_only_clones_default_max_budget(): "user_role": "internal_user", } mock_prisma_client.db.litellm_usertable.upsert = AsyncMock(return_value=mock_user_response) - mock_prisma_client.db.litellm_usertable.find_unique = AsyncMock(return_value=mock_user_response) + mock_prisma_client.db.litellm_usertable.find_unique = AsyncMock( + return_value=mock_user_response + ) mock_default_budget_row = MagicMock() mock_default_budget_row.model_dump.return_value = { "budget_id": "default-dc", @@ -367,10 +395,14 @@ async def test_add_new_member_budget_duration_only_clones_default_max_budget(): "budget_duration": "1d", "allowed_models": [], } - mock_prisma_client.db.litellm_budgettable.find_unique = AsyncMock(return_value=mock_default_budget_row) + mock_prisma_client.db.litellm_budgettable.find_unique = AsyncMock( + return_value=mock_default_budget_row + ) mock_cloned_budget_row = MagicMock() mock_cloned_budget_row.budget_id = "cloned-dc" - mock_prisma_client.db.litellm_budgettable.create = AsyncMock(return_value=mock_cloned_budget_row) + mock_prisma_client.db.litellm_budgettable.create = AsyncMock( + return_value=mock_cloned_budget_row + ) mock_team_membership_response = MagicMock() mock_team_membership_response.model_dump.return_value = { "team_id": "team-dc", @@ -378,7 +410,9 @@ async def test_add_new_member_budget_duration_only_clones_default_max_budget(): "budget_id": "cloned-dc", "litellm_budget_table": None, } - mock_prisma_client.db.litellm_teammembership.upsert = AsyncMock(return_value=mock_team_membership_response) + mock_prisma_client.db.litellm_teammembership.upsert = AsyncMock( + return_value=mock_team_membership_response + ) await add_new_member( new_member=new_member, @@ -392,7 +426,9 @@ async def test_add_new_member_budget_duration_only_clones_default_max_budget(): ) mock_prisma_client.db.litellm_budgettable.create.assert_called_once() - cloned_create_data = mock_prisma_client.db.litellm_budgettable.create.call_args.kwargs["data"] + cloned_create_data = ( + mock_prisma_client.db.litellm_budgettable.create.call_args.kwargs["data"] + ) assert cloned_create_data["max_budget"] == 100.0 # kept from the team default assert cloned_create_data["budget_duration"] == "7d" # overridden by the caller assert cloned_create_data["budget_reset_at"] > datetime.now(timezone.utc) @@ -415,7 +451,9 @@ async def test_add_new_member_no_budget_when_no_default_and_no_max_budget(): new_member = Member(user_id=test_user_id, role="user") - user_api_key_dict = UserAPIKeyAuth(user_id="admin_user", user_role=LitellmUserRoles.PROXY_ADMIN) + user_api_key_dict = UserAPIKeyAuth( + user_id="admin_user", user_role=LitellmUserRoles.PROXY_ADMIN + ) mock_prisma_client = AsyncMock() @@ -427,7 +465,9 @@ async def test_add_new_member_no_budget_when_no_default_and_no_max_budget(): "user_role": "internal_user", } mock_prisma_client.db.litellm_usertable.upsert = AsyncMock(return_value=mock_user_response) - mock_prisma_client.db.litellm_usertable.find_unique = AsyncMock(return_value=mock_user_response) + mock_prisma_client.db.litellm_usertable.find_unique = AsyncMock( + return_value=mock_user_response + ) # Even though we mock these, they must NOT be called on the no-budget path. mock_prisma_client.db.litellm_budgettable.find_unique = AsyncMock() @@ -442,7 +482,9 @@ async def test_add_new_member_no_budget_when_no_default_and_no_max_budget(): "total_spend": 0.0, "litellm_budget_table": None, } - mock_prisma_client.db.litellm_teammembership.upsert = AsyncMock(return_value=mock_team_membership_response) + mock_prisma_client.db.litellm_teammembership.upsert = AsyncMock( + return_value=mock_team_membership_response + ) result_user, result_team_membership = await add_new_member( new_member=new_member, @@ -466,7 +508,9 @@ async def test_add_new_member_no_budget_when_no_default_and_no_max_budget(): assert result_team_membership.budget_id is None mock_prisma_client.db.litellm_teammembership.upsert.assert_awaited_once() upsert_kwargs = mock_prisma_client.db.litellm_teammembership.upsert.call_args.kwargs - assert upsert_kwargs["where"] == {"user_id_team_id": {"user_id": test_user_id, "team_id": test_team_id}} + assert upsert_kwargs["where"] == { + "user_id_team_id": {"user_id": test_user_id, "team_id": test_team_id} + } assert upsert_kwargs["data"]["create"] == {"user_id": test_user_id, "team_id": test_team_id} assert "budget_id" not in upsert_kwargs["data"]["update"] @@ -496,7 +540,9 @@ async def test_add_new_member_creates_new_budget_when_max_budget_provided(): new_member = Member(user_id=test_user_id, role="user") # Create UserAPIKeyAuth object - user_api_key_dict = UserAPIKeyAuth(user_id="admin_user", user_role=LitellmUserRoles.PROXY_ADMIN) + user_api_key_dict = UserAPIKeyAuth( + user_id="admin_user", user_role=LitellmUserRoles.PROXY_ADMIN + ) # Mock the prisma client mock_prisma_client = AsyncMock() @@ -510,12 +556,16 @@ async def test_add_new_member_creates_new_budget_when_max_budget_provided(): "user_role": "internal_user", } mock_prisma_client.db.litellm_usertable.upsert = AsyncMock(return_value=mock_user_response) - mock_prisma_client.db.litellm_usertable.find_unique = AsyncMock(return_value=mock_user_response) + mock_prisma_client.db.litellm_usertable.find_unique = AsyncMock( + return_value=mock_user_response + ) # Mock the budget table creation mock_budget_response = MagicMock() mock_budget_response.budget_id = test_new_budget_id - mock_prisma_client.db.litellm_budgettable.create = AsyncMock(return_value=mock_budget_response) + mock_prisma_client.db.litellm_budgettable.create = AsyncMock( + return_value=mock_budget_response + ) # Mock the team membership creation mock_team_membership_response = MagicMock() @@ -525,7 +575,9 @@ async def test_add_new_member_creates_new_budget_when_max_budget_provided(): "budget_id": test_new_budget_id, "litellm_budget_table": None, } - mock_prisma_client.db.litellm_teammembership.upsert = AsyncMock(return_value=mock_team_membership_response) + mock_prisma_client.db.litellm_teammembership.upsert = AsyncMock( + return_value=mock_team_membership_response + ) # Call the function with max_budget_in_team provided result_user, result_team_membership = await add_new_member( @@ -551,7 +603,9 @@ async def test_add_new_member_creates_new_budget_when_max_budget_provided(): assert result_team_membership.budget_id == test_new_budget_id # Verify the team membership was created with the correct budget_id - team_membership_call_args = mock_prisma_client.db.litellm_teammembership.upsert.call_args + team_membership_call_args = ( + mock_prisma_client.db.litellm_teammembership.upsert.call_args + ) assert team_membership_call_args is not None create_data = team_membership_call_args.kwargs["data"]["create"] assert create_data["budget_id"] == test_new_budget_id @@ -567,7 +621,9 @@ async def test_add_new_member_persists_budget_duration(): from litellm.proxy._types import LitellmUserRoles new_member = Member(user_id="user-dur", role="user") - user_api_key_dict = UserAPIKeyAuth(user_id="admin_user", user_role=LitellmUserRoles.PROXY_ADMIN) + user_api_key_dict = UserAPIKeyAuth( + user_id="admin_user", user_role=LitellmUserRoles.PROXY_ADMIN + ) mock_prisma_client = AsyncMock() mock_user_response = MagicMock() @@ -578,10 +634,14 @@ async def test_add_new_member_persists_budget_duration(): "user_role": "internal_user", } mock_prisma_client.db.litellm_usertable.upsert = AsyncMock(return_value=mock_user_response) - mock_prisma_client.db.litellm_usertable.find_unique = AsyncMock(return_value=mock_user_response) + mock_prisma_client.db.litellm_usertable.find_unique = AsyncMock( + return_value=mock_user_response + ) mock_budget_response = MagicMock() mock_budget_response.budget_id = "budget-dur" - mock_prisma_client.db.litellm_budgettable.create = AsyncMock(return_value=mock_budget_response) + mock_prisma_client.db.litellm_budgettable.create = AsyncMock( + return_value=mock_budget_response + ) mock_team_membership_response = MagicMock() mock_team_membership_response.model_dump.return_value = { "team_id": "team-dur", @@ -589,7 +649,9 @@ async def test_add_new_member_persists_budget_duration(): "budget_id": "budget-dur", "litellm_budget_table": None, } - mock_prisma_client.db.litellm_teammembership.upsert = AsyncMock(return_value=mock_team_membership_response) + mock_prisma_client.db.litellm_teammembership.upsert = AsyncMock( + return_value=mock_team_membership_response + ) await add_new_member( new_member=new_member, @@ -604,7 +666,9 @@ async def test_add_new_member_persists_budget_duration(): ) mock_prisma_client.db.litellm_budgettable.create.assert_called_once() - budget_data = mock_prisma_client.db.litellm_budgettable.create.call_args.kwargs["data"] + budget_data = mock_prisma_client.db.litellm_budgettable.create.call_args.kwargs[ + "data" + ] assert budget_data["max_budget"] == 10.0 assert budget_data["allowed_models"] == ["gpt-4o-mini"] assert budget_data["budget_duration"] == "30d" @@ -621,7 +685,9 @@ async def test_add_new_member_persists_budget_duration_without_max_budget(): from litellm.proxy._types import LitellmUserRoles new_member = Member(user_id="user-dur2", role="user") - user_api_key_dict = UserAPIKeyAuth(user_id="admin_user", user_role=LitellmUserRoles.PROXY_ADMIN) + user_api_key_dict = UserAPIKeyAuth( + user_id="admin_user", user_role=LitellmUserRoles.PROXY_ADMIN + ) mock_prisma_client = AsyncMock() mock_user_response = MagicMock() @@ -632,10 +698,14 @@ async def test_add_new_member_persists_budget_duration_without_max_budget(): "user_role": "internal_user", } mock_prisma_client.db.litellm_usertable.upsert = AsyncMock(return_value=mock_user_response) - mock_prisma_client.db.litellm_usertable.find_unique = AsyncMock(return_value=mock_user_response) + mock_prisma_client.db.litellm_usertable.find_unique = AsyncMock( + return_value=mock_user_response + ) mock_budget_response = MagicMock() mock_budget_response.budget_id = "budget-dur2" - mock_prisma_client.db.litellm_budgettable.create = AsyncMock(return_value=mock_budget_response) + mock_prisma_client.db.litellm_budgettable.create = AsyncMock( + return_value=mock_budget_response + ) mock_team_membership_response = MagicMock() mock_team_membership_response.model_dump.return_value = { "team_id": "team-dur2", @@ -643,7 +713,9 @@ async def test_add_new_member_persists_budget_duration_without_max_budget(): "budget_id": "budget-dur2", "litellm_budget_table": None, } - mock_prisma_client.db.litellm_teammembership.upsert = AsyncMock(return_value=mock_team_membership_response) + mock_prisma_client.db.litellm_teammembership.upsert = AsyncMock( + return_value=mock_team_membership_response + ) _, result_team_membership = await add_new_member( new_member=new_member, @@ -657,7 +729,9 @@ async def test_add_new_member_persists_budget_duration_without_max_budget(): ) mock_prisma_client.db.litellm_budgettable.create.assert_called_once() - budget_data = mock_prisma_client.db.litellm_budgettable.create.call_args.kwargs["data"] + budget_data = mock_prisma_client.db.litellm_budgettable.create.call_args.kwargs[ + "data" + ] assert budget_data["budget_duration"] == "7d" assert budget_data["budget_reset_at"] > datetime.now(timezone.utc) assert result_team_membership is not None @@ -675,7 +749,9 @@ async def test_add_new_member_with_user_email_links_default_budget(): new_member = Member(user_email=test_user_email, role="user") - user_api_key_dict = UserAPIKeyAuth(user_id="admin_user", user_role=LitellmUserRoles.PROXY_ADMIN) + user_api_key_dict = UserAPIKeyAuth( + user_id="admin_user", user_role=LitellmUserRoles.PROXY_ADMIN + ) mock_prisma_client = AsyncMock() @@ -692,7 +768,9 @@ async def test_add_new_member_with_user_email_links_default_budget(): mock_default_budget_row = MagicMock() mock_default_budget_row.budget_id = test_default_budget_id - mock_prisma_client.db.litellm_budgettable.find_unique = AsyncMock(return_value=mock_default_budget_row) + mock_prisma_client.db.litellm_budgettable.find_unique = AsyncMock( + return_value=mock_default_budget_row + ) mock_prisma_client.db.litellm_budgettable.create = AsyncMock() mock_team_membership_response = MagicMock() @@ -702,7 +780,9 @@ async def test_add_new_member_with_user_email_links_default_budget(): "budget_id": test_default_budget_id, "litellm_budget_table": None, } - mock_prisma_client.db.litellm_teammembership.upsert = AsyncMock(return_value=mock_team_membership_response) + mock_prisma_client.db.litellm_teammembership.upsert = AsyncMock( + return_value=mock_team_membership_response + ) result_user, result_team_membership = await add_new_member( new_member=new_member, @@ -922,10 +1002,14 @@ async def test_attach_object_permission_to_dict_with_object_permission_id(): mock_object_permission.model_dump.return_value = expected_object_permission # Mock the database query - mock_prisma_client.db.litellm_objectpermissiontable.find_unique = AsyncMock(return_value=mock_object_permission) + mock_prisma_client.db.litellm_objectpermissiontable.find_unique = AsyncMock( + return_value=mock_object_permission + ) # Call the function - result = await attach_object_permission_to_dict(data_dict=test_data_dict, prisma_client=mock_prisma_client) + result = await attach_object_permission_to_dict( + data_dict=test_data_dict, prisma_client=mock_prisma_client + ) # Verify the result assert result is not None @@ -957,7 +1041,9 @@ async def test_attach_object_permission_to_dict_without_object_permission_id(): mock_prisma_client = AsyncMock() # Call the function - result = await attach_object_permission_to_dict(data_dict=test_data_dict, prisma_client=mock_prisma_client) + result = await attach_object_permission_to_dict( + data_dict=test_data_dict, prisma_client=mock_prisma_client + ) # Verify the result is unchanged assert result == test_data_dict @@ -989,10 +1075,14 @@ async def test_attach_object_permission_to_dict_object_permission_not_found(): mock_prisma_client = AsyncMock() # Mock the database query to return None (not found) - mock_prisma_client.db.litellm_objectpermissiontable.find_unique = AsyncMock(return_value=None) + mock_prisma_client.db.litellm_objectpermissiontable.find_unique = AsyncMock( + return_value=None + ) # Call the function - result = await attach_object_permission_to_dict(data_dict=test_data_dict, prisma_client=mock_prisma_client) + result = await attach_object_permission_to_dict( + data_dict=test_data_dict, prisma_client=mock_prisma_client + ) # Verify the result is unchanged assert result == test_data_dict @@ -1033,14 +1123,20 @@ async def test_attach_object_permission_to_dict_with_dict_method(): # Mock the object permission response that uses .dict() method mock_object_permission = MagicMock() - mock_object_permission.model_dump.side_effect = AttributeError("No model_dump method") + mock_object_permission.model_dump.side_effect = AttributeError( + "No model_dump method" + ) mock_object_permission.dict.return_value = expected_object_permission # Mock the database query - mock_prisma_client.db.litellm_objectpermissiontable.find_unique = AsyncMock(return_value=mock_object_permission) + mock_prisma_client.db.litellm_objectpermissiontable.find_unique = AsyncMock( + return_value=mock_object_permission + ) # Call the function - result = await attach_object_permission_to_dict(data_dict=test_data_dict, prisma_client=mock_prisma_client) + result = await attach_object_permission_to_dict( + data_dict=test_data_dict, prisma_client=mock_prisma_client + ) # Verify the result assert result is not None @@ -1069,8 +1165,7 @@ async def test_attach_object_permission_to_dict_with_none_prisma_client(): # Call the function with None prisma_client with pytest.raises(ValueError, match="Prisma client not found"): await attach_object_permission_to_dict( - data_dict=test_data_dict, - prisma_client=None, # type: ignore + data_dict=test_data_dict, prisma_client=None # type: ignore ) @@ -1090,7 +1185,9 @@ async def test_attach_object_permission_to_dict_with_empty_dict(): mock_prisma_client = AsyncMock() # Call the function - result = await attach_object_permission_to_dict(data_dict=test_data_dict, prisma_client=mock_prisma_client) + result = await attach_object_permission_to_dict( + data_dict=test_data_dict, prisma_client=mock_prisma_client + ) # Verify the result is unchanged assert result == {} @@ -1120,7 +1217,9 @@ async def test_attach_object_permission_to_dict_with_none_object_permission_id() mock_prisma_client = AsyncMock() # Call the function - result = await attach_object_permission_to_dict(data_dict=test_data_dict, prisma_client=mock_prisma_client) + result = await attach_object_permission_to_dict( + data_dict=test_data_dict, prisma_client=mock_prisma_client + ) # Verify the result is unchanged assert result == test_data_dict @@ -1146,7 +1245,9 @@ async def test_add_new_member_appends_team_only_if_absent_for_existing_user(): from litellm.proxy._types import LitellmUserRoles new_member = Member(user_id="existing-user", role="user") - user_api_key_dict = UserAPIKeyAuth(user_id="admin_user", user_role=LitellmUserRoles.PROXY_ADMIN) + user_api_key_dict = UserAPIKeyAuth( + user_id="admin_user", user_role=LitellmUserRoles.PROXY_ADMIN + ) mock_prisma_client = AsyncMock() @@ -1217,7 +1318,9 @@ async def test_add_new_member_creates_missing_user_atomically_via_upsert(): from litellm.proxy._types import LitellmUserRoles new_member = Member(user_id="brand-new-user", role="user") - user_api_key_dict = UserAPIKeyAuth(user_id="admin_user", user_role=LitellmUserRoles.PROXY_ADMIN) + user_api_key_dict = UserAPIKeyAuth( + user_id="admin_user", user_role=LitellmUserRoles.PROXY_ADMIN + ) mock_prisma_client = AsyncMock() @@ -1321,7 +1424,9 @@ async def test_add_new_member_runs_every_write_on_the_caller_transaction(new_mem max_budget_in_team=50.0, prisma_client=prisma_client, team_id="team-pool", - user_api_key_dict=UserAPIKeyAuth(user_id="admin_user", user_role=LitellmUserRoles.PROXY_ADMIN), + user_api_key_dict=UserAPIKeyAuth( + user_id="admin_user", user_role=LitellmUserRoles.PROXY_ADMIN + ), litellm_proxy_admin_name="admin", tx=tx, ) diff --git a/tests/unit/proxy/management_helpers/test_team_member_default_budget.py b/tests/unit/proxy/management_helpers/test_team_member_default_budget.py index c675f24e8aa..8220f681b1f 100644 --- a/tests/unit/proxy/management_helpers/test_team_member_default_budget.py +++ b/tests/unit/proxy/management_helpers/test_team_member_default_budget.py @@ -1,18 +1,12 @@ import json -from datetime import datetime, timezone -from types import SimpleNamespace +from datetime import datetime import pytest from pydantic import ValidationError -from litellm.proxy._types import TeamMemberBudgetBackfillResult, UpdateTeamRequest, UserAPIKeyAuth +from litellm.proxy._types import UpdateTeamRequest from litellm.proxy.management_helpers.team_member_default_budget import ( - MAX_MEMBER_BUDGETS_MOVED_PER_UPDATE, - MovedMemberBudgets, - TooManyMemberBudgetsToMove, - move_member_budgets_to_default, plan_team_member_default_budget_write, - write_team_member_default_budget, ) @@ -43,8 +37,6 @@ def test_clearing_an_existing_default_updates_it_without_relinking_members(): def test_a_first_default_gets_a_new_row_that_inherits_the_team_reset_period(): - before = datetime.now(timezone.utc) - write = _plan(team_budget_duration="30d", team_member_budget=25.0) assert write is not None @@ -52,7 +44,7 @@ def test_a_first_default_gets_a_new_row_that_inherits_the_team_reset_period(): assert write.create["max_budget"] == 25.0 assert write.create["budget_duration"] == "30d" reset_at = write.create["budget_reset_at"] - assert isinstance(reset_at, datetime) and reset_at > before + assert isinstance(reset_at, datetime) assert write.links_members is True @@ -66,14 +58,12 @@ def test_an_explicit_null_reset_period_is_not_replaced_by_the_team_period(): def test_changing_the_reset_period_restarts_the_window(): - before = datetime.now(timezone.utc) - write = _plan(existing_budget_id="default-1", team_member_budget_duration="7d") assert write is not None assert write.update["budget_duration"] == "7d" reset_at = write.update["budget_reset_at"] - assert isinstance(reset_at, datetime) and reset_at > before + assert isinstance(reset_at, datetime) @pytest.mark.parametrize("team_member_budget", [None, 0.0]) @@ -90,275 +80,9 @@ def test_keeping_custom_budgets_needs_no_default(backfill): def test_per_model_member_budgets_are_stored_as_plain_json(): - caps = {"gpt-4o": {"max_budget": 5.0, "budget_duration": "1d"}} + caps = {"test-model": {"max_budget": 5.0, "budget_duration": "1d"}} write = _plan(existing_budget_id="default-1", team_member_model_max_budget=caps) assert write is not None - assert json.loads(json.dumps(write.update["model_max_budget"]))["gpt-4o"]["max_budget"] == 5.0 - - -class _InMemoryTeam: - """One team's memberships and budget rows, changed the way the backfill's statements change Postgres.""" - - def __init__(self, default: dict[str, object], members: dict[str, dict[str, object] | None]) -> None: - self.budgets: dict[str, dict[str, object]] = {"default": {"budget_id": "default", **default}} - self.memberships: dict[str, str | None] = {} - for user_id, budget in members.items(): - if budget is None: - self.memberships[user_id] = "default" - continue - self.budgets[f"own-{user_id}"] = {"budget_id": f"own-{user_id}", **budget} - self.memberships[user_id] = f"own-{user_id}" - self.litellm_budgettable = SimpleNamespace( - find_unique=self._find_budget, upsert=self._upsert_budget, create=self._create_budget - ) - self.litellm_teammembership = SimpleNamespace(upsert=self._link_membership) - - def share(self, budget_id: str, *user_ids: str) -> None: - for user_id in user_ids: - self.memberships[user_id] = budget_id - - async def _create_budget(self, data: dict[str, object], include: dict[str, bool] | None = None): - budget_id = f"copy-{len(self.budgets)}" - self.budgets[budget_id] = {"budget_id": budget_id, **data} - return SimpleNamespace(budget_id=budget_id) - - async def _link_membership(self, where: dict[str, dict[str, str]], data: dict[str, dict[str, object]]) -> None: - self.memberships[where["user_id_team_id"]["user_id"]] = data["update"]["litellm_budget_table"]["connect"][ - "budget_id" - ] - - def budget_of(self, user_id: str) -> dict[str, object]: - return self.budgets[self.memberships[user_id]] - - async def _find_budget(self, where: dict[str, str]): - stored = self.budgets.get(where["budget_id"]) - if stored is None: - return None - row = {**_ROW_DEFAULTS, **stored} - return SimpleNamespace(**row, model_dump=lambda: row) - - async def _upsert_budget(self, where: dict[str, str], data: dict[str, dict[str, object]]) -> None: - current = self.budgets.get(where["budget_id"]) - self.budgets[where["budget_id"]] = {**(current or {}), **(data["update"] if current else data["create"])} - - def _on_chosen_side(self, budget: dict[str, object], direction: str, amount: float) -> bool: - own = budget.get("max_budget") - if budget["budget_id"] == "default" or own is None: - return False - return {"raise_to_default": own < amount, "lower_to_default": own > amount, "all_to_default": own != amount}[ - direction - ] - - async def query_raw(self, sql: str, *args: object) -> list[dict[str, object]]: - if "HAVING COUNT(*) > 1" in sql: - budget_ids = list(self.memberships.values()) - return [{"budget_id": b} for b in set(args[0]) if budget_ids.count(b) > 1] - _team, _default, direction, amount = args[:4] - chosen = [ - (u, self.budgets[b]) - for u, b in self.memberships.items() - if b and self._on_chosen_side(self.budgets[b], direction, amount) - ] - if "GROUP BY" in sql: - durations = [budget.get("budget_duration") for _, budget in chosen] - return [{"duration": d, "members": durations.count(d)} for d in set(durations)] - durations, include_none = args[4], args[5] - return [ - {**_ROW_DEFAULTS, **budget, "user_id": user_id} - for user_id, budget in chosen - if budget.get("budget_duration") in durations or (include_none and budget.get("budget_duration") is None) - ] - - async def execute_raw(self, sql: str, *args: object) -> int: - if "INSERT INTO" in sql: - for user_id in args[2]: - self.memberships.setdefault(user_id, args[1]) - elif "budget_id IS NULL" in sql: - self.memberships = {u: b or args[1] for u, b in self.memberships.items()} - elif "SET budget_reset_at" in sql: - for user_id in args[2]: - if self.memberships[user_id] != args[1]: - self.budget_of(user_id)["budget_reset_at"] = self.budgets[args[1]].get("budget_reset_at") - elif "SET max_budget = NULL" in sql: - for budget_id in args[0]: - self.budgets[budget_id]["max_budget"] = None - elif "SET budget_id = $2" in sql: - for user_id in args[2]: - self.memberships[user_id] = args[1] - return 0 - - -_ROW_DEFAULTS = { - "soft_budget": None, - "max_parallel_requests": None, - "tpm_limit": None, - "rpm_limit": None, - "model_max_budget": None, - "budget_duration": None, - "allowed_models": None, - "temp_budget_increase": None, - "temp_budget_expiry": None, -} -_DEFAULT_RESET = datetime(2030, 1, 1, tzinfo=timezone.utc) -_ADMIN = UserAPIKeyAuth(user_id="admin") - - -async def _backfill(team: _InMemoryTeam, backfill: str): - return await move_member_budgets_to_default( - team, team_id="team-1", default_budget_id="default", backfill=backfill, changed_by=_ADMIN - ) - - -def _team(**members: dict[str, object] | None) -> _InMemoryTeam: - return _InMemoryTeam({"max_budget": 50.0, "budget_duration": "30d", "budget_reset_at": _DEFAULT_RESET}, members) - - -@pytest.mark.asyncio -async def test_raise_moves_members_below_the_default_on_its_schedule_and_counts_the_rest(): - team = _team( - below={"max_budget": 10.0, "budget_duration": "30d"}, - own_rpm={"max_budget": 10.0, "budget_duration": "30d", "rpm_limit": 5, "budget_reset_at": "2030-02-01"}, - weekly={"max_budget": 10.0, "budget_duration": "7d"}, - above={"max_budget": 80.0, "budget_duration": "30d"}, - on_default=None, - ) - - moved = await _backfill(team, "raise_to_default") - - assert isinstance(moved, MovedMemberBudgets) - assert sorted(moved.user_ids) == ["below", "own_rpm"] - assert moved.result() == TeamMemberBudgetBackfillResult(moved_to_default=2, skipped_other_reset_period=1) - assert team.memberships["below"] == "default" - assert team.budget_of("own_rpm") == { - "budget_id": "own-own_rpm", - "max_budget": None, - "budget_duration": "30d", - "rpm_limit": 5, - "budget_reset_at": _DEFAULT_RESET, - } - assert team.budget_of("weekly")["max_budget"] == 10.0 - assert team.budget_of("above")["max_budget"] == 80.0 - - -@pytest.mark.asyncio -async def test_a_model_list_matching_the_default_still_keeps_the_members_own_row(): - team = _team(scoped={"max_budget": 10.0, "budget_duration": "30d", "allowed_models": ["gpt-5.4-mini"]}) - team.budgets["default"]["allowed_models"] = ["gpt-5.4-mini"] - - await _backfill(team, "raise_to_default") - - assert team.memberships["scoped"] == "own-scoped" - assert team.budget_of("scoped")["max_budget"] is None - - -@pytest.mark.asyncio -async def test_more_members_than_one_update_may_move_changes_nobody(): - members = { - f"m{i}": {"max_budget": 10.0, "budget_duration": "30d"} for i in range(MAX_MEMBER_BUDGETS_MOVED_PER_UPDATE + 1) - } - team = _team(**members) - - moved = await _backfill(team, "raise_to_default") - - assert moved == TooManyMemberBudgetsToMove(count=MAX_MEMBER_BUDGETS_MOVED_PER_UPDATE + 1) - assert all(budget_id != "default" for budget_id in team.memberships.values()) - - -@pytest.mark.asyncio -async def test_members_sharing_a_budget_with_their_own_limits_each_get_a_copy_on_the_default(): - team = _team() - team.budgets["shared"] = {"budget_id": "shared", "max_budget": 10.0, "budget_duration": "30d", "rpm_limit": 5} - team.share("shared", "first", "second") - - moved = await _backfill(team, "raise_to_default") - - assert isinstance(moved, MovedMemberBudgets) - assert sorted(moved.user_ids) == ["first", "second"] - copies = {team.memberships["first"], team.memberships["second"]} - assert len(copies) == 2 and "shared" not in copies - assert [(team.budgets[c]["max_budget"], team.budgets[c]["rpm_limit"]) for c in sorted(copies)] == [ - (None, 5), - (None, 5), - ] - assert team.budgets["shared"]["max_budget"] == 10.0 - - -@pytest.mark.asyncio -async def test_only_members_on_another_schedule_are_counted_and_left_alone(): - team = _team(weekly={"max_budget": 10.0, "budget_duration": "7d"}) - - moved = await _backfill(team, "raise_to_default") - - assert moved == MovedMemberBudgets(user_ids=(), skipped_other_reset_period=1) - assert team.memberships["weekly"] == "own-weekly" - - -@pytest.mark.asyncio -async def test_a_missing_default_row_moves_nobody(): - team = _team(below={"max_budget": 10.0, "budget_duration": "30d"}) - del team.budgets["default"] - - assert await _backfill(team, "raise_to_default") == MovedMemberBudgets(user_ids=(), skipped_other_reset_period=0) - - -def test_a_first_default_on_a_team_without_an_alias_gets_a_generic_id(): - write = plan_team_member_default_budget_write( - data=UpdateTeamRequest(team_id="team-1", team_member_budget=5.0), - existing_budget_id=None, - team_alias=None, - team_budget_duration=None, - ) - - assert write is not None - assert write.budget_id.startswith("team-budget-") - - -@pytest.mark.asyncio -async def test_keeping_custom_budgets_moves_nobody(): - team = _team(below={"max_budget": 10.0, "budget_duration": "30d"}) - - assert await _backfill(team, "none") == MovedMemberBudgets(user_ids=(), skipped_other_reset_period=0) - assert team.memberships["below"] == "own-below" - - -@pytest.mark.asyncio -async def test_writing_a_default_links_roster_members_without_a_budget_to_it(): - team = _team(own={"max_budget": 10.0, "budget_duration": "30d"}) - team.memberships["unbudgeted"] = None - write = _plan( - existing_budget_id="default", - team_member_budget=60.0, - team_member_model_max_budget={"gpt-4o": {"max_budget": 1.0}}, - ) - assert write is not None - - await write_team_member_default_budget( - team, write, team_id="team-1", member_user_ids=("own", "unbudgeted", "no-row"), changed_by="admin" - ) - - assert team.budgets["default"]["max_budget"] == 60.0 - assert team.budgets["default"]["model_max_budget"].data == { - "gpt-4o": {"max_budget": 1.0, "budget_duration": None, "tpm_limit": None, "rpm_limit": None} - } - assert (team.memberships["unbudgeted"], team.memberships["no-row"], team.memberships["own"]) == ( - "default", - "default", - "own-own", - ) - - -@pytest.mark.asyncio -async def test_clearing_the_default_does_not_link_members_without_a_budget_to_it(): - team = _team() - team.memberships["unbudgeted"] = None - write = _plan(existing_budget_id="default", team_member_budget=None) - assert write is not None - - await write_team_member_default_budget( - team, write, team_id="team-1", member_user_ids=("unbudgeted", "no-row"), changed_by="admin" - ) - - assert team.budgets["default"]["max_budget"] is None - assert team.memberships == {"unbudgeted": None} + assert json.loads(json.dumps(write.update["model_max_budget"]))["test-model"]["max_budget"] == 5.0