mirror of
https://github.com/BerriAI/litellm.git
synced 2026-09-24 00:52:24 +00:00
0d9c5159df
/config/field/info used to answer from the LiteLLM_Config row, so "the field 400s" proved the row did not carry it. It now answers from the resolved settings, and the CI stack config declares general_settings.max_parallel_requests, so the endpoint returns that value and the old assertion could never hold. The check that /add/allowed_ip writes only what the caller changed moves to /config/list, which still reports stored_in_db off the row, and the field/info call now asserts the ownership the endpoint reports: the config file owns the key, so it reads back as source=config and editable=false. Verified against a live proxy on an isolated Postgres rather than in CI, where this check has never run: it waits on protected-environment approval.
698 lines
25 KiB
Python
698 lines
25 KiB
Python
"""Live e2e: the config and miscellaneous Management/UI routes.
|
|
|
|
One method per registry cell, each asserting the real contract against a live
|
|
proxy: read-only inventory routes return their documented shape, stateless
|
|
validators compute their verdict from the request, and the write routes persist
|
|
so a read-back reflects the change. Router settings, which mutate global proxy
|
|
state, are exercised with a benign, self-restoring change so a shared proxy is left
|
|
as it was found.
|
|
|
|
Cache settings and the Vault config override are deliberately not covered here.
|
|
Both routes reconfigure the whole proxy: /cache/settings persists what it receives
|
|
into a row that outranks the YAML cache_params and is re-applied on a timer, and
|
|
/config_overrides/hashicorp_vault swaps the process-wide secret manager. Neither can
|
|
be exercised safely against the shared proxy the suites run on, so they need an
|
|
isolated proxy before a test lands. Do not add a read-then-write-back test for
|
|
either one.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import math
|
|
import time
|
|
from collections.abc import Callable
|
|
from typing import Final
|
|
|
|
import pytest
|
|
from pydantic import BaseModel, JsonValue, RootModel
|
|
|
|
from e2e_config import unique_marker
|
|
from e2e_http import NoBody, Success, unwrap, unwrap_status
|
|
from lifecycle import ResourceManager
|
|
from management_client import ManagementClient
|
|
from models import KeyGenerateBody, LiteLLMParamsBody, TeamNewBody
|
|
|
|
pytestmark = pytest.mark.e2e
|
|
|
|
|
|
def _poll[T](client: ManagementClient, attempt: Callable[[], T | None], failure: str) -> T:
|
|
deadline = time.monotonic() + client.proxy.poll_timeout
|
|
while time.monotonic() < deadline:
|
|
found = attempt()
|
|
if found is not None:
|
|
return found
|
|
time.sleep(client.proxy.poll_interval)
|
|
pytest.fail(failure)
|
|
|
|
|
|
# ---- callbacks -------------------------------------------------------------
|
|
|
|
|
|
class CallbacksListResponse(BaseModel):
|
|
success: list[str]
|
|
failure: list[str]
|
|
success_and_failure: list[str]
|
|
|
|
|
|
# ---- cost estimate ---------------------------------------------------------
|
|
|
|
|
|
class CostEstimateBody(BaseModel):
|
|
model: str
|
|
input_tokens: int
|
|
output_tokens: int
|
|
num_requests_per_day: int | None = None
|
|
|
|
|
|
class CostEstimateResponse(BaseModel):
|
|
model: str
|
|
input_tokens: int
|
|
output_tokens: int
|
|
cost_per_request: float
|
|
input_cost_per_request: float
|
|
output_cost_per_request: float
|
|
margin_cost_per_request: float
|
|
daily_cost: float | None = None
|
|
provider: str | None = None
|
|
|
|
|
|
# ---- credential migration check --------------------------------------------
|
|
|
|
|
|
class MigrationReport(BaseModel):
|
|
residual_legacy: int
|
|
total_undecryptable: int
|
|
|
|
|
|
class MigrationCheckResponse(BaseModel):
|
|
status: str
|
|
report: MigrationReport
|
|
|
|
|
|
# ---- tool + workflow inventories -------------------------------------------
|
|
|
|
|
|
class ToolListEntry(BaseModel):
|
|
name: str | None = None
|
|
|
|
|
|
class ToolListResponse(BaseModel):
|
|
tools: list[ToolListEntry]
|
|
total: int
|
|
|
|
|
|
class WorkflowRunEntry(BaseModel):
|
|
workflow_id: str | None = None
|
|
|
|
|
|
class WorkflowRunsResponse(BaseModel):
|
|
runs: list[WorkflowRunEntry]
|
|
count: int
|
|
|
|
|
|
# ---- compliance ------------------------------------------------------------
|
|
|
|
|
|
class ComplianceGdprBody(BaseModel):
|
|
request_id: str
|
|
user_id: str
|
|
model: str
|
|
timestamp: str
|
|
|
|
|
|
class ComplianceCheck(BaseModel):
|
|
check_name: str
|
|
article: str
|
|
passed: bool
|
|
detail: str
|
|
|
|
|
|
class ComplianceResponse(BaseModel):
|
|
compliant: bool
|
|
regulation: str
|
|
checks: list[ComplianceCheck]
|
|
|
|
|
|
# ---- fallback management ---------------------------------------------------
|
|
|
|
|
|
class FallbackShape(BaseModel):
|
|
model: str
|
|
fallback_models: list[str]
|
|
fallback_type: str
|
|
|
|
|
|
class FallbackCreateBody(FallbackShape):
|
|
pass
|
|
|
|
|
|
class FallbackResponse(FallbackShape):
|
|
message: str
|
|
|
|
|
|
class FallbackGetParams(BaseModel):
|
|
fallback_type: str
|
|
|
|
|
|
class FallbackGetResponse(FallbackShape):
|
|
pass
|
|
|
|
|
|
# ---- jwt key mapping -------------------------------------------------------
|
|
|
|
|
|
class JwtKeyMappingNewBody(BaseModel):
|
|
jwt_claim_name: str
|
|
jwt_claim_value: str
|
|
key: str
|
|
description: str
|
|
|
|
|
|
class JwtInfoParams(BaseModel):
|
|
id: str
|
|
|
|
|
|
class JwtDeleteBody(BaseModel):
|
|
id: str
|
|
|
|
|
|
class JwtKeyMappingResponse(BaseModel):
|
|
id: str
|
|
jwt_claim_name: str
|
|
jwt_claim_value: str
|
|
is_active: bool
|
|
description: str | None = None
|
|
|
|
|
|
# ---- router settings via /config/update ------------------------------------
|
|
|
|
|
|
class RouterSettingsPatch(BaseModel):
|
|
num_retries: int
|
|
|
|
|
|
class ConfigUpdateBody(BaseModel):
|
|
router_settings: RouterSettingsPatch
|
|
|
|
|
|
class ConfigUpdateResponse(BaseModel):
|
|
message: str
|
|
|
|
|
|
class AllowedIpBody(BaseModel):
|
|
ip: str
|
|
|
|
|
|
class ConfigFieldInfoParams(BaseModel):
|
|
field_name: str
|
|
|
|
|
|
class ConfigFieldInfoResponse(BaseModel):
|
|
field_name: str
|
|
field_value: JsonValue
|
|
source: str
|
|
editable: bool
|
|
|
|
|
|
class ConfigListParams(BaseModel):
|
|
config_type: str
|
|
|
|
|
|
class ConfigListEntry(BaseModel):
|
|
field_name: str
|
|
field_value: JsonValue
|
|
stored_in_db: bool | None
|
|
source: str
|
|
editable: bool
|
|
|
|
|
|
class ConfigListResponse(RootModel[list[ConfigListEntry]]):
|
|
pass
|
|
|
|
|
|
class RouterCurrentValues(BaseModel):
|
|
num_retries: int | None = None
|
|
|
|
|
|
class RouterSettingsResponse(BaseModel):
|
|
current_values: RouterCurrentValues
|
|
|
|
|
|
# ---- mcp server submission -------------------------------------------------
|
|
|
|
|
|
class McpRegisterBody(BaseModel):
|
|
server_name: str
|
|
url: str
|
|
transport: str
|
|
description: str
|
|
|
|
|
|
class McpServerResponse(BaseModel):
|
|
server_id: str
|
|
server_name: str | None = None
|
|
approval_status: str
|
|
transport: str
|
|
url: str | None = None
|
|
|
|
|
|
class TestInventoryRoutes:
|
|
@pytest.mark.covers("mgmt.callback.list.happy_path")
|
|
def test_callbacks_list_reports_active_logging_callbacks(self, client: ManagementClient) -> None:
|
|
listing = unwrap(
|
|
client.proxy.transport.get(
|
|
"/callbacks/list",
|
|
headers=client.proxy.transport.master,
|
|
params=NoBody(),
|
|
response_type=CallbacksListResponse,
|
|
)
|
|
)
|
|
every = [*listing.success, *listing.failure, *listing.success_and_failure]
|
|
assert every, "/callbacks/list reported no active logging callbacks; the proxy always runs the db logger"
|
|
assert "_ProxyDBLogger" in every, (
|
|
f"/callbacks/list omitted the always-on _ProxyDBLogger spend logger; got {every}"
|
|
)
|
|
|
|
@pytest.mark.covers("mgmt.tool_management.list.happy_path")
|
|
def test_tool_list_returns_catalog_with_consistent_total(self, client: ManagementClient) -> None:
|
|
listing = unwrap(
|
|
client.proxy.transport.get(
|
|
"/v1/tool/list",
|
|
headers=client.proxy.transport.master,
|
|
params=NoBody(),
|
|
response_type=ToolListResponse,
|
|
)
|
|
)
|
|
assert listing.total == len(listing.tools), (
|
|
f"/v1/tool/list total {listing.total} disagrees with the {len(listing.tools)} tools returned"
|
|
)
|
|
|
|
@pytest.mark.covers("mgmt.workflow.list.happy_path")
|
|
def test_workflow_runs_list_returns_consistent_count(self, client: ManagementClient) -> None:
|
|
listing = unwrap(
|
|
client.proxy.transport.get(
|
|
"/v1/workflows/runs",
|
|
headers=client.proxy.transport.master,
|
|
params=NoBody(),
|
|
response_type=WorkflowRunsResponse,
|
|
)
|
|
)
|
|
assert listing.count == len(listing.runs), (
|
|
f"/v1/workflows/runs count {listing.count} disagrees with the {len(listing.runs)} runs returned"
|
|
)
|
|
|
|
@pytest.mark.covers("mgmt.credential_migration.check.happy_path")
|
|
def test_credential_migration_check_reports_residual_scan(self, client: ManagementClient) -> None:
|
|
report = unwrap(
|
|
client.proxy.transport.get(
|
|
"/credentials/migrate-encryption/check",
|
|
headers=client.proxy.transport.master,
|
|
params=NoBody(),
|
|
response_type=MigrationCheckResponse,
|
|
)
|
|
)
|
|
assert report.status == "success", f"migrate-encryption/check status {report.status!r}, expected 'success'"
|
|
assert report.report.residual_legacy >= 0, (
|
|
f"residual_legacy count is negative ({report.report.residual_legacy}); the scan is broken"
|
|
)
|
|
assert report.report.total_undecryptable >= 0, (
|
|
f"total_undecryptable count is negative ({report.report.total_undecryptable}); the scan is broken"
|
|
)
|
|
|
|
|
|
class TestCostEstimate:
|
|
@pytest.mark.covers("mgmt.cost_tracking.estimate.happy_path")
|
|
def test_estimate_computes_cost_from_token_counts(self, client: ManagementClient) -> None:
|
|
estimate = unwrap(
|
|
client.proxy.transport.post(
|
|
"/cost/estimate",
|
|
headers=client.proxy.transport.master,
|
|
json=CostEstimateBody(
|
|
model="gpt-4o-mini", input_tokens=1000, output_tokens=500, num_requests_per_day=100
|
|
),
|
|
response_type=CostEstimateResponse,
|
|
)
|
|
)
|
|
assert estimate.input_cost_per_request > 0, (
|
|
f"input cost per request is {estimate.input_cost_per_request}; a priced model must cost more than zero"
|
|
)
|
|
assert estimate.output_cost_per_request > 0, (
|
|
f"output cost per request is {estimate.output_cost_per_request}; a priced model must cost more than zero"
|
|
)
|
|
expected_per_request = (
|
|
estimate.input_cost_per_request + estimate.output_cost_per_request + estimate.margin_cost_per_request
|
|
)
|
|
assert math.isclose(estimate.cost_per_request, expected_per_request, rel_tol=1e-9), (
|
|
f"cost_per_request {estimate.cost_per_request} != input+output+margin {expected_per_request}"
|
|
)
|
|
assert estimate.daily_cost is not None and math.isclose(
|
|
estimate.daily_cost, estimate.cost_per_request * 100, rel_tol=1e-9
|
|
), f"daily_cost {estimate.daily_cost} != cost_per_request * 100 requests {estimate.cost_per_request * 100}"
|
|
|
|
|
|
class TestComplianceRoutes:
|
|
@pytest.mark.covers("mgmt.compliance.gdpr.happy_path")
|
|
def test_gdpr_check_derives_verdict_from_the_request(self, client: ManagementClient) -> None:
|
|
result = unwrap(
|
|
client.proxy.transport.post(
|
|
"/compliance/gdpr",
|
|
headers=client.proxy.transport.master,
|
|
json=ComplianceGdprBody(
|
|
request_id=f"e2e-gdpr-{unique_marker()}",
|
|
user_id=f"e2e-user-{unique_marker()}",
|
|
model="gpt-4o-mini",
|
|
timestamp="2026-07-21T00:00:00Z",
|
|
),
|
|
response_type=ComplianceResponse,
|
|
)
|
|
)
|
|
assert result.regulation == "GDPR", (
|
|
f"/compliance/gdpr reported regulation {result.regulation!r}, expected 'GDPR'"
|
|
)
|
|
articles = {check.article for check in result.checks}
|
|
assert articles == {"Art. 32", "Art. 5(1)(c)", "Art. 30"}, (
|
|
f"/compliance/gdpr returned articles {articles}, expected the three GDPR articles"
|
|
)
|
|
assert result.compliant == all(check.passed for check in result.checks), (
|
|
"the overall compliant verdict must be the conjunction of the individual checks"
|
|
)
|
|
assert all(check.check_name and check.detail for check in result.checks), (
|
|
"every compliance check must carry a name and a human-readable detail"
|
|
)
|
|
|
|
|
|
class TestFallbackManagement:
|
|
@pytest.mark.covers("mgmt.fallback_management.update.happy_path")
|
|
def test_create_persists_and_is_read_back(self, client: ManagementClient, resources: ResourceManager) -> None:
|
|
primary = f"e2e-fallback-primary-{unique_marker()}"
|
|
secondary = f"e2e-fallback-secondary-{unique_marker()}"
|
|
params = LiteLLMParamsBody(model="openai/gpt-5.5", api_key="e2e-dummy-key")
|
|
primary_id = client.proxy.create_model(primary, params)
|
|
resources.defer(lambda: client.proxy.delete_model(primary_id))
|
|
secondary_id = client.proxy.create_model(secondary, params)
|
|
resources.defer(lambda: client.proxy.delete_model(secondary_id))
|
|
resources.defer(lambda: self._delete_fallback(client, primary))
|
|
|
|
created = unwrap(
|
|
client.proxy.transport.post(
|
|
"/fallback",
|
|
headers=client.proxy.transport.master,
|
|
json=FallbackCreateBody(model=primary, fallback_models=[secondary], fallback_type="general"),
|
|
response_type=FallbackResponse,
|
|
)
|
|
)
|
|
assert created.model == primary and created.fallback_models == [secondary], (
|
|
f"/fallback echoed model={created.model!r} fallbacks={created.fallback_models}, "
|
|
f"configured {primary!r} -> [{secondary!r}]"
|
|
)
|
|
|
|
def read_back() -> FallbackGetResponse | None:
|
|
result = client.proxy.transport.get(
|
|
f"/fallback/{primary}",
|
|
headers=client.proxy.transport.master,
|
|
params=FallbackGetParams(fallback_type="general"),
|
|
response_type=FallbackGetResponse,
|
|
)
|
|
match result:
|
|
case Success(data=data) if secondary in data.fallback_models:
|
|
return data
|
|
case _:
|
|
return None
|
|
|
|
got = _poll(client, read_back, f"GET /fallback/{primary} never reported {secondary} after /fallback")
|
|
assert got.fallback_models == [secondary], (
|
|
f"GET /fallback/{primary} reports fallbacks {got.fallback_models}, configured [{secondary!r}]"
|
|
)
|
|
|
|
@staticmethod
|
|
def _delete_fallback(client: ManagementClient, model: str) -> None:
|
|
_ = client.proxy.transport.delete(
|
|
f"/fallback/{model}",
|
|
headers=client.proxy.transport.master,
|
|
json=NoBody(),
|
|
params=FallbackGetParams(fallback_type="general"),
|
|
response_type=NoBody,
|
|
)
|
|
|
|
|
|
class TestJwtKeyMapping:
|
|
@pytest.mark.covers("mgmt.jwt_key_mapping.new.happy_path")
|
|
def test_new_persists_mapping_and_is_read_back(
|
|
self, client: ManagementClient, resources: ResourceManager
|
|
) -> None:
|
|
key = client.proxy.generate_key(KeyGenerateBody())
|
|
resources.defer(lambda: client.proxy.delete_key(key))
|
|
claim_value = f"e2e_jwt_{unique_marker()}"
|
|
|
|
created = unwrap(
|
|
client.proxy.transport.post(
|
|
"/jwt/key/mapping/new",
|
|
headers=client.proxy.transport.master,
|
|
json=JwtKeyMappingNewBody(
|
|
jwt_claim_name="team_id",
|
|
jwt_claim_value=claim_value,
|
|
key=key,
|
|
description="e2e coverage mapping",
|
|
),
|
|
response_type=JwtKeyMappingResponse,
|
|
)
|
|
)
|
|
resources.defer(lambda: self._delete_mapping(client, created.id))
|
|
assert created.jwt_claim_value == claim_value and created.is_active, (
|
|
f"/jwt/key/mapping/new returned claim_value={created.jwt_claim_value!r} active={created.is_active}, "
|
|
f"configured {claim_value!r} active=True"
|
|
)
|
|
|
|
info = unwrap(
|
|
client.proxy.transport.get(
|
|
"/jwt/key/mapping/info",
|
|
headers=client.proxy.transport.master,
|
|
params=JwtInfoParams(id=created.id),
|
|
response_type=JwtKeyMappingResponse,
|
|
)
|
|
)
|
|
assert info.id == created.id and info.jwt_claim_name == "team_id" and info.jwt_claim_value == claim_value, (
|
|
f"/jwt/key/mapping/info reports {info.jwt_claim_name!r}={info.jwt_claim_value!r} for id {info.id}, "
|
|
f"created team_id={claim_value!r}"
|
|
)
|
|
|
|
@staticmethod
|
|
def _delete_mapping(client: ManagementClient, mapping_id: str) -> None:
|
|
_ = client.proxy.transport.post(
|
|
"/jwt/key/mapping/delete",
|
|
headers=client.proxy.transport.master,
|
|
json=JwtDeleteBody(id=mapping_id),
|
|
response_type=NoBody,
|
|
)
|
|
|
|
|
|
class TestRouterSettings:
|
|
@pytest.mark.covers("mgmt.router_settings.update.happy_path")
|
|
def test_config_update_persists_router_setting_to_get(
|
|
self, client: ManagementClient, resources: ResourceManager
|
|
) -> None:
|
|
"""/config/update is the only write path for router_settings (there is no
|
|
dedicated router-settings write route). The change is restored on teardown so
|
|
the shared proxy keeps its original retry policy."""
|
|
original = self._read_num_retries(client)
|
|
assert original is not None, "GET /router/settings did not report num_retries; cannot prove a change"
|
|
resources.defer(lambda: self._write_num_retries(client, original))
|
|
|
|
target = original + 5
|
|
response = unwrap(
|
|
client.proxy.transport.post(
|
|
"/config/update",
|
|
headers=client.proxy.transport.master,
|
|
json=ConfigUpdateBody(router_settings=RouterSettingsPatch(num_retries=target)),
|
|
response_type=ConfigUpdateResponse,
|
|
)
|
|
)
|
|
assert "success" in response.message.lower(), (
|
|
f"/config/update reported {response.message!r}, expected a success message"
|
|
)
|
|
|
|
_ = _poll(
|
|
client,
|
|
lambda: True if self._read_num_retries(client) == target else None,
|
|
f"GET /router/settings never reported num_retries {target} after /config/update",
|
|
)
|
|
|
|
self._write_num_retries(client, original)
|
|
restored = _poll(
|
|
client,
|
|
lambda: original if self._read_num_retries(client) == original else None,
|
|
f"GET /router/settings never returned to the original num_retries {original} after the restore",
|
|
)
|
|
assert restored == original, f"router num_retries left at {restored}, expected the original {original}"
|
|
|
|
@staticmethod
|
|
def _read_num_retries(client: ManagementClient) -> int | None:
|
|
return unwrap(
|
|
client.proxy.transport.get(
|
|
"/router/settings",
|
|
headers=client.proxy.transport.master,
|
|
params=NoBody(),
|
|
response_type=RouterSettingsResponse,
|
|
)
|
|
).current_values.num_retries
|
|
|
|
@staticmethod
|
|
def _write_num_retries(client: ManagementClient, value: int) -> None:
|
|
_ = unwrap(
|
|
client.proxy.transport.post(
|
|
"/config/update",
|
|
headers=client.proxy.transport.master,
|
|
json=ConfigUpdateBody(router_settings=RouterSettingsPatch(num_retries=value)),
|
|
response_type=ConfigUpdateResponse,
|
|
)
|
|
)
|
|
|
|
|
|
class TestConfigPersistence:
|
|
@pytest.mark.covers("mgmt.config.allowed_ip.changed_key_only")
|
|
def test_add_allowed_ip_does_not_store_unrelated_config_value(
|
|
self, client: ManagementClient, resources: ResourceManager
|
|
) -> None:
|
|
allowed_ip: Final = "127.0.0.1"
|
|
added: Final = unwrap(
|
|
client.proxy.transport.post(
|
|
"/add/allowed_ip",
|
|
headers=client.proxy.transport.master,
|
|
json=AllowedIpBody(ip=allowed_ip),
|
|
response_type=ConfigUpdateResponse,
|
|
)
|
|
)
|
|
resources.defer(
|
|
lambda: unwrap(
|
|
client.proxy.transport.post(
|
|
"/delete/allowed_ip",
|
|
headers=client.proxy.transport.master,
|
|
json=AllowedIpBody(ip=allowed_ip),
|
|
response_type=ConfigUpdateResponse,
|
|
)
|
|
)
|
|
)
|
|
assert added.message == f"IP {allowed_ip} address added successfully"
|
|
|
|
listed: Final = unwrap(
|
|
client.proxy.transport.get(
|
|
"/config/list",
|
|
headers=client.proxy.transport.master,
|
|
params=ConfigListParams(config_type="general_settings"),
|
|
response_type=ConfigListResponse,
|
|
)
|
|
)
|
|
unrelated: Final = next(entry for entry in listed.root if entry.field_name == "max_parallel_requests")
|
|
assert unrelated.stored_in_db is not True
|
|
assert unrelated.source == "config"
|
|
assert unrelated.editable is False
|
|
|
|
field_info: Final = unwrap(
|
|
client.proxy.transport.get(
|
|
"/config/field/info",
|
|
headers=client.proxy.transport.master,
|
|
params=ConfigFieldInfoParams(field_name="max_parallel_requests"),
|
|
response_type=ConfigFieldInfoResponse,
|
|
)
|
|
)
|
|
assert field_info.source == "config"
|
|
assert field_info.editable is False
|
|
assert field_info.field_value == unrelated.field_value
|
|
|
|
|
|
class TestMcpServerSubmission:
|
|
@pytest.mark.covers("mgmt.mcp_server.register.happy_path")
|
|
def test_register_submits_pending_server(self, client: ManagementClient, resources: ResourceManager) -> None:
|
|
"""A non-admin, team-scoped key submits an MCP server for review; the proxy
|
|
stores it as pending_review without loading it into the runtime registry."""
|
|
team_id = client.create_team(TeamNewBody(team_alias=f"e2e-mcp-team-{unique_marker()}"))
|
|
resources.defer(lambda: client.delete_team(team_id))
|
|
team_key = client.proxy.generate_key(KeyGenerateBody(team_id=team_id))
|
|
resources.defer(lambda: client.proxy.delete_key(team_key))
|
|
|
|
server_name = f"e2e_mcp_{unique_marker()}"
|
|
submitted = unwrap_status(
|
|
client.proxy.transport.post(
|
|
"/v1/mcp/server/register",
|
|
headers=client.proxy.transport.bearer(team_key),
|
|
json=McpRegisterBody(
|
|
server_name=server_name,
|
|
url="https://example.com/mcp",
|
|
transport="sse",
|
|
description="e2e coverage submission",
|
|
),
|
|
response_type=McpServerResponse,
|
|
),
|
|
201,
|
|
)
|
|
resources.defer(lambda: self._delete_server(client, submitted.server_id))
|
|
assert submitted.approval_status == "pending_review", (
|
|
f"a user submission must be pending_review, got {submitted.approval_status!r}"
|
|
)
|
|
assert submitted.server_name == server_name and submitted.transport == "sse", (
|
|
f"/v1/mcp/server/register echoed name={submitted.server_name!r} transport={submitted.transport!r}, "
|
|
f"configured {server_name!r}/sse"
|
|
)
|
|
|
|
@pytest.mark.covers("mgmt.mcp_server.approve.persists")
|
|
def test_approve_activates_submission_and_persists(
|
|
self, client: ManagementClient, resources: ResourceManager
|
|
) -> None:
|
|
"""An admin approving a pending submission flips it to active, and the change
|
|
persists to a fresh read of the server."""
|
|
team_id = client.create_team(TeamNewBody(team_alias=f"e2e-mcp-team-{unique_marker()}"))
|
|
resources.defer(lambda: client.delete_team(team_id))
|
|
team_key = client.proxy.generate_key(KeyGenerateBody(team_id=team_id))
|
|
resources.defer(lambda: client.proxy.delete_key(team_key))
|
|
|
|
submitted = unwrap(
|
|
client.proxy.transport.post(
|
|
"/v1/mcp/server/register",
|
|
headers=client.proxy.transport.bearer(team_key),
|
|
json=McpRegisterBody(
|
|
server_name=f"e2e_mcp_{unique_marker()}",
|
|
url="https://example.com/mcp",
|
|
transport="sse",
|
|
description="e2e coverage submission",
|
|
),
|
|
response_type=McpServerResponse,
|
|
)
|
|
)
|
|
resources.defer(lambda: self._delete_server(client, submitted.server_id))
|
|
assert submitted.approval_status == "pending_review", (
|
|
f"a fresh submission must be pending_review before approval, got {submitted.approval_status!r}"
|
|
)
|
|
|
|
approved = unwrap(
|
|
client.proxy.transport.put(
|
|
f"/v1/mcp/server/{submitted.server_id}/approve",
|
|
headers=client.proxy.transport.master,
|
|
json=NoBody(),
|
|
response_type=McpServerResponse,
|
|
)
|
|
)
|
|
assert approved.approval_status == "active", (
|
|
f"approve must flip the submission to active, got {approved.approval_status!r}"
|
|
)
|
|
|
|
fetched = unwrap(
|
|
client.proxy.transport.get(
|
|
f"/v1/mcp/server/{submitted.server_id}",
|
|
headers=client.proxy.transport.master,
|
|
params=NoBody(),
|
|
response_type=McpServerResponse,
|
|
)
|
|
)
|
|
assert fetched.server_id == submitted.server_id and fetched.approval_status == "active", (
|
|
f"GET /v1/mcp/server/{submitted.server_id} reports approval_status {fetched.approval_status!r} "
|
|
"after approve, expected 'active'"
|
|
)
|
|
|
|
@staticmethod
|
|
def _delete_server(client: ManagementClient, server_id: str) -> None:
|
|
_ = client.proxy.transport.delete(
|
|
f"/v1/mcp/server/{server_id}",
|
|
headers=client.proxy.transport.master,
|
|
json=NoBody(),
|
|
response_type=NoBody,
|
|
)
|