π OpenHands: AI-Driven Development
feat(backend): develop post /api/organizations api (org project) (#12263)
Hiep Le030ff59c4096
diff --git a/enterprise/poetry.lock b/enterprise/poetry.lockindex 6096729fe1..274e138a06 100644--- a/enterprise/poetry.lock+++ b/enterprise/poetry.lock@@ -6126,7 +6126,7 @@ wsproto = ">=1.2.0"[[package]]name = "openhands-ai"-version = "1.1.0"+version = "1.2.1"description = "OpenHands: Code Less, Make More"optional = falsepython-versions = "^3.12,<3.14"diff --git a/enterprise/saas_server.py b/enterprise/saas_server.pyindex 803530a794..1734536d53 100644--- a/enterprise/saas_server.py+++ b/enterprise/saas_server.py@@ -38,6 +38,7 @@ from server.routes.integration.linear import linear_integration_router # noqa:from server.routes.integration.slack import slack_router # noqa: E402from server.routes.mcp_patch import patch_mcp_server # noqa: E402from server.routes.oauth_device import oauth_device_router # noqa: E402+from server.routes.orgs import org_router # noqa: E402from server.routes.readiness import readiness_router # noqa: E402from server.routes.user import saas_user_router # noqa: E402from server.sharing.shared_conversation_router import ( # noqa: E402@@ -90,6 +91,7 @@ if GITLAB_APP_CLIENT_ID:base_app.include_router(gitlab_integration_router)base_app.include_router(api_keys_router) # Add routes for API key management+base_app.include_router(org_router) # Add routes for organization managementadd_github_proxy_routes(base_app)add_debugging_routes(base_appdiff --git a/enterprise/server/auth/saas_user_auth.py b/enterprise/server/auth/saas_user_auth.pyindex 893cda0527..5cd6a1e2c4 100644--- a/enterprise/server/auth/saas_user_auth.py+++ b/enterprise/server/auth/saas_user_auth.py@@ -77,6 +77,15 @@ class SaasUserAuth(UserAuth):self.access_token = SecretStr(tokens['access_token'])self.refresh_token = SecretStr(tokens['refresh_token'])self.refreshed = True+ if not self.email or not self.email_verified or not self.user_id:+ # We don't need to verify the signature here because we just refreshed+ # this token from the IDP via token_manager.refresh()+ access_token_payload = jwt.decode(+ tokens['access_token'], options={'verify_signature': False}+ )+ self.user_id = access_token_payload['sub']+ self.email = access_token_payload['email']+ self.email_verified = access_token_payload['email_verified']def _is_token_expired(self, token: SecretStr):logger.debug('saas_user_auth_is_token_expired')@@ -273,11 +282,13 @@ async def saas_user_auth_from_bearer(request: Request) -> SaasUserAuth | None:if not user_id:return Noneoffline_token = await token_manager.load_offline_token(user_id)- return SaasUserAuth(+ saas_user_auth = SaasUserAuth(user_id=user_id,refresh_token=SecretStr(offline_token),auth_type=AuthType.BEARER,)+ await saas_user_auth.refresh()+ return saas_user_authexcept Exception as exc:raise BearerTokenError from excdiff --git a/enterprise/server/email_validation.py b/enterprise/server/email_validation.pynew file mode 100644index 0000000000..b3242cd281--- /dev/null+++ b/enterprise/server/email_validation.py@@ -0,0 +1,68 @@+"""+Email domain validation utilities for enterprise endpoints.+"""++from fastapi import Depends, HTTPException, Request, status++from openhands.core.logger import openhands_logger as logger+from openhands.server.user_auth import get_user_auth, get_user_id+++async def get_admin_user_id(+ request: Request, user_id: str | None = Depends(get_user_id)+) -> str:+ """+ Dependency that validates user has @openhands.dev email domain.++ This dependency can be used in place of get_user_id for endpoints that+ should only be accessible to admin users. Currently, this is implemented+ by checking for @openhands.dev email domain.++ TODO: In the future, this should be replaced with an explicit is_admin flag+ in user/org settings instead of relying on email domain validation.++ Args:+ request: FastAPI request object+ user_id: User ID from get_user_id dependency++ Returns:+ str: User ID if email domain is valid++ Raises:+ HTTPException: 403 if email domain is not @openhands.dev+ HTTPException: 401 if user is not authenticated++ Example:+ @router.post('/endpoint')+ async def create_resource(+ user_id: str = Depends(get_admin_user_id),+ ):+ # Only admin users can access this endpoint+ pass+ """+ if not user_id:+ raise HTTPException(+ status_code=status.HTTP_401_UNAUTHORIZED,+ detail='User not authenticated',+ )++ user_auth = await get_user_auth(request)+ user_email = await user_auth.get_user_email()++ if not user_email:+ raise HTTPException(+ status_code=status.HTTP_401_UNAUTHORIZED,+ detail='User email not available',+ )++ if not user_email.endswith('@openhands.dev'):+ logger.warning(+ 'Access denied - invalid email domain',+ extra={'user_id': user_id, 'email_domain': user_email.split('@')[-1]},+ )+ raise HTTPException(+ status_code=status.HTTP_403_FORBIDDEN,+ detail='Access restricted to @openhands.dev users',+ )++ return user_iddiff --git a/enterprise/server/routes/org_models.py b/enterprise/server/routes/org_models.pynew file mode 100644index 0000000000..4fe480bf3a--- /dev/null+++ b/enterprise/server/routes/org_models.py@@ -0,0 +1,67 @@+from pydantic import BaseModel, EmailStr, Field+++class OrgCreationError(Exception):+ """Base exception for organization creation errors."""++ pass+++class OrgNameExistsError(OrgCreationError):+ """Raised when an organization name already exists."""++ def __init__(self, name: str):+ self.name = name+ super().__init__(f'Organization with name "{name}" already exists')+++class LiteLLMIntegrationError(OrgCreationError):+ """Raised when LiteLLM integration fails."""++ pass+++class OrgDatabaseError(OrgCreationError):+ """Raised when database operations fail."""++ pass+++class OrgCreate(BaseModel):+ """Request model for creating a new organization."""++ # Required fields+ name: str = Field(min_length=1, max_length=255, strip_whitespace=True)+ contact_name: str+ contact_email: EmailStr = Field(strip_whitespace=True)+++class OrgResponse(BaseModel):+ """Response model for organization."""++ id: str+ name: str+ contact_name: str+ contact_email: str+ conversation_expiration: int | None = None+ agent: str | None = None+ default_max_iterations: int | None = None+ security_analyzer: str | None = None+ confirmation_mode: bool | None = None+ default_llm_model: str | None = None+ default_llm_api_key_for_byor: str | None = None+ default_llm_base_url: str | None = None+ remote_runtime_resource_factor: int | None = None+ enable_default_condenser: bool = True+ billing_margin: float | None = None+ enable_proactive_conversation_starters: bool = True+ sandbox_base_container_image: str | None = None+ sandbox_runtime_container_image: str | None = None+ org_version: int = 0+ mcp_config: dict | None = None+ search_api_key: str | None = None+ sandbox_api_key: str | None = None+ max_budget_per_task: float | None = None+ enable_solvability_analysis: bool | None = None+ v1_enabled: bool | None = None+ credits: float | None = Nonediff --git a/enterprise/server/routes/orgs.py b/enterprise/server/routes/orgs.pynew file mode 100644index 0000000000..fa61cb3664--- /dev/null+++ b/enterprise/server/routes/orgs.py@@ -0,0 +1,117 @@+from fastapi import APIRouter, Depends, HTTPException, status+from server.email_validation import get_admin_user_id+from server.routes.org_models import (+ LiteLLMIntegrationError,+ OrgCreate,+ OrgDatabaseError,+ OrgNameExistsError,+ OrgResponse,+)+from storage.org_service import OrgService++from openhands.core.logger import openhands_logger as logger++# Initialize API router+org_router = APIRouter(prefix='/api/organizations')+++@org_router.post('', response_model=OrgResponse, status_code=status.HTTP_201_CREATED)+async def create_org(+ org_data: OrgCreate,+ user_id: str = Depends(get_admin_user_id),+) -> OrgResponse:+ """Create a new organization.++ This endpoint allows authenticated users with @openhands.dev email to create+ a new organization. The user who creates the organization automatically becomes+ its owner.++ Args:+ org_data: Organization creation data+ user_id: Authenticated user ID (injected by dependency)++ Returns:+ OrgResponse: The created organization details++ Raises:+ HTTPException: 403 if user email domain is not @openhands.dev+ HTTPException: 409 if organization name already exists+ HTTPException: 500 if creation fails+ """+ logger.info(+ 'Creating new organization',+ extra={+ 'user_id': user_id,+ 'org_name': org_data.name,+ },+ )++ try:+ # Use service layer to create organization+ org = await OrgService.create_org_with_owner(+ name=org_data.name,+ contact_name=org_data.contact_name,+ contact_email=org_data.contact_email,+ user_id=user_id,+ )++ # Retrieve credits from LiteLLM+ credits = await OrgService.get_org_credits(user_id, org.id)++ return OrgResponse(+ id=str(org.id),+ name=org.name,+ contact_name=org.contact_name,+ contact_email=org.contact_email,+ conversation_expiration=org.conversation_expiration,+ agent=org.agent,+ default_max_iterations=org.default_max_iterations,+ security_analyzer=org.security_analyzer,+ confirmation_mode=org.confirmation_mode,+ default_llm_model=org.default_llm_model,+ default_llm_base_url=org.default_llm_base_url,+ remote_runtime_resource_factor=org.remote_runtime_resource_factor,+ enable_default_condenser=org.enable_default_condenser,+ billing_margin=org.billing_margin,+ enable_proactive_conversation_starters=org.enable_proactive_conversation_starters,+ sandbox_base_container_image=org.sandbox_base_container_image,+ sandbox_runtime_container_image=org.sandbox_runtime_container_image,+ org_version=org.org_version,+ mcp_config=org.mcp_config,+ max_budget_per_task=org.max_budget_per_task,+ enable_solvability_analysis=org.enable_solvability_analysis,+ v1_enabled=org.v1_enabled,+ credits=credits,+ )+ except OrgNameExistsError as e:+ raise HTTPException(+ status_code=status.HTTP_409_CONFLICT,+ detail=str(e),+ )+ except LiteLLMIntegrationError as e:+ logger.error(+ 'LiteLLM integration failed',+ extra={'user_id': user_id, 'error': str(e)},+ )+ raise HTTPException(+ status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,+ detail='Failed to create LiteLLM integration',+ )+ except OrgDatabaseError as e:+ logger.error(+ 'Database operation failed',+ extra={'user_id': user_id, 'error': str(e)},+ )+ raise HTTPException(+ status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,+ detail='Failed to create organization',+ )+ except Exception as e:+ logger.exception(+ 'Unexpected error creating organization',+ extra={'user_id': user_id, 'error': str(e)},+ )+ raise HTTPException(+ status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,+ detail='An unexpected error occurred',+ )diff --git a/enterprise/storage/lite_llm_manager.py b/enterprise/storage/lite_llm_manager.pyindex 09a7a5147c..b23e3c28d2 100644--- a/enterprise/storage/lite_llm_manager.py+++ b/enterprise/storage/lite_llm_manager.py@@ -38,6 +38,7 @@ class LiteLlmManager:org_id: str,keycloak_user_id: str,oss_settings: Settings,+ create_user: bool,) -> Settings | None:logger.info('SettingsStore:update_settings_with_litellm_default:start',@@ -64,9 +65,10 @@ class LiteLlmManager:client, keycloak_user_id, org_id, DEFAULT_INITIAL_BUDGET)- await LiteLlmManager._create_user(- client, keycloak_user_info.get('email'), keycloak_user_id- )+ if create_user:+ await LiteLlmManager._create_user(+ client, keycloak_user_info.get('email'), keycloak_user_id+ )await LiteLlmManager._add_user_to_team(client, keycloak_user_id, org_id, DEFAULT_INITIAL_BUDGET@@ -76,7 +78,7 @@ class LiteLlmManager:client,keycloak_user_id,org_id,- f'OpenHands Cloud - user {keycloak_user_id}',+ f'OpenHands Cloud - user {keycloak_user_id} - org {org_id}',None,)@@ -474,6 +476,41 @@ class LiteLlmManager:)response.raise_for_status()+ @staticmethod+ async def _delete_team(+ client: httpx.AsyncClient,+ team_id: str,+ ):+ if LITE_LLM_API_KEY is None or LITE_LLM_API_URL is None:+ logger.warning('LiteLLM API configuration not found')+ return+ response = await client.post(+ f'{LITE_LLM_API_URL}/team/delete',+ json={'team_ids': [team_id]},+ )++ if not response.is_success:+ if response.status_code == 404:+ # Team doesn't exist, that's fine+ logger.info(+ 'Team already deleted or does not exist',+ extra={'team_id': team_id},+ )+ return+ logger.error(+ 'error_deleting_litellm_team',+ extra={+ 'status_code': response.status_code,+ 'text': response.text,+ 'team_id': team_id,+ },+ )+ response.raise_for_status()+ logger.info(+ 'LiteLlmManager:_delete_team:team_deleted',+ extra={'team_id': team_id},+ )+@staticmethodasync def _add_user_to_team(client: httpx.AsyncClient,@@ -817,6 +854,7 @@ class LiteLlmManager:get_user = staticmethod(with_http_client(_get_user))update_user = staticmethod(with_http_client(_update_user))delete_user = staticmethod(with_http_client(_delete_user))+ delete_team = staticmethod(with_http_client(_delete_team))add_user_to_team = staticmethod(with_http_client(_add_user_to_team))get_user_team_info = staticmethod(with_http_client(_get_user_team_info))update_user_in_team = staticmethod(with_http_client(_update_user_in_team))diff --git a/enterprise/storage/org_service.py b/enterprise/storage/org_service.pynew file mode 100644index 0000000000..1bd3afb17d--- /dev/null+++ b/enterprise/storage/org_service.py@@ -0,0 +1,443 @@+"""+Service class for managing organization operations.+Separates business logic from route handlers.+"""++from uuid import UUID, uuid4+from uuid import UUID as parse_uuid++from server.constants import ORG_SETTINGS_VERSION, get_default_litellm_model+from server.routes.org_models import (+ LiteLLMIntegrationError,+ OrgDatabaseError,+ OrgNameExistsError,+)+from storage.lite_llm_manager import LiteLlmManager+from storage.org import Org+from storage.org_member import OrgMember+from storage.org_member_store import OrgMemberStore+from storage.org_store import OrgStore+from storage.role_store import RoleStore+from storage.user_store import UserStore++from openhands.core.logger import openhands_logger as logger+++class OrgService:+ """Service for handling organization-related operations."""++ @staticmethod+ def validate_name_uniqueness(name: str) -> None:+ """+ Validate that organization name is unique.++ Args:+ name: Organization name to validate++ Raises:+ OrgNameExistsError: If organization name already exists+ """+ existing_org = OrgStore.get_org_by_name(name)+ if existing_org is not None:+ raise OrgNameExistsError(name)++ @staticmethod+ async def create_litellm_integration(org_id: UUID, user_id: str) -> dict:+ """+ Create LiteLLM team integration for the organization.++ Args:+ org_id: Organization ID+ user_id: User ID who will own the organization++ Returns:+ dict: LiteLLM settings object++ Raises:+ LiteLLMIntegrationError: If LiteLLM integration fails+ """+ try:+ settings = await UserStore.create_default_settings(+ org_id=str(org_id), user_id=user_id, create_user=False+ )++ if not settings:+ logger.error(+ 'Failed to create LiteLLM settings',+ extra={'org_id': str(org_id), 'user_id': user_id},+ )+ raise LiteLLMIntegrationError('Failed to create LiteLLM settings')++ logger.debug(+ 'LiteLLM integration created',+ extra={'org_id': str(org_id), 'user_id': user_id},+ )+ return settings++ except LiteLLMIntegrationError:+ raise+ except Exception as e:+ logger.exception(+ 'Error creating LiteLLM integration',+ extra={'org_id': str(org_id), 'user_id': user_id, 'error': str(e)},+ )+ raise LiteLLMIntegrationError(f'LiteLLM integration failed: {str(e)}')++ @staticmethod+ def create_org_entity(+ org_id: UUID,+ name: str,+ contact_name: str,+ contact_email: str,+ ) -> Org:+ """+ Create an organization entity with basic information.++ Args:+ org_id: Organization UUID+ name: Organization name+ contact_name: Contact person name+ contact_email: Contact email address++ Returns:+ Org: New organization entity (not yet persisted)+ """+ return Org(+ id=org_id,+ name=name,+ contact_name=contact_name,+ contact_email=contact_email,+ org_version=ORG_SETTINGS_VERSION,+ default_llm_model=get_default_litellm_model(),+ )++ @staticmethod+ def apply_litellm_settings_to_org(org: Org, settings: dict) -> None:+ """+ Apply LiteLLM settings to organization entity.++ Args:+ org: Organization entity to update+ settings: LiteLLM settings object+ """+ org_kwargs = OrgStore.get_kwargs_from_settings(settings)+ for key, value in org_kwargs.items():+ if hasattr(org, key):+ setattr(org, key, value)++ @staticmethod+ def get_owner_role():+ """+ Get the owner role from the database.++ Returns:+ Role: The owner role object++ Raises:+ Exception: If owner role not found+ """+ owner_role = RoleStore.get_role_by_name('owner')+ if not owner_role:+ raise Exception('Owner role not found in database')+ return owner_role++ @staticmethod+ def create_org_member_entity(+ org_id: UUID,+ user_id: str,+ role_id: int,+ settings: dict,+ ) -> OrgMember:+ """+ Create an organization member entity.++ Args:+ org_id: Organization UUID+ user_id: User ID (string that will be converted to UUID)+ role_id: Role ID+ settings: LiteLLM settings object++ Returns:+ OrgMember: New organization member entity (not yet persisted)+ """+ org_member_kwargs = OrgMemberStore.get_kwargs_from_settings(settings)+ return OrgMember(+ org_id=org_id,+ user_id=parse_uuid(user_id),+ role_id=role_id,+ status='active',+ **org_member_kwargs,+ )++ @staticmethod+ async def create_org_with_owner(+ name: str,+ contact_name: str,+ contact_email: str,+ user_id: str,+ ) -> Org:+ """+ Create a new organization with the specified user as owner.++ This method orchestrates the complete organization creation workflow:+ 1. Validates that the organization name doesn't already exist+ 2. Generates a unique organization ID+ 3. Creates LiteLLM team integration+ 4. Creates the organization entity+ 5. Applies LiteLLM settings+ 6. Creates owner membership+ 7. Persists everything in a transaction++ If database persistence fails, LiteLLM resources are cleaned up (compensation).++ Args:+ name: Organization name (must be unique)+ contact_name: Contact person name+ contact_email: Contact email address+ user_id: ID of the user who will be the owner++ Returns:+ Org: The created organization object++ Raises:+ OrgNameExistsError: If organization name already exists+ LiteLLMIntegrationError: If LiteLLM integration fails+ OrgDatabaseError: If database operations fail+ """+ logger.info(+ 'Starting organization creation',+ extra={'user_id': user_id, 'org_name': name},+ )++ # Step 1: Validate name uniqueness (fails early, no cleanup needed)+ OrgService.validate_name_uniqueness(name)++ # Step 2: Generate organization ID+ org_id = uuid4()++ # Step 3: Create LiteLLM integration (external state created)+ settings = await OrgService.create_litellm_integration(org_id, user_id)++ # Steps 4-7: Create entities and persist with compensation+ # If any of these fail, we need to clean up LiteLLM resources+ try:+ # Step 4: Create organization entity+ org = OrgService.create_org_entity(+ org_id=org_id,+ name=name,+ contact_name=contact_name,+ contact_email=contact_email,+ )++ # Step 5: Apply LiteLLM settings+ OrgService.apply_litellm_settings_to_org(org, settings)++ # Step 6: Get owner role and create member entity+ owner_role = OrgService.get_owner_role()+ org_member = OrgService.create_org_member_entity(+ org_id=org_id,+ user_id=user_id,+ role_id=owner_role.id,+ settings=settings,+ )++ # Step 7: Persist in transaction (critical section)+ persisted_org = await OrgService._persist_with_compensation(+ org, org_member, org_id, user_id+ )++ logger.info(+ 'Successfully created organization',+ extra={+ 'org_id': str(persisted_org.id),+ 'org_name': persisted_org.name,+ 'user_id': user_id,+ 'role': 'owner',+ },+ )++ return persisted_org++ except OrgDatabaseError:+ # Already handled by _persist_with_compensation, just re-raise+ raise+ except Exception as e:+ # Unexpected error in steps 4-6, need to clean up LiteLLM+ logger.error(+ 'Unexpected error during organization creation, initiating cleanup',+ extra={+ 'org_id': str(org_id),+ 'user_id': user_id,+ 'error': str(e),+ },+ )+ await OrgService._handle_failure_with_cleanup(+ org_id, user_id, e, 'Failed to create organization'+ )++ @staticmethod+ async def _persist_with_compensation(+ org: Org,+ org_member: OrgMember,+ org_id: UUID,+ user_id: str,+ ) -> Org:+ """+ Persist organization with compensation on failure.++ If database persistence fails, cleans up LiteLLM resources.++ Args:+ org: Organization entity to persist+ org_member: Organization member entity to persist+ org_id: Organization ID (for cleanup)+ user_id: User ID (for cleanup)++ Returns:+ Org: The persisted organization object++ Raises:+ OrgDatabaseError: If database operations fail+ """+ try:+ persisted_org = OrgStore.persist_org_with_owner(org, org_member)+ return persisted_org++ except Exception as e:+ logger.error(+ 'Database persistence failed, initiating LiteLLM cleanup',+ extra={+ 'org_id': str(org_id),+ 'user_id': user_id,+ 'error': str(e),+ },+ )+ await OrgService._handle_failure_with_cleanup(+ org_id, user_id, e, 'Failed to create organization'+ )++ @staticmethod+ async def _handle_failure_with_cleanup(+ org_id: UUID,+ user_id: str,+ original_error: Exception,+ error_message: str,+ ) -> None:+ """+ Handle failure by cleaning up LiteLLM resources and raising appropriate error.++ This method performs compensating transaction and raises OrgDatabaseError.++ Args:+ org_id: Organization ID+ user_id: User ID+ original_error: The original exception that caused the failure+ error_message: Base error message for the exception++ Raises:+ OrgDatabaseError: Always raises with details about the failure+ """+ cleanup_error = await OrgService._cleanup_litellm_resources(org_id, user_id)++ if cleanup_error:+ logger.error(+ 'Both operation and cleanup failed',+ extra={+ 'org_id': str(org_id),+ 'user_id': user_id,+ 'original_error': str(original_error),+ 'cleanup_error': str(cleanup_error),+ },+ )+ raise OrgDatabaseError(+ f'{error_message}: {str(original_error)}. '+ f'Cleanup also failed: {str(cleanup_error)}'+ )++ raise OrgDatabaseError(f'{error_message}: {str(original_error)}')++ @staticmethod+ async def _cleanup_litellm_resources(+ org_id: UUID, user_id: str+ ) -> Exception | None:+ """+ Compensating transaction: Clean up LiteLLM resources.++ Deletes the team which should cascade to remove keys and memberships.+ This is a best-effort operation - errors are logged but not raised.++ Args:+ org_id: Organization ID+ user_id: User ID++ Returns:+ Exception | None: Exception if cleanup failed, None if successful+ """+ try:+ await LiteLlmManager.delete_team(str(org_id))++ logger.info(+ 'Successfully cleaned up LiteLLM team',+ extra={'org_id': str(org_id), 'user_id': user_id},+ )+ return None++ except Exception as e:+ logger.error(+ 'Failed to cleanup LiteLLM team (resources may be orphaned)',+ extra={+ 'org_id': str(org_id),+ 'user_id': user_id,+ 'error': str(e),+ },+ )+ return e++ @staticmethod+ async def get_org_credits(user_id: str, org_id: UUID) -> float | None:+ """+ Get organization credits from LiteLLM team.++ Args:+ user_id: User ID+ org_id: Organization ID++ Returns:+ float | None: Credits (max_budget - spend) or None if LiteLLM not configured+ """+ try:+ user_team_info = await LiteLlmManager.get_user_team_info(+ user_id, str(org_id)+ )+ if not user_team_info:+ logger.warning(+ 'No team info available from LiteLLM',+ extra={'user_id': user_id, 'org_id': str(org_id)},+ )+ return None++ max_budget = (user_team_info.get('litellm_budget_table') or {}).get(+ 'max_budget', 0+ )+ spend = user_team_info.get('spend', 0)+ credits = max(max_budget - spend, 0)++ logger.debug(+ 'Retrieved organization credits',+ extra={+ 'user_id': user_id,+ 'org_id': str(org_id),+ 'credits': credits,+ 'max_budget': max_budget,+ 'spend': spend,+ },+ )++ return credits++ except Exception as e:+ logger.warning(+ 'Failed to retrieve organization credits',+ extra={'user_id': user_id, 'org_id': str(org_id), 'error': str(e)},+ )+ return Nonediff --git a/enterprise/storage/org_store.py b/enterprise/storage/org_store.pyindex f7a706349b..87e67865ed 100644--- a/enterprise/storage/org_store.py+++ b/enterprise/storage/org_store.py@@ -13,6 +13,7 @@ from server.constants import (from sqlalchemy.orm import joinedloadfrom storage.database import session_makerfrom storage.org import Org+from storage.org_member import OrgMemberfrom storage.user import Userfrom storage.user_settings import UserSettings@@ -160,3 +161,28 @@ class OrgStore:kwargs['org_version'] = user_settings.user_versionreturn kwargs++ @staticmethod+ def persist_org_with_owner(+ org: Org,+ org_member: OrgMember,+ ) -> Org:+ """+ Persist organization and owner membership in a single transaction.++ Args:+ org: Organization entity to persist+ org_member: Organization member entity to persist++ Returns:+ Org: The persisted organization object++ Raises:+ Exception: If database operations fail+ """+ with session_maker() as session:+ session.add(org)+ session.add(org_member)+ session.commit()+ session.refresh(org)+ return orgdiff --git a/enterprise/storage/user_store.py b/enterprise/storage/user_store.pyindex 847cd19e0d..ca30612285 100644--- a/enterprise/storage/user_store.py+++ b/enterprise/storage/user_store.py@@ -435,7 +435,7 @@ class UserStore:@staticmethodasync def create_default_settings(- org_id: str, user_id: str+ org_id: str, user_id: str, create_user: bool = True) -> Optional['Settings']:logger.info('UserStore:create_default_settings:start',@@ -451,7 +451,9 @@ class UserStore:from storage.lite_llm_manager import LiteLlmManager- settings = await LiteLlmManager.create_entries(org_id, user_id, settings)+ settings = await LiteLlmManager.create_entries(+ org_id, user_id, settings, create_user+ )if not settings:logger.info('UserStore:create_default_settings:litellm_create_failed',diff --git a/enterprise/tests/unit/server/routes/test_orgs.py b/enterprise/tests/unit/server/routes/test_orgs.pynew file mode 100644index 0000000000..1ec450b4de--- /dev/null+++ b/enterprise/tests/unit/server/routes/test_orgs.py@@ -0,0 +1,377 @@+"""+Integration tests for organization API routes.++Tests the POST /api/organizations endpoint with various scenarios.+"""++import uuid+from unittest.mock import AsyncMock, patch++import pytest+from fastapi import FastAPI, HTTPException, status+from fastapi.testclient import TestClient++# Mock database before imports+with patch('storage.database.engine', create=True), patch(+ 'storage.database.a_engine', create=True+):+ from server.email_validation import get_admin_user_id+ from server.routes.org_models import (+ LiteLLMIntegrationError,+ OrgDatabaseError,+ OrgNameExistsError,+ )+ from server.routes.orgs import org_router+ from storage.org import Org+++def mock_app():+ """Create a test FastAPI app with organization routes and mocked auth."""+ app = FastAPI()+ app.include_router(org_router)++ # Override the auth dependency to return a test user+ def mock_get_openhands_user_id():+ return 'test-user-123'++ app.dependency_overrides[get_admin_user_id] = mock_get_openhands_user_id++ return app+++async def test_create_org_success(mock_app):+ """+ GIVEN: Valid organization creation request+ WHEN: POST /api/organizations is called+ THEN: Organization is created and returned with 201 status+ """+ # Arrange+ org_id = uuid.uuid4()+ mock_org = Org(+ id=org_id,+ name='Test Organization',+ contact_name='John Doe',+ contact_email='[email protected]',+ org_version=5,+ default_llm_model='claude-opus-4-5-20251101',+ enable_default_condenser=True,+ enable_proactive_conversation_starters=True,+ )++ request_data = {+ 'name': 'Test Organization',+ 'contact_name': 'John Doe',+ 'contact_email': '[email protected]',+ }++ with (+ patch(+ 'server.routes.orgs.OrgService.create_org_with_owner',+ AsyncMock(return_value=mock_org),+ ),+ patch(+ 'server.routes.orgs.OrgService.get_org_credits',+ AsyncMock(return_value=100.0),+ ),+ ):+ client = TestClient(mock_app)++ # Act+ response = client.post('/api/organizations', json=request_data)++ # Assert+ assert response.status_code == status.HTTP_201_CREATED+ response_data = response.json()+ assert response_data['name'] == 'Test Organization'+ assert response_data['contact_name'] == 'John Doe'+ assert response_data['contact_email'] == '[email protected]'+ assert response_data['credits'] == 100.0+ assert response_data['org_version'] == 5+ assert response_data['default_llm_model'] == 'claude-opus-4-5-20251101'+++async def test_create_org_invalid_email(mock_app):+ """+ GIVEN: Request with invalid email format+ WHEN: POST /api/organizations is called+ THEN: 422 validation error is returned+ """+ # Arrange+ request_data = {+ 'name': 'Test Organization',+ 'contact_name': 'John Doe',+ 'contact_email': 'invalid-email', # Missing @+ }++ client = TestClient(mock_app)++ # Act+ response = client.post('/api/organizations', json=request_data)++ # Assert+ assert response.status_code == status.HTTP_422_UNPROCESSABLE_ENTITY+++async def test_create_org_empty_name(mock_app):+ """+ GIVEN: Request with empty organization name+ WHEN: POST /api/organizations is called+ THEN: 422 validation error is returned+ """+ # Arrange+ request_data = {+ 'name': '', # Empty string (after whitespace stripping)+ 'contact_name': 'John Doe',+ 'contact_email': '[email protected]',+ }++ client = TestClient(mock_app)++ # Act+ response = client.post('/api/organizations', json=request_data)++ # Assert+ assert response.status_code == status.HTTP_422_UNPROCESSABLE_ENTITY+++async def test_create_org_duplicate_name(mock_app):+ """+ GIVEN: Organization name already exists+ WHEN: POST /api/organizations is called+ THEN: 409 Conflict error is returned+ """+ # Arrange+ request_data = {+ 'name': 'Existing Organization',+ 'contact_name': 'John Doe',+ 'contact_email': '[email protected]',+ }++ with patch(+ 'server.routes.orgs.OrgService.create_org_with_owner',+ AsyncMock(side_effect=OrgNameExistsError('Existing Organization')),+ ):+ client = TestClient(mock_app)++ # Act+ response = client.post('/api/organizations', json=request_data)++ # Assert+ assert response.status_code == status.HTTP_409_CONFLICT+ assert 'already exists' in response.json()['detail'].lower()+++async def test_create_org_litellm_failure(mock_app):+ """+ GIVEN: LiteLLM integration fails+ WHEN: POST /api/organizations is called+ THEN: 500 Internal Server Error is returned+ """+ # Arrange+ request_data = {+ 'name': 'Test Organization',+ 'contact_name': 'John Doe',+ 'contact_email': '[email protected]',+ }++ with patch(+ 'server.routes.orgs.OrgService.create_org_with_owner',+ AsyncMock(side_effect=LiteLLMIntegrationError('LiteLLM API unavailable')),+ ):+ client = TestClient(mock_app)++ # Act+ response = client.post('/api/organizations', json=request_data)++ # Assert+ assert response.status_code == status.HTTP_500_INTERNAL_SERVER_ERROR+ assert 'LiteLLM integration' in response.json()['detail']+++async def test_create_org_database_failure(mock_app):+ """+ GIVEN: Database operation fails+ WHEN: POST /api/organizations is called+ THEN: 500 Internal Server Error is returned+ """+ # Arrange+ request_data = {+ 'name': 'Test Organization',+ 'contact_name': 'John Doe',+ 'contact_email': '[email protected]',+ }++ with patch(+ 'server.routes.orgs.OrgService.create_org_with_owner',+ AsyncMock(side_effect=OrgDatabaseError('Database connection failed')),+ ):+ client = TestClient(mock_app)++ # Act+ response = client.post('/api/organizations', json=request_data)++ # Assert+ assert response.status_code == status.HTTP_500_INTERNAL_SERVER_ERROR+ assert 'Failed to create organization' in response.json()['detail']+++async def test_create_org_unexpected_error(mock_app):+ """+ GIVEN: Unexpected error occurs+ WHEN: POST /api/organizations is called+ THEN: 500 Internal Server Error is returned with generic message+ """+ # Arrange+ request_data = {+ 'name': 'Test Organization',+ 'contact_name': 'John Doe',+ 'contact_email': '[email protected]',+ }++ with patch(+ 'server.routes.orgs.OrgService.create_org_with_owner',+ AsyncMock(side_effect=RuntimeError('Unexpected system error')),+ ):+ client = TestClient(mock_app)++ # Act+ response = client.post('/api/organizations', json=request_data)++ # Assert+ assert response.status_code == status.HTTP_500_INTERNAL_SERVER_ERROR+ assert 'unexpected error' in response.json()['detail'].lower()+++async def test_create_org_unauthorized():+ """+ GIVEN: User is not authenticated+ WHEN: POST /api/organizations is called+ THEN: 401 Unauthorized error is returned+ """+ # Arrange+ app = FastAPI()+ app.include_router(org_router)++ # Override to simulate unauthenticated user+ async def mock_unauthenticated():+ raise HTTPException(status_code=401, detail='User not authenticated')++ app.dependency_overrides[get_admin_user_id] = mock_unauthenticated++ request_data = {+ 'name': 'Test Organization',+ 'contact_name': 'John Doe',+ 'contact_email': '[email protected]',+ }++ client = TestClient(app)++ # Act+ response = client.post('/api/organizations', json=request_data)++ # Assert+ assert response.status_code == status.HTTP_401_UNAUTHORIZED+++async def test_create_org_forbidden_non_openhands_email():+ """+ GIVEN: User email is not @openhands.dev+ WHEN: POST /api/organizations is called+ THEN: 403 Forbidden error is returned+ """+ # Arrange+ app = FastAPI()+ app.include_router(org_router)++ # Override to simulate [email protected] user+ async def mock_forbidden():+ raise HTTPException(+ status_code=403, detail='Access restricted to @openhands.dev users'+ )++ app.dependency_overrides[get_admin_user_id] = mock_forbidden++ request_data = {+ 'name': 'Test Organization',+ 'contact_name': 'John Doe',+ 'contact_email': '[email protected]',+ }++ client = TestClient(app)++ # Act+ response = client.post('/api/organizations', json=request_data)++ # Assert+ assert response.status_code == status.HTTP_403_FORBIDDEN+ assert 'openhands.dev' in response.json()['detail'].lower()+++async def test_create_org_sensitive_fields_not_exposed(mock_app):+ """+ GIVEN: Organization is created successfully+ WHEN: Response is returned+ THEN: Sensitive fields (API keys) are not exposed+ """+ # Arrange+ org_id = uuid.uuid4()+ mock_org = Org(+ id=org_id,+ name='Test Organization',+ contact_name='John Doe',+ contact_email='[email protected]',+ org_version=5,+ default_llm_model='claude-opus-4-5-20251101',+ enable_default_condenser=True,+ enable_proactive_conversation_starters=True,+ )++ request_data = {+ 'name': 'Test Organization',+ 'contact_name': 'John Doe',+ 'contact_email': '[email protected]',+ }++ with (+ patch(+ 'server.routes.orgs.OrgService.create_org_with_owner',+ AsyncMock(return_value=mock_org),+ ),+ patch(+ 'server.routes.orgs.OrgService.get_org_credits',+ AsyncMock(return_value=100.0),+ ),+ ):+ client = TestClient(mock_app)++ # Act+ response = client.post('/api/organizations', json=request_data)++ # Assert+ assert response.status_code == status.HTTP_201_CREATED+ response_data = response.json()++ # Verify sensitive fields are not in response or are None+ assert (+ 'default_llm_api_key_for_byor' not in response_data+ or response_data.get('default_llm_api_key_for_byor') is None+ )+ assert (+ 'search_api_key' not in response_data+ or response_data.get('search_api_key') is None+ )+ assert (+ 'sandbox_api_key' not in response_data+ or response_data.get('sandbox_api_key') is None+ )diff --git a/enterprise/tests/unit/test_email_validation_dependency.py b/enterprise/tests/unit/test_email_validation_dependency.pynew file mode 100644index 0000000000..8ac481a6e2--- /dev/null+++ b/enterprise/tests/unit/test_email_validation_dependency.py@@ -0,0 +1,272 @@+"""+Unit tests for email validation dependency (get_admin_user_id).++Tests the FastAPI dependency that validates @openhands.dev email domain.+"""++from unittest.mock import AsyncMock, MagicMock, patch++import pytest+from fastapi import HTTPException, Request+from server.email_validation import get_admin_user_id+++def mock_request():+ """Create a mock FastAPI request."""+ return MagicMock(spec=Request)+++def mock_user_auth():+ """Create a mock user auth object."""+ mock_auth = AsyncMock()+ mock_auth.get_user_email = AsyncMock()+ return mock_auth+++async def test_get_openhands_user_id_success(mock_request, mock_user_auth):+ """+ GIVEN: Valid user ID and @openhands.dev email+ WHEN: get_admin_user_id is called+ THEN: User ID is returned successfully+ """+ # Arrange+ user_id = 'test-user-123'+ mock_user_auth.get_user_email.return_value = '[email protected]'++ with patch('server.email_validation.get_user_auth', return_value=mock_user_auth):+ # Act+ result = await get_admin_user_id(mock_request, user_id)++ # Assert+ assert result == user_id+ mock_user_auth.get_user_email.assert_called_once()+++async def test_get_openhands_user_id_no_user_id(mock_request):+ """+ GIVEN: No user ID provided (None)+ WHEN: get_admin_user_id is called+ THEN: 401 Unauthorized is raised+ """+ # Arrange+ user_id = None++ # Act & Assert+ with pytest.raises(HTTPException) as exc_info:+ await get_admin_user_id(mock_request, user_id)++ assert exc_info.value.status_code == 401+ assert 'not authenticated' in exc_info.value.detail.lower()+++async def test_get_openhands_user_id_no_email(mock_request, mock_user_auth):+ """+ GIVEN: User ID provided but email is None+ WHEN: get_admin_user_id is called+ THEN: 401 Unauthorized is raised+ """+ # Arrange+ user_id = 'test-user-123'+ mock_user_auth.get_user_email.return_value = None++ with patch('server.email_validation.get_user_auth', return_value=mock_user_auth):+ # Act & Assert+ with pytest.raises(HTTPException) as exc_info:+ await get_admin_user_id(mock_request, user_id)++ assert exc_info.value.status_code == 401+ assert 'email not available' in exc_info.value.detail.lower()+++async def test_get_openhands_user_id_invalid_domain(mock_request, mock_user_auth):+ """+ GIVEN: User ID and email with [email protected] domain+ WHEN: get_admin_user_id is called+ THEN: 403 Forbidden is raised+ """+ # Arrange+ user_id = 'test-user-123'+ mock_user_auth.get_user_email.return_value = '[email protected]'++ with patch('server.email_validation.get_user_auth', return_value=mock_user_auth):+ # Act & Assert+ with pytest.raises(HTTPException) as exc_info:+ await get_admin_user_id(mock_request, user_id)++ assert exc_info.value.status_code == 403+ assert 'openhands.dev' in exc_info.value.detail.lower()+++async def test_get_openhands_user_id_empty_string_user_id(mock_request):+ """+ GIVEN: Empty string user ID+ WHEN: get_admin_user_id is called+ THEN: 401 Unauthorized is raised+ """+ # Arrange+ user_id = ''++ # Act & Assert+ with pytest.raises(HTTPException) as exc_info:+ await get_admin_user_id(mock_request, user_id)++ assert exc_info.value.status_code == 401+ assert 'not authenticated' in exc_info.value.detail.lower()+++async def test_get_openhands_user_id_case_sensitivity(mock_request, mock_user_auth):+ """+ GIVEN: Email with uppercase @OPENHANDS.DEV domain+ WHEN: get_admin_user_id is called+ THEN: 403 Forbidden is raised (case-sensitive check)+ """+ # Arrange+ user_id = 'test-user-123'+ mock_user_auth.get_user_email.return_value = '[email protected]'++ with patch('server.email_validation.get_user_auth', return_value=mock_user_auth):+ # Act & Assert+ with pytest.raises(HTTPException) as exc_info:+ await get_admin_user_id(mock_request, user_id)++ assert exc_info.value.status_code == 403+++async def test_get_openhands_user_id_subdomain_not_allowed(+ mock_request, mock_user_auth+):+ """+ GIVEN: Email with subdomain like @test.openhands.dev+ WHEN: get_admin_user_id is called+ THEN: 403 Forbidden is raised+ """+ # Arrange+ user_id = 'test-user-123'+ mock_user_auth.get_user_email.return_value = '[email protected]'++ with patch('server.email_validation.get_user_auth', return_value=mock_user_auth):+ # Act & Assert+ with pytest.raises(HTTPException) as exc_info:+ await get_admin_user_id(mock_request, user_id)++ assert exc_info.value.status_code == 403+++async def test_get_openhands_user_id_similar_domain_not_allowed(+ mock_request, mock_user_auth+):+ """+ GIVEN: Email with similar but different domain like @openhands.dev.fake.com+ WHEN: get_admin_user_id is called+ THEN: 403 Forbidden is raised+ """+ # Arrange+ user_id = 'test-user-123'+ mock_user_auth.get_user_email.return_value = '[email protected]'++ with patch('server.email_validation.get_user_auth', return_value=mock_user_auth):+ # Act & Assert+ with pytest.raises(HTTPException) as exc_info:+ await get_admin_user_id(mock_request, user_id)++ assert exc_info.value.status_code == 403+++async def test_get_openhands_user_id_logs_warning_on_invalid_domain(+ mock_request, mock_user_auth+):+ """+ GIVEN: User with invalid email domain+ WHEN: get_admin_user_id is called+ THEN: Warning is logged with user_id and email_domain+ """+ # Arrange+ user_id = 'test-user-123'+ invalid_email = '[email protected]'+ mock_user_auth.get_user_email.return_value = invalid_email++ with (+ patch('server.email_validation.get_user_auth', return_value=mock_user_auth),+ patch('server.email_validation.logger') as mock_logger,+ ):+ # Act & Assert+ with pytest.raises(HTTPException):+ await get_admin_user_id(mock_request, user_id)++ # Verify warning was logged+ mock_logger.warning.assert_called_once()+ call_args = mock_logger.warning.call_args+ assert 'Access denied' in call_args[0][0]+ assert call_args[1]['extra']['user_id'] == user_id+ assert call_args[1]['extra']['email_domain'] == 'external.com'+++async def test_get_openhands_user_id_with_plus_addressing(mock_request, mock_user_auth):+ """+ GIVEN: Email with plus addressing ([email protected])+ WHEN: get_admin_user_id is called+ THEN: User ID is returned successfully+ """+ # Arrange+ user_id = 'test-user-123'+ mock_user_auth.get_user_email.return_value = '[email protected]'++ with patch('server.email_validation.get_user_auth', return_value=mock_user_auth):+ # Act+ result = await get_admin_user_id(mock_request, user_id)++ # Assert+ assert result == user_id+++async def test_get_openhands_user_id_with_dots_in_local_part(+ mock_request, mock_user_auth+):+ """+ GIVEN: Email with dots in local part ([email protected])+ WHEN: get_admin_user_id is called+ THEN: User ID is returned successfully+ """+ # Arrange+ user_id = 'test-user-123'+ mock_user_auth.get_user_email.return_value = '[email protected]'++ with patch('server.email_validation.get_user_auth', return_value=mock_user_auth):+ # Act+ result = await get_admin_user_id(mock_request, user_id)++ # Assert+ assert result == user_id+++async def test_get_openhands_user_id_empty_email(mock_request, mock_user_auth):+ """+ GIVEN: Empty string email+ WHEN: get_admin_user_id is called+ THEN: 401 Unauthorized is raised+ """+ # Arrange+ user_id = 'test-user-123'+ mock_user_auth.get_user_email.return_value = ''++ with patch('server.email_validation.get_user_auth', return_value=mock_user_auth):+ # Act & Assert+ with pytest.raises(HTTPException) as exc_info:+ await get_admin_user_id(mock_request, user_id)++ assert exc_info.value.status_code == 401+ assert 'email not available' in exc_info.value.detail.lower()diff --git a/enterprise/tests/unit/test_lite_llm_manager.py b/enterprise/tests/unit/test_lite_llm_manager.pyindex 986869f81c..daf4166de4 100644--- a/enterprise/tests/unit/test_lite_llm_manager.py+++ b/enterprise/tests/unit/test_lite_llm_manager.py@@ -113,7 +113,7 @@ class TestLiteLlmManager:with patch('storage.lite_llm_manager.LITE_LLM_API_KEY', None):with patch('storage.lite_llm_manager.LITE_LLM_API_URL', None):result = await LiteLlmManager.create_entries(- 'test-org-id', 'test-user-id', mock_settings+ 'test-org-id', 'test-user-id', mock_settings, create_user=True)assert result is None@@ -126,7 +126,7 @@ class TestLiteLlmManager:'storage.lite_llm_manager.LITE_LLM_API_URL', 'http://test.com'):result = await LiteLlmManager.create_entries(- 'test-org-id', 'test-user-id', mock_settings+ 'test-org-id', 'test-user-id', mock_settings, create_user=True)assert result is not None@@ -158,7 +158,10 @@ class TestLiteLlmManager:mock_client.post.return_value = mock_responseresult = await LiteLlmManager.create_entries(- 'test-org-id', 'test-user-id', mock_settings+ 'test-org-id',+ 'test-user-id',+ mock_settings,+ create_user=False,)assert result is not None@@ -171,7 +174,7 @@ class TestLiteLlmManager:# Verify API calls were madeassert (- mock_client.post.call_count == 4+ mock_client.post.call_count == 3) # create_team, create_user, add_user_to_team, generate_key@pytest.mark.asyncio@@ -988,3 +991,138 @@ class TestLiteLlmManager:# Verify no HTTP calls were mademock_client.get.assert_not_called()mock_client.post.assert_not_called()++ @pytest.mark.asyncio+ async def test_delete_team_success(self, mock_http_client, mock_response):+ """+ GIVEN: Valid team_id and configured LiteLLM API+ WHEN: delete_team is called+ THEN: Team is deleted successfully via POST /team/delete+ """+ # Arrange+ team_id = 'test-team-123'+ mock_response.is_success = True+ mock_response.status_code = 200+ mock_http_client.post.return_value = mock_response++ with (+ patch('storage.lite_llm_manager.LITE_LLM_API_KEY', 'test-key'),+ patch('storage.lite_llm_manager.LITE_LLM_API_URL', 'http://test.url'),+ patch('storage.lite_llm_manager.LITE_LLM_TEAM_ID', 'test-team'),+ ):+ # Act+ await LiteLlmManager._delete_team(mock_http_client, team_id)++ # Assert+ mock_http_client.post.assert_called_once_with(+ 'http://test.url/team/delete',+ json={'team_ids': [team_id]},+ )++ @pytest.mark.asyncio+ async def test_delete_team_not_found_is_idempotent(+ self, mock_http_client, mock_response+ ):+ """+ GIVEN: Team does not exist (404 response)+ WHEN: delete_team is called+ THEN: Operation succeeds without raising exception (idempotent)+ """+ # Arrange+ team_id = 'non-existent-team'+ mock_response.is_success = False+ mock_response.status_code = 404+ mock_http_client.post.return_value = mock_response++ with (+ patch('storage.lite_llm_manager.LITE_LLM_API_KEY', 'test-key'),+ patch('storage.lite_llm_manager.LITE_LLM_API_URL', 'http://test.url'),+ patch('storage.lite_llm_manager.LITE_LLM_TEAM_ID', 'test-team'),+ ):+ # Act - should not raise+ await LiteLlmManager._delete_team(mock_http_client, team_id)++ # Assert+ mock_http_client.post.assert_called_once()++ @pytest.mark.asyncio+ async def test_delete_team_api_error_raises_exception(+ self, mock_http_client, mock_response+ ):+ """+ GIVEN: LiteLLM API returns error (non-404)+ WHEN: delete_team is called+ THEN: HTTPStatusError is raised+ """+ # Arrange+ team_id = 'test-team-123'+ mock_response.is_success = False+ mock_response.status_code = 500+ mock_response.text = 'Internal Server Error'+ mock_response.raise_for_status = MagicMock(+ side_effect=httpx.HTTPStatusError(+ 'Server error', request=MagicMock(), response=mock_response+ )+ )+ mock_http_client.post.return_value = mock_response++ with (+ patch('storage.lite_llm_manager.LITE_LLM_API_KEY', 'test-key'),+ patch('storage.lite_llm_manager.LITE_LLM_API_URL', 'http://test.url'),+ patch('storage.lite_llm_manager.LITE_LLM_TEAM_ID', 'test-team'),+ ):+ # Act & Assert+ with pytest.raises(httpx.HTTPStatusError):+ await LiteLlmManager._delete_team(mock_http_client, team_id)++ @pytest.mark.asyncio+ async def test_delete_team_no_config_returns_early(self, mock_http_client):+ """+ GIVEN: LiteLLM API is not configured+ WHEN: delete_team is called+ THEN: Function returns early without making API call+ """+ # Arrange+ team_id = 'test-team-123'++ with (+ patch('storage.lite_llm_manager.LITE_LLM_API_KEY', None),+ patch('storage.lite_llm_manager.LITE_LLM_API_URL', None),+ ):+ # Act+ await LiteLlmManager._delete_team(mock_http_client, team_id)++ # Assert+ mock_http_client.post.assert_not_called()++ @pytest.mark.asyncio+ async def test_delete_team_public_method(self):+ """+ GIVEN: Valid team_id+ WHEN: Public delete_team method is called+ THEN: HTTP client is created and team is deleted+ """+ # Arrange+ team_id = 'test-team-123'+ mock_response = AsyncMock()+ mock_response.is_success = True+ mock_response.status_code = 200++ with (+ patch('storage.lite_llm_manager.LITE_LLM_API_KEY', 'test-key'),+ patch('storage.lite_llm_manager.LITE_LLM_API_URL', 'http://test.url'),+ patch('storage.lite_llm_manager.LITE_LLM_TEAM_ID', 'test-team'),+ patch('httpx.AsyncClient') as mock_client_class,+ ):+ mock_client = AsyncMock()+ mock_client.post.return_value = mock_response+ mock_client_class.return_value.__aenter__.return_value = mock_client++ # Act+ await LiteLlmManager.delete_team(team_id)++ # Assert+ mock_client.post.assert_called_once_with(+ 'http://test.url/team/delete',+ json={'team_ids': [team_id]},+ )diff --git a/enterprise/tests/unit/test_org_service.py b/enterprise/tests/unit/test_org_service.pynew file mode 100644index 0000000000..8b9f214392--- /dev/null+++ b/enterprise/tests/unit/test_org_service.py@@ -0,0 +1,564 @@+"""+Unit tests for OrgService.++Tests the organization creation workflow with compensation pattern,+including LiteLLM integration and cleanup on failures.+"""++import uuid+from unittest.mock import AsyncMock, MagicMock, patch++import pytest++# Mock the database module before importing OrgService+with patch('storage.database.engine', create=True), patch(+ 'storage.database.a_engine', create=True+):+ from server.routes.org_models import (+ LiteLLMIntegrationError,+ OrgDatabaseError,+ OrgNameExistsError,+ )+ from storage.org import Org+ from storage.org_member import OrgMember+ from storage.org_service import OrgService+ from storage.role import Role+ from storage.user import User+++def mock_litellm_api():+ """Mock LiteLLM API for testing."""+ api_key_patch = patch('storage.lite_llm_manager.LITE_LLM_API_KEY', 'test_key')+ api_url_patch = patch(+ 'storage.lite_llm_manager.LITE_LLM_API_URL', 'http://test.url'+ )+ team_id_patch = patch('storage.lite_llm_manager.LITE_LLM_TEAM_ID', 'test_team')+ client_patch = patch('httpx.AsyncClient')++ with api_key_patch, api_url_patch, team_id_patch, client_patch as mock_client:+ mock_response = AsyncMock()+ mock_response.is_success = True+ mock_response.status_code = 200+ mock_response.json = MagicMock(+ return_value={+ 'team_id': 'test-team-id',+ 'user_id': 'test-user-id',+ 'key': 'test-api-key',+ }+ )+ mock_client.return_value.__aenter__.return_value.post.return_value = (+ mock_response+ )+ mock_client.return_value.__aenter__.return_value.get.return_value = (+ mock_response+ )+ yield mock_client+++def owner_role(session_maker):+ """Create owner role in database."""+ with session_maker() as session:+ role = Role(id=1, name='owner', rank=1)+ session.add(role)+ session.commit()+ return role+++def test_validate_name_uniqueness_with_unique_name(session_maker):+ """+ GIVEN: A unique organization name+ WHEN: validate_name_uniqueness is called+ THEN: No exception is raised+ """+ # Arrange+ unique_name = 'unique-org-name'++ # Act & Assert - should not raise+ with patch('storage.org_store.session_maker', session_maker):+ OrgService.validate_name_uniqueness(unique_name)+++def test_validate_name_uniqueness_with_duplicate_name(session_maker):+ """+ GIVEN: An organization name that already exists+ WHEN: validate_name_uniqueness is called+ THEN: OrgNameExistsError is raised+ """+ # Arrange+ existing_name = 'existing-org'+ existing_org = Org(name=existing_name)++ # Mock OrgStore.get_org_by_name to return the existing org+ with patch(+ 'storage.org_service.OrgStore.get_org_by_name',+ return_value=existing_org,+ ):+ # Act & Assert+ with pytest.raises(OrgNameExistsError) as exc_info:+ OrgService.validate_name_uniqueness(existing_name)++ assert existing_name in str(exc_info.value)+++async def test_create_org_with_owner_success(+ session_maker, owner_role, mock_litellm_api+):+ """+ GIVEN: Valid organization data and user ID+ WHEN: create_org_with_owner is called+ THEN: Organization and owner membership are created successfully+ """+ # Arrange+ org_name = 'test-org'+ contact_name = 'John Doe'+ contact_email = '[email protected]'+ user_id = uuid.uuid4()+ temp_org_id = uuid.uuid4()++ # Create user in database first+ with session_maker() as session:+ user = User(id=user_id, current_org_id=temp_org_id)+ session.add(user)+ session.commit()++ mock_settings = {'team_id': 'test-team', 'user_id': str(user_id)}++ with (+ patch('storage.org_store.session_maker', session_maker),+ patch('storage.role_store.session_maker', session_maker),+ patch(+ 'storage.org_service.UserStore.create_default_settings',+ AsyncMock(return_value=mock_settings),+ ),+ patch(+ 'storage.org_service.OrgStore.get_kwargs_from_settings',+ return_value={},+ ),+ patch(+ 'storage.org_service.OrgMemberStore.get_kwargs_from_settings',+ return_value={'llm_api_key': 'test-key'},+ ),+ ):+ # Act+ result = await OrgService.create_org_with_owner(+ name=org_name,+ contact_name=contact_name,+ contact_email=contact_email,+ user_id=str(user_id),+ )++ # Assert+ assert result is not None+ assert result.name == org_name+ assert result.contact_name == contact_name+ assert result.contact_email == contact_email+ assert result.org_version > 0 # Should be set to ORG_SETTINGS_VERSION+ assert result.default_llm_model is not None # Should be set++ # Verify organization was persisted+ with session_maker() as session:+ persisted_org = session.get(Org, result.id)+ assert persisted_org is not None+ assert persisted_org.name == org_name++ # Verify owner membership was created+ org_member = (+ session.query(OrgMember)+ .filter_by(org_id=result.id, user_id=user_id)+ .first()+ )+ assert org_member is not None+ assert org_member.role_id == 1 # owner role id+ assert org_member.status == 'active'+++async def test_create_org_with_owner_duplicate_name(+ session_maker, owner_role, mock_litellm_api+):+ """+ GIVEN: An organization name that already exists+ WHEN: create_org_with_owner is called+ THEN: OrgNameExistsError is raised without creating LiteLLM resources+ """+ # Arrange+ existing_name = 'existing-org'+ with session_maker() as session:+ org = Org(name=existing_name)+ session.add(org)+ session.commit()++ mock_create_settings = AsyncMock()++ # Act & Assert+ with (+ patch('storage.org_store.session_maker', session_maker),+ patch('storage.role_store.session_maker', session_maker),+ patch(+ 'storage.org_service.UserStore.create_default_settings',+ mock_create_settings,+ ),+ ):+ with pytest.raises(OrgNameExistsError):+ await OrgService.create_org_with_owner(+ name=existing_name,+ contact_name='John Doe',+ contact_email='[email protected]',+ user_id='test-user-123',+ )++ # Verify no LiteLLM API calls were made (early exit)+ mock_create_settings.assert_not_called()+++async def test_create_org_with_owner_litellm_failure(+ session_maker, owner_role, mock_litellm_api+):+ """+ GIVEN: LiteLLM integration fails+ WHEN: create_org_with_owner is called+ THEN: LiteLLMIntegrationError is raised and no database records are created+ """+ # Arrange+ org_name = 'test-org'++ # Mock LiteLLM failure+ with (+ patch('storage.org_store.session_maker', session_maker),+ patch(+ 'storage.org_service.UserStore.create_default_settings',+ AsyncMock(return_value=None),+ ),+ ):+ # Act & Assert+ with pytest.raises(LiteLLMIntegrationError):+ await OrgService.create_org_with_owner(+ name=org_name,+ contact_name='John Doe',+ contact_email='[email protected]',+ user_id='test-user-123',+ )++ # Verify no organization was created in database+ with session_maker() as session:+ org = session.query(Org).filter_by(name=org_name).first()+ assert org is None+++async def test_create_org_with_owner_database_failure_triggers_cleanup(+ session_maker, owner_role, mock_litellm_api+):+ """+ GIVEN: Database persistence fails after LiteLLM integration succeeds+ WHEN: create_org_with_owner is called+ THEN: OrgDatabaseError is raised and LiteLLM cleanup is triggered+ """+ # Arrange+ org_name = 'test-org'+ user_id = str(uuid.uuid4())+ cleanup_called = False++ def mock_cleanup(*args, **kwargs):+ nonlocal cleanup_called+ cleanup_called = True+ return None++ mock_settings = {'team_id': 'test-team', 'user_id': user_id}++ with (+ patch('storage.org_store.session_maker', session_maker),+ patch('storage.role_store.session_maker', session_maker),+ patch(+ 'storage.org_service.UserStore.create_default_settings',+ AsyncMock(return_value=mock_settings),+ ),+ patch(+ 'storage.org_service.OrgStore.get_kwargs_from_settings',+ return_value={},+ ),+ patch(+ 'storage.org_service.OrgMemberStore.get_kwargs_from_settings',+ return_value={'llm_api_key': 'test-key'},+ ),+ patch(+ 'storage.org_service.OrgStore.persist_org_with_owner',+ side_effect=Exception('Database connection failed'),+ ),+ patch(+ 'storage.org_service.OrgService._cleanup_litellm_resources',+ AsyncMock(side_effect=mock_cleanup),+ ),+ ):+ # Act & Assert+ with pytest.raises(OrgDatabaseError) as exc_info:+ await OrgService.create_org_with_owner(+ name=org_name,+ contact_name='John Doe',+ contact_email='[email protected]',+ user_id=user_id,+ )++ # Verify cleanup was called+ assert cleanup_called+ assert 'Database connection failed' in str(exc_info.value)+++async def test_create_org_with_owner_entity_creation_failure_triggers_cleanup(+ session_maker, owner_role, mock_litellm_api+):+ """+ GIVEN: Entity creation fails after LiteLLM integration succeeds+ WHEN: create_org_with_owner is called+ THEN: OrgDatabaseError is raised and LiteLLM cleanup is triggered+ """+ # Arrange+ org_name = 'test-org'+ user_id = str(uuid.uuid4())++ mock_settings = {'team_id': 'test-team', 'user_id': user_id}++ with (+ patch('storage.org_store.session_maker', session_maker),+ patch(+ 'storage.org_service.UserStore.create_default_settings',+ AsyncMock(return_value=mock_settings),+ ),+ patch(+ 'storage.org_service.OrgStore.get_kwargs_from_settings',+ return_value={},+ ),+ patch(+ 'storage.org_service.OrgMemberStore.get_kwargs_from_settings',+ return_value={'llm_api_key': 'test-key'},+ ),+ patch(+ 'storage.org_service.OrgService.get_owner_role',+ side_effect=Exception('Owner role not found'),+ ),+ patch(+ 'storage.org_service.LiteLlmManager.delete_team',+ AsyncMock(),+ ) as mock_delete,+ ):+ # Act & Assert+ with pytest.raises(OrgDatabaseError) as exc_info:+ await OrgService.create_org_with_owner(+ name=org_name,+ contact_name='John Doe',+ contact_email='[email protected]',+ user_id=user_id,+ )++ # Verify cleanup was called+ mock_delete.assert_called_once()+ assert 'Owner role not found' in str(exc_info.value)+++async def test_cleanup_litellm_resources_success(mock_litellm_api):+ """+ GIVEN: Valid org_id and user_id+ WHEN: _cleanup_litellm_resources is called+ THEN: LiteLLM team is deleted successfully and None is returned+ """+ # Arrange+ org_id = uuid.uuid4()+ user_id = 'test-user-123'++ with patch(+ 'storage.org_service.LiteLlmManager.delete_team',+ AsyncMock(),+ ) as mock_delete:+ # Act+ result = await OrgService._cleanup_litellm_resources(org_id, user_id)++ # Assert+ assert result is None+ mock_delete.assert_called_once_with(str(org_id))+++async def test_cleanup_litellm_resources_failure_returns_exception(mock_litellm_api):+ """+ GIVEN: LiteLLM delete_team fails+ WHEN: _cleanup_litellm_resources is called+ THEN: Exception is returned (not raised) for logging+ """+ # Arrange+ org_id = uuid.uuid4()+ user_id = 'test-user-123'+ expected_error = Exception('LiteLLM API unavailable')++ with patch(+ 'storage.org_service.LiteLlmManager.delete_team',+ AsyncMock(side_effect=expected_error),+ ):+ # Act+ result = await OrgService._cleanup_litellm_resources(org_id, user_id)++ # Assert+ assert result is expected_error+ assert 'LiteLLM API unavailable' in str(result)+++async def test_handle_failure_with_cleanup_success():+ """+ GIVEN: Original error and successful cleanup+ WHEN: _handle_failure_with_cleanup is called+ THEN: OrgDatabaseError is raised with original error message+ """+ # Arrange+ org_id = uuid.uuid4()+ user_id = 'test-user-123'+ original_error = Exception('Database write failed')++ with patch(+ 'storage.org_service.OrgService._cleanup_litellm_resources',+ AsyncMock(return_value=None),+ ):+ # Act & Assert+ with pytest.raises(OrgDatabaseError) as exc_info:+ await OrgService._handle_failure_with_cleanup(+ org_id, user_id, original_error, 'Failed to create organization'+ )++ assert 'Database write failed' in str(exc_info.value)+ assert 'Cleanup also failed' not in str(exc_info.value)+++async def test_handle_failure_with_cleanup_both_fail():+ """+ GIVEN: Original error and cleanup also fails+ WHEN: _handle_failure_with_cleanup is called+ THEN: OrgDatabaseError is raised with both error messages+ """+ # Arrange+ org_id = uuid.uuid4()+ user_id = 'test-user-123'+ original_error = Exception('Database write failed')+ cleanup_error = Exception('LiteLLM API unavailable')++ with patch(+ 'storage.org_service.OrgService._cleanup_litellm_resources',+ AsyncMock(return_value=cleanup_error),+ ):+ # Act & Assert+ with pytest.raises(OrgDatabaseError) as exc_info:+ await OrgService._handle_failure_with_cleanup(+ org_id, user_id, original_error, 'Failed to create organization'+ )++ error_message = str(exc_info.value)+ assert 'Database write failed' in error_message+ assert 'Cleanup also failed' in error_message+ assert 'LiteLLM API unavailable' in error_message+++async def test_get_org_credits_success(mock_litellm_api):+ """+ GIVEN: Valid user_id and org_id with LiteLLM team info+ WHEN: get_org_credits is called+ THEN: Credits are calculated correctly (max_budget - spend)+ """+ # Arrange+ user_id = 'test-user-123'+ org_id = uuid.uuid4()+ max_budget = 100.0+ spend = 25.0++ mock_team_info = {+ 'litellm_budget_table': {'max_budget': max_budget},+ 'spend': spend,+ }++ with patch(+ 'storage.org_service.LiteLlmManager.get_user_team_info',+ AsyncMock(return_value=mock_team_info),+ ):+ # Act+ credits = await OrgService.get_org_credits(user_id, org_id)++ # Assert+ assert credits == 75.0 # 100 - 25+++async def test_get_org_credits_no_team_info(mock_litellm_api):+ """+ GIVEN: LiteLLM returns no team info+ WHEN: get_org_credits is called+ THEN: None is returned+ """+ # Arrange+ user_id = 'test-user-123'+ org_id = uuid.uuid4()++ with patch(+ 'storage.org_service.LiteLlmManager.get_user_team_info',+ AsyncMock(return_value=None),+ ):+ # Act+ credits = await OrgService.get_org_credits(user_id, org_id)++ # Assert+ assert credits is None+++async def test_get_org_credits_negative_credits_returns_zero(mock_litellm_api):+ """+ GIVEN: Spend exceeds max_budget+ WHEN: get_org_credits is called+ THEN: Zero credits are returned (not negative)+ """+ # Arrange+ user_id = 'test-user-123'+ org_id = uuid.uuid4()+ max_budget = 100.0+ spend = 150.0 # Over budget++ mock_team_info = {+ 'litellm_budget_table': {'max_budget': max_budget},+ 'spend': spend,+ }++ with patch(+ 'storage.org_service.LiteLlmManager.get_user_team_info',+ AsyncMock(return_value=mock_team_info),+ ):+ # Act+ credits = await OrgService.get_org_credits(user_id, org_id)++ # Assert+ assert credits == 0.0+++async def test_get_org_credits_api_failure_returns_none(mock_litellm_api):+ """+ GIVEN: LiteLLM API call fails+ WHEN: get_org_credits is called+ THEN: None is returned and error is logged+ """+ # Arrange+ user_id = 'test-user-123'+ org_id = uuid.uuid4()++ with patch(+ 'storage.org_service.LiteLlmManager.get_user_team_info',+ AsyncMock(side_effect=Exception('API error')),+ ):+ # Act+ credits = await OrgService.get_org_credits(user_id, org_id)++ # Assert+ assert credits is Nonediff --git a/enterprise/tests/unit/test_org_store.py b/enterprise/tests/unit/test_org_store.pyindex f5257ac26d..3601bbd54b 100644--- a/enterprise/tests/unit/test_org_store.py+++ b/enterprise/tests/unit/test_org_store.py@@ -3,11 +3,17 @@ from unittest.mock import AsyncMock, MagicMock, patchimport pytestfrom pydantic import SecretStr+from sqlalchemy.exc import IntegrityError# Mock the database module before importing OrgStore-with patch('storage.database.engine'), patch('storage.database.a_engine'):+with patch('storage.database.engine', create=True), patch(+ 'storage.database.a_engine', create=True+):from storage.org import Org+ from storage.org_member import OrgMemberfrom storage.org_store import OrgStore+ from storage.role import Role+ from storage.user import Userfrom openhands.storage.data_models.settings import Settings@@ -195,3 +201,217 @@ def test_get_kwargs_from_settings():assert 'llm_api_key' not in kwargsassert 'llm_model' not in kwargsassert 'enable_sound_notifications' not in kwargs+++def test_persist_org_with_owner_success(session_maker, mock_litellm_api):+ """+ GIVEN: Valid org and org_member entities+ WHEN: persist_org_with_owner is called+ THEN: Both entities are persisted in a single transaction and org is returned+ """+ # Arrange+ org_id = uuid.uuid4()+ user_id = uuid.uuid4()++ # Create user and role first+ with session_maker() as session:+ user = User(id=user_id, current_org_id=org_id)+ role = Role(id=1, name='owner', rank=1)+ session.add(user)+ session.add(role)+ session.commit()++ org = Org(+ id=org_id,+ name='Test Organization',+ contact_name='John Doe',+ contact_email='[email protected]',+ )++ org_member = OrgMember(+ org_id=org_id,+ user_id=user_id,+ role_id=1,+ status='active',+ llm_api_key='test-api-key-123',+ )++ # Act+ with patch('storage.org_store.session_maker', session_maker):+ result = OrgStore.persist_org_with_owner(org, org_member)++ # Assert+ assert result is not None+ assert result.id == org_id+ assert result.name == 'Test Organization'++ # Verify both entities were persisted+ with session_maker() as session:+ persisted_org = session.get(Org, org_id)+ assert persisted_org is not None+ assert persisted_org.name == 'Test Organization'++ persisted_member = (+ session.query(OrgMember).filter_by(org_id=org_id, user_id=user_id).first()+ )+ assert persisted_member is not None+ assert persisted_member.status == 'active'+ assert persisted_member.role_id == 1+++def test_persist_org_with_owner_returns_refreshed_org(session_maker, mock_litellm_api):+ """+ GIVEN: Valid org and org_member entities+ WHEN: persist_org_with_owner is called+ THEN: The returned org is refreshed from database with all fields populated+ """+ # Arrange+ org_id = uuid.uuid4()+ user_id = uuid.uuid4()++ with session_maker() as session:+ user = User(id=user_id, current_org_id=org_id)+ role = Role(id=1, name='owner', rank=1)+ session.add(user)+ session.add(role)+ session.commit()++ org = Org(+ id=org_id,+ name='Test Org',+ contact_name='Jane Doe',+ contact_email='[email protected]',+ agent='CodeActAgent',+ )++ org_member = OrgMember(+ org_id=org_id,+ user_id=user_id,+ role_id=1,+ status='active',+ llm_api_key='test-key',+ )++ # Act+ with patch('storage.org_store.session_maker', session_maker):+ result = OrgStore.persist_org_with_owner(org, org_member)++ # Assert - verify the returned object has database-generated fields+ assert result.id == org_id+ assert result.name == 'Test Org'+ assert result.agent == 'CodeActAgent'+ # Verify org_version was set by create_org logic (if applicable)+ assert hasattr(result, 'org_version')+++def test_persist_org_with_owner_transaction_atomicity(session_maker, mock_litellm_api):+ """+ GIVEN: Valid org but invalid org_member (missing required field)+ WHEN: persist_org_with_owner is called+ THEN: Transaction fails and neither entity is persisted+ """+ # Arrange+ org_id = uuid.uuid4()+ user_id = uuid.uuid4()++ with session_maker() as session:+ user = User(id=user_id, current_org_id=org_id)+ role = Role(id=1, name='owner', rank=1)+ session.add(user)+ session.add(role)+ session.commit()++ org = Org(+ id=org_id,+ name='Test Org',+ contact_name='John Doe',+ contact_email='[email protected]',+ )++ # Create invalid org_member (missing required llm_api_key field)+ org_member = OrgMember(+ org_id=org_id,+ user_id=user_id,+ role_id=1,+ status='active',+ # llm_api_key is missing - should cause NOT NULL constraint violation+ )++ # Act & Assert+ with patch('storage.org_store.session_maker', session_maker):+ with pytest.raises(IntegrityError): # NOT NULL constraint violation+ OrgStore.persist_org_with_owner(org, org_member)++ # Verify neither entity was persisted (transaction rolled back)+ with session_maker() as session:+ persisted_org = session.get(Org, org_id)+ assert persisted_org is None++ persisted_member = (+ session.query(OrgMember).filter_by(org_id=org_id, user_id=user_id).first()+ )+ assert persisted_member is None+++def test_persist_org_with_owner_with_multiple_fields(session_maker, mock_litellm_api):+ """+ GIVEN: Org with multiple optional fields populated+ WHEN: persist_org_with_owner is called+ THEN: All fields are persisted correctly+ """+ # Arrange+ org_id = uuid.uuid4()+ user_id = uuid.uuid4()++ with session_maker() as session:+ user = User(id=user_id, current_org_id=org_id)+ role = Role(id=1, name='owner', rank=1)+ session.add(user)+ session.add(role)+ session.commit()++ org = Org(+ id=org_id,+ name='Complex Org',+ contact_name='Alice Smith',+ contact_email='[email protected]',+ agent='CodeActAgent',+ default_max_iterations=50,+ confirmation_mode=True,+ billing_margin=0.15,+ )++ org_member = OrgMember(+ org_id=org_id,+ user_id=user_id,+ role_id=1,+ status='active',+ llm_api_key='test-key',+ max_iterations=100,+ llm_model='gpt-4',+ )++ # Act+ with patch('storage.org_store.session_maker', session_maker):+ result = OrgStore.persist_org_with_owner(org, org_member)++ # Assert+ assert result.name == 'Complex Org'+ assert result.agent == 'CodeActAgent'+ assert result.default_max_iterations == 50+ assert result.confirmation_mode is True+ assert result.billing_margin == 0.15++ # Verify persistence+ with session_maker() as session:+ persisted_org = session.get(Org, org_id)+ assert persisted_org.agent == 'CodeActAgent'+ assert persisted_org.default_max_iterations == 50+ assert persisted_org.confirmation_mode is True+ assert persisted_org.billing_margin == 0.15++ persisted_member = (+ session.query(OrgMember).filter_by(org_id=org_id, user_id=user_id).first()+ )+ assert persisted_member.max_iterations == 100+ assert persisted_member.llm_model == 'gpt-4'diff --git a/enterprise/tests/unit/test_saas_user_auth.py b/enterprise/tests/unit/test_saas_user_auth.pyindex 6d9ced0057..66b4e45dd0 100644--- a/enterprise/tests/unit/test_saas_user_auth.py+++ b/enterprise/tests/unit/test_saas_user_auth.py@@ -30,15 +30,27 @@ def mock_request():return request+def create_mock_jwt_tokens(user_id='test_user_id', exp_offset=3600):+ """Helper to create valid JWT tokens for mocking."""+ payload = {+ 'sub': user_id,+ 'exp': int(time.time()) + exp_offset,+ 'email': '[email protected]',+ 'email_verified': True,+ }+ access_token = jwt.encode(payload, 'secret', algorithm='HS256')+ refresh_token = jwt.encode(+ {'sub': user_id, 'exp': int(time.time()) + exp_offset},+ 'secret',+ algorithm='HS256',+ )+ return {'access_token': access_token, 'refresh_token': refresh_token}++@pytest.fixturedef mock_token_manager():with patch('server.auth.saas_user_auth.token_manager') as mock_tm:- mock_tm.refresh = AsyncMock(- return_value={- 'access_token': 'new_access_token',- 'refresh_token': 'new_refresh_token',- }- )+ mock_tm.refresh = AsyncMock(return_value=create_mock_jwt_tokens())mock_tm.get_user_info_from_user_id = AsyncMock(return_value={'federatedIdentities': [@@ -108,8 +120,11 @@ async def test_refresh(mock_token_manager):await user_auth.refresh()mock_token_manager.refresh.assert_called_once_with(refresh_token)- assert user_auth.access_token.get_secret_value() == 'new_access_token'- assert user_auth.refresh_token.get_secret_value() == 'new_refresh_token'+ # Access token should be a valid JWT+ access_token = user_auth.access_token.get_secret_value()+ decoded = jwt.decode(access_token, options={'verify_signature': False})+ assert decoded['sub'] == 'test_user_id'+ assert decoded['email'] == '[email protected]'assert user_auth.refreshed is True@@ -159,7 +174,9 @@ async def test_get_access_token_with_expired_token(mock_token_manager):result = await user_auth.get_access_token()- assert result.get_secret_value() == 'new_access_token'+ # Verify the returned token is a valid JWT with correct user_id+ decoded = jwt.decode(result.get_secret_value(), options={'verify_signature': False})+ assert decoded['sub'] == 'test_user_id'mock_token_manager.refresh.assert_called_once_with(refresh_token)@@ -182,7 +199,9 @@ async def test_get_access_token_with_no_token(mock_token_manager):result = await user_auth.get_access_token()- assert result.get_secret_value() == 'new_access_token'+ # Verify the returned token is a valid JWT with correct user_id+ decoded = jwt.decode(result.get_secret_value(), options={'verify_signature': False})+ assert decoded['sub'] == 'test_user_id'mock_token_manager.refresh.assert_called_once_with(refresh_token)@@ -339,6 +358,13 @@ async def test_saas_user_auth_from_bearer_success():mock_request = MagicMock()mock_request.headers = {'Authorization': 'Bearer test_api_key'}+ # Create a valid offline token (refresh token)+ offline_token = jwt.encode(+ {'sub': 'test_user_id', 'exp': int(time.time()) + 3600},+ 'secret',+ algorithm='HS256',+ )+with (patch('server.auth.saas_user_auth.ApiKeyStore') as mock_api_key_store_cls,patch('server.auth.saas_user_auth.token_manager') as mock_token_manager,@@ -347,15 +373,18 @@ async def test_saas_user_auth_from_bearer_success():mock_api_key_store.validate_api_key.return_value = 'test_user_id'mock_api_key_store_cls.get_instance.return_value = mock_api_key_store- mock_token_manager.load_offline_token = AsyncMock(return_value='offline_token')+ mock_token_manager.load_offline_token = AsyncMock(return_value=offline_token)+ mock_token_manager.refresh = AsyncMock(+ return_value=create_mock_jwt_tokens('test_user_id')+ )result = await saas_user_auth_from_bearer(mock_request)assert isinstance(result, SaasUserAuth)assert result.user_id == 'test_user_id'- assert result.refresh_token.get_secret_value() == 'offline_token'mock_api_key_store.validate_api_key.assert_called_once_with('test_api_key')mock_token_manager.load_offline_token.assert_called_once_with('test_user_id')+ mock_token_manager.refresh.assert_called_once_with(offline_token)@pytest.mark.asyncio