Skip to content

πŸ™Œ OpenHands: AI-Driven Development

feat(backend): add organization members financial data endpoint (#13595)

Hiep Lefbe6eb30cb92
diff --git a/enterprise/server/auth/authorization.py b/enterprise/server/auth/authorization.py
index 203f74f112..ef2b7e91c4 100644
--- a/enterprise/server/auth/authorization.py
+++ b/enterprise/server/auth/authorization.py
@@ -41,7 +41,7 @@ from storage.role import Role
from storage.role_store import RoleStore
from openhands.core.logger import openhands_logger as logger
-from openhands.server.user_auth import get_user_id
+from openhands.server.user_auth import get_user_auth, get_user_id
class Permission(str, Enum):
@@ -311,3 +311,96 @@ def require_permission(permission: Permission):
return user_id
return permission_checker
+
+
+async def require_financial_data_access(
+ request: Request,
+ org_id: UUID,
+ user_id: str | None = Depends(get_user_id),
+) -> str:
+ """
+ Authorization dependency for accessing organization financial data.
+
+ Allows access if ANY of these conditions are met:
+ 1. User has Admin or Owner role in the organization
+ 2. User has @openhands.dev email domain
+
+ This is used for the organization members financial data endpoint.
+
+ Args:
+ request: FastAPI request object
+ org_id: Organization UUID from path parameter
+ user_id: User ID from authentication
+
+ Returns:
+ str: User ID if authorized
+
+ Raises:
+ HTTPException: 401 if not authenticated, 403 if not authorized
+ """
+ if not user_id:
+ raise HTTPException(
+ status_code=status.HTTP_401_UNAUTHORIZED,
+ detail='User not authenticated',
+ )
+
+ # Validate API key organization binding
+ api_key_org_id = await get_api_key_org_id_from_request(request)
+ if api_key_org_id is not None:
+ if api_key_org_id != org_id:
+ logger.warning(
+ 'API key organization mismatch for financial data access',
+ extra={
+ 'user_id': user_id,
+ 'api_key_org_id': str(api_key_org_id),
+ 'target_org_id': str(org_id),
+ },
+ )
+ raise HTTPException(
+ status_code=status.HTTP_403_FORBIDDEN,
+ detail='API key is not authorized for this organization',
+ )
+
+ # Check if user has @openhands.dev email
+ user_auth = await get_user_auth(request)
+ user_email = await user_auth.get_user_email()
+
+ if user_email and user_email.endswith('@openhands.dev'):
+ logger.debug(
+ 'Financial data access granted via @openhands.dev email',
+ extra={'user_id': user_id, 'org_id': str(org_id)},
+ )
+ return user_id
+
+ # Check if user has Admin or Owner role in the organization
+ user_role = await get_user_org_role(user_id, org_id)
+
+ if not user_role:
+ logger.warning(
+ 'Financial data access denied - user not a member of organization',
+ extra={'user_id': user_id, 'org_id': str(org_id)},
+ )
+ raise HTTPException(
+ status_code=status.HTTP_403_FORBIDDEN,
+ detail='User is not a member of this organization',
+ )
+
+ if user_role.name not in (RoleName.OWNER.value, RoleName.ADMIN.value):
+ logger.warning(
+ 'Financial data access denied - insufficient role',
+ extra={
+ 'user_id': user_id,
+ 'org_id': str(org_id),
+ 'user_role': user_role.name,
+ },
+ )
+ raise HTTPException(
+ status_code=status.HTTP_403_FORBIDDEN,
+ detail='Access restricted to organization admins, owners, or OpenHands members',
+ )
+
+ logger.debug(
+ 'Financial data access granted via admin/owner role',
+ extra={'user_id': user_id, 'org_id': str(org_id), 'role': user_role.name},
+ )
+ return user_id
diff --git a/enterprise/server/routes/org_models.py b/enterprise/server/routes/org_models.py
index 257c43473a..dcccc6f9e8 100644
--- a/enterprise/server/routes/org_models.py
+++ b/enterprise/server/routes/org_models.py
@@ -483,3 +483,22 @@ class OrgAppSettingsUpdate(BaseModel):
if v is not None and v <= 0:
raise ValueError('max_budget_per_task must be greater than 0')
return v
+
+
+class OrgMemberFinancialResponse(BaseModel):
+ """Financial data for a single organization member."""
+
+ user_id: str
+ email: str | None
+ lifetime_spend: float # Total amount spent (from LiteLLM)
+ current_budget: float # Remaining budget (max_budget - spend)
+ max_budget: float | None # Total allocated budget (None = unlimited)
+
+
+class OrgMemberFinancialPage(BaseModel):
+ """Paginated response for organization member financial data."""
+
+ items: list[OrgMemberFinancialResponse]
+ current_page: int = 1
+ per_page: int = 10
+ next_page_id: str | None = None
diff --git a/enterprise/server/routes/orgs.py b/enterprise/server/routes/orgs.py
index 3a49f23d70..d4ee26c3c5 100644
--- a/enterprise/server/routes/orgs.py
+++ b/enterprise/server/routes/orgs.py
@@ -4,6 +4,7 @@ from uuid import UUID
from fastapi import APIRouter, Depends, HTTPException, Query, status
from server.auth.authorization import (
Permission,
+ require_financial_data_access,
require_permission,
)
from server.email_validation import get_admin_user_id
@@ -22,6 +23,7 @@ from server.routes.org_models import (
OrgDatabaseError,
OrgLLMSettingsResponse,
OrgLLMSettingsUpdate,
+ OrgMemberFinancialPage,
OrgMemberNotFoundError,
OrgMemberPage,
OrgMemberResponse,
@@ -42,6 +44,7 @@ from server.services.org_llm_settings_service import (
OrgLLMSettingsService,
OrgLLMSettingsServiceInjector,
)
+from server.services.org_member_financial_service import OrgMemberFinancialService
from server.services.org_member_service import OrgMemberService
from storage.org_service import OrgService
from storage.user_store import UserStore
@@ -883,6 +886,104 @@ async def get_org_members_count(
)
+@org_router.get(
+ '/{org_id}/members/financial',
+ response_model=OrgMemberFinancialPage,
+)
+async def get_org_members_financial(
+ org_id: UUID,
+ page_id: Annotated[
+ str | None,
+ Query(
+ title='Pagination offset encoded as string',
+ description='Offset for pagination (e.g., "0", "10", "20")',
+ ),
+ ] = None,
+ limit: Annotated[
+ int,
+ Query(
+ title='Maximum items per page',
+ gt=0,
+ le=100,
+ ),
+ ] = 10,
+ email: Annotated[
+ str | None,
+ Query(
+ title='Filter members by email (case-insensitive partial match)',
+ min_length=1,
+ max_length=255,
+ ),
+ ] = None,
+ user_id: str = Depends(require_financial_data_access),
+) -> OrgMemberFinancialPage:
+ """Get paginated financial data for organization members.
+
+ Returns financial information (lifetime spend, current budget) for all members
+ within the specified organization. Access is restricted to:
+ - Organization Admins
+ - Organization Owners
+ - OpenHands members (users with @openhands.dev emails)
+
+ Args:
+ org_id: Organization ID (UUID)
+ page_id: Optional pagination offset encoded as string
+ limit: Maximum items per page (1-100, default 10)
+ email: Optional email filter (case-insensitive partial match)
+ user_id: Authenticated user ID (injected by require_financial_data_access)
+
+ Returns:
+ OrgMemberFinancialPage: Paginated response with member financial data
+ - items: List of members with user_id, email, lifetime_spend,
+ current_budget, and max_budget
+ - current_page: Current page number (1-indexed)
+ - per_page: Items per page
+ - next_page_id: Offset for next page, or None if no more pages
+
+ Raises:
+ HTTPException: 401 if user is not authenticated
+ HTTPException: 403 if user lacks access (not admin/owner and not @openhands.dev)
+ HTTPException: 400 if page_id is invalid
+ HTTPException: 500 if retrieval fails
+ """
+ logger.info(
+ 'Getting financial data for organization members',
+ extra={
+ 'org_id': str(org_id),
+ 'user_id': user_id,
+ 'page_id': page_id,
+ 'limit': limit,
+ 'email_filter': email,
+ },
+ )
+
+ try:
+ return await OrgMemberFinancialService.get_org_members_financial_data(
+ org_id=org_id,
+ page_id=page_id,
+ limit=limit,
+ email_filter=email,
+ )
+ except ValueError as e:
+ logger.warning(
+ 'Invalid page_id for financial data request',
+ extra={'org_id': str(org_id), 'page_id': page_id, 'error': str(e)},
+ )
+ raise HTTPException(
+ status_code=status.HTTP_400_BAD_REQUEST,
+ detail=str(e),
+ )
+ except Exception:
+ logger.exception(
+ 'Error retrieving organization member financial data',
+ extra={'org_id': str(org_id)},
+ )
+ raise HTTPException(
+ status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+ detail='Failed to retrieve member financial data',
+ )
+
+
@org_router.delete('/{org_id}/members/{user_id}')
async def remove_org_member(
org_id: UUID,
diff --git a/enterprise/server/services/org_member_financial_service.py b/enterprise/server/services/org_member_financial_service.py
new file mode 100644
index 0000000000..7dc959c4f1
--- /dev/null
+++ b/enterprise/server/services/org_member_financial_service.py
@@ -0,0 +1,171 @@
+"""Service for managing organization member financial data."""
+
+from uuid import UUID
+
+import httpx
+from server.routes.org_models import (
+ OrgMemberFinancialPage,
+ OrgMemberFinancialResponse,
+)
+from storage.lite_llm_manager import LiteLlmManager
+from storage.org_member_store import OrgMemberStore
+
+from openhands.core.logger import openhands_logger as logger
+
+
+class OrgMemberFinancialService:
+ """Service for organization member financial data operations."""
+
+ @staticmethod
+ async def get_org_members_financial_data(
+ org_id: UUID,
+ page_id: str | None = None,
+ limit: int = 10,
+ email_filter: str | None = None,
+ ) -> OrgMemberFinancialPage:
+ """Get paginated financial data for organization members.
+
+ Fetches member list from database and joins with financial data from LiteLLM.
+
+ Args:
+ org_id: Organization UUID
+ page_id: Offset encoded as string (e.g., "0", "10", "20")
+ limit: Maximum items per page (default 10)
+ email_filter: Optional case-insensitive partial email match
+
+ Returns:
+ OrgMemberFinancialPage: Paginated response with financial data
+
+ Raises:
+ ValueError: If page_id is invalid
+ """
+ # Parse page_id to get offset
+ offset = 0
+ if page_id is not None:
+ try:
+ offset = int(page_id)
+ if offset < 0:
+ raise ValueError('page_id must be non-negative')
+ except ValueError as e:
+ raise ValueError(f'Invalid page_id: {page_id}') from e
+
+ # Fetch paginated members from database
+ members, total_count = await OrgMemberStore.get_org_members_paginated(
+ org_id=org_id,
+ offset=offset,
+ limit=limit,
+ email_filter=email_filter,
+ )
+
+ if not members:
+ return OrgMemberFinancialPage(
+ items=[],
+ current_page=(offset // limit) + 1,
+ per_page=limit,
+ next_page_id=None,
+ )
+
+ # Fetch financial data from LiteLLM for the entire team
+ # This is a single API call that returns all team members' data
+ try:
+ financial_data = await LiteLlmManager.get_team_members_financial_data(
+ str(org_id)
+ )
+ except httpx.HTTPStatusError as e:
+ # Re-raise auth errors - these indicate configuration issues that need fixing
+ if e.response.status_code in (401, 403):
+ logger.error(
+ 'LiteLLM authentication/authorization failed',
+ extra={
+ 'org_id': str(org_id),
+ 'status_code': e.response.status_code,
+ 'error': str(e),
+ },
+ )
+ raise
+ # For other HTTP errors (404, 500, etc.), use graceful degradation
+ logger.warning(
+ 'Failed to fetch financial data from LiteLLM',
+ extra={
+ 'org_id': str(org_id),
+ 'status_code': e.response.status_code,
+ 'error_type': type(e).__name__,
+ 'error': str(e),
+ },
+ )
+ financial_data = {}
+ except Exception as e:
+ # For network errors, timeouts, etc., use graceful degradation
+ logger.warning(
+ 'Failed to fetch financial data from LiteLLM',
+ extra={
+ 'org_id': str(org_id),
+ 'error_type': type(e).__name__,
+ 'error': str(e),
+ },
+ )
+ financial_data = {}
+
+ # Extract team-level data for shared budget calculation
+ team_spend = financial_data.get('team_spend', 0) or 0
+ members_financial = financial_data.get('members', {})
+
+ # Build response items by joining DB members with LiteLLM financial data
+ items: list[OrgMemberFinancialResponse] = []
+ for member in members:
+ user = member.user
+ user_id_str = str(member.user_id)
+
+ # Get financial data for this user (or defaults if not found)
+ user_financial = members_financial.get(user_id_str, {})
+ individual_spend = user_financial.get('spend', 0) or 0
+ max_budget = user_financial.get('max_budget')
+ uses_shared_budget = user_financial.get('uses_shared_budget', False)
+
+ # Calculate current budget (remaining)
+ # For shared team budgets, use team_spend to calculate remaining budget
+ # This ensures all members see the same remaining budget
+ if max_budget is not None:
+ if uses_shared_budget:
+ # Shared budget - use team's total spend
+ current_budget = max(max_budget - team_spend, 0)
+ else:
+ # Individual budget - use individual spend
+ current_budget = max(max_budget - individual_spend, 0)
+ else:
+ # If no max_budget, current_budget is unlimited (represented as 0)
+ current_budget = 0
+
+ items.append(
+ OrgMemberFinancialResponse(
+ user_id=user_id_str,
+ email=user.email if user else None,
+ lifetime_spend=individual_spend,
+ current_budget=current_budget,
+ max_budget=max_budget,
+ )
+ )
+
+ # Calculate current page (1-indexed)
+ current_page = (offset // limit) + 1
+
+ # Calculate next_page_id
+ next_offset = offset + limit
+ next_page_id = str(next_offset) if next_offset < total_count else None
+
+ logger.debug(
+ 'OrgMemberFinancialService:get_org_members_financial_data:success',
+ extra={
+ 'org_id': str(org_id),
+ 'items_count': len(items),
+ 'current_page': current_page,
+ 'total_count': total_count,
+ },
+ )
+
+ return OrgMemberFinancialPage(
+ items=items,
+ current_page=current_page,
+ per_page=limit,
+ next_page_id=next_page_id,
+ )
diff --git a/enterprise/storage/lite_llm_manager.py b/enterprise/storage/lite_llm_manager.py
index e5afcb65c8..2b378faa11 100644
--- a/enterprise/storage/lite_llm_manager.py
+++ b/enterprise/storage/lite_llm_manager.py
@@ -1524,6 +1524,83 @@ class LiteLlmManager:
'LiteLlmManager:_delete_key:key_deleted',
)
+ @staticmethod
+ async def _get_team_members_financial_data(
+ client: httpx.AsyncClient,
+ team_id: str,
+ ) -> dict:
+ """
+ Get financial data for all members in a team.
+
+ Fetches team info from LiteLLM and extracts spending/budget data for each member.
+
+ Args:
+ client: HTTP client for LiteLLM API
+ team_id: The team/organization ID
+
+ Returns:
+ Dict with structure:
+ {
+ "team_max_budget": float | None, # Team's shared budget
+ "team_spend": float, # Team's total spend (for shared budget calc)
+ "members": {
+ user_id: {
+ "spend": float,
+ "max_budget": float | None,
+ "uses_shared_budget": bool # True if using team budget
+ },
+ ...
+ }
+ }
+ Returns empty dict if team not found or LiteLLM is not configured.
+ """
+ if LITE_LLM_API_KEY is None or LITE_LLM_API_URL is None:
+ logger.warning('LiteLLM API configuration not found')
+ return {}
+
+ team_info = await LiteLlmManager._get_team(client, team_id)
+ if not team_info:
+ logger.warning(
+ 'LiteLlmManager:_get_team_members_financial_data:team_not_found',
+ extra={'team_id': team_id},
+ )
+ return {}
+
+ members: dict[str, dict] = {}
+ team_memberships = team_info.get('team_memberships', [])
+
+ # Get team-level budget info (shared across all members in team orgs)
+ team_data = team_info.get('team_info', {})
+ team_max_budget = team_data.get('max_budget')
+ team_spend = team_data.get('spend', 0) or 0
+
+ for membership in team_memberships:
+ user_id = membership.get('user_id')
+ if not user_id:
+ continue
+
+ # Use individual max_budget_in_team if set, otherwise fall back to team budget
+ member_max_budget = membership.get('max_budget_in_team')
+ uses_shared_budget = member_max_budget is None
+ if uses_shared_budget:
+ member_max_budget = team_max_budget
+
+ members[user_id] = {
+ 'spend': membership.get('spend', 0) or 0,
+ 'max_budget': member_max_budget,
+ 'uses_shared_budget': uses_shared_budget,
+ }
+
+ logger.debug(
+ 'LiteLlmManager:_get_team_members_financial_data:success',
+ extra={'team_id': team_id, 'member_count': len(members)},
+ )
+ return {
+ 'team_max_budget': team_max_budget,
+ 'team_spend': team_spend,
+ 'members': members,
+ }
+
@staticmethod
def with_http_client(
internal_fn: Callable[..., Awaitable[Any]],
@@ -1559,3 +1636,6 @@ class LiteLlmManager:
get_user_keys = staticmethod(with_http_client(_get_user_keys))
delete_key_by_alias = staticmethod(with_http_client(_delete_key_by_alias))
update_user_keys = staticmethod(with_http_client(_update_user_keys))
+ get_team_members_financial_data = staticmethod(
+ with_http_client(_get_team_members_financial_data)
+ )
diff --git a/enterprise/tests/unit/server/services/test_org_member_financial_service.py b/enterprise/tests/unit/server/services/test_org_member_financial_service.py
new file mode 100644
index 0000000000..8bd25a290f
--- /dev/null
+++ b/enterprise/tests/unit/server/services/test_org_member_financial_service.py
@@ -0,0 +1,420 @@
+"""Tests for OrgMemberFinancialService."""
+
+import uuid
+from unittest.mock import AsyncMock, MagicMock, patch
+
+import pytest
+from server.routes.org_models import OrgMemberFinancialPage
+from server.services.org_member_financial_service import OrgMemberFinancialService
+from storage.org_member import OrgMember
+
+
+def org_id():
+ """Create a test organization ID."""
+ return uuid.uuid4()
+
+
+def mock_user():
+ """Create a mock user."""
+ user = MagicMock()
+ user.email = '[email protected]'
+ return user
+
+
+def mock_role():
+ """Create a mock role."""
+ role = MagicMock()
+ role.id = 1
+ role.name = 'member'
+ role.rank = 1000
+ return role
+
+
+def mock_org_member(org_id, mock_user, mock_role):
+ """Create a mock org member with user and role."""
+ member = MagicMock(spec=OrgMember)
+ member.org_id = org_id
+ member.user_id = uuid.uuid4()
+ member.role_id = mock_role.id
+ member.status = 'active'
+ member.user = mock_user
+ member.role = mock_role
+ return member
+
+
+class TestOrgMemberFinancialServiceGetFinancialData:
+ """Test cases for OrgMemberFinancialService.get_org_members_financial_data."""
+
+ @pytest.mark.asyncio
+ async def test_returns_paginated_financial_data_with_individual_budget(
+ self, org_id, mock_org_member
+ ):
+ """
+ GIVEN: Organization with members having individual budget limits
+ WHEN: get_org_members_financial_data is called
+ THEN: Returns financial data using individual spend for current_budget calc
+ """
+ # Arrange
+ user_id_str = str(mock_org_member.user_id)
+ litellm_data = {
+ 'team_max_budget': 1000.0,
+ 'team_spend': 200.0,
+ 'members': {
+ user_id_str: {'spend': 125.50, 'max_budget': 500.0} # Individual budget
+ },
+ }
+
+ with (
+ patch(
+ 'server.services.org_member_financial_service.OrgMemberStore.get_org_members_paginated',
+ new_callable=AsyncMock,
+ ) as mock_get_paginated,
+ patch(
+ 'server.services.org_member_financial_service.LiteLlmManager.get_team_members_financial_data',
+ new_callable=AsyncMock,
+ ) as mock_get_financial,
+ ):
+ mock_get_paginated.return_value = ([mock_org_member], 1)
+ mock_get_financial.return_value = litellm_data
+
+ # Act
+ result = await OrgMemberFinancialService.get_org_members_financial_data(
+ org_id=org_id,
+ page_id=None,
+ limit=10,
+ )
+
+ # Assert
+ assert isinstance(result, OrgMemberFinancialPage)
+ assert len(result.items) == 1
+ assert result.items[0].user_id == user_id_str
+ assert result.items[0].email == '[email protected]'
+ assert result.items[0].lifetime_spend == 125.50
+ assert result.items[0].max_budget == 500.0
+ # Individual budget: 500 - 125.50 = 374.50
+ assert result.items[0].current_budget == 374.50
+ assert result.current_page == 1
+ assert result.per_page == 10
+
+ @pytest.mark.asyncio
+ async def test_returns_shared_budget_using_team_spend(
+ self, org_id, mock_org_member
+ ):
+ """
+ GIVEN: Organization with shared team budget
+ WHEN: get_org_members_financial_data is called
+ THEN: Uses team_spend (not individual spend) for current_budget calculation
+ """
+ # Arrange
+ user_id_str = str(mock_org_member.user_id)
+ litellm_data = {
+ 'team_max_budget': 500.0,
+ 'team_spend': 150.0, # Total team spend
+ 'members': {
+ user_id_str: {
+ 'spend': 50.0,
+ 'max_budget': 500.0,
+ 'uses_shared_budget': True, # Explicitly using shared budget
+ }
+ },
+ }
+
+ with (
+ patch(
+ 'server.services.org_member_financial_service.OrgMemberStore.get_org_members_paginated',
+ new_callable=AsyncMock,
+ ) as mock_get_paginated,
+ patch(
+ 'server.services.org_member_financial_service.LiteLlmManager.get_team_members_financial_data',
+ new_callable=AsyncMock,
+ ) as mock_get_financial,
+ ):
+ mock_get_paginated.return_value = ([mock_org_member], 1)
+ mock_get_financial.return_value = litellm_data
+
+ # Act
+ result = await OrgMemberFinancialService.get_org_members_financial_data(
+ org_id=org_id,
+ )
+
+ # Assert
+ assert len(result.items) == 1
+ assert result.items[0].lifetime_spend == 50.0 # Individual spend
+ assert result.items[0].max_budget == 500.0
+ # Shared budget: 500 - 150 (team_spend) = 350
+ assert result.items[0].current_budget == 350.0
+
+ @pytest.mark.asyncio
+ async def test_returns_defaults_when_litellm_data_missing(
+ self, org_id, mock_org_member
+ ):
+ """
+ GIVEN: Organization with members but no LiteLLM data for them
+ WHEN: get_org_members_financial_data is called
+ THEN: Returns financial data with default values (spend=0, budget=None)
+ """
+ # Arrange
+ with (
+ patch(
+ 'server.services.org_member_financial_service.OrgMemberStore.get_org_members_paginated',
+ new_callable=AsyncMock,
+ ) as mock_get_paginated,
+ patch(
+ 'server.services.org_member_financial_service.LiteLlmManager.get_team_members_financial_data',
+ new_callable=AsyncMock,
+ ) as mock_get_financial,
+ ):
+ mock_get_paginated.return_value = ([mock_org_member], 1)
+ mock_get_financial.return_value = {
+ 'team_max_budget': None,
+ 'team_spend': 0,
+ 'members': {},
+ }
+
+ # Act
+ result = await OrgMemberFinancialService.get_org_members_financial_data(
+ org_id=org_id,
+ )
+
+ # Assert
+ assert len(result.items) == 1
+ assert result.items[0].lifetime_spend == 0
+ assert result.items[0].max_budget is None
+ assert result.items[0].current_budget == 0
+
+ @pytest.mark.asyncio
+ async def test_handles_litellm_failure_gracefully(self, org_id, mock_org_member):
+ """
+ GIVEN: LiteLLM service throws an exception
+ WHEN: get_org_members_financial_data is called
+ THEN: Returns financial data with default values (doesn't fail)
+ """
+ # Arrange
+ with (
+ patch(
+ 'server.services.org_member_financial_service.OrgMemberStore.get_org_members_paginated',
+ new_callable=AsyncMock,
+ ) as mock_get_paginated,
+ patch(
+ 'server.services.org_member_financial_service.LiteLlmManager.get_team_members_financial_data',
+ new_callable=AsyncMock,
+ ) as mock_get_financial,
+ ):
+ mock_get_paginated.return_value = ([mock_org_member], 1)
+ mock_get_financial.side_effect = Exception('LiteLLM unavailable')
+
+ # Act
+ result = await OrgMemberFinancialService.get_org_members_financial_data(
+ org_id=org_id,
+ )
+
+ # Assert - should not raise, returns defaults
+ assert len(result.items) == 1
+ assert result.items[0].lifetime_spend == 0
+ assert result.items[0].max_budget is None
+
+ @pytest.mark.asyncio
+ async def test_pagination_returns_next_page_id(self, org_id, mock_org_member):
+ """
+ GIVEN: Organization with more members than limit
+ WHEN: get_org_members_financial_data is called
+ THEN: Returns next_page_id for pagination
+ """
+ # Arrange
+ with (
+ patch(
+ 'server.services.org_member_financial_service.OrgMemberStore.get_org_members_paginated',
+ new_callable=AsyncMock,
+ ) as mock_get_paginated,
+ patch(
+ 'server.services.org_member_financial_service.LiteLlmManager.get_team_members_financial_data',
+ new_callable=AsyncMock,
+ ) as mock_get_financial,
+ ):
+ mock_get_paginated.return_value = ([mock_org_member], 25) # 25 total
+ mock_get_financial.return_value = {
+ 'team_max_budget': None,
+ 'team_spend': 0,
+ 'members': {},
+ }
+
+ # Act
+ result = await OrgMemberFinancialService.get_org_members_financial_data(
+ org_id=org_id,
+ page_id='0',
+ limit=10,
+ )
+
+ # Assert
+ assert result.current_page == 1
+ assert result.next_page_id == '10'
+
+ @pytest.mark.asyncio
+ async def test_pagination_no_next_page_on_last_page(self, org_id, mock_org_member):
+ """
+ GIVEN: Organization on last page of results
+ WHEN: get_org_members_financial_data is called
+ THEN: Returns next_page_id as None
+ """
+ # Arrange
+ with (
+ patch(
+ 'server.services.org_member_financial_service.OrgMemberStore.get_org_members_paginated',
+ new_callable=AsyncMock,
+ ) as mock_get_paginated,
+ patch(
+ 'server.services.org_member_financial_service.LiteLlmManager.get_team_members_financial_data',
+ new_callable=AsyncMock,
+ ) as mock_get_financial,
+ ):
+ mock_get_paginated.return_value = ([mock_org_member], 5) # 5 total
+ mock_get_financial.return_value = {
+ 'team_max_budget': None,
+ 'team_spend': 0,
+ 'members': {},
+ }
+
+ # Act
+ result = await OrgMemberFinancialService.get_org_members_financial_data(
+ org_id=org_id,
+ page_id='0',
+ limit=10,
+ )
+
+ # Assert
+ assert result.next_page_id is None
+
+ @pytest.mark.asyncio
+ async def test_empty_organization_returns_empty_items(self, org_id):
+ """
+ GIVEN: Organization with no members
+ WHEN: get_org_members_financial_data is called
+ THEN: Returns empty items list
+ """
+ # Arrange
+ with patch(
+ 'server.services.org_member_financial_service.OrgMemberStore.get_org_members_paginated',
+ new_callable=AsyncMock,
+ ) as mock_get_paginated:
+ mock_get_paginated.return_value = ([], 0)
+
+ # Act
+ result = await OrgMemberFinancialService.get_org_members_financial_data(
+ org_id=org_id,
+ )
+
+ # Assert
+ assert len(result.items) == 0
+ assert result.next_page_id is None
+
+ @pytest.mark.asyncio
+ async def test_invalid_page_id_raises_value_error(self, org_id):
+ """
+ GIVEN: Invalid page_id format
+ WHEN: get_org_members_financial_data is called
+ THEN: Raises ValueError
+ """
+ # Act & Assert
+ with pytest.raises(ValueError) as exc_info:
+ await OrgMemberFinancialService.get_org_members_financial_data(
+ org_id=org_id,
+ page_id='invalid',
+ )
+
+ assert 'Invalid page_id' in str(exc_info.value)
+
+ @pytest.mark.asyncio
+ async def test_negative_page_id_raises_value_error(self, org_id):
+ """
+ GIVEN: Negative page_id
+ WHEN: get_org_members_financial_data is called
+ THEN: Raises ValueError
+ """
+ # Act & Assert
+ with pytest.raises(ValueError) as exc_info:
+ await OrgMemberFinancialService.get_org_members_financial_data(
+ org_id=org_id,
+ page_id='-5',
+ )
+
+ assert 'Invalid page_id' in str(exc_info.value)
+
+ @pytest.mark.asyncio
+ async def test_passes_email_filter_to_store(self, org_id, mock_org_member):
+ """
+ GIVEN: Email filter parameter
+ WHEN: get_org_members_financial_data is called
+ THEN: Passes email filter to the store
+ """
+ # Arrange
+ with (
+ patch(
+ 'server.services.org_member_financial_service.OrgMemberStore.get_org_members_paginated',
+ new_callable=AsyncMock,
+ ) as mock_get_paginated,
+ patch(
+ 'server.services.org_member_financial_service.LiteLlmManager.get_team_members_financial_data',
+ new_callable=AsyncMock,
+ ) as mock_get_financial,
+ ):
+ mock_get_paginated.return_value = ([mock_org_member], 1)
+ mock_get_financial.return_value = {
+ 'team_max_budget': None,
+ 'team_spend': 0,
+ 'members': {},
+ }
+
+ # Act
+ await OrgMemberFinancialService.get_org_members_financial_data(
+ org_id=org_id,
+ email_filter='alice',
+ )
+
+ # Assert
+ mock_get_paginated.assert_called_once_with(
+ org_id=org_id, offset=0, limit=10, email_filter='alice'
+ )
+
+ @pytest.mark.asyncio
+ async def test_handles_missing_user_relationship(self, org_id, mock_role):
+ """
+ GIVEN: Member with no user relationship loaded
+ WHEN: get_org_members_financial_data is called
+ THEN: Returns None for email
+ """
+ # Arrange
+ member_no_user = MagicMock(spec=OrgMember)
+ member_no_user.org_id = org_id
+ member_no_user.user_id = uuid.uuid4()
+ member_no_user.role_id = mock_role.id
+ member_no_user.user = None # No user relationship
+
+ with (
+ patch(
+ 'server.services.org_member_financial_service.OrgMemberStore.get_org_members_paginated',
+ new_callable=AsyncMock,
+ ) as mock_get_paginated,
+ patch(
+ 'server.services.org_member_financial_service.LiteLlmManager.get_team_members_financial_data',
+ new_callable=AsyncMock,
+ ) as mock_get_financial,
+ ):
+ mock_get_paginated.return_value = ([member_no_user], 1)
+ mock_get_financial.return_value = {
+ 'team_max_budget': None,
+ 'team_spend': 0,
+ 'members': {},
+ }
+
+ # Act
+ result = await OrgMemberFinancialService.get_org_members_financial_data(
+ org_id=org_id,
+ )
+
+ # Assert
+ assert len(result.items) == 1
+ assert result.items[0].email is None
diff --git a/enterprise/tests/unit/test_authorization.py b/enterprise/tests/unit/test_authorization.py
index a4051b4824..5a35c3836d 100644
--- a/enterprise/tests/unit/test_authorization.py
+++ b/enterprise/tests/unit/test_authorization.py
@@ -1008,3 +1008,234 @@ class TestGetApiKeyOrgIdFromRequest:
# Assert
assert result is None
+
+
+# =============================================================================
+# Tests for require_financial_data_access dependency
+# =============================================================================
+
+
+def _create_mock_request_with_email(api_key_org_id=None, user_email='[email protected]'):
+ """Helper to create a mock request with optional api_key_org_id and email."""
+ mock_request = MagicMock()
+ mock_user_auth = MagicMock()
+ # get_api_key_org_id is sync, not async
+ mock_user_auth.get_api_key_org_id.return_value = api_key_org_id
+ # get_user_email is async
+ mock_user_auth.get_user_email = AsyncMock(return_value=user_email)
+ mock_request.state.user_auth = mock_user_auth
+ return mock_request
+
+
+class TestRequireFinancialDataAccess:
+ """Tests for require_financial_data_access compound authorization dependency."""
+
+ @pytest.mark.asyncio
+ async def test_grants_access_for_openhands_email(self):
+ """
+ GIVEN: User with @openhands.dev email
+ WHEN: require_financial_data_access is called
+ THEN: Returns user_id (access granted)
+ """
+ from server.auth.authorization import require_financial_data_access
+
+ # Arrange
+ user_id = str(uuid4())
+ org_id = uuid4()
+ mock_request = _create_mock_request_with_email(user_email='[email protected]')
+
+ with patch(
+ 'server.auth.authorization.get_user_auth',
+ AsyncMock(return_value=mock_request.state.user_auth),
+ ):
+ # Act
+ result = await require_financial_data_access(
+ request=mock_request, org_id=org_id, user_id=user_id
+ )
+
+ # Assert
+ assert result == user_id
+
+ @pytest.mark.asyncio
+ async def test_grants_access_for_owner_role(self):
+ """
+ GIVEN: User with owner role in organization ([email protected] email)
+ WHEN: require_financial_data_access is called
+ THEN: Returns user_id (access granted)
+ """
+ from server.auth.authorization import require_financial_data_access
+
+ # Arrange
+ user_id = str(uuid4())
+ org_id = uuid4()
+ mock_request = _create_mock_request_with_email(user_email='[email protected]')
+ mock_role = MagicMock()
+ mock_role.name = 'owner'
+
+ with (
+ patch(
+ 'server.auth.authorization.get_user_auth',
+ AsyncMock(return_value=mock_request.state.user_auth),
+ ),
+ patch(
+ 'server.auth.authorization.get_user_org_role',
+ AsyncMock(return_value=mock_role),
+ ),
+ ):
+ # Act
+ result = await require_financial_data_access(
+ request=mock_request, org_id=org_id, user_id=user_id
+ )
+
+ # Assert
+ assert result == user_id
+
+ @pytest.mark.asyncio
+ async def test_grants_access_for_admin_role(self):
+ """
+ GIVEN: User with admin role in organization ([email protected] email)
+ WHEN: require_financial_data_access is called
+ THEN: Returns user_id (access granted)
+ """
+ from server.auth.authorization import require_financial_data_access
+
+ # Arrange
+ user_id = str(uuid4())
+ org_id = uuid4()
+ mock_request = _create_mock_request_with_email(user_email='[email protected]')
+ mock_role = MagicMock()
+ mock_role.name = 'admin'
+
+ with (
+ patch(
+ 'server.auth.authorization.get_user_auth',
+ AsyncMock(return_value=mock_request.state.user_auth),
+ ),
+ patch(
+ 'server.auth.authorization.get_user_org_role',
+ AsyncMock(return_value=mock_role),
+ ),
+ ):
+ # Act
+ result = await require_financial_data_access(
+ request=mock_request, org_id=org_id, user_id=user_id
+ )
+
+ # Assert
+ assert result == user_id
+
+ @pytest.mark.asyncio
+ async def test_denies_access_for_member_role_without_openhands_email(self):
+ """
+ GIVEN: User with member role (not admin/owner) and [email protected] email
+ WHEN: require_financial_data_access is called
+ THEN: Raises 403 Forbidden
+ """
+ from server.auth.authorization import require_financial_data_access
+
+ # Arrange
+ user_id = str(uuid4())
+ org_id = uuid4()
+ mock_request = _create_mock_request_with_email(user_email='[email protected]')
+ mock_role = MagicMock()
+ mock_role.name = 'member'
+
+ with (
+ patch(
+ 'server.auth.authorization.get_user_auth',
+ AsyncMock(return_value=mock_request.state.user_auth),
+ ),
+ patch(
+ 'server.auth.authorization.get_user_org_role',
+ AsyncMock(return_value=mock_role),
+ ),
+ ):
+ # Act & Assert
+ with pytest.raises(HTTPException) as exc_info:
+ await require_financial_data_access(
+ request=mock_request, org_id=org_id, user_id=user_id
+ )
+
+ assert exc_info.value.status_code == 403
+ assert 'admins, owners, or OpenHands' in exc_info.value.detail
+
+ @pytest.mark.asyncio
+ async def test_denies_access_for_non_member(self):
+ """
+ GIVEN: User who is not a member of the organization
+ WHEN: require_financial_data_access is called
+ THEN: Raises 403 Forbidden
+ """
+ from server.auth.authorization import require_financial_data_access
+
+ # Arrange
+ user_id = str(uuid4())
+ org_id = uuid4()
+ mock_request = _create_mock_request_with_email(user_email='[email protected]')
+
+ with (
+ patch(
+ 'server.auth.authorization.get_user_auth',
+ AsyncMock(return_value=mock_request.state.user_auth),
+ ),
+ patch(
+ 'server.auth.authorization.get_user_org_role',
+ AsyncMock(return_value=None),
+ ),
+ ):
+ # Act & Assert
+ with pytest.raises(HTTPException) as exc_info:
+ await require_financial_data_access(
+ request=mock_request, org_id=org_id, user_id=user_id
+ )
+
+ assert exc_info.value.status_code == 403
+ assert 'not a member' in exc_info.value.detail
+
+ @pytest.mark.asyncio
+ async def test_denies_access_when_not_authenticated(self):
+ """
+ GIVEN: No user_id (not authenticated)
+ WHEN: require_financial_data_access is called
+ THEN: Raises 401 Unauthorized
+ """
+ from server.auth.authorization import require_financial_data_access
+
+ # Arrange
+ org_id = uuid4()
+ mock_request = _create_mock_request_with_email()
+
+ # Act & Assert
+ with pytest.raises(HTTPException) as exc_info:
+ await require_financial_data_access(
+ request=mock_request, org_id=org_id, user_id=None
+ )
+
+ assert exc_info.value.status_code == 401
+ assert 'not authenticated' in exc_info.value.detail
+
+ @pytest.mark.asyncio
+ async def test_denies_access_when_api_key_org_mismatch(self):
+ """
+ GIVEN: API key created for Org A, but user tries to access Org B
+ WHEN: require_financial_data_access is called
+ THEN: Raises 403 Forbidden with org mismatch message
+ """
+ from server.auth.authorization import require_financial_data_access
+
+ # Arrange
+ user_id = str(uuid4())
+ api_key_org_id = uuid4() # Org A
+ target_org_id = uuid4() # Org B
+ mock_request = _create_mock_request_with_email(
+ api_key_org_id=api_key_org_id, user_email='[email protected]'
+ )
+
+ # Act & Assert
+ with pytest.raises(HTTPException) as exc_info:
+ await require_financial_data_access(
+ request=mock_request, org_id=target_org_id, user_id=user_id
+ )
+
+ assert exc_info.value.status_code == 403
+ assert 'API key is not authorized' in exc_info.value.detail
diff --git a/enterprise/tests/unit/test_lite_llm_manager.py b/enterprise/tests/unit/test_lite_llm_manager.py
index ffd964b77f..74611f0a8d 100644
--- a/enterprise/tests/unit/test_lite_llm_manager.py
+++ b/enterprise/tests/unit/test_lite_llm_manager.py
@@ -2576,3 +2576,304 @@ class TestBudgetPayloadHandling:
'max_budget_in_team' in json_payload
), 'max_budget_in_team should be in payload when set to a value'
assert json_payload['max_budget_in_team'] == 75.0
+
+
+class TestGetTeamMembersFinancialData:
+ """Test cases for _get_team_members_financial_data method."""
+
+ @pytest.fixture
+ def mock_http_client(self):
+ """Create a mock HTTP client."""
+ return AsyncMock(spec=httpx.AsyncClient)
+
+ @pytest.mark.asyncio
+ async def test_returns_financial_data_for_all_team_members(self, mock_http_client):
+ """
+ GIVEN: Team with multiple members having financial data
+ WHEN: _get_team_members_financial_data is called
+ THEN: Returns dict with team info and member data
+ """
+ # Arrange
+ mock_response = MagicMock()
+ mock_response.is_success = True
+ mock_response.status_code = 200
+ mock_response.json.return_value = {
+ 'team_info': {'team_id': 'test-team', 'max_budget': 500.0, 'spend': 125.5},
+ 'team_memberships': [
+ {
+ 'user_id': 'user-1',
+ 'spend': 50.0,
+ 'max_budget_in_team': 200.0,
+ },
+ {
+ 'user_id': 'user-2',
+ 'spend': 75.5,
+ 'max_budget_in_team': 150.0,
+ },
+ ],
+ }
+ mock_response.raise_for_status = MagicMock()
+ mock_http_client.get.return_value = mock_response
+
+ with patch('storage.lite_llm_manager.LITE_LLM_API_KEY', 'test-key'):
+ with patch('storage.lite_llm_manager.LITE_LLM_API_URL', 'http://test.com'):
+ # Act
+ result = await LiteLlmManager._get_team_members_financial_data(
+ mock_http_client, 'test-team'
+ )
+
+ # Assert
+ assert result['team_max_budget'] == 500.0
+ assert result['team_spend'] == 125.5
+ assert len(result['members']) == 2
+ # Both users have individual budgets (max_budget_in_team is set)
+ assert result['members']['user-1'] == {
+ 'spend': 50.0,
+ 'max_budget': 200.0,
+ 'uses_shared_budget': False,
+ }
+ assert result['members']['user-2'] == {
+ 'spend': 75.5,
+ 'max_budget': 150.0,
+ 'uses_shared_budget': False,
+ }
+
+ @pytest.mark.asyncio
+ async def test_returns_empty_dict_when_litellm_not_configured(
+ self, mock_http_client
+ ):
+ """
+ GIVEN: LiteLLM API key or URL not configured
+ WHEN: _get_team_members_financial_data is called
+ THEN: Returns empty dict
+ """
+ # Arrange - no patching, so LITE_LLM_API_KEY/URL are None
+ with patch('storage.lite_llm_manager.LITE_LLM_API_KEY', None):
+ with patch('storage.lite_llm_manager.LITE_LLM_API_URL', None):
+ # Act
+ result = await LiteLlmManager._get_team_members_financial_data(
+ mock_http_client, 'test-team'
+ )
+
+ # Assert
+ assert result == {}
+ mock_http_client.get.assert_not_called()
+
+ @pytest.mark.asyncio
+ async def test_returns_empty_dict_when_team_not_found(self, mock_http_client):
+ """
+ GIVEN: Team does not exist in LiteLLM
+ WHEN: _get_team_members_financial_data is called
+ THEN: Returns empty dict
+ """
+ # Arrange
+ mock_response = MagicMock()
+ mock_response.status_code = 404
+ mock_response.raise_for_status.side_effect = httpx.HTTPStatusError(
+ 'Not found', request=MagicMock(), response=mock_response
+ )
+ mock_http_client.get.return_value = mock_response
+
+ with patch('storage.lite_llm_manager.LITE_LLM_API_KEY', 'test-key'):
+ with patch('storage.lite_llm_manager.LITE_LLM_API_URL', 'http://test.com'):
+ # Act & Assert
+ with pytest.raises(httpx.HTTPStatusError):
+ await LiteLlmManager._get_team_members_financial_data(
+ mock_http_client, 'nonexistent-team'
+ )
+
+ @pytest.mark.asyncio
+ async def test_returns_empty_members_when_team_has_no_members(
+ self, mock_http_client
+ ):
+ """
+ GIVEN: Team exists but has no members
+ WHEN: _get_team_members_financial_data is called
+ THEN: Returns structure with empty members dict
+ """
+ # Arrange
+ mock_response = MagicMock()
+ mock_response.is_success = True
+ mock_response.status_code = 200
+ mock_response.json.return_value = {
+ 'team_info': {'team_id': 'empty-team', 'max_budget': 100.0, 'spend': 0},
+ 'team_memberships': [],
+ }
+ mock_response.raise_for_status = MagicMock()
+ mock_http_client.get.return_value = mock_response
+
+ with patch('storage.lite_llm_manager.LITE_LLM_API_KEY', 'test-key'):
+ with patch('storage.lite_llm_manager.LITE_LLM_API_URL', 'http://test.com'):
+ # Act
+ result = await LiteLlmManager._get_team_members_financial_data(
+ mock_http_client, 'empty-team'
+ )
+
+ # Assert
+ assert result['team_max_budget'] == 100.0
+ assert result['team_spend'] == 0
+ assert result['members'] == {}
+
+ @pytest.mark.asyncio
+ async def test_falls_back_to_team_budget_when_member_budget_missing(
+ self, mock_http_client
+ ):
+ """
+ GIVEN: Team with shared budget, members without individual max_budget_in_team
+ WHEN: _get_team_members_financial_data is called
+ THEN: Falls back to team_info.max_budget for members without individual budget
+ """
+ # Arrange
+ mock_response = MagicMock()
+ mock_response.is_success = True
+ mock_response.status_code = 200
+ mock_response.json.return_value = {
+ 'team_info': {'team_id': 'test-team', 'max_budget': 500.0, 'spend': 150.0},
+ 'team_memberships': [
+ {
+ 'user_id': 'user-no-individual-budget',
+ 'spend': 50.0,
+ # No max_budget_in_team - should fall back to team budget
+ },
+ {
+ 'user_id': 'user-with-individual-budget',
+ 'spend': 75.0,
+ 'max_budget_in_team': 200.0, # Individual budget set
+ },
+ {
+ 'user_id': 'user-null-budget',
+ 'spend': 25.0,
+ 'max_budget_in_team': None, # Explicit null - fall back to team
+ },
+ ],
+ }
+ mock_response.raise_for_status = MagicMock()
+ mock_http_client.get.return_value = mock_response
+
+ with patch('storage.lite_llm_manager.LITE_LLM_API_KEY', 'test-key'):
+ with patch('storage.lite_llm_manager.LITE_LLM_API_URL', 'http://test.com'):
+ # Act
+ result = await LiteLlmManager._get_team_members_financial_data(
+ mock_http_client, 'test-team'
+ )
+
+ # Assert
+ assert result['team_max_budget'] == 500.0
+ assert result['team_spend'] == 150.0
+ members = result['members']
+ assert members['user-no-individual-budget'] == {
+ 'spend': 50.0,
+ 'max_budget': 500.0,
+ 'uses_shared_budget': True,
+ }
+ assert members['user-with-individual-budget'] == {
+ 'spend': 75.0,
+ 'max_budget': 200.0,
+ 'uses_shared_budget': False,
+ }
+ assert members['user-null-budget'] == {
+ 'spend': 25.0,
+ 'max_budget': 500.0,
+ 'uses_shared_budget': True,
+ }
+
+ @pytest.mark.asyncio
+ async def test_uses_defaults_when_no_budget_data_available(self, mock_http_client):
+ """
+ GIVEN: Team without budget and members without individual budgets
+ WHEN: _get_team_members_financial_data is called
+ THEN: Returns default values (spend=0, max_budget=None)
+ """
+ # Arrange
+ mock_response = MagicMock()
+ mock_response.is_success = True
+ mock_response.status_code = 200
+ mock_response.json.return_value = {
+ 'team_info': {'team_id': 'test-team'}, # No max_budget at team level
+ 'team_memberships': [
+ {
+ 'user_id': 'user-no-data',
+ # No spend or max_budget_in_team
+ },
+ {
+ 'user_id': 'user-null-spend',
+ 'spend': None, # Explicit null
+ },
+ ],
+ }
+ mock_response.raise_for_status = MagicMock()
+ mock_http_client.get.return_value = mock_response
+
+ with patch('storage.lite_llm_manager.LITE_LLM_API_KEY', 'test-key'):
+ with patch('storage.lite_llm_manager.LITE_LLM_API_URL', 'http://test.com'):
+ # Act
+ result = await LiteLlmManager._get_team_members_financial_data(
+ mock_http_client, 'test-team'
+ )
+
+ # Assert
+ assert result['team_max_budget'] is None
+ assert result['team_spend'] == 0
+ members = result['members']
+ # Both users fall back to team budget (which is None)
+ assert members['user-no-data'] == {
+ 'spend': 0,
+ 'max_budget': None,
+ 'uses_shared_budget': True,
+ }
+ assert members['user-null-spend'] == {
+ 'spend': 0,
+ 'max_budget': None,
+ 'uses_shared_budget': True,
+ }
+
+ @pytest.mark.asyncio
+ async def test_skips_members_without_user_id(self, mock_http_client):
+ """
+ GIVEN: Team with members, some missing user_id
+ WHEN: _get_team_members_financial_data is called
+ THEN: Skips members without user_id
+ """
+ # Arrange
+ mock_response = MagicMock()
+ mock_response.is_success = True
+ mock_response.status_code = 200
+ mock_response.json.return_value = {
+ 'team_info': {'team_id': 'test-team', 'max_budget': 300.0, 'spend': 105.0},
+ 'team_memberships': [
+ {
+ 'user_id': 'valid-user',
+ 'spend': 25.0,
+ 'max_budget_in_team': 100.0,
+ },
+ {
+ # Missing user_id
+ 'spend': 50.0,
+ 'max_budget_in_team': 200.0,
+ },
+ {
+ 'user_id': None, # Explicit null
+ 'spend': 30.0,
+ },
+ ],
+ }
+ mock_response.raise_for_status = MagicMock()
+ mock_http_client.get.return_value = mock_response
+
+ with patch('storage.lite_llm_manager.LITE_LLM_API_KEY', 'test-key'):
+ with patch('storage.lite_llm_manager.LITE_LLM_API_URL', 'http://test.com'):
+ # Act
+ result = await LiteLlmManager._get_team_members_financial_data(
+ mock_http_client, 'test-team'
+ )
+
+ # Assert - only valid user should be included
+ assert result['team_max_budget'] == 300.0
+ assert result['team_spend'] == 105.0
+ assert len(result['members']) == 1
+ assert 'valid-user' in result['members']
+ assert result['members']['valid-user'] == {
+ 'spend': 25.0,
+ 'max_budget': 100.0,
+ 'uses_shared_budget': False,
+ }