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>
This commit is contained in:
ryan 2026-09-18 12:38:45 +00:00
parent dee583470b
commit 74e7940ef6
6 changed files with 145 additions and 97 deletions

View file

@ -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)

View file

@ -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)

View file

@ -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

View file

@ -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(
[

View file

@ -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))

View file

@ -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):