fix(proxy): check user soft_budget against the effective max_budget on every update path

Validate soft_budget against the max_budget that a role change injects and on
the email upsert path, keep the generic SMTP body for key and team soft budget
alerts, add tests for the auth wiring, update and bulk paths, and drop the
unrelated test reformatting.
This commit is contained in:
Jesus Velarde 2026-11-14 14:20:15 -08:00
parent 16ebfb098f
commit 7b3c2982a2
6 changed files with 284 additions and 133 deletions

View file

@ -93,17 +93,12 @@ def _budget_alert_email_html(webhook_event: WebhookEvent, email_logo_url: str, e
Best, <br />
The LiteLLM team <br />
"""
if webhook_event.event == "soft_budget_crossed":
hard_limit: Final = (
f" until your budget of ${webhook_event.max_budget} is reached"
if webhook_event.max_budget is not None
else ""
)
if webhook_event.event == "soft_budget_crossed" and webhook_event.event_group == Litellm_EntityType.USER:
return f"""
<img src="{email_logo_url}" alt="LiteLLM Logo" width="150" height="50" />
<p> Hi {user_id}, <br/>
Your LLM API spend of <b> ${webhook_event.spend} </b> has reached your <b> soft budget of ${webhook_event.soft_budget} </b>. <br /> <br />
This is a warning only. API requests keep going through{hard_limit}. <br /> <br />
This is a warning only. API requests keep going through. <br /> <br />
If you have any questions, please send an email to {email_support_contact} <br /> <br />
Best, <br />
The LiteLLM team <br />

View file

@ -305,6 +305,11 @@ def _validate_user_soft_budget(soft_budget: float | None, max_budget: float | No
)
def _validate_updated_user_soft_budget(updates: _UserBudgetRow, stored: _UserBudgetRow) -> None:
budgets: Final = stored.model_copy(update=updates.model_dump(exclude_unset=True))
_validate_user_soft_budget(soft_budget=budgets.soft_budget, max_budget=budgets.max_budget)
async def _check_duplicate_user_field(
field_name: str,
field_value: str | None,
@ -1642,14 +1647,14 @@ async def _update_single_user_helper(
existing_user_row = await _user_table(prisma_client).find_first(where={"user_email": user_request.user_email})
_check_user_update_authz(user_request, user_api_key_dict, existing_user_row)
if "soft_budget" in non_default_values or "max_budget" in non_default_values:
_validate_updated_user_soft_budget(
_UserBudgetRow.model_validate(non_default_values),
_UserBudgetRow.model_validate(existing_user_row) if existing_user_row is not None else _UserBudgetRow(),
)
if existing_user_row is not None:
existing_user_row = LiteLLM_UserTable.model_validate(existing_user_row.model_dump(exclude_none=True))
requested: Final = user_request.model_fields_set
_validate_user_soft_budget(
soft_budget=user_request.soft_budget if "soft_budget" in requested else existing_user_row.soft_budget,
max_budget=user_request.max_budget if "max_budget" in requested else existing_user_row.max_budget,
)
if (
"budget_reset_at" in non_default_values
and isinstance(non_default_values["budget_duration"], str)
@ -2128,16 +2133,7 @@ async def bulk_user_update(
if "soft_budget" in non_default_values or "max_budget" in non_default_values:
for user_budget in _USER_BUDGET_ROWS.validate_python(all_users_in_db, from_attributes=True):
_validate_user_soft_budget(
soft_budget=(
data.user_updates.soft_budget
if "soft_budget" in non_default_values
else user_budget.soft_budget
),
max_budget=(
data.user_updates.max_budget if "max_budget" in non_default_values else user_budget.max_budget
),
)
_validate_updated_user_soft_budget(_UserBudgetRow.model_validate(non_default_values), user_budget)
shared_values: Final = MappingProxyType({k: v for k, v in non_default_values.items() if k != "budget_limits"})

View file

@ -103,7 +103,7 @@ def test_user_over_soft_budget_gets_alert_and_request_still_succeeds(
assert response["choices"], response
(alert, *_) = alerts_naming(alerting.alerts, user_id, seconds=ALERT_SECONDS)
assert "Soft Budget Crossed" in alert, alert
assert "soft_budget: 0.5" in alert, alert
assert "*soft_budget:* `0.5`" in alert, alert
def test_user_under_soft_budget_gets_no_alert(alerting: AlertingProxy) -> None:

View file

@ -621,8 +621,9 @@ async def test_daily_report_schedule_cache_calls_declare_their_key_family():
@pytest.fixture
def slack_alerting() -> SlackAlerting:
return SlackAlerting(alerting_threshold=1, internal_usage_cache=DualCache(), alerting=["slack"])
return SlackAlerting(
alerting_threshold=1, internal_usage_cache=DualCache(), alerting=["slack"]
)
key_info: Final = CallInfo(
token="test_token",
@ -664,7 +665,6 @@ key_no_max_budget_info: Final = CallInfo(
event_group=Litellm_EntityType.KEY,
)
@pytest.mark.parametrize(
"model, optional_params, expected_api_base",
[
@ -701,10 +701,11 @@ async def test_response_taking_too_long_callback(slack_alerting):
end_time = start_time + timedelta(seconds=301)
kwargs = {"model": "test_model", "messages": "test_messages", "litellm_params": {}}
with patch.object(slack_alerting, "send_alert", new=AsyncMock()) as mock_send_alert:
await slack_alerting.response_taking_too_long_callback(kwargs, None, start_time, end_time)
await slack_alerting.response_taking_too_long_callback(
kwargs, None, start_time, end_time
)
mock_send_alert.assert_awaited_once()
@pytest.mark.asyncio
async def test_alerting_metadata(slack_alerting):
"""
@ -718,13 +719,15 @@ async def test_alerting_metadata(slack_alerting):
"litellm_params": {"metadata": {"alerting_metadata": {"hello": "world"}}},
}
with patch.object(slack_alerting, "send_alert", new=AsyncMock()) as mock_send_alert:
## RESPONSE TAKING TOO LONG
await slack_alerting.response_taking_too_long_callback(kwargs, None, start_time, end_time)
await slack_alerting.response_taking_too_long_callback(
kwargs, None, start_time, end_time
)
mock_send_alert.assert_awaited_once()
assert "hello" in mock_send_alert.call_args[1]["alerting_metadata"]
@pytest.mark.asyncio
async def test_budget_alerts_crossed(slack_alerting):
user_max_budget = 100
@ -741,7 +744,6 @@ async def test_budget_alerts_crossed(slack_alerting):
)
mock_send_alert.assert_awaited_once()
@pytest.mark.asyncio
async def test_budget_alerts_crossed_again(slack_alerting):
user_max_budget = 100
@ -769,7 +771,6 @@ async def test_budget_alerts_crossed_again(slack_alerting):
)
mock_send_alert.assert_not_awaited()
@pytest.mark.asyncio
async def test_daily_reports_unit_test(slack_alerting):
with patch.object(slack_alerting, "send_alert", new=AsyncMock()) as mock_send_alert:
@ -789,7 +790,9 @@ async def test_daily_reports_unit_test(slack_alerting):
updated_at=litellm.utils.get_utc_datetime(),
)
updated_val = await slack_alerting.async_update_daily_reports(deployment_metrics=deployment_metrics)
updated_val = await slack_alerting.async_update_daily_reports(
deployment_metrics=deployment_metrics
)
assert updated_val == 1
@ -797,7 +800,6 @@ async def test_daily_reports_unit_test(slack_alerting):
mock_send_alert.assert_awaited_once()
@pytest.mark.asyncio
async def test_send_daily_reports_ignores_zero_values():
router = MagicMock()
@ -805,7 +807,9 @@ async def test_send_daily_reports_ignores_zero_values():
slack_alerting = SlackAlerting(internal_usage_cache=MagicMock())
# model1:failed=None, model2:failed=0, model3:failed=10, model1:latency=0; model2:latency=0; model3:latency=None
slack_alerting.internal_usage_cache.async_batch_get_cache = AsyncMock(return_value=[None, 0, 10, 0, 0, None])
slack_alerting.internal_usage_cache.async_batch_get_cache = AsyncMock(
return_value=[None, 0, 10, 0, 0, None]
)
slack_alerting.internal_usage_cache.async_set_cache_pipeline = AsyncMock()
router.registry.return_value.deployment_dict.side_effect = lambda x: {"litellm_params": {"model": x}}
@ -824,14 +828,15 @@ async def test_send_daily_reports_ignores_zero_values():
assert result == True
@pytest.mark.asyncio
async def test_send_daily_reports_all_zero_or_none():
router = MagicMock()
router.registry.return_value.names.return_value = ["model1", "model2", "model3"]
slack_alerting = SlackAlerting(internal_usage_cache=MagicMock())
slack_alerting.internal_usage_cache.async_batch_get_cache = AsyncMock(return_value=[None, 0, None, 0, None, 0])
slack_alerting.internal_usage_cache.async_batch_get_cache = AsyncMock(
return_value=[None, 0, None, 0, None, 0]
)
with patch.object(slack_alerting, "send_alert", new=AsyncMock()) as mock_send_alert:
result = await slack_alerting.send_daily_reports(router)
@ -841,7 +846,6 @@ async def test_send_daily_reports_all_zero_or_none():
assert result == False
@pytest.mark.parametrize(
"alerting_type",
[
@ -879,7 +883,6 @@ async def test_send_token_budget_crossed_alerts(alerting_type):
)
mock_send_alert.assert_awaited_once()
@pytest.mark.parametrize(
"alerting_type",
[
@ -895,7 +898,9 @@ async def test_send_token_budget_crossed_alerts(alerting_type):
async def test_webhook_alerting(alerting_type):
slack_alerting = SlackAlerting(alerting=["webhook"])
with patch.object(slack_alerting, "send_webhook_alert", new=AsyncMock()) as mock_send_alert:
with patch.object(
slack_alerting, "send_webhook_alert", new=AsyncMock()
) as mock_send_alert:
user_info = {
"token": "sk-test-mock-token-606",
"spend": 1,
@ -916,7 +921,6 @@ async def test_webhook_alerting(alerting_type):
)
mock_send_alert.assert_awaited_once()
@pytest.mark.parametrize(
"model, api_base, llm_provider, vertex_project, vertex_location",
[
@ -933,7 +937,9 @@ async def test_webhook_alerting(alerting_type):
)
@pytest.mark.parametrize("error_code", [500, 408, 400])
@pytest.mark.asyncio
async def test_outage_alerting_called(model, api_base, llm_provider, vertex_project, vertex_location, error_code):
async def test_outage_alerting_called(
model, api_base, llm_provider, vertex_project, vertex_location, error_code
):
"""
If call fails, outage alert is called
@ -954,7 +960,9 @@ async def test_outage_alerting_called(model, api_base, llm_provider, vertex_proj
)
elif error_code == 408:
print("RAISING 408 ERROR CODE")
error_to_raise = litellm.Timeout(message="A timeout occurred", model=model, llm_provider=llm_provider)
error_to_raise = litellm.Timeout(
message="A timeout occurred", model=model, llm_provider=llm_provider
)
elif error_code == 500:
print("RAISING 500 ERROR CODE")
error_to_raise = litellm.ServiceUnavailableError(
@ -988,7 +996,9 @@ async def test_outage_alerting_called(model, api_base, llm_provider, vertex_proj
)
slack_alerting.update_values(llm_router=router)
with patch.object(slack_alerting, "outage_alerts", new=AsyncMock()) as mock_outage_alert:
with patch.object(
slack_alerting, "outage_alerts", new=AsyncMock()
) as mock_outage_alert:
try:
await router.acompletion(
model=model,
@ -1016,7 +1026,6 @@ async def test_outage_alerting_called(model, api_base, llm_provider, vertex_proj
else:
mock_send_alert.assert_not_called()
@pytest.mark.parametrize(
"model, api_base, llm_provider, vertex_project, vertex_location",
[
@ -1041,7 +1050,9 @@ async def test_region_outage_alerting_called(
If multiple calls fail, outage alert is sent
"""
slack_alerting = SlackAlerting(alerting=["webhook"], alert_types=[AlertType.region_outage_alerts])
slack_alerting = SlackAlerting(
alerting=["webhook"], alert_types=[AlertType.region_outage_alerts]
)
litellm.callbacks = [slack_alerting]
@ -1056,7 +1067,9 @@ async def test_region_outage_alerting_called(
)
elif error_code == 408:
print("RAISING 408 ERROR CODE")
error_to_raise = litellm.Timeout(message="A timeout occurred", model=model, llm_provider=llm_provider)
error_to_raise = litellm.Timeout(
message="A timeout occurred", model=model, llm_provider=llm_provider
)
elif error_code == 500:
print("RAISING 500 ERROR CODE")
error_to_raise = litellm.ServiceUnavailableError(
@ -1109,15 +1122,13 @@ async def test_region_outage_alerting_called(
else:
deployment_id = "2"
await slack_alerting.region_outage_alerts(
exception=error_to_raise,
deployment_id=deployment_id, # type: ignore
exception=error_to_raise, deployment_id=deployment_id # type: ignore
)
if model == "gemini-3.8-flash" and (error_code == 500 or error_code == 408):
mock_send_alert.assert_called_once()
else:
mock_send_alert.assert_not_called()
@pytest.mark.asyncio
async def test_print_alerting_payload_warning():
"""
@ -1147,7 +1158,9 @@ async def test_print_alerting_payload_warning():
test_payload = {"text": "Test alert message"}
# Send an alert
with patch.object(slack_alerting.async_http_handler, "post", new=AsyncMock()) as mock_post:
with patch.object(
slack_alerting.async_http_handler, "post", new=AsyncMock()
) as mock_post:
await send_to_webhook(
slackAlertingInstance=slack_alerting,
item={
@ -1167,7 +1180,6 @@ async def test_print_alerting_payload_warning():
verbose_proxy_logger.removeHandler(handler)
log_stream.close()
@pytest.mark.asyncio
async def test_soft_budget_alerts():
"""
@ -1211,7 +1223,6 @@ async def test_soft_budget_alerts():
)
assert alert_message == expected_message
@pytest.mark.parametrize(
"entity_info",
[
@ -1276,10 +1287,29 @@ def test_soft_budget_crossed_email_names_spend_and_threshold() -> None:
assert "$52.5" in html
assert "soft budget of $50" in html
assert "until your budget of $100" in html
assert "will be rejected" not in html
@pytest.mark.parametrize("event_group", [Litellm_EntityType.KEY, Litellm_EntityType.TEAM])
def test_soft_budget_crossed_email_for_keys_and_teams_keeps_generic_body(event_group: Litellm_EntityType) -> None:
from litellm.integrations.SlackAlerting.slack_alerting import _budget_alert_email_html
from litellm.proxy._types import WebhookEvent
event: Final = WebhookEvent(
spend=6,
soft_budget=5,
token="hashed-token",
event="soft_budget_crossed",
event_group=event_group,
event_message="Soft budget crossed",
)
html: Final = _budget_alert_email_html(
webhook_event=event, email_logo_url="https://logo", email_support_contact="support@example.com"
)
assert html == "Alert from LiteLLM Server"
def test_budget_crossed_email_keeps_the_max_budget_body() -> None:
from litellm.integrations.SlackAlerting.slack_alerting import _budget_alert_email_html
from litellm.proxy._types import Litellm_EntityType, WebhookEvent

View file

@ -163,15 +163,12 @@ async def test_team_require_trace_id_accepts_supported_trace_carriers(
@pytest.mark.parametrize("route", ["/v1/traces", "/v1/logs", "/v1/traces/query"])
@pytest.mark.asyncio
async def test_team_require_trace_id_accepts_trace_telemetry_routes(route: str) -> None:
assert (
await _run_team_trace_id_check(
route=route,
method="POST",
request_body={},
team_metadata={"require_trace_id": True},
)
is True
)
assert await _run_team_trace_id_check(
route=route,
method="POST",
request_body={},
team_metadata={"require_trace_id": True},
) is True
@pytest.mark.asyncio
@ -203,14 +200,11 @@ async def test_team_require_trace_id_rejects_overridden_body_metadata_on_chat()
async def test_team_require_trace_id_accepts_effective_metadata_on_responses_route(
request_body: dict[str, object],
) -> None:
assert (
await _run_team_trace_id_check(
route="/v1/responses",
request_body=request_body,
team_metadata={"require_trace_id": True},
)
is True
)
assert await _run_team_trace_id_check(
route="/v1/responses",
request_body=request_body,
team_metadata={"require_trace_id": True},
) is True
@pytest.mark.parametrize(
@ -249,15 +243,12 @@ async def test_team_require_trace_id_rejects_fallback_carriers_when_litellm_trac
@pytest.mark.asyncio
async def test_team_require_trace_id_accepts_header_on_mcp_with_empty_body() -> None:
assert (
await _run_team_trace_id_check(
route="/mcp/",
request_body={},
headers={"x-litellm-trace-id": "trace-mcp-123"},
team_metadata={"require_trace_id": True},
)
is True
)
assert await _run_team_trace_id_check(
route="/mcp/",
request_body={},
headers={"x-litellm-trace-id": "trace-mcp-123"},
team_metadata={"require_trace_id": True},
) is True
@pytest.mark.parametrize(
@ -290,15 +281,12 @@ async def test_team_require_trace_id_rejects_nonheader_carriers_on_pass_through_
@pytest.mark.asyncio
async def test_team_require_trace_id_accepts_header_on_pass_through_route() -> None:
assert (
await _run_team_trace_id_check(
route="/anthropic/v1/messages",
request_body={},
headers={"x-litellm-trace-id": "trace-provider-123"},
team_metadata={"require_trace_id": True},
)
is True
)
assert await _run_team_trace_id_check(
route="/anthropic/v1/messages",
request_body={},
headers={"x-litellm-trace-id": "trace-provider-123"},
team_metadata={"require_trace_id": True},
) is True
@pytest.mark.parametrize(
@ -344,9 +332,7 @@ async def test_team_require_trace_id_rejects_nonheader_carriers_on_registered_pa
"jsonrpc": "2.0",
"id": "1",
"method": "message/send",
"params": {
"message": {"messageId": "msg-1", "role": "user", "parts": [{"type": "text", "text": "hi"}]}
},
"params": {"message": {"messageId": "msg-1", "role": "user", "parts": [{"type": "text", "text": "hi"}]}},
},
),
],
@ -387,9 +373,7 @@ async def test_team_require_trace_id_rejects_traceparent_on_mcp_and_agent_routes
"jsonrpc": "2.0",
"id": "1",
"method": "message/send",
"params": {
"message": {"messageId": "msg-1", "role": "user", "parts": [{"type": "text", "text": "hi"}]}
},
"params": {"message": {"messageId": "msg-1", "role": "user", "parts": [{"type": "text", "text": "hi"}]}},
"metadata": {"trace_id": "trace-body-123"},
},
),
@ -482,7 +466,7 @@ def test_lens_management_does_not_require_an_inference_user_parameter(route: str
async def test_get_end_user_object(customer_spend, customer_budget):
"""
Scenario 1: normal - get_end_user_object returns the cached user
Scenario 2: user over budget - NOTE: budget enforcement now happens in
Scenario 2: user over budget - NOTE: budget enforcement now happens in
common_checks() via _check_end_user_budget(), not in get_end_user_object()
This test verifies that get_end_user_object correctly retrieves the end user
@ -610,7 +594,7 @@ async def test_can_key_call_model(model, expect_to_work):
if expect_to_work:
await can_key_call_model(**args)
else:
with pytest.raises(Exception, match="is not available for this API key") as e:
with pytest.raises(Exception, match='is not available for this API key') as e:
await can_key_call_model(**args)
print(e)
@ -927,12 +911,16 @@ async def test_is_valid_fallback_model():
)
try:
await is_valid_fallback_model(model="gpt-3.5-turbo", llm_router=router, user_model=None)
await is_valid_fallback_model(
model="gpt-3.5-turbo", llm_router=router, user_model=None
)
except Exception as e:
pytest.fail(f"Expected is_valid_fallback_model to work, got exception: {e}")
with pytest.raises(Exception, match="Invalid") as exc_info:
await is_valid_fallback_model(model="gpt-4o", llm_router=router, user_model=None)
await is_valid_fallback_model(
model="gpt-4o", llm_router=router, user_model=None
)
e = exc_info.value
assert "Invalid" in str(e)
@ -946,7 +934,9 @@ async def test_is_valid_fallback_model():
],
)
@pytest.mark.asyncio
async def test_virtual_key_max_budget_check(token_spend, max_budget, expect_budget_error):
async def test_virtual_key_max_budget_check(
token_spend, max_budget, expect_budget_error
):
"""
Test if virtual key budget checks work as expected:
1. Triggers budget alert for all cases
@ -1061,7 +1051,9 @@ async def test_can_team_access_model(model, team_models, expect_to_work):
team_model_aliases=None,
)
if not expect_to_work:
pytest.fail(f"Expected model access check to fail for model={model}, team_models={team_models}")
pytest.fail(
f"Expected model access check to fail for model={model}, team_models={team_models}"
)
except Exception as e:
if expect_to_work:
pytest.fail(
@ -1114,9 +1106,9 @@ async def test_virtual_key_soft_budget_check(spend, soft_budget, expect_alert):
await asyncio.sleep(0.1) # Allow time for the alert task to complete
assert alert_triggered == expect_alert, (
f"Expected alert_triggered to be {expect_alert} for spend={spend}, soft_budget={soft_budget}"
)
assert (
alert_triggered == expect_alert
), f"Expected alert_triggered to be {expect_alert} for spend={spend}, soft_budget={soft_budget}"
@pytest.mark.parametrize(
@ -1169,7 +1161,9 @@ async def test_virtual_key_soft_budget_check(spend, soft_budget, expect_alert):
],
)
@pytest.mark.asyncio
async def test_team_soft_budget_check(spend, soft_budget, expect_alert, metadata, expected_alert_emails):
async def test_team_soft_budget_check(
spend, soft_budget, expect_alert, metadata, expected_alert_emails
):
"""
Test cases for _team_soft_budget_check:
1. Spend over soft budget, no alert_emails configured - should NOT trigger alert (alerts only sent when alert_emails configured)
@ -1217,9 +1211,9 @@ async def test_team_soft_budget_check(spend, soft_budget, expect_alert, metadata
await asyncio.sleep(0.1) # Allow time for the alert task to complete
assert alert_triggered == expect_alert, (
f"Expected alert_triggered to be {expect_alert} for spend={spend}, soft_budget={soft_budget}"
)
assert (
alert_triggered == expect_alert
), f"Expected alert_triggered to be {expect_alert} for spend={spend}, soft_budget={soft_budget}"
if expect_alert:
assert captured_call_info is not None
@ -1231,7 +1225,10 @@ async def test_team_soft_budget_check(spend, soft_budget, expect_alert, metadata
if expected_alert_emails is not None:
assert captured_call_info.alert_emails == expected_alert_emails
else:
assert captured_call_info.alert_emails is None or captured_call_info.alert_emails == []
assert (
captured_call_info.alert_emails is None
or captured_call_info.alert_emails == []
)
@pytest.mark.asyncio
@ -1362,7 +1359,9 @@ async def test_get_fuzzy_user_object():
# Test 5: Only email provided (no SSO ID)
mock_prisma.db.litellm_usertable.find_first = AsyncMock(return_value=test_user)
result = await _get_fuzzy_user_object(prisma_client=mock_prisma, user_email="test@example.com")
result = await _get_fuzzy_user_object(
prisma_client=mock_prisma, user_email="test@example.com"
)
assert result == test_user
mock_prisma.db.litellm_usertable.find_first.assert_called_with(
where={"user_email": {"equals": "test@example.com", "mode": "insensitive"}},
@ -1371,7 +1370,9 @@ async def test_get_fuzzy_user_object():
# Test 6: Only SSO ID provided (no email)
mock_prisma.db.litellm_usertable.find_unique = AsyncMock(return_value=test_user)
result = await _get_fuzzy_user_object(prisma_client=mock_prisma, sso_user_id="sso_123")
result = await _get_fuzzy_user_object(
prisma_client=mock_prisma, sso_user_id="sso_123"
)
assert result == test_user
mock_prisma.db.litellm_usertable.find_unique.assert_called_with(
where={"sso_user_id": "sso_123"}, include={"organization_memberships": True}
@ -1418,7 +1419,7 @@ async def test_can_key_call_model_with_aliases(model, alias_map, expect_to_work)
llm_router=router,
)
else:
with pytest.raises(Exception, match="is not available for this API key") as e:
with pytest.raises(Exception, match='is not available for this API key') as e:
await can_key_call_model(
model=model,
llm_model_list=llm_model_list,
@ -1504,7 +1505,9 @@ async def test_delete_cache_access_object():
],
)
@pytest.mark.asyncio
async def test_get_resources_from_access_groups(resource_field, access_group_data, expected):
async def test_get_resources_from_access_groups(
resource_field, access_group_data, expected
):
"""Test _get_resources_from_access_groups returns correct resource list from access groups."""
from unittest.mock import AsyncMock, MagicMock, patch
@ -2094,9 +2097,7 @@ def test_is_model_cost_zero_judges_an_alias_chain_by_the_deployment_its_entry_ro
model_group_alias={"chain-entry": "local-free", "local-free": "paid-gpt"},
)
expected: Final = {"chain-entry": True, "local-free": False, "paid-gpt": False}
order: Final = (
("chain-entry", "local-free", "paid-gpt") if entry_first else ("local-free", "paid-gpt", "chain-entry")
)
order: Final = ("chain-entry", "local-free", "paid-gpt") if entry_first else ("local-free", "paid-gpt", "chain-entry")
verdicts: Final = {name: is_model_cost_zero(model=name, llm_router=router) for name in order}
@ -2339,7 +2340,10 @@ async def test_bulk_eviction_clears_this_worker_before_waiting_on_a_wedged_redis
monkeypatch.setattr(pubsub_module, "_BULK_EVICTION_WAIT_SECONDS", 0.5)
client = _WedgedPublishRedisClient()
cache: Final = UserApiKeyCache(key_object_in_memory_cache=InMemoryCache(max_size_in_memory=2_000))
hashed_tokens: Final = tuple(hashlib.sha256(f"token-{index}".encode()).hexdigest() for index in range(600))
hashed_tokens: Final = tuple(
hashlib.sha256(f"token-{index}".encode()).hexdigest()
for index in range(600)
)
for hashed_token in hashed_tokens:
cache.set_local(hashed_token, {"token": hashed_token}, None)
seeded: Final = tuple(token for token in hashed_tokens if cache.get_local(token) is not None)
@ -2468,6 +2472,28 @@ async def test_bulk_eviction_broadcasts_while_the_usage_cache_redis_is_wedged(
assert {json.loads(message)["cache_key"] for message in client.published} == set(hashed_tokens)
@pytest.mark.parametrize("route", ("/v1/chat/completions", "/queue/chat/completions"))
def test_chat_routes_require_the_user_param_when_enforced(route: str) -> None:
from starlette.requests import Request
from litellm.proxy.auth.auth_checks import _enforce_user_param_check
request: Final = Request({"type": "http", "method": "POST", "path": route})
with pytest.raises(Exception, match="'user' param not passed"):
_enforce_user_param_check({"enforce_user_param": True}, request, {}, route)
_enforce_user_param_check({"enforce_user_param": True}, request, {"user": "u"}, route)
@pytest.mark.parametrize("route", ("/v1/chat/completions", "/queue/chat/completions"))
def test_spent_proxy_budget_refuses_chat_routes(monkeypatch: pytest.MonkeyPatch, route: str) -> None:
from litellm.proxy.auth.auth_checks import _global_proxy_budget_check
monkeypatch.setattr(litellm, "max_budget", 0.5)
_global_proxy_budget_check(global_proxy_spend=0.4, skip_budget_checks=False, route=route)
with pytest.raises(litellm.BudgetExceededError):
_global_proxy_budget_check(global_proxy_spend=1.0, skip_budget_checks=False, route=route)
@pytest.mark.parametrize(
"spend, soft_budget, expect_alert",
[
@ -2511,23 +2537,37 @@ async def test_user_soft_budget_check(spend: float, soft_budget: float | None, e
assert call_info.event_group == Litellm_EntityType.USER
@pytest.mark.parametrize("route", ("/v1/chat/completions", "/queue/chat/completions"))
def test_chat_routes_require_the_user_param_when_enforced(route: str) -> None:
from starlette.requests import Request
@pytest.mark.parametrize("max_budget", [None, 100.0])
@pytest.mark.asyncio
async def test_common_checks_alerts_user_over_soft_budget_without_blocking(max_budget: float | None) -> None:
from litellm.models.user import LiteLLM_UserTable
from litellm.proxy.auth.auth_checks import common_checks
from litellm.proxy.auth.auth_checks import _enforce_user_param_check
alerts: Final[list[tuple[str, CallInfo]]] = []
request: Final = Request({"type": "http", "method": "POST", "path": route})
with pytest.raises(Exception, match="'user' param not passed"):
_enforce_user_param_check({"enforce_user_param": True}, request, {}, route)
_enforce_user_param_check({"enforce_user_param": True}, request, {"user": "u"}, route)
class RecordingProxyLogging:
async def budget_alerts(self, type: str, user_info: CallInfo) -> None:
alerts.append((type, user_info))
user_id: Final = f"soft-user-{uuid.uuid4().hex}"
result: Final = await common_checks(
request_body={"model": "gpt-4o-mini"},
team_object=None,
user_object=LiteLLM_UserTable(user_id=user_id, soft_budget=5.0, max_budget=max_budget, spend=7.0),
end_user_object=None,
global_proxy_spend=None,
general_settings={},
route="/chat/completions",
llm_router=None,
proxy_logging_obj=cast(ProxyLogging, RecordingProxyLogging()), # cast-ok: test double for budget_alerts
valid_token=UserAPIKeyAuth(token=f"token-{user_id}", user_id=user_id),
request=MagicMock(),
)
await asyncio.sleep(0)
@pytest.mark.parametrize("route", ("/v1/chat/completions", "/queue/chat/completions"))
def test_spent_proxy_budget_refuses_chat_routes(monkeypatch: pytest.MonkeyPatch, route: str) -> None:
from litellm.proxy.auth.auth_checks import _global_proxy_budget_check
monkeypatch.setattr(litellm, "max_budget", 0.5)
_global_proxy_budget_check(global_proxy_spend=0.4, skip_budget_checks=False, route=route)
with pytest.raises(litellm.BudgetExceededError):
_global_proxy_budget_check(global_proxy_spend=1.0, skip_budget_checks=False, route=route)
assert result is True
soft_alerts: Final = [info for alert_type, info in alerts if alert_type == "soft_budget"]
assert len(soft_alerts) == 1, alerts
assert soft_alerts[0].user_id == user_id
assert soft_alerts[0].spend == 7.0
assert soft_alerts[0].soft_budget == 5.0

View file

@ -6060,3 +6060,93 @@ async def test_fips_user_update_hashes_off_the_event_loop(pbkdf2_on_event_loop:
assert pbkdf2_on_event_loop == [False]
assert data["password"].startswith("pbkdf2:")
def _soft_budget_prisma(mocker: MockerFixture, saved_users: tuple[LiteLLM_UserTable, ...]) -> MagicMock:
prisma_client: Final = mocker.MagicMock()
prisma_client.db.litellm_usertable.find_first = mocker.AsyncMock(return_value=saved_users[0] if saved_users else None)
prisma_client.db.litellm_usertable.find_many = mocker.AsyncMock(return_value=list(saved_users))
prisma_client.get_data = mocker.AsyncMock(return_value=list(saved_users))
prisma_client.update_data = mocker.AsyncMock()
prisma_client.insert_data = mocker.AsyncMock()
prisma_client.tx = lambda: _transaction_over(prisma_client.db)
mocker.patch(
"litellm.proxy.proxy_server.prisma_client", prisma_client
) # test-quality-ok: substitute the database dependency
return prisma_client
@pytest.mark.asyncio
@pytest.mark.parametrize(
("saved_users", "update"),
[
pytest.param(
(LiteLLM_UserTable(user_id="u-soft", user_role="proxy_admin_viewer", soft_budget=8),),
UpdateUserRequest(user_id="u-soft", user_role="internal_user"),
id="role-change-injects-lower-max",
),
pytest.param(
(),
UpdateUserRequest(user_email="new@example.test", soft_budget=100, max_budget=50),
id="email-upsert-of-new-user",
),
pytest.param(
(LiteLLM_UserTable(user_id="u-soft", soft_budget=8),),
UpdateUserRequest(user_id="u-soft", max_budget=8),
id="max-lowered-to-stored-soft",
),
],
)
async def test_user_update_rejects_soft_budget_at_or_above_effective_max_budget(
mocker: MockerFixture,
monkeypatch: pytest.MonkeyPatch,
saved_users: tuple[LiteLLM_UserTable, ...],
update: UpdateUserRequest,
) -> None:
import litellm
from litellm.proxy.management_endpoints.internal_user_endpoints import _update_single_user_helper
monkeypatch.setattr(litellm, "max_internal_user_budget", 5.0)
prisma_client: Final = _soft_budget_prisma(mocker, saved_users)
with pytest.raises(HTTPException) as caught:
await _update_single_user_helper(
user_request=update,
user_api_key_dict=UserAPIKeyAuth(user_id="admin-soft", user_role=LitellmUserRoles.PROXY_ADMIN),
)
assert caught.value.status_code == 400
assert "soft_budget" in str(caught.value.detail)
prisma_client.update_data.assert_not_awaited()
prisma_client.insert_data.assert_not_awaited()
@pytest.mark.asyncio
@pytest.mark.parametrize(
"user_updates",
[{"soft_budget": 5.0}, {"max_budget": 4.0}],
ids=["soft-above-one-users-max", "max-below-one-users-soft"],
)
async def test_bulk_user_update_checks_soft_budget_against_each_user(
mocker: MockerFixture, user_updates: dict[str, float]
) -> None:
from litellm.proxy.management_endpoints.internal_user_endpoints import bulk_user_update
from litellm.types.proxy.management_endpoints.internal_user_endpoints import BulkUpdateUserRequest
saved_users: Final = (
LiteLLM_UserTable(user_id="u-open"),
LiteLLM_UserTable(user_id="u-tight", max_budget=3.0, soft_budget=None),
LiteLLM_UserTable(user_id="u-soft", soft_budget=6.0),
)
prisma_client: Final = _soft_budget_prisma(mocker, saved_users)
prisma_client.db.litellm_usertable.update_many = mocker.AsyncMock(return_value=len(saved_users))
with pytest.raises(HTTPException) as caught:
await bulk_user_update(
data=BulkUpdateUserRequest(all_users=True, user_updates=user_updates),
user_api_key_dict=UserAPIKeyAuth(user_id="admin-soft", user_role=LitellmUserRoles.PROXY_ADMIN),
litellm_changed_by=None,
)
assert caught.value.status_code == 400
prisma_client.db.litellm_usertable.update_many.assert_not_awaited()