π 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.pyindex 203f74f112..ef2b7e91c4 100644--- a/enterprise/server/auth/authorization.py+++ b/enterprise/server/auth/authorization.py@@ -41,7 +41,7 @@ from storage.role import Rolefrom storage.role_store import RoleStorefrom 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_idclass Permission(str, Enum):@@ -311,3 +311,96 @@ def require_permission(permission: Permission):return user_idreturn 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_iddiff --git a/enterprise/server/routes/org_models.py b/enterprise/server/routes/org_models.pyindex 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 = Nonediff --git a/enterprise/server/routes/orgs.py b/enterprise/server/routes/orgs.pyindex 3a49f23d70..d4ee26c3c5 100644--- a/enterprise/server/routes/orgs.py+++ b/enterprise/server/routes/orgs.py@@ -4,6 +4,7 @@ from uuid import UUIDfrom fastapi import APIRouter, Depends, HTTPException, Query, statusfrom 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 OrgMemberFinancialServicefrom server.services.org_member_service import OrgMemberServicefrom storage.org_service import OrgServicefrom 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.pynew file mode 100644index 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.pyindex 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,+ }+@staticmethoddef 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.pynew file mode 100644index 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 Nonediff --git a/enterprise/tests/unit/test_authorization.py b/enterprise/tests/unit/test_authorization.pyindex a4051b4824..5a35c3836d 100644--- a/enterprise/tests/unit/test_authorization.py+++ b/enterprise/tests/unit/test_authorization.py@@ -1008,3 +1008,234 @@ class TestGetApiKeyOrgIdFromRequest:# Assertassert 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.detaildiff --git a/enterprise/tests/unit/test_lite_llm_manager.py b/enterprise/tests/unit/test_lite_llm_manager.pyindex 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,+ }