From edd697564b6e9edaac8e4e5f8525ea28e697b220 Mon Sep 17 00:00:00 2001 From: shrey kharbanda Date: Sat, 24 Oct 2026 11:22:03 -0700 Subject: [PATCH] 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