From 74e7940ef65e4f9a2327d416b91200dc99ddf41c Mon Sep 17 00:00:00 2001 From: ryan Date: Fri, 18 Sep 2026 12:38:45 +0000 Subject: [PATCH] fix(proxy): validate rollover cap on customer and org budgets, drop cascade counters instead of replaying snapshot deltas Co-Authored-By: Devin AI <158243242+devin-ai-integration[bot]@users.noreply.github.com> --- .../proxy/common_utils/reset_budget_job.py | 40 ++--- .../customer_endpoints.py | 6 +- .../organization_endpoints.py | 2 + .../common_utils/test_reset_budget_job.py | 142 ++++++++++-------- .../test_customer_endpoints.py | 25 ++- .../test_organization_endpoints.py | 27 +++- 6 files changed, 145 insertions(+), 97 deletions(-) diff --git a/litellm/proxy/common_utils/reset_budget_job.py b/litellm/proxy/common_utils/reset_budget_job.py index 4909f040729..86d65e20447 100644 --- a/litellm/proxy/common_utils/reset_budget_job.py +++ b/litellm/proxy/common_utils/reset_budget_job.py @@ -181,21 +181,6 @@ def _item_rollover_max_budget( assert_never(item_type) -@dataclass(frozen=True, slots=True) -class _CounterReset: - key: str - spend: float - decrement: float - - -def _row_counter_reset(key: str, row: _BudgetLinkedRow, bands: Mapping[str, _ResetBand]) -> _CounterReset: - band: Final = bands.get(row.budget_id) if bands and row.budget_id is not None else None - if band is None: - return _CounterReset(key=key, spend=0.0, decrement=0.0) - spend: Final = _reset_spend(row.spend, band) - return _CounterReset(key=key, spend=spend, decrement=float(row.spend or 0.0) - spend) - - def _team_membership_counter_key(row: _TeamMembershipRow) -> str: return f"spend:team_member:{row.user_id}:{row.team_id}" @@ -388,7 +373,7 @@ class _BudgetCascade: budgets: tuple[LiteLLM_BudgetTableFull, ...] = () budget_ids: tuple[str, ...] = () budget_resets: tuple[tuple[str, datetime], ...] = () - counter_resets: tuple[_CounterReset, ...] = () + counter_keys: tuple[str, ...] = () cache_keys: tuple[str, ...] = () bands: Mapping[str, _ResetBand] = field(default_factory=lambda: MappingProxyType({})) @@ -920,12 +905,12 @@ class ResetBudgetJob: for b in budgets_to_reset if b.budget_id is not None and b.budget_duration is not None ), - counter_resets=( - *(_row_counter_reset(_team_membership_counter_key(row), row, bands) for row in team_memberships), - *(_row_counter_reset(_key_counter_key(row), row, bands) for row in keys), - *(_row_counter_reset(_org_counter_key(row), row, bands) for row in orgs), - *(_row_counter_reset(_tag_counter_key(row), row, bands) for row in tags), - *(_row_counter_reset(_model_access_group_counter_key(row), row, bands) for row in model_access_groups), + counter_keys=( + *(_team_membership_counter_key(row) for row in team_memberships), + *(_key_counter_key(row) for row in keys), + *(_org_counter_key(row) for row in orgs), + *(_tag_counter_key(row) for row in tags), + *(_model_access_group_counter_key(row) for row in model_access_groups), ), bands=bands, cache_keys=( @@ -965,13 +950,10 @@ class ResetBudgetJob: uow.budgets.queue_window_advance(budget_id=budget_id, budget_reset_at=budget_reset_at) async def _invalidate_budget_cascade_caches(self, cascade: _BudgetCascade) -> None: - await self._invalidate_caches( - counter_keys=tuple(reset.key for reset in cascade.counter_resets if reset.spend == 0.0), - cache_keys=cascade.cache_keys, - ) - for reset in cascade.counter_resets: - if reset.spend != 0.0: - await self._decrement_spend_counter(reset.key, reset.decrement) + """The band statements rewrite each row from the spend it holds at + commit, not the snapshot's, so only a reseed from the committed row + can follow a flush that moved the row across a band in between.""" + await self._invalidate_caches(counter_keys=cascade.counter_keys, cache_keys=cascade.cache_keys) async def _reset_expired_budget_cascade(self) -> _BudgetCascadeCommitted | _BudgetCascadeFailed: now: Final = datetime.now(timezone.utc) diff --git a/litellm/proxy/management_endpoints/customer_endpoints.py b/litellm/proxy/management_endpoints/customer_endpoints.py index 37d29b342f2..82834f4c2b4 100644 --- a/litellm/proxy/management_endpoints/customer_endpoints.py +++ b/litellm/proxy/management_endpoints/customer_endpoints.py @@ -34,7 +34,10 @@ from litellm.proxy.common_utils.user_api_key_cache import ( end_user_restricted_registry_cache_key, ) from litellm.proxy.management_endpoints.common_daily_activity import get_daily_activity -from litellm.proxy.management_endpoints.common_utils import validate_budget_duration +from litellm.proxy.management_endpoints.common_utils import ( + validate_budget_duration, + validate_rollover_max_budget, +) from litellm.proxy.management_helpers.object_permission_utils import ( _set_object_permission, handle_update_object_permission_common, @@ -265,6 +268,7 @@ def new_budget_request(data: NewCustomerRequest) -> BudgetNewRequest | None: if budget_kv_pairs: budget_request: Final = BudgetNewRequest.model_validate(budget_kv_pairs) validate_budget_duration(budget_request.budget_duration) + validate_rollover_max_budget(budget_request.rollover_max_budget) if budget_request.budget_reset_at is None and budget_request.budget_duration is not None: budget_request.budget_reset_at = datetime.utcnow() + timedelta( seconds=duration_in_seconds(duration=budget_request.budget_duration) diff --git a/litellm/proxy/management_endpoints/organization_endpoints.py b/litellm/proxy/management_endpoints/organization_endpoints.py index 93fa3559c23..551ead12d81 100644 --- a/litellm/proxy/management_endpoints/organization_endpoints.py +++ b/litellm/proxy/management_endpoints/organization_endpoints.py @@ -42,6 +42,7 @@ from litellm.proxy.management_endpoints.common_utils import ( _set_object_metadata_field, _user_has_admin_view, validate_budget_duration, + validate_rollover_max_budget, ) from litellm.proxy.management_helpers.object_permission_utils import ( handle_update_object_permission_common, @@ -444,6 +445,7 @@ async def new_organization( status_code=400, detail={"error": f"soft_budget must be a non-negative finite number. Received: {data.soft_budget}"}, ) + validate_rollover_max_budget(data.rollover_max_budget) user_object_correct_type: LiteLLM_UserTable | None = None diff --git a/tests/test_litellm/proxy/common_utils/test_reset_budget_job.py b/tests/test_litellm/proxy/common_utils/test_reset_budget_job.py index 429711470c4..ac1376989d1 100644 --- a/tests/test_litellm/proxy/common_utils/test_reset_budget_job.py +++ b/tests/test_litellm/proxy/common_utils/test_reset_budget_job.py @@ -1677,7 +1677,9 @@ def test_budget_table_reset_invalidates_enduser_counter_and_cache(reset_budget_j counter_cache.in_memory_cache.delete_cache.assert_any_call(key="spend:end_user:customer-42") counter_cache.redis_cache.async_delete_cache.assert_any_await(key="spend:end_user:customer-42") - deleted: Final = {call.kwargs.get("key") for call in counter_cache.user_api_key_cache.async_delete_cache.await_args_list} + deleted: Final = { + call.kwargs.get("key") for call in counter_cache.user_api_key_cache.async_delete_cache.await_args_list + } assert "end_user_id:customer-42" in deleted @@ -1715,9 +1717,7 @@ def test_enduser_invalidation_is_paged_and_batched(reset_budget_job, mock_prisma assert counter_cache.user_api_key_cache.async_delete_cache_keys.await_count == 3 counter_cache.async_delete_cache.assert_not_called() - invalidated: Final = { - key for call in counter_cache.async_delete_cache_keys.await_args_list for key in call.args[0] - } + invalidated: Final = {key for call in counter_cache.async_delete_cache_keys.await_args_list for key in call.args[0]} assert invalidated == {f"spend:end_user:cust-{i:06d}" for i in range(population)} evicted: Final = { key for call in counter_cache.user_api_key_cache.async_delete_cache_keys.await_args_list for key in call.args[0] @@ -1725,10 +1725,7 @@ def test_enduser_invalidation_is_paged_and_batched(reset_budget_job, mock_prisma assert evicted == {f"end_user_id:cust-{i:06d}" for i in range(population)} - -def test_enduser_invalidation_reports_a_page_read_failure_instead_of_a_clean_finish( - mock_prisma_client, monkeypatch -): +def test_enduser_invalidation_reports_a_page_read_failure_instead_of_a_clean_finish(mock_prisma_client, monkeypatch): """A page that fails to read is not the end of the customer list. The tier's window is already advanced by the time this walk runs, so no later @@ -1756,9 +1753,7 @@ def test_enduser_invalidation_reports_a_page_read_failure_instead_of_a_clean_fin assert metadata["num_endusers_updated"] == RESET_BUDGET_JOB_BATCH_SIZE -def test_a_failed_counter_batch_still_evicts_the_management_cache( - reset_budget_job, mock_prisma_client, monkeypatch -): +def test_a_failed_counter_batch_still_evicts_the_management_cache(reset_budget_job, mock_prisma_client, monkeypatch): """The spend counters and the management cache are invalidated independently. Sharing one handler meant a Redis failure on the counters returned before the @@ -1776,9 +1771,7 @@ def test_a_failed_counter_batch_still_evicts_the_management_cache( asyncio.run(reset_budget_job.reset_budget_for_litellm_budget_table()) evicted: Final = { - key - for call in counter_cache.user_api_key_cache.async_delete_cache_keys.await_args_list - for key in call.args[0] + key for call in counter_cache.user_api_key_cache.async_delete_cache_keys.await_args_list for key in call.args[0] } assert "end_user_id:customer-42" in evicted @@ -1865,7 +1858,8 @@ def test_budget_cascade_carries_access_group_overage_when_rollover_enabled( ): """A group 5 over the tier cap keeps a spend of 5 in the next window, the same way a tag or a team member does: over-cap rows are decremented by the - cap, the rest are zeroed, and a live counter is decremented by the cap.""" + cap, the rest are zeroed, and the live counter is dropped so it reseeds + from the committed row.""" counter_cache = _make_counter_invalidation_job(monkeypatch) counter_cache.counters["spend:model_access_group:gpt-4-group"] = 15.0 mock_prisma_client.data["budget"] = [_budget_row(budget_id="budget-roll", budget_duration="7d", max_budget=10.0)] @@ -1890,7 +1884,8 @@ def test_budget_cascade_carries_access_group_overage_when_rollover_enabled( } in writes assert _replay_spend_writes(writes, 15.0) == 5.0 assert _replay_spend_writes(writes, 8.0) == 0 - assert counter_cache.counters["spend:model_access_group:gpt-4-group"] == 5.0 + assert "spend:model_access_group:gpt-4-group" not in counter_cache.counters + counter_cache.redis_cache.async_delete_cache.assert_any_await(key="spend:model_access_group:gpt-4-group") # --------------------------------------------------------------------------- @@ -1992,7 +1987,11 @@ def test_budget_cascade_writes_land_in_a_single_transaction(reset_budget_job, mo budget = _budget_row(budget_id="budget-1", budget_duration="7d") mock_prisma_client.data["budget"] = [budget] mock_prisma_client.data["enduser"] = [ - type("EndUser", (), {"spend": 5.0, "litellm_budget_table": budget, "user_id": "enduser-1", "budget_id": "budget-1"}) + type( + "EndUser", + (), + {"spend": 5.0, "litellm_budget_table": budget, "user_id": "enduser-1", "budget_id": "budget-1"}, + ) ] asyncio.run(reset_budget_job.reset_budget_for_litellm_budget_table()) @@ -3196,7 +3195,15 @@ def rollover_enabled(monkeypatch): ], ) def test_direct_reset_carries_overage_when_rollover_enabled( - rollover_enabled, reset_budget_job, mock_prisma_client, monkeypatch, run_phase, table, id_field, id_value, row_factory + rollover_enabled, + reset_budget_job, + mock_prisma_client, + monkeypatch, + run_phase, + table, + id_field, + id_value, + row_factory, ): """spend=150 against max_budget=100 must decrement by the cap (leaving 50) rather than zero the row, and a live spend counter must drop by 100.""" @@ -3261,8 +3268,8 @@ def test_budget_cascade_carries_overage_per_tier_when_rollover_enabled( rollover_enabled, reset_budget_job, mock_prisma_client, monkeypatch ): """A team member 5 over the tier cap keeps a spend of 5 in the next window: - the cascade decrements over-cap rows by the cap, zeroes the rest, and takes - the cap off a live spend counter.""" + the cascade decrements over-cap rows by the cap, zeroes the rest, and drops + the live spend counter so it reseeds from the committed row.""" counter_cache = _make_counter_invalidation_job(monkeypatch) counter_cache.counters["spend:team_member:member-1:team-1"] = 15.0 budget = _budget_row(budget_id="budget-roll", budget_duration="7d", max_budget=10.0) @@ -3291,7 +3298,8 @@ def test_budget_cascade_carries_overage_per_tier_when_rollover_enabled( "data": {"spend": {"decrement": 10.0}}, }, ] - assert counter_cache.counters["spend:team_member:member-1:team-1"] == 5.0 + assert "spend:team_member:member-1:team-1" not in counter_cache.counters + counter_cache.redis_cache.async_delete_cache.assert_any_await(key="spend:team_member:member-1:team-1") def test_budget_cascade_carries_enduser_overage_when_rollover_enabled( @@ -3346,7 +3354,12 @@ def test_budget_cascade_carries_default_tier_enduser_counter_when_rollover_enabl "spend": 15.0, "user_id": "enduser-implicit", "budget_id": None, - "model_dump": lambda self=None: {"spend": 15.0, "user_id": "enduser-implicit", "budget_id": None, "blocked": False}, + "model_dump": lambda self=None: { + "spend": 15.0, + "user_id": "enduser-implicit", + "budget_id": None, + "blocked": False, + }, }, ) mock_prisma_client.db.litellm_endusertable.set_find_many_results([implicit_enduser]) @@ -3355,7 +3368,9 @@ def test_budget_cascade_carries_default_tier_enduser_counter_when_rollover_enabl counter_cache.in_memory_cache.delete_cache.assert_any_call(key="spend:end_user:enduser-implicit") counter_cache.redis_cache.async_delete_cache.assert_any_await(key="spend:end_user:enduser-implicit") - deleted: Final = {call.kwargs.get("key") for call in counter_cache.user_api_key_cache.async_delete_cache.await_args_list} + deleted: Final = { + call.kwargs.get("key") for call in counter_cache.user_api_key_cache.async_delete_cache.await_args_list + } assert "end_user_id:enduser-implicit" in deleted @@ -3704,9 +3719,7 @@ def test_reset_band_negative_max_budget_never_opens_a_band(rollover_enabled): assert _reset_spend(30.0, _reset_band(-50.0, 600.0)) == 0.0 -def test_direct_reset_carries_unused_allowance_as_negative_spend( - reset_budget_job, mock_prisma_client, monkeypatch -): +def test_direct_reset_carries_unused_allowance_as_negative_spend(reset_budget_job, mock_prisma_client, monkeypatch): """max_budget 100, rollover_max_budget 600, spend 30: the write decrements by the 100 allowance so the row lands at -70. A charge of 1 that landed after the reset read the row must survive in the counter, which lands at @@ -3848,9 +3861,7 @@ def test_budget_cascade_queues_ordered_band_statements_for_capped_tier( """A capped tier emits floor -> decrement -> forgive-overage in that order, and the caller's spend filter is stripped so zero-spend rows are swept.""" _make_counter_invalidation_job(monkeypatch) - budget = _budget_row( - budget_id="budget-credit", budget_duration="7d", max_budget=100.0, rollover_max_budget=250.0 - ) + budget = _budget_row(budget_id="budget-credit", budget_duration="7d", max_budget=100.0, rollover_max_budget=250.0) mock_prisma_client.data["budget"] = [budget] member = type( "Membership", @@ -3891,9 +3902,7 @@ def test_budget_cascade_keeps_spend_filter_for_plain_tier_but_strips_for_banded( still only touch rows that spent) and is stripped for banded budgets (a member who spent nothing still banks the period's allowance).""" _make_counter_invalidation_job(monkeypatch) - banded = _budget_row( - budget_id="budget-credit", budget_duration="7d", max_budget=100.0, rollover_max_budget=250.0 - ) + banded = _budget_row(budget_id="budget-credit", budget_duration="7d", max_budget=100.0, rollover_max_budget=250.0) plain = _budget_row(budget_id="budget-plain", budget_duration="7d", max_budget=10.0) mock_prisma_client.data["budget"] = [banded, plain] @@ -3913,15 +3922,11 @@ def test_budget_cascade_keeps_spend_filter_for_plain_tier_but_strips_for_banded( } in enduser_writes -def test_budget_cascade_credit_reaches_idle_and_spending_members( - reset_budget_job, mock_prisma_client, monkeypatch -): +def test_budget_cascade_credit_reaches_idle_and_spending_members(reset_budget_job, mock_prisma_client, monkeypatch): """Replay the committed statements over member rows: a member at spend 30 lands at -70 and a mid-cycle joiner at spend 0 banks the full -100.""" _make_counter_invalidation_job(monkeypatch) - budget = _budget_row( - budget_id="budget-credit", budget_duration="7d", max_budget=100.0, rollover_max_budget=600.0 - ) + budget = _budget_row(budget_id="budget-credit", budget_duration="7d", max_budget=100.0, rollover_max_budget=600.0) mock_prisma_client.data["budget"] = [budget] mock_prisma_client.db.litellm_teammembership.set_find_many_results( [ @@ -3943,9 +3948,7 @@ def test_budget_cascade_invalidates_zero_spend_rows_on_banded_tiers(reset_budget fetched despite the spend > 0 filter or its Redis counter stays stale.""" counter_cache = _make_counter_invalidation_job(monkeypatch) counter_cache.counters["spend:tag:tenant-42"] = 0.0 - banded = _budget_row( - budget_id="budget-credit", budget_duration="7d", max_budget=100.0, rollover_max_budget=250.0 - ) + banded = _budget_row(budget_id="budget-credit", budget_duration="7d", max_budget=100.0, rollover_max_budget=250.0) plain = _budget_row(budget_id="budget-plain", budget_duration="7d", max_budget=10.0) mock_prisma_client.data["budget"] = [banded, plain] mock_prisma_client.db.litellm_tagtable.set_find_many_results( @@ -3961,20 +3964,16 @@ def test_budget_cascade_invalidates_zero_spend_rows_on_banded_tiers(reset_budget ] } assert mock_prisma_client.db.litellm_tagtable.find_many_calls == [{"where": expected_where}] - assert counter_cache.counters["spend:tag:tenant-42"] == -100.0 - counter_cache.redis_cache.async_increment_if_exists.assert_any_await(key="spend:tag:tenant-42", value=-100.0) + assert "spend:tag:tenant-42" not in counter_cache.counters + counter_cache.redis_cache.async_delete_cache.assert_any_await(key="spend:tag:tenant-42") -def test_budget_cascade_seeds_credit_counters_and_deletes_zeroed_ones( - reset_budget_job, mock_prisma_client, monkeypatch -): - """Rows a banded tier carries into credit get the allowance taken off their - live counter; rows a plain tier zeroes keep the delete-then-reseed path.""" +def test_budget_cascade_drops_counters_on_banded_and_plain_tiers(reset_budget_job, mock_prisma_client, monkeypatch): + """Banded and plain tiers both leave the counter absent so the next read + reseeds from the committed row; nothing is seeded from the snapshot.""" counter_cache = _make_counter_invalidation_job(monkeypatch) counter_cache.counters["spend:team_member:m-1:t-1"] = 0.5 - banded = _budget_row( - budget_id="budget-credit", budget_duration="7d", max_budget=100.0, rollover_max_budget=250.0 - ) + banded = _budget_row(budget_id="budget-credit", budget_duration="7d", max_budget=100.0, rollover_max_budget=250.0) plain = _budget_row(budget_id="budget-plain", budget_duration="7d", max_budget=10.0) mock_prisma_client.data["budget"] = [banded, plain] mock_prisma_client.db.litellm_teammembership.set_find_many_results( @@ -3986,26 +3985,45 @@ def test_budget_cascade_seeds_credit_counters_and_deletes_zeroed_ones( asyncio.run(reset_budget_job.reset_budget_for_litellm_budget_table()) - assert counter_cache.counters["spend:team_member:m-1:t-1"] == -99.5 - counter_cache.redis_cache.async_increment_if_exists.assert_awaited_once_with( - key="spend:team_member:m-1:t-1", value=-100.0 - ) - counter_cache.in_memory_cache.delete_cache.assert_any_call(key="spend:team_member:m-2:t-2") - deleted_keys = {call.kwargs.get("key") for call in counter_cache.in_memory_cache.delete_cache.call_args_list} - assert "spend:team_member:m-1:t-1" not in deleted_keys + assert counter_cache.counters == {} + counter_cache.redis_cache.async_delete_cache.assert_any_await(key="spend:team_member:m-1:t-1") + counter_cache.redis_cache.async_delete_cache.assert_any_await(key="spend:team_member:m-2:t-2") + counter_cache.redis_cache.async_increment_if_exists.assert_not_awaited() + counter_cache.redis_cache.async_set_cache.assert_not_awaited() -def test_band_statements_reproduce_reset_spend_for_every_spend_value( +def test_budget_cascade_never_applies_snapshot_delta_to_a_counter_that_moved( reset_budget_job, mock_prisma_client, monkeypatch ): + """Regression: a flush that lands between the cascade's read and its commit + can move a row into a different band than the snapshot planned (30 read, + 130 at commit: the DB zeroes it instead of carrying -70). Replaying the + snapshot's delta would leave the counter at 30 against a DB row of 0, so the + counter must be dropped and reseeded, whatever value it holds at commit.""" + counter_cache = _make_counter_invalidation_job(monkeypatch) + counter_cache.counters["spend:team_member:m-1:t-1"] = 130.0 + banded = _budget_row(budget_id="budget-credit", budget_duration="7d", max_budget=100.0, rollover_max_budget=250.0) + mock_prisma_client.data["budget"] = [banded] + mock_prisma_client.db.litellm_teammembership.set_find_many_results( + [type("Membership", (), {"user_id": "m-1", "team_id": "t-1", "spend": 30.0, "budget_id": "budget-credit"})] + ) + + asyncio.run(reset_budget_job.reset_budget_for_litellm_budget_table()) + + membership_writes = _batch_writes(mock_prisma_client, "team_membership") + assert _replay_spend_writes(membership_writes, 130.0) == 0.0 + assert "spend:team_member:m-1:t-1" not in counter_cache.counters + counter_cache.redis_cache.async_delete_cache.assert_any_await(key="spend:team_member:m-1:t-1") + counter_cache.redis_cache.async_increment_if_exists.assert_not_awaited() + + +def test_band_statements_reproduce_reset_spend_for_every_spend_value(reset_budget_job, mock_prisma_client, monkeypatch): """Ordering proof: replaying the queued statements in order over rows at -400, -200, 0, 30, 100, 150 (base 100, cap 250, overage forgiven) must land each row exactly on _reset_spend. Any statement reordering or filter gap leaves at least one row wrong.""" _make_counter_invalidation_job(monkeypatch) - budget = _budget_row( - budget_id="budget-credit", budget_duration="7d", max_budget=100.0, rollover_max_budget=250.0 - ) + budget = _budget_row(budget_id="budget-credit", budget_duration="7d", max_budget=100.0, rollover_max_budget=250.0) mock_prisma_client.data["budget"] = [budget] mock_prisma_client.db.litellm_teammembership.set_find_many_results( [ diff --git a/tests/test_litellm/proxy/management_endpoints/test_customer_endpoints.py b/tests/test_litellm/proxy/management_endpoints/test_customer_endpoints.py index 37a50708251..108ee985366 100644 --- a/tests/test_litellm/proxy/management_endpoints/test_customer_endpoints.py +++ b/tests/test_litellm/proxy/management_endpoints/test_customer_endpoints.py @@ -10,10 +10,11 @@ from fastapi.testclient import TestClient from litellm.proxy._types import ( LiteLLM_EndUserTable, LitellmUserRoles, + NewCustomerRequest, ProxyException, ) from litellm.proxy.auth.user_api_key_auth import UserAPIKeyAuth, user_api_key_auth -from litellm.proxy.management_endpoints.customer_endpoints import router +from litellm.proxy.management_endpoints.customer_endpoints import new_budget_request, router from litellm.types.proxy.management_endpoints.common_daily_activity import ( SpendAnalyticsPaginatedResponse, ) @@ -377,6 +378,24 @@ def test_customer_new_documented_in_openapi_schema(): assert json_schema["$ref"].endswith("/CustomerResponse") +@pytest.mark.parametrize("rollover_max_budget", [-5, 0, float("inf")]) +def test_new_customer_budget_rejects_invalid_rollover_max_budget(rollover_max_budget): + """The inline budget a /customer/new request carries gets the same rollover cap validation as + /budget/new instead of persisting a cap the reset job would silently ignore.""" + with pytest.raises(HTTPException) as exc: + new_budget_request( + NewCustomerRequest(user_id="cust-1", max_budget=100, rollover_max_budget=rollover_max_budget) + ) + assert exc.value.status_code == 400 + assert "rollover_max_budget" in str(exc.value.detail) + + +def test_new_customer_budget_keeps_valid_rollover_max_budget(): + budget = new_budget_request(NewCustomerRequest(user_id="cust-1", max_budget=100, rollover_max_budget=250)) + assert budget is not None + assert budget.rollover_max_budget == 250 + + def test_update_customer_response_preserves_budget_id(mock_prisma_client, mock_user_api_key_auth): """ Regression for the response_model field-stripping concern: budget_id is a real @@ -857,9 +876,7 @@ def test_char_new_body(mock_prisma_client, mock_user_api_key_auth): @pytest.mark.parametrize("bad_duration", ["0s", "-5m"]) -def test_customer_new_rejects_a_duration_that_never_advances( - mock_prisma_client, mock_user_api_key_auth, bad_duration -): +def test_customer_new_rejects_a_duration_that_never_advances(mock_prisma_client, mock_user_api_key_auth, bad_duration): """A zero-length window resets to "now", leaving the customer's budget row permanently due for the reset job to re-read every tick.""" mock_prisma_client.db.litellm_endusertable.create = AsyncMock(return_value=_row(_FULL_DB_ROW)) diff --git a/tests/test_litellm/proxy/management_endpoints/test_organization_endpoints.py b/tests/test_litellm/proxy/management_endpoints/test_organization_endpoints.py index 47ee5dc1dd2..52ee193254f 100644 --- a/tests/test_litellm/proxy/management_endpoints/test_organization_endpoints.py +++ b/tests/test_litellm/proxy/management_endpoints/test_organization_endpoints.py @@ -10,7 +10,6 @@ from fastapi import HTTPException from fastapi.testclient import TestClient - @pytest.mark.asyncio async def test_organization_update_object_permissions_existing_permission(monkeypatch): """ @@ -641,6 +640,7 @@ async def test_organization_member_add_budget_omission_and_null_leave_budget_uns from litellm.proxy.management_endpoints.organization_endpoints import organization_member_add user = LiteLLM_UserTable(user_id="user-1", user_role="internal_user") + async def create_membership(data): return LiteLLM_OrganizationMembershipTable( user_id="user-1", @@ -956,6 +956,31 @@ async def test_v2_rejects_negative_max_budget(monkeypatch): assert "max_budget" in str(exc.value.detail) +@pytest.mark.asyncio +@pytest.mark.parametrize("rollover_max_budget", [-5, 0, float("inf")]) +async def test_new_organization_rejects_invalid_rollover_max_budget(monkeypatch, rollover_max_budget): + """/organization/new applies the same rollover cap validation as /budget/new, /user/new and /team/new + instead of persisting a cap the reset job would silently ignore.""" + from litellm.proxy._types import LitellmUserRoles, NewOrganizationRequest, UserAPIKeyAuth + from litellm.proxy.management_endpoints.organization_endpoints import new_organization + + prisma = AsyncMock() + monkeypatch.setattr("litellm.proxy.proxy_server.prisma_client", prisma) + monkeypatch.setattr("litellm.proxy.proxy_server.llm_router", MagicMock()) + + auth = UserAPIKeyAuth(user_role=LitellmUserRoles.PROXY_ADMIN, user_id="admin-1") + with pytest.raises(HTTPException) as exc: + await new_organization( + data=NewOrganizationRequest( + organization_alias="org-1", max_budget=100, rollover_max_budget=rollover_max_budget + ), + user_api_key_dict=auth, + ) + assert exc.value.status_code == 400 + assert "rollover_max_budget" in str(exc.value.detail) + prisma.db.litellm_budgettable.create.assert_not_called() + + @pytest.mark.asyncio @pytest.mark.parametrize("field", ["tpm_limit", "rpm_limit", "max_parallel_requests"]) async def test_v2_rejects_negative_integer_limits(monkeypatch: pytest.MonkeyPatch, field: str):