mirror of
https://github.com/BerriAI/litellm.git
synced 2026-11-21 10:15:47 +00:00
Merge d2f3c7a86c into 4710c3b30e
This commit is contained in:
commit
b1dcc9119c
6 changed files with 1358 additions and 6 deletions
|
|
@ -32,6 +32,7 @@ from litellm._uuid import uuid
|
|||
from litellm.llms.custom_httpx.http_handler import AsyncHTTPHandler
|
||||
from litellm.proxy._types import *
|
||||
from litellm.proxy.auth.auth_checks import (
|
||||
TeamNotFoundError,
|
||||
delete_cache_key_objects,
|
||||
forget_missing_user,
|
||||
get_jwt_key_mapping_cache_keys_for_tokens,
|
||||
|
|
@ -80,9 +81,11 @@ from litellm.proxy.management_helpers.object_permission_utils import ( # noqa:
|
|||
_set_object_permission, # pyright: ignore[reportPrivateUsage,reportUnusedImport] # backwards-compatible package export
|
||||
handle_update_object_permission_common,
|
||||
set_object_permission,
|
||||
validate_user_mcp_grants_against_teams,
|
||||
)
|
||||
from litellm.proxy.management_helpers.utils import management_endpoint_wrapper
|
||||
from litellm.proxy.utils import handle_exception_on_proxy, hash_password
|
||||
from litellm.repositories.object_permission_repository import ObjectPermissionRepository
|
||||
from litellm.repositories.organization_repository import OrganizationRepository
|
||||
from litellm.repositories.prisma_protocols import TableActions
|
||||
from litellm.repositories.table_repositories import (
|
||||
|
|
@ -459,6 +462,73 @@ async def _fetch_user_team_ids(user_id: str, prisma_client: "PrismaClient") -> t
|
|||
return tuple(user_row.teams) if user_row is not None else ()
|
||||
|
||||
|
||||
async def _load_user_mcp_grant_teams(
|
||||
team_ids: Sequence[str],
|
||||
prisma_client: "PrismaClient",
|
||||
user_api_key_cache: "UserApiKeyCache",
|
||||
) -> tuple["LiteLLM_TeamTableCachedObj", ...]:
|
||||
async def _load_team(team_id: str) -> "LiteLLM_TeamTableCachedObj | None":
|
||||
try:
|
||||
return await get_team_object(
|
||||
team_id=team_id,
|
||||
prisma_client=prisma_client,
|
||||
user_api_key_cache=user_api_key_cache,
|
||||
check_db_only=True,
|
||||
)
|
||||
except TeamNotFoundError:
|
||||
return None
|
||||
|
||||
return tuple(
|
||||
team_obj
|
||||
for team_obj in await asyncio.gather(*(_load_team(team_id) for team_id in team_ids))
|
||||
if team_obj is not None
|
||||
)
|
||||
|
||||
|
||||
async def _validate_user_mcp_grants(
|
||||
object_permission: object,
|
||||
team_ids: Sequence[str],
|
||||
existing_object_permission_id: str | None,
|
||||
prisma_client: "PrismaClient",
|
||||
user_api_key_cache: "UserApiKeyCache",
|
||||
*,
|
||||
is_proxy_admin: bool,
|
||||
) -> None:
|
||||
validated_object_permission: Final[ObjectPermissionDict | None] = TypeAdapter[ObjectPermissionDict | None](
|
||||
ObjectPermissionDict | None
|
||||
).validate_python(object_permission)
|
||||
if validated_object_permission is None or (not team_ids and is_proxy_admin):
|
||||
return
|
||||
|
||||
team_objs: Final = (
|
||||
await _load_user_mcp_grant_teams(
|
||||
team_ids=team_ids,
|
||||
prisma_client=prisma_client,
|
||||
user_api_key_cache=user_api_key_cache,
|
||||
)
|
||||
if team_ids
|
||||
else ()
|
||||
)
|
||||
existing_object_permission_row: Final = (
|
||||
await ObjectPermissionRepository(prisma_client).table.find_unique(
|
||||
where={"object_permission_id": existing_object_permission_id},
|
||||
)
|
||||
if existing_object_permission_id is not None
|
||||
else None
|
||||
)
|
||||
existing_object_permission: Final[LiteLLM_ObjectPermissionTable | None] = (
|
||||
LiteLLM_ObjectPermissionTable.model_validate(existing_object_permission_row.model_dump())
|
||||
if existing_object_permission_row is not None
|
||||
else None
|
||||
)
|
||||
await validate_user_mcp_grants_against_teams(
|
||||
object_permission=validated_object_permission,
|
||||
team_objs=team_objs,
|
||||
prisma_client=prisma_client,
|
||||
existing_user_object_permission=existing_object_permission,
|
||||
)
|
||||
|
||||
|
||||
@router.post(
|
||||
"/user/new",
|
||||
tags=["Internal User management"],
|
||||
|
|
@ -535,7 +605,7 @@ async def new_user(
|
|||
```
|
||||
"""
|
||||
try:
|
||||
from litellm.proxy.proxy_server import _license_check, prisma_client
|
||||
from litellm.proxy.proxy_server import _license_check, prisma_client, user_api_key_cache
|
||||
|
||||
if prisma_client is None:
|
||||
raise HTTPException(status_code=400, detail=CommonProxyErrors.db_not_connected_error.value)
|
||||
|
|
@ -582,6 +652,22 @@ async def new_user(
|
|||
|
||||
data_json = data.json()
|
||||
data_json = _update_internal_new_user_params(data_json, data)
|
||||
teams: Final = data.teams if data.teams is not None else check_if_default_team_set()
|
||||
team_ids: Final = (
|
||||
(data.team_id,)
|
||||
if data.team_id is not None
|
||||
else tuple(team if isinstance(team, str) else team.team_id for team in teams or ())
|
||||
)
|
||||
await _validate_user_mcp_grants(
|
||||
object_permission=TypeAdapter[dict[str, object]](dict[str, object])
|
||||
.validate_python(data_json)
|
||||
.get("object_permission"),
|
||||
team_ids=team_ids,
|
||||
existing_object_permission_id=None,
|
||||
prisma_client=prisma_client,
|
||||
user_api_key_cache=user_api_key_cache,
|
||||
is_proxy_admin=user_api_key_dict.user_role == LitellmUserRoles.PROXY_ADMIN.value,
|
||||
)
|
||||
# Persist the requested grants as their own row and link it, mirroring key/team creation.
|
||||
# generate_key_helper_fn only forwards object_permission_id, so without this the entitlement
|
||||
# the caller sent would be dropped on the floor.
|
||||
|
|
@ -589,9 +675,6 @@ async def new_user(
|
|||
data_json=data_json, prisma_client=prisma_client
|
||||
)
|
||||
data_json.pop("password", None)
|
||||
teams = data.teams
|
||||
if teams is None:
|
||||
teams = check_if_default_team_set()
|
||||
organization_ids: Final = cast(list[str] | None, data_json.pop("organizations", None))
|
||||
|
||||
response: Final = await generate_key_helper_fn(request_type="user", **data_json, llm_router=None)
|
||||
|
|
@ -1539,6 +1622,20 @@ async def _update_single_user_helper(
|
|||
# Upsert the grants into their own row and link it, mirroring /key/update and /team/update.
|
||||
# This also removes object_permission from the payload, which is not a column on the user table.
|
||||
if "object_permission" in non_default_values:
|
||||
await _validate_user_mcp_grants(
|
||||
object_permission=TypeAdapter[dict[str, object]](dict[str, object]).validate_python(non_default_values)[
|
||||
"object_permission"
|
||||
],
|
||||
team_ids=TypeAdapter[tuple[str, ...]](tuple[str, ...]).validate_python(
|
||||
getattr(existing_user_row, "teams", ()) or ()
|
||||
),
|
||||
existing_object_permission_id=TypeAdapter[str | None](str | None).validate_python(
|
||||
getattr(existing_user_row, "object_permission_id", None)
|
||||
),
|
||||
prisma_client=prisma_client,
|
||||
user_api_key_cache=user_api_key_cache,
|
||||
is_proxy_admin=user_api_key_dict.user_role == LitellmUserRoles.PROXY_ADMIN.value,
|
||||
)
|
||||
object_permission_id: Final = await handle_update_object_permission_common(
|
||||
data_json=non_default_values,
|
||||
existing_object_permission_id=getattr(existing_user_row, "object_permission_id", None),
|
||||
|
|
|
|||
|
|
@ -40,6 +40,7 @@ from litellm.proxy.management.teams.dependencies import get_team_access
|
|||
from litellm.proxy.management_endpoints.common_utils import validate_budget_duration
|
||||
from litellm.proxy.management_endpoints.internal_user_endpoints import (
|
||||
_update_internal_new_user_params, # pyright: ignore[reportPrivateUsage, reportUnknownVariableType] # /user/new defaults; result validated below
|
||||
_validate_user_mcp_grants, # pyright: ignore[reportPrivateUsage] # shared user-grant validator
|
||||
check_if_default_team_set,
|
||||
)
|
||||
from litellm.proxy.management_endpoints.key_management_endpoints import ( # noqa: F401 # legacy module exports
|
||||
|
|
@ -340,11 +341,24 @@ def _db_failure(
|
|||
return None
|
||||
|
||||
|
||||
async def _prepare_user(user: _PendingUser, prisma_client: PrismaClient) -> _PreparedUser | _RowFailure:
|
||||
async def _prepare_user(
|
||||
user: _PendingUser,
|
||||
prisma_client: PrismaClient,
|
||||
user_api_key_cache: "UserApiKeyCache",
|
||||
is_proxy_admin: bool,
|
||||
) -> _PreparedUser | _RowFailure:
|
||||
try:
|
||||
dumped: Final = user.request.model_dump(exclude={"user_id"})
|
||||
data: Final = {**dumped, "user_id": user.user_id}
|
||||
data_json: Final = _JSON_OBJECT.validate_python(_update_internal_new_user_params(data, user.request))
|
||||
await _validate_user_mcp_grants(
|
||||
object_permission=data_json.get("object_permission"),
|
||||
team_ids=tuple(team.team_id for team in user.teams),
|
||||
existing_object_permission_id=None,
|
||||
prisma_client=prisma_client,
|
||||
user_api_key_cache=user_api_key_cache,
|
||||
is_proxy_admin=is_proxy_admin,
|
||||
)
|
||||
with_permission: Final = _JSON_OBJECT.validate_python(
|
||||
await set_object_permission(data_json=data_json, prisma_client=prisma_client)
|
||||
)
|
||||
|
|
@ -783,6 +797,7 @@ async def bulk_create_users(
|
|||
pending, request_failures = _partition_rows(users, user_api_key_dict)
|
||||
existing_ids, existing_emails = await _existing_user_conflicts(prisma_client, pending)
|
||||
teams, team_errors = await _unusable_teams(prisma_client, pending, user_api_key_dict)
|
||||
is_proxy_admin: Final = user_api_key_dict.user_role == LitellmUserRoles.PROXY_ADMIN.value
|
||||
db_failures: Final = tuple(
|
||||
failure
|
||||
for user in pending
|
||||
|
|
@ -802,7 +817,17 @@ async def bulk_create_users(
|
|||
)
|
||||
)
|
||||
|
||||
prepared_outcomes: Final = tuple([await _prepare_user(user, prisma_client) for user in creatable])
|
||||
prepared_outcomes: Final = tuple(
|
||||
[
|
||||
await _prepare_user(
|
||||
user,
|
||||
prisma_client,
|
||||
user_api_key_cache,
|
||||
is_proxy_admin=is_proxy_admin,
|
||||
)
|
||||
for user in creatable
|
||||
]
|
||||
)
|
||||
prepare_failures: Final = tuple(o for o in prepared_outcomes if isinstance(o, _RowFailure))
|
||||
created, insert_failures = await _insert_users(
|
||||
prisma_client, tuple(o for o in prepared_outcomes if isinstance(o, _PreparedUser))
|
||||
|
|
|
|||
|
|
@ -3,6 +3,7 @@ Common utility functions for handling object permission updates across
|
|||
organizations, teams, and keys.
|
||||
"""
|
||||
|
||||
import asyncio
|
||||
import json
|
||||
from collections.abc import Iterable, Mapping, Sequence
|
||||
from collections.abc import Set as AbstractSet
|
||||
|
|
@ -855,6 +856,128 @@ def _validate_requested_toolsets(
|
|||
)
|
||||
|
||||
|
||||
async def validate_user_mcp_grants_against_teams(
|
||||
object_permission: ObjectPermissionDict | None,
|
||||
team_objs: Sequence["LiteLLM_TeamTableCachedObj"],
|
||||
prisma_client: PrismaClient | None = None,
|
||||
existing_user_object_permission: "LiteLLM_ObjectPermissionTable | None" = None,
|
||||
) -> None:
|
||||
"""Validate user MCP grants against the combined grants of the user's teams."""
|
||||
requested_servers: Final = _extract_requested_mcp_server_ids(object_permission)
|
||||
requested_access_groups: Final = _extract_requested_mcp_access_groups(object_permission)
|
||||
requested_toolsets: Final = _extract_requested_mcp_toolsets(object_permission)
|
||||
if not requested_servers and not requested_access_groups and not requested_toolsets:
|
||||
return
|
||||
|
||||
allow_all_keys_servers: Final = get_allow_all_keys_server_ids()
|
||||
team_server_results: Final = await asyncio.gather(
|
||||
*(get_team_allowed_mcp_servers(team_obj=team_obj, prisma_client=prisma_client) for team_obj in team_objs)
|
||||
)
|
||||
team_allowed_servers: Final = frozenset[str]().union(*team_server_results)
|
||||
all_allowed_servers: Final = team_allowed_servers | allow_all_keys_servers
|
||||
grandfathered_servers: Final = (
|
||||
await _get_grandfathered_key_mcp_server_ids(
|
||||
existing_object_permission=existing_user_object_permission,
|
||||
prisma_client=prisma_client,
|
||||
)
|
||||
if requested_servers or requested_toolsets
|
||||
else frozenset[str]()
|
||||
)
|
||||
allowed_mcp_servers: Final = all_allowed_servers | grandfathered_servers
|
||||
|
||||
if requested_servers:
|
||||
identifier_to_server_ids: Final = await _resolve_mcp_server_identifiers_to_ids(
|
||||
identifiers=requested_servers,
|
||||
prisma_client=prisma_client,
|
||||
)
|
||||
active_requested_servers: Final = _flatten_resolved_mcp_server_ids(identifier_to_server_ids)
|
||||
disallowed_servers: Final = active_requested_servers - allowed_mcp_servers
|
||||
if disallowed_servers:
|
||||
raise HTTPException(
|
||||
status_code=status.HTTP_403_FORBIDDEN,
|
||||
detail={
|
||||
"error": (
|
||||
"User requests MCP servers not allowed by any of the user's teams: "
|
||||
f"{sorted(disallowed_servers)}."
|
||||
)
|
||||
},
|
||||
)
|
||||
|
||||
if requested_access_groups:
|
||||
team_access_groups: Final = frozenset[str]().union(
|
||||
*(
|
||||
team_obj.object_permission.mcp_access_groups or []
|
||||
for team_obj in team_objs
|
||||
if team_obj.object_permission is not None
|
||||
)
|
||||
)
|
||||
existing_access_groups: Final = (
|
||||
frozenset(existing_user_object_permission.mcp_access_groups or [])
|
||||
if existing_user_object_permission is not None
|
||||
else frozenset[str]()
|
||||
)
|
||||
allowed_access_groups: Final = team_access_groups | existing_access_groups
|
||||
disallowed_groups: Final = requested_access_groups - allowed_access_groups
|
||||
if disallowed_groups:
|
||||
raise HTTPException(
|
||||
status_code=status.HTTP_403_FORBIDDEN,
|
||||
detail={
|
||||
"error": (
|
||||
"User requests MCP access groups not allowed by any of the user's teams: "
|
||||
f"{sorted(disallowed_groups)}."
|
||||
)
|
||||
},
|
||||
)
|
||||
|
||||
if requested_toolsets:
|
||||
team_toolsets: Final = frozenset[str]().union(
|
||||
*(
|
||||
team_obj.object_permission.mcp_toolsets or []
|
||||
for team_obj in team_objs
|
||||
if team_obj.object_permission is not None
|
||||
)
|
||||
)
|
||||
existing_toolsets: Final = (
|
||||
frozenset(existing_user_object_permission.mcp_toolsets or [])
|
||||
if existing_user_object_permission is not None
|
||||
else frozenset[str]()
|
||||
)
|
||||
remaining_toolsets: Final = tuple(sorted(requested_toolsets - team_toolsets - existing_toolsets))
|
||||
if remaining_toolsets:
|
||||
from litellm.proxy._experimental.mcp_server.mcp_server_manager import (
|
||||
global_mcp_server_manager,
|
||||
)
|
||||
|
||||
resolved_toolset_permissions: Final = await asyncio.gather(
|
||||
*(
|
||||
global_mcp_server_manager.resolve_toolset_tool_permissions(
|
||||
toolset_ids=[toolset_id],
|
||||
requires_fresh_policy=True,
|
||||
)
|
||||
for toolset_id in remaining_toolsets
|
||||
)
|
||||
)
|
||||
disallowed_toolsets: Final = frozenset(
|
||||
toolset_id
|
||||
for toolset_id, tool_permissions in zip(
|
||||
remaining_toolsets,
|
||||
resolved_toolset_permissions,
|
||||
strict=True,
|
||||
)
|
||||
if not tool_permissions or not set(tool_permissions).issubset(allowed_mcp_servers)
|
||||
)
|
||||
if disallowed_toolsets:
|
||||
raise HTTPException(
|
||||
status_code=status.HTTP_403_FORBIDDEN,
|
||||
detail={
|
||||
"error": (
|
||||
"User requests MCP toolsets not allowed by any of the user's teams: "
|
||||
f"{sorted(disallowed_toolsets)}."
|
||||
)
|
||||
},
|
||||
)
|
||||
|
||||
|
||||
def _extract_requested_vector_stores(
|
||||
object_permission: ObjectPermissionDict | None,
|
||||
) -> set[str]:
|
||||
|
|
|
|||
|
|
@ -13,6 +13,7 @@ import httpx
|
|||
import pytest
|
||||
from fastapi import HTTPException
|
||||
from fastapi.testclient import TestClient
|
||||
from prisma.models import LiteLLM_ObjectPermissionTable as PrismaLiteLLM_ObjectPermissionTable
|
||||
from pytest_mock import MockerFixture
|
||||
|
||||
from litellm.llms.custom_httpx.http_handler import AsyncHTTPHandler
|
||||
|
|
@ -5211,3 +5212,534 @@ async def test_user_update_without_password_revokes_nothing(_admin_prisma, mocke
|
|||
await _update_single_user_helper(user_request=user_request, user_api_key_dict=admin_caller)
|
||||
|
||||
revoke_mock.assert_not_awaited()
|
||||
|
||||
|
||||
def _user_mcp_grant_prisma_mocks(mocker: MockerFixture, teams: Sequence[str] = ()) -> MagicMock:
|
||||
mock_prisma_client: Final = mocker.MagicMock()
|
||||
existing_user: Final = mocker.MagicMock()
|
||||
existing_user.model_dump.return_value = {
|
||||
"user_id": "target-user",
|
||||
"object_permission_id": None,
|
||||
"teams": list(teams),
|
||||
}
|
||||
existing_user.user_id = "target-user"
|
||||
existing_user.object_permission_id = None
|
||||
mock_prisma_client.db.litellm_usertable.find_first = mocker.AsyncMock(return_value=existing_user)
|
||||
mock_prisma_client.db.litellm_objectpermissiontable.find_unique = mocker.AsyncMock(return_value=None)
|
||||
mock_prisma_client.db.litellm_objectpermissiontable.upsert = mocker.AsyncMock(
|
||||
return_value=SimpleNamespace(object_permission_id="perm-new")
|
||||
)
|
||||
mock_prisma_client.db.litellm_mcpservertable.find_many = mocker.AsyncMock(return_value=[])
|
||||
mock_prisma_client.update_data = mocker.AsyncMock(return_value={"user_id": "target-user"})
|
||||
mock_prisma_client.jsonify_object = mocker.MagicMock(side_effect=lambda value: value)
|
||||
mocker.patch("litellm.proxy.proxy_server.prisma_client", mock_prisma_client)
|
||||
mocker.patch("litellm.proxy.proxy_server.litellm_proxy_admin_name", "admin")
|
||||
mocker.patch(
|
||||
"litellm.proxy.proxy_server.invalidate_spend_counter",
|
||||
new=mocker.AsyncMock(),
|
||||
)
|
||||
return mock_prisma_client
|
||||
|
||||
|
||||
def _patch_user_mcp_grant_env(
|
||||
mocker: MockerFixture,
|
||||
server_ids: Sequence[str],
|
||||
allow_all_server_ids: Sequence[str] = (),
|
||||
) -> None:
|
||||
server_objects: Final = {
|
||||
server_id: SimpleNamespace(server_id=server_id, alias=None, server_name=None, name=server_id)
|
||||
for server_id in server_ids
|
||||
}
|
||||
manager: Final = mocker.MagicMock()
|
||||
manager.get_registry.return_value = server_objects
|
||||
manager.get_mcp_server_by_id.side_effect = lambda server_id: server_objects.get(server_id)
|
||||
manager.get_allow_all_keys_server_ids.return_value = list(allow_all_server_ids)
|
||||
mocker.patch(
|
||||
"litellm.proxy._experimental.mcp_server.mcp_server_manager.global_mcp_server_manager",
|
||||
manager,
|
||||
)
|
||||
mocker.patch(
|
||||
"litellm.proxy.auth.auth_checks.get_mcp_server_ids_from_access_groups",
|
||||
new=mocker.AsyncMock(return_value=[]),
|
||||
)
|
||||
|
||||
|
||||
def _user_mcp_team(team_id: str, access_group_ids: Sequence[str] = ()) -> SimpleNamespace:
|
||||
return SimpleNamespace(
|
||||
team_id=team_id,
|
||||
access_group_ids=list(access_group_ids),
|
||||
object_permission=None,
|
||||
)
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_user_update_rejects_server_outside_every_team_before_upserting(mocker: MockerFixture):
|
||||
from litellm.proxy.management_endpoints.internal_user_endpoints import _update_single_user_helper
|
||||
|
||||
mock_prisma_client: Final = _user_mcp_grant_prisma_mocks(mocker, teams=("team-a",))
|
||||
_patch_user_mcp_grant_env(mocker, ("server-in-team", "server-outside"))
|
||||
cache: Final = mocker.MagicMock()
|
||||
cache.async_delete_cache = mocker.AsyncMock()
|
||||
mocker.patch("litellm.proxy.proxy_server.user_api_key_cache", cache)
|
||||
mocker.patch(
|
||||
"litellm.proxy.management_endpoints.internal_user_endpoints.get_team_object",
|
||||
new=mocker.AsyncMock(return_value=_user_mcp_team("team-a", ("group-a",))),
|
||||
)
|
||||
mocker.patch(
|
||||
"litellm.proxy.auth.auth_checks.get_mcp_server_ids_from_access_groups",
|
||||
new=mocker.AsyncMock(return_value=["server-in-team"]),
|
||||
)
|
||||
handle_update: Final = mocker.patch(
|
||||
"litellm.proxy.management_endpoints.internal_user_endpoints.handle_update_object_permission_common",
|
||||
new=mocker.AsyncMock(),
|
||||
)
|
||||
|
||||
with pytest.raises(HTTPException) as exc_info:
|
||||
await _update_single_user_helper(
|
||||
user_request=UpdateUserRequest(
|
||||
user_id="target-user",
|
||||
object_permission={"mcp_servers": ["server-outside"]},
|
||||
),
|
||||
user_api_key_dict=UserAPIKeyAuth(user_id="admin-1", user_role=LitellmUserRoles.PROXY_ADMIN),
|
||||
)
|
||||
|
||||
assert exc_info.value.status_code == 403
|
||||
handle_update.assert_not_called()
|
||||
mock_prisma_client.db.litellm_objectpermissiontable.upsert.assert_not_called()
|
||||
mock_prisma_client.update_data.assert_not_called()
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_user_update_persists_server_allowed_by_a_team(mocker: MockerFixture):
|
||||
from litellm.proxy.management_endpoints.internal_user_endpoints import _update_single_user_helper
|
||||
|
||||
mock_prisma_client: Final = _user_mcp_grant_prisma_mocks(mocker, teams=("team-a",))
|
||||
_patch_user_mcp_grant_env(mocker, ("server-in-team",))
|
||||
cache: Final = mocker.MagicMock()
|
||||
cache.async_delete_cache = mocker.AsyncMock()
|
||||
mocker.patch("litellm.proxy.proxy_server.user_api_key_cache", cache)
|
||||
mocker.patch(
|
||||
"litellm.proxy.management_endpoints.internal_user_endpoints.get_team_object",
|
||||
new=mocker.AsyncMock(return_value=_user_mcp_team("team-a", ("group-a",))),
|
||||
)
|
||||
mocker.patch(
|
||||
"litellm.proxy.auth.auth_checks.get_mcp_server_ids_from_access_groups",
|
||||
new=mocker.AsyncMock(return_value=["server-in-team"]),
|
||||
)
|
||||
|
||||
await _update_single_user_helper(
|
||||
user_request=UpdateUserRequest(
|
||||
user_id="target-user",
|
||||
object_permission={"mcp_servers": ["server-in-team"]},
|
||||
),
|
||||
user_api_key_dict=UserAPIKeyAuth(user_id="admin-1", user_role=LitellmUserRoles.PROXY_ADMIN),
|
||||
)
|
||||
|
||||
upsert_kwargs: Final = mock_prisma_client.db.litellm_objectpermissiontable.upsert.call_args.kwargs
|
||||
assert upsert_kwargs["data"]["create"]["mcp_servers"] == ["server-in-team"]
|
||||
assert mock_prisma_client.update_data.call_args.kwargs["data"]["object_permission_id"] == "perm-new"
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_user_update_rejects_server_when_all_teams_are_missing(mocker: MockerFixture):
|
||||
from litellm.proxy.management_endpoints.internal_user_endpoints import _update_single_user_helper
|
||||
|
||||
mock_prisma_client: Final = _user_mcp_grant_prisma_mocks(
|
||||
mocker,
|
||||
teams=("missing-team-a", "missing-team-b"),
|
||||
)
|
||||
_patch_user_mcp_grant_env(mocker, ("server-in-team", "server-outside"))
|
||||
cache: Final = mocker.MagicMock()
|
||||
cache.async_delete_cache = mocker.AsyncMock()
|
||||
mocker.patch("litellm.proxy.proxy_server.user_api_key_cache", cache)
|
||||
|
||||
async def get_team(team_id: str, **kwargs: object) -> SimpleNamespace:
|
||||
raise auth_checks.TeamNotFoundError(team_id)
|
||||
|
||||
mocker.patch(
|
||||
"litellm.proxy.management_endpoints.internal_user_endpoints.get_team_object",
|
||||
side_effect=get_team,
|
||||
)
|
||||
|
||||
with pytest.raises(HTTPException) as exc_info:
|
||||
await _update_single_user_helper(
|
||||
user_request=UpdateUserRequest(
|
||||
user_id="target-user",
|
||||
object_permission={"mcp_servers": ["server-outside"]},
|
||||
),
|
||||
user_api_key_dict=UserAPIKeyAuth(user_id="admin-1", user_role=LitellmUserRoles.PROXY_ADMIN),
|
||||
)
|
||||
|
||||
assert exc_info.value.status_code == 403
|
||||
mock_prisma_client.db.litellm_objectpermissiontable.upsert.assert_not_called()
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_user_update_allows_global_server_when_all_teams_are_missing(mocker: MockerFixture):
|
||||
from litellm.proxy.management_endpoints.internal_user_endpoints import _update_single_user_helper
|
||||
|
||||
mock_prisma_client: Final = _user_mcp_grant_prisma_mocks(mocker, teams=("missing-team",))
|
||||
_patch_user_mcp_grant_env(
|
||||
mocker,
|
||||
("global-server",),
|
||||
allow_all_server_ids=("global-server",),
|
||||
)
|
||||
cache: Final = mocker.MagicMock()
|
||||
cache.async_delete_cache = mocker.AsyncMock()
|
||||
mocker.patch("litellm.proxy.proxy_server.user_api_key_cache", cache)
|
||||
mocker.patch(
|
||||
"litellm.proxy.management_endpoints.internal_user_endpoints.get_team_object",
|
||||
new=mocker.AsyncMock(side_effect=auth_checks.TeamNotFoundError("missing-team")),
|
||||
)
|
||||
|
||||
await _update_single_user_helper(
|
||||
user_request=UpdateUserRequest(
|
||||
user_id="target-user",
|
||||
object_permission={"mcp_servers": ["global-server"]},
|
||||
),
|
||||
user_api_key_dict=UserAPIKeyAuth(user_id="admin-1", user_role=LitellmUserRoles.PROXY_ADMIN),
|
||||
)
|
||||
|
||||
upsert_data: Final = mock_prisma_client.db.litellm_objectpermissiontable.upsert.call_args.kwargs["data"]
|
||||
assert upsert_data["create"]["mcp_servers"] == ["global-server"]
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_user_update_propagates_non_missing_team_lookup_errors(mocker: MockerFixture):
|
||||
from litellm.proxy.management_endpoints.internal_user_endpoints import _update_single_user_helper
|
||||
|
||||
mock_prisma_client: Final = _user_mcp_grant_prisma_mocks(mocker, teams=("team-a",))
|
||||
_patch_user_mcp_grant_env(mocker, ("server-a",))
|
||||
cache: Final = mocker.MagicMock()
|
||||
cache.async_delete_cache = mocker.AsyncMock()
|
||||
mocker.patch("litellm.proxy.proxy_server.user_api_key_cache", cache)
|
||||
mocker.patch(
|
||||
"litellm.proxy.management_endpoints.internal_user_endpoints.get_team_object",
|
||||
new=mocker.AsyncMock(side_effect=RuntimeError("team lookup failed")),
|
||||
)
|
||||
|
||||
with pytest.raises(RuntimeError, match="team lookup failed"):
|
||||
await _update_single_user_helper(
|
||||
user_request=UpdateUserRequest(
|
||||
user_id="target-user",
|
||||
object_permission={"mcp_servers": ["server-a"]},
|
||||
),
|
||||
user_api_key_dict=UserAPIKeyAuth(user_id="admin-1", user_role=LitellmUserRoles.PROXY_ADMIN),
|
||||
)
|
||||
|
||||
mock_prisma_client.db.litellm_objectpermissiontable.upsert.assert_not_called()
|
||||
mock_prisma_client.update_data.assert_not_called()
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_user_mcp_grant_validation_for_teamless_users(mocker: MockerFixture):
|
||||
from litellm.proxy.management_endpoints.internal_user_endpoints import _validate_user_mcp_grants
|
||||
|
||||
prisma_client: Final = mocker.MagicMock()
|
||||
prisma_client.db.litellm_objectpermissiontable.find_unique = mocker.AsyncMock(
|
||||
return_value=PrismaLiteLLM_ObjectPermissionTable(
|
||||
object_permission_id="permission-id",
|
||||
mcp_servers=["stored-server"],
|
||||
mcp_access_groups=["stored-group"],
|
||||
vector_stores=[],
|
||||
agents=[],
|
||||
agent_access_groups=[],
|
||||
models=[],
|
||||
blocked_tools=[],
|
||||
mcp_toolsets=["stored-toolset"],
|
||||
search_tools=[],
|
||||
skills=[],
|
||||
)
|
||||
)
|
||||
prisma_client.db.litellm_mcpservertable.find_many = mocker.AsyncMock(return_value=[])
|
||||
get_team: Final = mocker.AsyncMock(side_effect=RuntimeError("team lookup should not run"))
|
||||
cache: Final = mocker.MagicMock()
|
||||
_patch_user_mcp_grant_env(
|
||||
mocker,
|
||||
("server-outside", "allow-all-server", "stored-server"),
|
||||
allow_all_server_ids=("allow-all-server",),
|
||||
)
|
||||
mocker.patch(
|
||||
"litellm.proxy.management_endpoints.internal_user_endpoints.get_team_object",
|
||||
new=get_team,
|
||||
)
|
||||
|
||||
no_permission_result: Final = await _validate_user_mcp_grants(
|
||||
object_permission=None,
|
||||
team_ids=("team-a",),
|
||||
existing_object_permission_id="permission-id",
|
||||
prisma_client=prisma_client,
|
||||
user_api_key_cache=cache,
|
||||
is_proxy_admin=False,
|
||||
)
|
||||
no_teams_result: Final = await _validate_user_mcp_grants(
|
||||
object_permission={"mcp_servers": ["server-outside"]},
|
||||
team_ids=(),
|
||||
existing_object_permission_id="permission-id",
|
||||
prisma_client=prisma_client,
|
||||
user_api_key_cache=cache,
|
||||
is_proxy_admin=True,
|
||||
)
|
||||
|
||||
assert no_permission_result is None
|
||||
assert no_teams_result is None
|
||||
|
||||
with pytest.raises(HTTPException) as exc_info:
|
||||
await _validate_user_mcp_grants(
|
||||
object_permission={"mcp_servers": ["server-outside"]},
|
||||
team_ids=(),
|
||||
existing_object_permission_id=None,
|
||||
prisma_client=prisma_client,
|
||||
user_api_key_cache=cache,
|
||||
is_proxy_admin=False,
|
||||
)
|
||||
|
||||
assert exc_info.value.status_code == 403
|
||||
assert exc_info.value.detail == {
|
||||
"error": "User requests MCP servers not allowed by any of the user's teams: ['server-outside']."
|
||||
}
|
||||
|
||||
allow_all_result: Final = await _validate_user_mcp_grants(
|
||||
object_permission={"mcp_servers": ["allow-all-server"]},
|
||||
team_ids=(),
|
||||
existing_object_permission_id=None,
|
||||
prisma_client=prisma_client,
|
||||
user_api_key_cache=cache,
|
||||
is_proxy_admin=False,
|
||||
)
|
||||
stored_grant_result: Final = await _validate_user_mcp_grants(
|
||||
object_permission={
|
||||
"mcp_servers": ["stored-server"],
|
||||
"mcp_access_groups": ["stored-group"],
|
||||
"mcp_toolsets": ["stored-toolset"],
|
||||
},
|
||||
team_ids=(),
|
||||
existing_object_permission_id="permission-id",
|
||||
prisma_client=prisma_client,
|
||||
user_api_key_cache=cache,
|
||||
is_proxy_admin=False,
|
||||
)
|
||||
|
||||
assert allow_all_result is None
|
||||
assert stored_grant_result is None
|
||||
get_team.assert_not_awaited()
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
@pytest.mark.parametrize(
|
||||
"team_args",
|
||||
({"teams": ["team-a"]}, {"team_id": "team-a"}),
|
||||
)
|
||||
async def test_new_user_rejects_server_outside_requested_teams_before_persisting(
|
||||
mocker: MockerFixture,
|
||||
team_args: dict[str, object],
|
||||
):
|
||||
mock_prisma_client: Final = mocker.MagicMock()
|
||||
mock_prisma_client.db.litellm_objectpermissiontable.create = mocker.AsyncMock()
|
||||
mock_prisma_client.db.litellm_mcpservertable.find_many = mocker.AsyncMock(return_value=[])
|
||||
mock_prisma_client.db.litellm_usertable.find_first = mocker.AsyncMock(return_value=None)
|
||||
mock_prisma_client.db.litellm_usertable.find_unique = mocker.AsyncMock(
|
||||
return_value=SimpleNamespace(teams=["team-a"])
|
||||
)
|
||||
mock_prisma_client.db.litellm_usertable.count = mocker.AsyncMock(return_value=0)
|
||||
mocker.patch("litellm.proxy.proxy_server.prisma_client", mock_prisma_client)
|
||||
mocker.patch("litellm.proxy.proxy_server.user_api_key_cache", mocker.MagicMock())
|
||||
_patch_user_mcp_grant_env(mocker, ("server-in-team", "server-outside"))
|
||||
mocker.patch(
|
||||
"litellm.proxy.management_endpoints.internal_user_endpoints.get_team_object",
|
||||
new=mocker.AsyncMock(return_value=_user_mcp_team("team-a", ("group-a",))),
|
||||
)
|
||||
mocker.patch(
|
||||
"litellm.proxy.auth.auth_checks.get_mcp_server_ids_from_access_groups",
|
||||
new=mocker.AsyncMock(return_value=["server-in-team"]),
|
||||
)
|
||||
mocker.patch(
|
||||
"litellm.proxy.hooks.user_management_event_hooks.UserManagementEventHooks.async_user_created_hook",
|
||||
new=mocker.AsyncMock(),
|
||||
)
|
||||
mocker.patch(
|
||||
"litellm.proxy.management_endpoints.team_endpoints.team_member_add",
|
||||
new=mocker.AsyncMock(),
|
||||
)
|
||||
generate_key: Final = mocker.patch(
|
||||
"litellm.proxy.management_endpoints.internal_user_endpoints.generate_key_helper_fn",
|
||||
new=mocker.AsyncMock(return_value={"user_id": "new-human", "token": "sk-x", "expires": None}),
|
||||
)
|
||||
|
||||
with pytest.raises(ProxyException) as exc_info:
|
||||
await new_user(
|
||||
data=NewUserRequest(
|
||||
user_id="new-human",
|
||||
object_permission={"mcp_servers": ["server-outside"]},
|
||||
**team_args,
|
||||
),
|
||||
user_api_key_dict=UserAPIKeyAuth(user_id="admin-1", user_role=LitellmUserRoles.PROXY_ADMIN),
|
||||
)
|
||||
|
||||
assert exc_info.value.code == "403"
|
||||
assert "server-outside" in exc_info.value.message
|
||||
mock_prisma_client.db.litellm_objectpermissiontable.create.assert_not_called()
|
||||
generate_key.assert_not_called()
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_new_user_rejects_outside_server_for_teamless_non_admin_before_persisting(
|
||||
mocker: MockerFixture,
|
||||
) -> None:
|
||||
mock_prisma_client: Final = mocker.MagicMock()
|
||||
mock_prisma_client.db.litellm_objectpermissiontable.create = mocker.AsyncMock()
|
||||
mock_prisma_client.db.litellm_mcpservertable.find_many = mocker.AsyncMock(return_value=[])
|
||||
mock_prisma_client.db.litellm_usertable.find_first = mocker.AsyncMock(return_value=None)
|
||||
mock_prisma_client.db.litellm_usertable.find_unique = mocker.AsyncMock(return_value=None)
|
||||
mock_prisma_client.db.litellm_usertable.count = mocker.AsyncMock(return_value=0)
|
||||
mocker.patch("litellm.proxy.proxy_server.prisma_client", mock_prisma_client)
|
||||
mocker.patch("litellm.proxy.proxy_server.user_api_key_cache", mocker.MagicMock())
|
||||
mocker.patch("litellm.proxy.proxy_server._license_check.is_over_limit", return_value=False)
|
||||
mocker.patch(
|
||||
"litellm.proxy.management_endpoints.internal_user_endpoints.check_if_default_team_set",
|
||||
return_value=None,
|
||||
)
|
||||
_patch_user_mcp_grant_env(mocker, ("server-outside",))
|
||||
get_team: Final = mocker.patch(
|
||||
"litellm.proxy.management_endpoints.internal_user_endpoints.get_team_object",
|
||||
new=mocker.AsyncMock(side_effect=RuntimeError("team lookup should not run")),
|
||||
)
|
||||
generate_key: Final = mocker.patch(
|
||||
"litellm.proxy.management_endpoints.internal_user_endpoints.generate_key_helper_fn",
|
||||
new=mocker.AsyncMock(return_value={"user_id": "new-human", "token": "sk-x", "expires": None}),
|
||||
)
|
||||
|
||||
with pytest.raises(ProxyException) as exc_info:
|
||||
await new_user(
|
||||
data=NewUserRequest(
|
||||
user_id="new-human",
|
||||
user_role=LitellmUserRoles.INTERNAL_USER,
|
||||
object_permission={"mcp_servers": ["server-outside"]},
|
||||
),
|
||||
user_api_key_dict=UserAPIKeyAuth(
|
||||
user_id="internal-caller",
|
||||
user_role=LitellmUserRoles.INTERNAL_USER,
|
||||
),
|
||||
)
|
||||
|
||||
assert exc_info.value.code == "403"
|
||||
assert "server-outside" in exc_info.value.message
|
||||
mock_prisma_client.db.litellm_objectpermissiontable.create.assert_not_awaited()
|
||||
generate_key.assert_not_awaited()
|
||||
get_team.assert_not_awaited()
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_new_user_uses_team_id_instead_of_teams_for_mcp_grants(mocker: MockerFixture):
|
||||
mock_prisma_client: Final = mocker.MagicMock()
|
||||
mock_prisma_client.db.litellm_objectpermissiontable.create = mocker.AsyncMock(
|
||||
return_value=SimpleNamespace(object_permission_id="perm-created")
|
||||
)
|
||||
mock_prisma_client.db.litellm_mcpservertable.find_many = mocker.AsyncMock(return_value=[])
|
||||
mock_prisma_client.db.litellm_usertable.find_first = mocker.AsyncMock(return_value=None)
|
||||
mock_prisma_client.db.litellm_usertable.find_unique = mocker.AsyncMock(
|
||||
return_value=SimpleNamespace(teams=["team-b"])
|
||||
)
|
||||
mock_prisma_client.db.litellm_usertable.count = mocker.AsyncMock(return_value=0)
|
||||
mocker.patch("litellm.proxy.proxy_server.prisma_client", mock_prisma_client)
|
||||
mocker.patch("litellm.proxy.proxy_server.user_api_key_cache", mocker.MagicMock())
|
||||
_patch_user_mcp_grant_env(mocker, ("server-in-team-a",))
|
||||
|
||||
teams: Final = {
|
||||
"team-a": _user_mcp_team("team-a", ("group-a",)),
|
||||
"team-b": _user_mcp_team("team-b"),
|
||||
}
|
||||
|
||||
async def get_team(team_id: str, **kwargs: object) -> SimpleNamespace:
|
||||
return teams[team_id]
|
||||
|
||||
async def get_access_group_servers(access_group_ids: Sequence[str], **kwargs: object) -> list[str]:
|
||||
return ["server-in-team-a"] if "group-a" in access_group_ids else []
|
||||
|
||||
mocker.patch(
|
||||
"litellm.proxy.management_endpoints.internal_user_endpoints.get_team_object",
|
||||
new=mocker.AsyncMock(side_effect=get_team),
|
||||
)
|
||||
mocker.patch(
|
||||
"litellm.proxy.auth.auth_checks.get_mcp_server_ids_from_access_groups",
|
||||
new=mocker.AsyncMock(side_effect=get_access_group_servers),
|
||||
)
|
||||
mocker.patch(
|
||||
"litellm.proxy.hooks.user_management_event_hooks.UserManagementEventHooks.async_user_created_hook",
|
||||
new=mocker.AsyncMock(),
|
||||
)
|
||||
mocker.patch(
|
||||
"litellm.proxy.management_endpoints.team_endpoints.team_member_add",
|
||||
new=mocker.AsyncMock(),
|
||||
)
|
||||
generate_key: Final = mocker.patch(
|
||||
"litellm.proxy.management_endpoints.internal_user_endpoints.generate_key_helper_fn",
|
||||
new=mocker.AsyncMock(return_value={"user_id": "new-human", "token": "sk-x", "expires": None}),
|
||||
)
|
||||
|
||||
with pytest.raises(ProxyException) as exc_info:
|
||||
await new_user(
|
||||
data=NewUserRequest(
|
||||
user_id="new-human",
|
||||
team_id="team-b",
|
||||
teams=["team-a"],
|
||||
object_permission={"mcp_servers": ["server-in-team-a"]},
|
||||
),
|
||||
user_api_key_dict=UserAPIKeyAuth(user_id="admin-1", user_role=LitellmUserRoles.PROXY_ADMIN),
|
||||
)
|
||||
|
||||
assert exc_info.value.code == "403"
|
||||
assert "server-in-team-a" in exc_info.value.message
|
||||
mock_prisma_client.db.litellm_objectpermissiontable.create.assert_not_called()
|
||||
generate_key.assert_not_called()
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_user_update_grandfathers_prisma_object_permission_model(mocker: MockerFixture) -> None:
|
||||
from litellm.proxy.management_endpoints.internal_user_endpoints import _update_single_user_helper
|
||||
|
||||
mock_prisma_client: Final = _user_mcp_grant_prisma_mocks(mocker, teams=("team-a",))
|
||||
mock_prisma_client.db.litellm_usertable.find_first.return_value.object_permission_id = "perm-existing"
|
||||
mock_prisma_client.db.litellm_usertable.find_first.return_value.model_dump.return_value = {
|
||||
"user_id": "target-user",
|
||||
"object_permission_id": "perm-existing",
|
||||
"teams": ["team-a"],
|
||||
}
|
||||
mock_prisma_client.db.litellm_objectpermissiontable.find_unique = mocker.AsyncMock(
|
||||
return_value=PrismaLiteLLM_ObjectPermissionTable(
|
||||
object_permission_id="perm-existing",
|
||||
mcp_servers=["srv_b"],
|
||||
mcp_access_groups=[],
|
||||
vector_stores=[],
|
||||
agents=[],
|
||||
agent_access_groups=[],
|
||||
models=[],
|
||||
blocked_tools=[],
|
||||
mcp_toolsets=[],
|
||||
search_tools=[],
|
||||
skills=[],
|
||||
)
|
||||
)
|
||||
_patch_user_mcp_grant_env(mocker, ("srv_a", "srv_b"))
|
||||
cache: Final = mocker.MagicMock()
|
||||
cache.async_delete_cache = mocker.AsyncMock()
|
||||
mocker.patch("litellm.proxy.proxy_server.user_api_key_cache", cache)
|
||||
mocker.patch(
|
||||
"litellm.proxy.management_endpoints.internal_user_endpoints.get_team_object",
|
||||
new=mocker.AsyncMock(return_value=_user_mcp_team("team-a", ("group-a",))),
|
||||
)
|
||||
mocker.patch(
|
||||
"litellm.proxy.auth.auth_checks.get_mcp_server_ids_from_access_groups",
|
||||
new=mocker.AsyncMock(return_value=["srv_a"]),
|
||||
)
|
||||
|
||||
await _update_single_user_helper(
|
||||
user_request=UpdateUserRequest(
|
||||
user_id="target-user",
|
||||
object_permission={"mcp_servers": ["srv_b"]},
|
||||
),
|
||||
user_api_key_dict=UserAPIKeyAuth(user_id="admin-1", user_role=LitellmUserRoles.PROXY_ADMIN),
|
||||
)
|
||||
|
||||
upsert_data: Final = mock_prisma_client.db.litellm_objectpermissiontable.upsert.call_args.kwargs["data"]
|
||||
assert upsert_data["update"]["mcp_servers"] == ["srv_b"]
|
||||
|
|
|
|||
|
|
@ -1,13 +1,18 @@
|
|||
import json
|
||||
from contextlib import asynccontextmanager
|
||||
from dataclasses import dataclass
|
||||
from types import SimpleNamespace
|
||||
from typing import Final
|
||||
|
||||
import httpx
|
||||
import pytest
|
||||
from pytest_mock import MockerFixture
|
||||
from prisma.errors import UniqueViolationError
|
||||
from pydantic import BaseModel, ConfigDict, ValidationError
|
||||
|
||||
from litellm.caching.caching import DualCache
|
||||
from litellm.models.object_permission import LiteLLM_ObjectPermissionTable
|
||||
from litellm.models.team import LiteLLM_TeamTableCachedObj
|
||||
from litellm.proxy._types import LiteLLM_TeamTable, LitellmUserRoles, Member, UserAPIKeyAuth
|
||||
from litellm.proxy.list_api.common import ManagementProblem
|
||||
from litellm.proxy.management_helpers.bulk_user_creation import bulk_create_users
|
||||
|
|
@ -28,6 +33,7 @@ class _UserRow(BaseModel):
|
|||
user_role: str | None = None
|
||||
teams: list[str] = []
|
||||
max_budget: float | None = None
|
||||
object_permission_id: str | None = None
|
||||
|
||||
|
||||
class _UserTable:
|
||||
|
|
@ -109,6 +115,26 @@ class _MembershipTable:
|
|||
return len(data)
|
||||
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class _CreatedPermission:
|
||||
object_permission_id: str
|
||||
|
||||
|
||||
class _ObjectPermissionTable:
|
||||
def __init__(self) -> None:
|
||||
self.rows: dict[str, dict[str, object]] = {}
|
||||
|
||||
async def create(self, data: dict[str, object]) -> _CreatedPermission:
|
||||
object_permission_id: Final = f"permission-{len(self.rows) + 1}"
|
||||
self.rows[object_permission_id] = data
|
||||
return _CreatedPermission(object_permission_id=object_permission_id)
|
||||
|
||||
|
||||
class _MCPServerTable:
|
||||
async def find_many(self, where: dict[str, object]) -> list[object]:
|
||||
return []
|
||||
|
||||
|
||||
class _Tx:
|
||||
def __init__(self, db: "_Db") -> None:
|
||||
self.litellm_teamtable = db.litellm_teamtable
|
||||
|
|
@ -136,6 +162,8 @@ class _Db:
|
|||
self.litellm_usertable = _UserTable(fail_ids, commit_then_drop, raced_ids)
|
||||
self.litellm_teamtable = _TeamTable(teams)
|
||||
self.litellm_teammembership = _MembershipTable()
|
||||
self.litellm_objectpermissiontable = _ObjectPermissionTable()
|
||||
self.litellm_mcpservertable = _MCPServerTable()
|
||||
|
||||
|
||||
class _FakePrisma:
|
||||
|
|
@ -281,6 +309,101 @@ async def test_bad_rows_fail_alone_and_good_rows_still_land():
|
|||
assert [m.user_id for m in prisma.db.litellm_teamtable.rows["t1"].members_with_roles] == ["u1", "u7"]
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_bulk_user_mcp_grants_are_checked_before_permission_rows_are_created(
|
||||
mocker: MockerFixture,
|
||||
) -> None:
|
||||
prisma: Final = _FakePrisma(teams=[_team("team_9193")])
|
||||
team_obj: Final = LiteLLM_TeamTableCachedObj(
|
||||
team_id="team_9193",
|
||||
object_permission=LiteLLM_ObjectPermissionTable(
|
||||
object_permission_id="team-permission",
|
||||
mcp_servers=["srv_a"],
|
||||
),
|
||||
)
|
||||
server_objects: Final = {
|
||||
server_id: SimpleNamespace(server_id=server_id, alias=None, server_name=None, name=server_id)
|
||||
for server_id in ("srv_a", "srv_b")
|
||||
}
|
||||
manager: Final = mocker.MagicMock()
|
||||
manager.get_registry.return_value = server_objects
|
||||
manager.get_allow_all_keys_server_ids.return_value = []
|
||||
mocker.patch(
|
||||
"litellm.proxy._experimental.mcp_server.mcp_server_manager.global_mcp_server_manager",
|
||||
manager,
|
||||
)
|
||||
mocker.patch(
|
||||
"litellm.proxy.management_endpoints.internal_user_endpoints.get_team_object",
|
||||
new=mocker.AsyncMock(return_value=team_obj),
|
||||
)
|
||||
mocker.patch(
|
||||
"litellm.proxy.auth.auth_checks.get_mcp_server_ids_from_access_groups",
|
||||
new=mocker.AsyncMock(return_value=[]),
|
||||
)
|
||||
|
||||
response = await _run(
|
||||
prisma,
|
||||
[
|
||||
{
|
||||
"user_id": "u1",
|
||||
"teams": ["team_9193"],
|
||||
"object_permission": {"mcp_servers": ["srv_b"]},
|
||||
},
|
||||
{
|
||||
"user_id": "u2",
|
||||
"teams": ["team_9193"],
|
||||
"object_permission": {"mcp_servers": ["srv_a"]},
|
||||
},
|
||||
],
|
||||
)
|
||||
|
||||
rejected: Final = response.data[0]
|
||||
accepted: Final = response.data[1]
|
||||
assert (rejected.user_id, rejected.success) == ("u1", False)
|
||||
assert rejected.error is not None and "srv_b" in rejected.error
|
||||
assert (accepted.user_id, accepted.success, accepted.error) == ("u2", True, None)
|
||||
assert set(prisma.db.litellm_usertable.rows) == {"u2"}
|
||||
permission_rows: Final = prisma.db.litellm_objectpermissiontable.rows
|
||||
assert len(permission_rows) == 1
|
||||
accepted_permission_id: Final = prisma.db.litellm_usertable.rows["u2"].object_permission_id
|
||||
assert accepted_permission_id is not None
|
||||
assert set(permission_rows) == {accepted_permission_id}
|
||||
assert permission_rows[accepted_permission_id]["mcp_servers"] == ["srv_a"]
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_bulk_user_mcp_grants_reject_outside_server_for_teamless_non_admin(
|
||||
mocker: MockerFixture,
|
||||
) -> None:
|
||||
prisma: Final = _FakePrisma()
|
||||
server_objects: Final = {
|
||||
"srv_outside": SimpleNamespace(server_id="srv_outside", alias=None, server_name=None, name="srv_outside")
|
||||
}
|
||||
manager: Final = mocker.MagicMock()
|
||||
manager.get_registry.return_value = server_objects
|
||||
manager.get_allow_all_keys_server_ids.return_value = []
|
||||
mocker.patch(
|
||||
"litellm.proxy._experimental.mcp_server.mcp_server_manager.global_mcp_server_manager",
|
||||
manager,
|
||||
)
|
||||
mocker.patch(
|
||||
"litellm.proxy.management_endpoints.internal_user_endpoints.get_team_object",
|
||||
new=mocker.AsyncMock(side_effect=RuntimeError("team lookup should not run")),
|
||||
)
|
||||
|
||||
response: Final = await _run(
|
||||
prisma,
|
||||
[{"user_id": "u1", "object_permission": {"mcp_servers": ["srv_outside"]}}],
|
||||
caller=INTERNAL,
|
||||
)
|
||||
|
||||
rejected: Final = response.data[0]
|
||||
assert (rejected.user_id, rejected.success) == ("u1", False)
|
||||
assert rejected.error is not None and "srv_outside" in rejected.error
|
||||
assert prisma.db.litellm_usertable.rows == {}
|
||||
assert prisma.db.litellm_objectpermissiontable.rows == {}
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_insert_failure_falls_back_to_per_row_and_reports_only_that_row():
|
||||
prisma = _FakePrisma(teams=[_team("t1")], fail_ids=frozenset({"u2"}))
|
||||
|
|
|
|||
|
|
@ -25,6 +25,7 @@ from litellm.proxy.management_helpers.object_permission_utils import (
|
|||
validate_key_mcp_servers_against_team,
|
||||
validate_key_search_tools_against_team,
|
||||
validate_key_vector_stores_against_team,
|
||||
validate_user_mcp_grants_against_teams,
|
||||
)
|
||||
|
||||
|
||||
|
|
@ -1636,3 +1637,454 @@ def test_object_permission_dict_mirrors_pydantic_model():
|
|||
f"Only in Pydantic model: {sorted(pydantic_fields - typeddict_fields)}\n"
|
||||
f"Only in TypedDict: {sorted(typeddict_fields - pydantic_fields)}"
|
||||
)
|
||||
|
||||
|
||||
def _make_user_mcp_team(
|
||||
team_id: str,
|
||||
mcp_servers: list[str] | None = None,
|
||||
mcp_access_groups: list[str] | None = None,
|
||||
access_group_ids: list[str] | None = None,
|
||||
mcp_toolsets: list[str] | None = None,
|
||||
) -> MagicMock:
|
||||
team: Final = MagicMock()
|
||||
team.team_id = team_id
|
||||
team.access_group_ids = access_group_ids or []
|
||||
if any(
|
||||
value is not None
|
||||
for value in (mcp_servers, mcp_access_groups, mcp_toolsets)
|
||||
):
|
||||
team.object_permission = MagicMock(spec=LiteLLM_ObjectPermissionTable)
|
||||
team.object_permission.mcp_servers = mcp_servers or []
|
||||
team.object_permission.mcp_access_groups = mcp_access_groups or []
|
||||
team.object_permission.mcp_tool_permissions = {}
|
||||
team.object_permission.mcp_toolsets = mcp_toolsets
|
||||
else:
|
||||
team.object_permission = None
|
||||
return team
|
||||
|
||||
|
||||
def _patch_user_mcp_grant_env(
|
||||
monkeypatch: pytest.MonkeyPatch,
|
||||
*server_ids: str,
|
||||
allow_all_server_ids: tuple[str, ...] = (),
|
||||
access_group_server_ids: tuple[str, ...] = (),
|
||||
) -> MagicMock:
|
||||
manager: Final = _make_mock_mcp_manager(*server_ids)
|
||||
manager.resolve_toolset_tool_permissions = AsyncMock(return_value={})
|
||||
mock_prisma: Final = MagicMock()
|
||||
mock_prisma.db.litellm_mcpservertable.find_many = AsyncMock(return_value=[])
|
||||
monkeypatch.setattr(
|
||||
"litellm.proxy._experimental.mcp_server.mcp_server_manager.global_mcp_server_manager",
|
||||
manager,
|
||||
)
|
||||
monkeypatch.setattr(
|
||||
"litellm.proxy.management_helpers.object_permission_utils.get_allow_all_keys_server_ids",
|
||||
lambda: set(allow_all_server_ids),
|
||||
)
|
||||
monkeypatch.setattr(
|
||||
"litellm.proxy.auth.auth_checks.get_mcp_server_ids_from_access_groups",
|
||||
AsyncMock(return_value=list(access_group_server_ids)),
|
||||
)
|
||||
return mock_prisma
|
||||
|
||||
|
||||
def _patch_user_mcp_toolset_resolution(
|
||||
monkeypatch: pytest.MonkeyPatch,
|
||||
server_tool_permissions: dict[str, list[str]],
|
||||
) -> AsyncMock:
|
||||
resolver: Final = AsyncMock(return_value=server_tool_permissions)
|
||||
monkeypatch.setattr(
|
||||
"litellm.proxy._experimental.mcp_server.mcp_server_manager.global_mcp_server_manager.resolve_toolset_tool_permissions",
|
||||
resolver,
|
||||
)
|
||||
return resolver
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_validate_user_mcp_grants_rejects_servers_outside_every_team(monkeypatch: pytest.MonkeyPatch):
|
||||
mock_prisma: Final = _patch_user_mcp_grant_env(monkeypatch, "server-a", "server-b")
|
||||
team: Final = _make_user_mcp_team(team_id="team-a", mcp_servers=["server-a"])
|
||||
|
||||
with pytest.raises(HTTPException) as exc_info:
|
||||
await validate_user_mcp_grants_against_teams(
|
||||
object_permission={"mcp_servers": ["server-b"]},
|
||||
team_objs=[team],
|
||||
prisma_client=mock_prisma,
|
||||
)
|
||||
|
||||
assert exc_info.value.status_code == 403
|
||||
assert exc_info.value.detail == {
|
||||
"error": (
|
||||
"User requests MCP servers not allowed by any of the user's teams: ['server-b']."
|
||||
)
|
||||
}
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_validate_user_mcp_grants_allows_the_union_of_teams_and_global_servers(
|
||||
monkeypatch: pytest.MonkeyPatch,
|
||||
):
|
||||
mock_prisma: Final = _patch_user_mcp_grant_env(
|
||||
monkeypatch,
|
||||
"server-a",
|
||||
"server-b",
|
||||
"global-server",
|
||||
allow_all_server_ids=("global-server",),
|
||||
)
|
||||
teams: Final = (
|
||||
_make_user_mcp_team(team_id="team-a", mcp_servers=["server-a"]),
|
||||
_make_user_mcp_team(team_id="team-b", mcp_servers=["server-b"]),
|
||||
)
|
||||
|
||||
result: Final = await validate_user_mcp_grants_against_teams(
|
||||
object_permission={"mcp_servers": ["server-a", "server-b", "global-server"]},
|
||||
team_objs=teams,
|
||||
prisma_client=mock_prisma,
|
||||
)
|
||||
|
||||
assert result is None
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_validate_user_mcp_grants_allows_servers_from_team_unified_access_groups(
|
||||
monkeypatch: pytest.MonkeyPatch,
|
||||
):
|
||||
mock_prisma: Final = _patch_user_mcp_grant_env(
|
||||
monkeypatch,
|
||||
"group-server",
|
||||
access_group_server_ids=("group-server",),
|
||||
)
|
||||
team: Final = _make_user_mcp_team(team_id="team-a", access_group_ids=["group-a"])
|
||||
|
||||
result: Final = await validate_user_mcp_grants_against_teams(
|
||||
object_permission={"mcp_servers": ["group-server"]},
|
||||
team_objs=[team],
|
||||
prisma_client=mock_prisma,
|
||||
)
|
||||
|
||||
assert result is None
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
@pytest.mark.parametrize(
|
||||
"object_permission",
|
||||
(
|
||||
{"mcp_servers": ["server-a"]},
|
||||
{"mcp_access_groups": ["group-a"]},
|
||||
{"mcp_toolsets": ["toolset-a"]},
|
||||
),
|
||||
ids=("server", "access-group", "toolset"),
|
||||
)
|
||||
async def test_validate_user_mcp_grants_without_teams_rejects_non_global_grants(
|
||||
monkeypatch: pytest.MonkeyPatch,
|
||||
object_permission: ObjectPermissionDict,
|
||||
) -> None:
|
||||
mock_prisma: Final = _patch_user_mcp_grant_env(monkeypatch, "server-a")
|
||||
if object_permission.get("mcp_toolsets"):
|
||||
_patch_user_mcp_toolset_resolution(monkeypatch, {"server-a": ["tool-a"]})
|
||||
|
||||
with pytest.raises(HTTPException) as exc_info:
|
||||
await validate_user_mcp_grants_against_teams(
|
||||
object_permission=object_permission,
|
||||
team_objs=[],
|
||||
prisma_client=mock_prisma,
|
||||
)
|
||||
|
||||
assert exc_info.value.status_code == 403
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_validate_user_mcp_grants_without_teams_allows_global_servers(
|
||||
monkeypatch: pytest.MonkeyPatch,
|
||||
) -> None:
|
||||
mock_prisma: Final = _patch_user_mcp_grant_env(
|
||||
monkeypatch,
|
||||
"global-server",
|
||||
allow_all_server_ids=("global-server",),
|
||||
)
|
||||
result: Final = await validate_user_mcp_grants_against_teams(
|
||||
object_permission={"mcp_servers": ["global-server"]},
|
||||
team_objs=[],
|
||||
prisma_client=mock_prisma,
|
||||
)
|
||||
|
||||
assert result is None
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_validate_user_mcp_grants_without_requested_grants_returns_without_error():
|
||||
team: Final = _make_user_mcp_team(team_id="team-a", mcp_servers=["server-a"])
|
||||
|
||||
result: Final = await validate_user_mcp_grants_against_teams(
|
||||
object_permission={"mcp_servers": []},
|
||||
team_objs=[team],
|
||||
)
|
||||
|
||||
assert result is None
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_validate_user_mcp_grants_grandfathers_existing_server(monkeypatch: pytest.MonkeyPatch):
|
||||
mock_prisma: Final = _patch_user_mcp_grant_env(monkeypatch, "legacy-server")
|
||||
existing_permission: Final = MagicMock()
|
||||
existing_permission.mcp_servers = ["legacy-server"]
|
||||
existing_permission.mcp_tool_permissions = {}
|
||||
team: Final = _make_user_mcp_team(team_id="team-a", mcp_servers=[])
|
||||
|
||||
result: Final = await validate_user_mcp_grants_against_teams(
|
||||
object_permission={"mcp_servers": ["legacy-server"]},
|
||||
team_objs=[team],
|
||||
prisma_client=mock_prisma,
|
||||
existing_user_object_permission=existing_permission,
|
||||
)
|
||||
|
||||
assert result is None
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_validate_user_mcp_grants_rejects_disallowed_access_group(monkeypatch: pytest.MonkeyPatch):
|
||||
mock_prisma: Final = _patch_user_mcp_grant_env(monkeypatch)
|
||||
team: Final = _make_user_mcp_team(team_id="team-a", mcp_access_groups=["group-a"])
|
||||
|
||||
with pytest.raises(HTTPException) as exc_info:
|
||||
await validate_user_mcp_grants_against_teams(
|
||||
object_permission={"mcp_access_groups": ["group-b"]},
|
||||
team_objs=[team],
|
||||
prisma_client=mock_prisma,
|
||||
)
|
||||
|
||||
assert exc_info.value.status_code == 403
|
||||
assert exc_info.value.detail == {
|
||||
"error": (
|
||||
"User requests MCP access groups not allowed by any of the user's teams: ['group-b']."
|
||||
)
|
||||
}
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_user_grant_errors_do_not_disclose_team_allowlists(monkeypatch: pytest.MonkeyPatch) -> None:
|
||||
mock_prisma: Final = _patch_user_mcp_grant_env(
|
||||
monkeypatch,
|
||||
"srv_a",
|
||||
"srv_b",
|
||||
"srv_g",
|
||||
allow_all_server_ids=("srv_g",),
|
||||
)
|
||||
team: Final = _make_user_mcp_team(
|
||||
team_id="team-a",
|
||||
mcp_servers=["srv_a"],
|
||||
mcp_access_groups=["grp_a"],
|
||||
)
|
||||
|
||||
with pytest.raises(HTTPException) as server_exc_info:
|
||||
await validate_user_mcp_grants_against_teams(
|
||||
object_permission={"mcp_servers": ["srv_b"]},
|
||||
team_objs=[team],
|
||||
prisma_client=mock_prisma,
|
||||
)
|
||||
|
||||
assert server_exc_info.value.status_code == 403
|
||||
assert server_exc_info.value.detail == {
|
||||
"error": "User requests MCP servers not allowed by any of the user's teams: ['srv_b']."
|
||||
}
|
||||
|
||||
with pytest.raises(HTTPException) as access_group_exc_info:
|
||||
await validate_user_mcp_grants_against_teams(
|
||||
object_permission={"mcp_access_groups": ["grp_b"]},
|
||||
team_objs=[team],
|
||||
prisma_client=mock_prisma,
|
||||
)
|
||||
|
||||
assert access_group_exc_info.value.status_code == 403
|
||||
assert access_group_exc_info.value.detail == {
|
||||
"error": "User requests MCP access groups not allowed by any of the user's teams: ['grp_b']."
|
||||
}
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_validate_user_mcp_grants_grandfathers_existing_access_groups(monkeypatch: pytest.MonkeyPatch):
|
||||
mock_prisma: Final = _patch_user_mcp_grant_env(monkeypatch)
|
||||
existing_permission: Final = MagicMock()
|
||||
existing_permission.mcp_access_groups = ["existing-group"]
|
||||
team: Final = _make_user_mcp_team(team_id="team-a", mcp_access_groups=["team-group"])
|
||||
|
||||
result: Final = await validate_user_mcp_grants_against_teams(
|
||||
object_permission={"mcp_access_groups": ["team-group", "existing-group"]},
|
||||
team_objs=[team],
|
||||
prisma_client=mock_prisma,
|
||||
existing_user_object_permission=existing_permission,
|
||||
)
|
||||
|
||||
assert result is None
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_validate_user_mcp_grants_unions_toolsets_and_grandfathers_existing_toolsets(
|
||||
monkeypatch: pytest.MonkeyPatch,
|
||||
):
|
||||
mock_prisma: Final = _patch_user_mcp_grant_env(monkeypatch)
|
||||
team_a: Final = _make_user_mcp_team(team_id="team-a", mcp_toolsets=["toolset-a"])
|
||||
team_b: Final = _make_user_mcp_team(team_id="team-b", mcp_toolsets=["toolset-b"])
|
||||
existing_permission: Final = MagicMock()
|
||||
existing_permission.mcp_access_groups = []
|
||||
existing_permission.mcp_toolsets = ["toolset-existing"]
|
||||
existing_permission.mcp_servers = []
|
||||
existing_permission.mcp_tool_permissions = {}
|
||||
|
||||
result: Final = await validate_user_mcp_grants_against_teams(
|
||||
object_permission={"mcp_toolsets": ["toolset-a", "toolset-b", "toolset-existing"]},
|
||||
team_objs=(team_a, team_b),
|
||||
prisma_client=mock_prisma,
|
||||
existing_user_object_permission=existing_permission,
|
||||
)
|
||||
|
||||
assert result is None
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_validate_user_mcp_grants_rejects_toolsets_resolving_outside_team_servers(
|
||||
monkeypatch: pytest.MonkeyPatch,
|
||||
) -> None:
|
||||
mock_prisma: Final = _patch_user_mcp_grant_env(monkeypatch, "srv_a", "srv_b")
|
||||
resolver: Final = _patch_user_mcp_toolset_resolution(monkeypatch, {"srv_b": ["tool_b"]})
|
||||
team: Final = _make_user_mcp_team(team_id="team-a", mcp_servers=["srv_a"])
|
||||
|
||||
with pytest.raises(HTTPException) as exc_info:
|
||||
await validate_user_mcp_grants_against_teams(
|
||||
object_permission={"mcp_toolsets": ["ts_b"]},
|
||||
team_objs=[team],
|
||||
prisma_client=mock_prisma,
|
||||
)
|
||||
|
||||
assert exc_info.value.status_code == 403
|
||||
assert exc_info.value.detail == {
|
||||
"error": "User requests MCP toolsets not allowed by any of the user's teams: ['ts_b']."
|
||||
}
|
||||
resolver.assert_awaited_once_with(toolset_ids=["ts_b"], requires_fresh_policy=True)
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_validate_user_mcp_grants_rejects_toolsets_with_no_resolved_servers(
|
||||
monkeypatch: pytest.MonkeyPatch,
|
||||
) -> None:
|
||||
mock_prisma: Final = _patch_user_mcp_grant_env(monkeypatch, "srv_a")
|
||||
resolver: Final = _patch_user_mcp_toolset_resolution(monkeypatch, {})
|
||||
team: Final = _make_user_mcp_team(team_id="team-a", mcp_servers=["srv_a"])
|
||||
|
||||
with pytest.raises(HTTPException) as exc_info:
|
||||
await validate_user_mcp_grants_against_teams(
|
||||
object_permission={"mcp_toolsets": ["ts_missing"]},
|
||||
team_objs=[team],
|
||||
prisma_client=mock_prisma,
|
||||
)
|
||||
|
||||
assert exc_info.value.status_code == 403
|
||||
assert exc_info.value.detail == {
|
||||
"error": "User requests MCP toolsets not allowed by any of the user's teams: ['ts_missing']."
|
||||
}
|
||||
resolver.assert_awaited_once_with(toolset_ids=["ts_missing"], requires_fresh_policy=True)
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_validate_user_mcp_grants_allows_toolsets_resolving_to_team_servers(
|
||||
monkeypatch: pytest.MonkeyPatch,
|
||||
) -> None:
|
||||
mock_prisma: Final = _patch_user_mcp_grant_env(monkeypatch, "srv_a")
|
||||
resolver: Final = _patch_user_mcp_toolset_resolution(monkeypatch, {"srv_a": ["tool_a"]})
|
||||
team: Final = _make_user_mcp_team(team_id="team-a", mcp_servers=["srv_a"])
|
||||
|
||||
result: Final = await validate_user_mcp_grants_against_teams(
|
||||
object_permission={"mcp_toolsets": ["ts_a"]},
|
||||
team_objs=[team],
|
||||
prisma_client=mock_prisma,
|
||||
)
|
||||
|
||||
assert result is None
|
||||
resolver.assert_awaited_once_with(toolset_ids=["ts_a"], requires_fresh_policy=True)
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_validate_user_mcp_grants_allows_toolsets_resolving_to_allow_all_servers(
|
||||
monkeypatch: pytest.MonkeyPatch,
|
||||
) -> None:
|
||||
mock_prisma: Final = _patch_user_mcp_grant_env(
|
||||
monkeypatch,
|
||||
"srv_a",
|
||||
"srv_g",
|
||||
allow_all_server_ids=("srv_g",),
|
||||
)
|
||||
resolver: Final = _patch_user_mcp_toolset_resolution(monkeypatch, {"srv_g": ["tool_g"]})
|
||||
team: Final = _make_user_mcp_team(team_id="team-a", mcp_servers=["srv_a"])
|
||||
|
||||
result: Final = await validate_user_mcp_grants_against_teams(
|
||||
object_permission={"mcp_toolsets": ["ts_g"]},
|
||||
team_objs=[team],
|
||||
prisma_client=mock_prisma,
|
||||
)
|
||||
|
||||
assert result is None
|
||||
resolver.assert_awaited_once_with(toolset_ids=["ts_g"], requires_fresh_policy=True)
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_validate_user_mcp_grants_allows_team_toolset_resolving_outside_team_servers(
|
||||
monkeypatch: pytest.MonkeyPatch,
|
||||
) -> None:
|
||||
mock_prisma: Final = _patch_user_mcp_grant_env(monkeypatch, "srv_a", "srv_b")
|
||||
resolver: Final = _patch_user_mcp_toolset_resolution(monkeypatch, {"srv_b": ["tool_b"]})
|
||||
team: Final = _make_user_mcp_team(
|
||||
team_id="team-a",
|
||||
mcp_servers=["srv_a"],
|
||||
mcp_toolsets=["ts_team"],
|
||||
)
|
||||
|
||||
result: Final = await validate_user_mcp_grants_against_teams(
|
||||
object_permission={"mcp_toolsets": ["ts_team"]},
|
||||
team_objs=[team],
|
||||
prisma_client=mock_prisma,
|
||||
)
|
||||
|
||||
assert result is None
|
||||
resolver.assert_not_awaited()
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_validate_user_mcp_grants_allows_existing_user_toolset_resolving_outside_team_servers(
|
||||
monkeypatch: pytest.MonkeyPatch,
|
||||
) -> None:
|
||||
mock_prisma: Final = _patch_user_mcp_grant_env(monkeypatch, "srv_b")
|
||||
resolver: Final = _patch_user_mcp_toolset_resolution(monkeypatch, {"srv_b": ["tool_b"]})
|
||||
existing_permission: Final = MagicMock()
|
||||
existing_permission.mcp_servers = []
|
||||
existing_permission.mcp_access_groups = []
|
||||
existing_permission.mcp_tool_permissions = {}
|
||||
existing_permission.mcp_toolsets = ["ts_existing"]
|
||||
team: Final = _make_user_mcp_team(team_id="team-a", mcp_servers=[])
|
||||
|
||||
result: Final = await validate_user_mcp_grants_against_teams(
|
||||
object_permission={"mcp_toolsets": ["ts_existing"]},
|
||||
team_objs=[team],
|
||||
prisma_client=mock_prisma,
|
||||
existing_user_object_permission=existing_permission,
|
||||
)
|
||||
|
||||
assert result is None
|
||||
resolver.assert_not_awaited()
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_validate_user_mcp_grants_ignores_stale_server_identifiers_without_mutating_input(
|
||||
monkeypatch: pytest.MonkeyPatch,
|
||||
):
|
||||
mock_prisma: Final = _patch_user_mcp_grant_env(monkeypatch, "server-a")
|
||||
requested: Final[ObjectPermissionDict] = {"mcp_servers": ["stale-server"]}
|
||||
team: Final = _make_user_mcp_team(team_id="team-a", mcp_servers=["server-a"])
|
||||
|
||||
result: Final = await validate_user_mcp_grants_against_teams(
|
||||
object_permission=requested,
|
||||
team_objs=[team],
|
||||
prisma_client=mock_prisma,
|
||||
)
|
||||
|
||||
assert result is None
|
||||
assert requested == {"mcp_servers": ["stale-server"]}
|
||||
|
|
|
|||
Loading…
Add table
Reference in a new issue