Skip to content

πŸ™Œ OpenHands: AI-Driven Development

feat(backend): saas – organizations app settings api (#13022)

Hiep Leb4a3e5db2f11
diff --git a/enterprise/server/routes/org_models.py b/enterprise/server/routes/org_models.py
index 1c5a93e8db..825d16db22 100644
--- a/enterprise/server/routes/org_models.py
+++ b/enterprise/server/routes/org_models.py
@@ -1,6 +1,13 @@
from typing import Annotated
-from pydantic import BaseModel, EmailStr, Field, SecretStr, StringConstraints
+from pydantic import (
+ BaseModel,
+ EmailStr,
+ Field,
+ SecretStr,
+ StringConstraints,
+ field_validator,
+)
from storage.org import Org
from storage.org_member import OrgMember
from storage.role import Role
@@ -327,3 +334,44 @@ class MeResponse(BaseModel):
llm_base_url=member.llm_base_url,
status=member.status,
)
+
+
+class OrgAppSettingsResponse(BaseModel):
+ """Response model for organization app settings."""
+
+ enable_proactive_conversation_starters: bool = True
+ enable_solvability_analysis: bool | None = None
+ max_budget_per_task: float | None = None
+
+ @classmethod
+ def from_org(cls, org: Org) -> 'OrgAppSettingsResponse':
+ """Create an OrgAppSettingsResponse from an Org entity.
+
+ Args:
+ org: The organization entity
+
+ Returns:
+ OrgAppSettingsResponse with app settings
+ """
+ return cls(
+ enable_proactive_conversation_starters=org.enable_proactive_conversation_starters
+ if org.enable_proactive_conversation_starters is not None
+ else True,
+ enable_solvability_analysis=org.enable_solvability_analysis,
+ max_budget_per_task=org.max_budget_per_task,
+ )
+
+
+class OrgAppSettingsUpdate(BaseModel):
+ """Request model for updating organization app settings."""
+
+ enable_proactive_conversation_starters: bool | None = None
+ enable_solvability_analysis: bool | None = None
+ max_budget_per_task: float | None = None
+
+ @field_validator('max_budget_per_task')
+ @classmethod
+ def validate_max_budget_per_task(cls, v: float | None) -> float | None:
+ if v is not None and v <= 0:
+ raise ValueError('max_budget_per_task must be greater than 0')
+ return v
diff --git a/enterprise/server/routes/orgs.py b/enterprise/server/routes/orgs.py
index 9e1931715f..338b2b2ea0 100644
--- a/enterprise/server/routes/orgs.py
+++ b/enterprise/server/routes/orgs.py
@@ -15,6 +15,8 @@ from server.routes.org_models import (
LiteLLMIntegrationError,
MemberUpdateError,
MeResponse,
+ OrgAppSettingsResponse,
+ OrgAppSettingsUpdate,
OrgAuthorizationError,
OrgCreate,
OrgDatabaseError,
@@ -30,6 +32,10 @@ from server.routes.org_models import (
OrphanedUserError,
RoleNotFoundError,
)
+from server.services.org_app_settings_service import (
+ OrgAppSettingsService,
+ OrgAppSettingsServiceInjector,
+)
from server.services.org_member_service import OrgMemberService
from storage.org_service import OrgService
from storage.user_store import UserStore
@@ -40,6 +46,10 @@ from openhands.server.user_auth import get_user_id
# Initialize API router
org_router = APIRouter(prefix='/api/organizations', tags=['Orgs'])
+# Create injector instance and dependency at module level
+_org_app_settings_injector = OrgAppSettingsServiceInjector()
+org_app_settings_service_dependency = Depends(_org_app_settings_injector.depends)
+
@org_router.get('', response_model=OrgPage)
async def list_user_orgs(
@@ -201,6 +211,96 @@ async def create_org(
)
+@org_router.get(
+ '/app',
+ response_model=OrgAppSettingsResponse,
+ dependencies=[Depends(require_permission(Permission.MANAGE_APPLICATION_SETTINGS))],
+)
+async def get_org_app_settings(
+ service: OrgAppSettingsService = org_app_settings_service_dependency,
+) -> OrgAppSettingsResponse:
+ """Get organization app settings for the user's current organization.
+
+ This endpoint retrieves application settings for the authenticated user's
+ current organization. Access requires the MANAGE_APPLICATION_SETTINGS permission,
+ which is granted to all organization members (member, admin, and owner roles).
+
+ Args:
+ service: OrgAppSettingsService (injected by dependency)
+
+ Returns:
+ OrgAppSettingsResponse: The organization app settings
+
+ Raises:
+ HTTPException: 401 if user is not authenticated
+ HTTPException: 403 if user lacks MANAGE_APPLICATION_SETTINGS permission
+ HTTPException: 404 if current organization not found
+ """
+ try:
+ return await service.get_org_app_settings()
+ except OrgNotFoundError:
+ raise HTTPException(
+ status_code=status.HTTP_404_NOT_FOUND,
+ detail='Current organization not found',
+ )
+ except Exception as e:
+ logger.exception(
+ 'Unexpected error retrieving organization app settings',
+ extra={'error': str(e)},
+ )
+ raise HTTPException(
+ status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+ detail='An unexpected error occurred',
+ )
+
+
+@org_router.post(
+ '/app',
+ response_model=OrgAppSettingsResponse,
+ dependencies=[Depends(require_permission(Permission.MANAGE_APPLICATION_SETTINGS))],
+)
+async def update_org_app_settings(
+ update_data: OrgAppSettingsUpdate,
+ service: OrgAppSettingsService = org_app_settings_service_dependency,
+) -> OrgAppSettingsResponse:
+ """Update organization app settings for the user's current organization.
+
+ This endpoint updates application settings for the authenticated user's
+ current organization. Access requires the MANAGE_APPLICATION_SETTINGS permission,
+ which is granted to all organization members (member, admin, and owner roles).
+
+ Args:
+ update_data: App settings update data
+ service: OrgAppSettingsService (injected by dependency)
+
+ Returns:
+ OrgAppSettingsResponse: The updated organization app settings
+
+ Raises:
+ HTTPException: 401 if user is not authenticated
+ HTTPException: 403 if user lacks MANAGE_APPLICATION_SETTINGS permission
+ HTTPException: 404 if current organization not found
+ HTTPException: 422 if validation errors occur (handled by FastAPI)
+ HTTPException: 500 if update fails
+ """
+ try:
+ return await service.update_org_app_settings(update_data)
+ except OrgNotFoundError:
+ raise HTTPException(
+ status_code=status.HTTP_404_NOT_FOUND,
+ detail='Current organization not found',
+ )
+ except Exception as e:
+ logger.exception(
+ 'Unexpected error updating organization app settings',
+ extra={'error': str(e)},
+ )
+ raise HTTPException(
+ status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+ detail='An unexpected error occurred',
+ )
+
+
@org_router.get('/{org_id}', response_model=OrgResponse, status_code=status.HTTP_200_OK)
async def get_org(
org_id: UUID,
diff --git a/enterprise/server/services/org_app_settings_service.py b/enterprise/server/services/org_app_settings_service.py
new file mode 100644
index 0000000000..d98ce4e05c
--- /dev/null
+++ b/enterprise/server/services/org_app_settings_service.py
@@ -0,0 +1,130 @@
+"""Service class for managing organization app settings.
+
+Separates business logic from route handlers.
+Uses dependency injection for db_session and user_context.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import AsyncGenerator
+
+from fastapi import Request
+from server.routes.org_models import (
+ OrgAppSettingsResponse,
+ OrgAppSettingsUpdate,
+ OrgNotFoundError,
+)
+from storage.org_app_settings_store import OrgAppSettingsStore
+
+from openhands.app_server.services.injector import Injector, InjectorState
+from openhands.app_server.user.user_context import UserContext
+from openhands.core.logger import openhands_logger as logger
+
+
+@dataclass
+class OrgAppSettingsService:
+ """Service for organization app settings with injected dependencies."""
+
+ store: OrgAppSettingsStore
+ user_context: UserContext
+
+ async def get_org_app_settings(self) -> OrgAppSettingsResponse:
+ """Get organization app settings.
+
+ User ID is obtained from the injected user_context.
+
+ Returns:
+ OrgAppSettingsResponse: The organization's app settings
+
+ Raises:
+ OrgNotFoundError: If current organization is not found
+ """
+ user_id = await self.user_context.get_user_id()
+
+ logger.info(
+ 'Getting organization app settings',
+ extra={'user_id': user_id},
+ )
+
+ org = await self.store.get_current_org_by_user_id(user_id)
+
+ if not org:
+ raise OrgNotFoundError('current')
+
+ return OrgAppSettingsResponse.from_org(org)
+
+ async def update_org_app_settings(
+ self,
+ update_data: OrgAppSettingsUpdate,
+ ) -> OrgAppSettingsResponse:
+ """Update organization app settings.
+
+ Only updates fields that are explicitly provided in update_data.
+ User ID is obtained from the injected user_context.
+ Session auto-commits at request end via DbSessionInjector.
+
+ Args:
+ update_data: The update data from the request
+
+ Returns:
+ OrgAppSettingsResponse: The updated organization's app settings
+
+ Raises:
+ OrgNotFoundError: If current organization is not found
+ """
+ user_id = await self.user_context.get_user_id()
+
+ logger.info(
+ 'Updating organization app settings',
+ extra={'user_id': user_id},
+ )
+
+ # Get current org first
+ org = await self.store.get_current_org_by_user_id(user_id)
+
+ if not org:
+ raise OrgNotFoundError('current')
+
+ # Check if any fields are provided
+ update_dict = update_data.model_dump(exclude_unset=True)
+
+ if not update_dict:
+ # No fields to update, just return current settings
+ logger.info(
+ 'No fields to update in app settings',
+ extra={'user_id': user_id, 'org_id': str(org.id)},
+ )
+ return OrgAppSettingsResponse.from_org(org)
+
+ updated_org = await self.store.update_org_app_settings(
+ org_id=org.id,
+ update_data=update_data,
+ )
+
+ if not updated_org:
+ raise OrgNotFoundError('current')
+
+ logger.info(
+ 'Organization app settings updated successfully',
+ extra={'user_id': user_id, 'updated_fields': list(update_dict.keys())},
+ )
+
+ return OrgAppSettingsResponse.from_org(updated_org)
+
+
+class OrgAppSettingsServiceInjector(Injector[OrgAppSettingsService]):
+ """Injector that composes store and user_context for OrgAppSettingsService."""
+
+ async def inject(
+ self, state: InjectorState, request: Request | None = None
+ ) -> AsyncGenerator[OrgAppSettingsService, None]:
+ # Local imports to avoid circular dependencies
+ from openhands.app_server.config import get_db_session, get_user_context
+
+ async with (
+ get_user_context(state, request) as user_context,
+ get_db_session(state, request) as db_session,
+ ):
+ store = OrgAppSettingsStore(db_session=db_session)
+ yield OrgAppSettingsService(store=store, user_context=user_context)
diff --git a/enterprise/storage/org_app_settings_store.py b/enterprise/storage/org_app_settings_store.py
new file mode 100644
index 0000000000..9812265958
--- /dev/null
+++ b/enterprise/storage/org_app_settings_store.py
@@ -0,0 +1,105 @@
+"""Store class for managing organization app settings."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from uuid import UUID
+
+from server.constants import (
+ LITE_LLM_API_URL,
+ ORG_SETTINGS_VERSION,
+ get_default_litellm_model,
+)
+from server.routes.org_models import OrgAppSettingsUpdate
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+from storage.org import Org
+from storage.user import User
+
+
+@dataclass
+class OrgAppSettingsStore:
+ """Store for organization app settings with injected db_session."""
+
+ db_session: AsyncSession
+
+ async def get_current_org_by_user_id(self, user_id: str) -> Org | None:
+ """Get the current organization for a user.
+
+ Args:
+ user_id: The user's ID (Keycloak user ID)
+
+ Returns:
+ Org: The organization object, or None if not found
+ """
+ # Get user with their current_org_id
+ result = await self.db_session.execute(
+ select(User).filter(User.id == UUID(user_id))
+ )
+ user = result.scalars().first()
+
+ if not user:
+ return None
+
+ org_id = user.current_org_id
+ if not org_id:
+ return None
+
+ # Get the organization
+ result = await self.db_session.execute(select(Org).filter(Org.id == org_id))
+ org = result.scalars().first()
+
+ if not org:
+ return None
+
+ return await self._validate_org_version(org)
+
+ async def _validate_org_version(self, org: Org) -> Org:
+ """Check if we need to update org version.
+
+ Args:
+ org: The organization to validate
+
+ Returns:
+ Org: The validated (and potentially updated) organization
+ """
+ if org.org_version < ORG_SETTINGS_VERSION:
+ org.org_version = ORG_SETTINGS_VERSION
+ org.default_llm_model = get_default_litellm_model()
+ org.llm_base_url = LITE_LLM_API_URL
+ await self.db_session.flush()
+ await self.db_session.refresh(org)
+
+ return org
+
+ async def update_org_app_settings(
+ self, org_id: UUID, update_data: OrgAppSettingsUpdate
+ ) -> Org | None:
+ """Update organization app settings.
+
+ Only updates fields that are explicitly provided in update_data.
+ Uses flush() - commit happens at request end via DbSessionInjector.
+
+ Args:
+ org_id: The organization's ID
+ update_data: Pydantic model with fields to update
+
+ Returns:
+ Org: The updated organization object, or None if not found
+ """
+ result = await self.db_session.execute(
+ select(Org).filter(Org.id == org_id).with_for_update()
+ )
+ org = result.scalars().first()
+
+ if not org:
+ return None
+
+ # Update only explicitly provided fields
+ for field, value in update_data.model_dump(exclude_unset=True).items():
+ setattr(org, field, value)
+
+ # flush instead of commit - DbSessionInjector auto-commits at request end
+ await self.db_session.flush()
+ await self.db_session.refresh(org)
+ return org
diff --git a/enterprise/storage/org_service.py b/enterprise/storage/org_service.py
index 00fdf4443e..1489369b10 100644
--- a/enterprise/storage/org_service.py
+++ b/enterprise/storage/org_service.py
@@ -9,6 +9,7 @@ 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,
+ OrgAppSettingsUpdate,
OrgAuthorizationError,
OrgDatabaseError,
OrgNameExistsError,
@@ -951,3 +952,96 @@ class OrgService:
extra={'user_id': user_id, 'org_id': str(org_id), 'error': str(e)},
)
raise OrgDatabaseError(f'Failed to switch organization: {str(e)}')
+
+ @staticmethod
+ def get_current_org_app_settings(user_id: str) -> Org:
+ """
+ Get organization app settings for the user's current organization.
+
+ Args:
+ user_id: User ID
+
+ Returns:
+ Org: The user's current organization
+
+ Raises:
+ OrgNotFoundError: If user has no current organization
+ """
+ logger.info(
+ 'Retrieving organization app settings',
+ extra={'user_id': user_id},
+ )
+
+ org = OrgStore.get_current_org_from_keycloak_user_id(user_id)
+ if not org:
+ logger.warning(
+ 'Current organization not found for user',
+ extra={'user_id': user_id},
+ )
+ raise OrgNotFoundError('current')
+
+ logger.info(
+ 'Successfully retrieved organization app settings',
+ extra={'user_id': user_id, 'org_id': str(org.id)},
+ )
+
+ return org
+
+ @staticmethod
+ def update_current_org_app_settings(
+ user_id: str,
+ update_data: OrgAppSettingsUpdate,
+ ) -> Org:
+ """
+ Update organization app settings for the user's current organization.
+
+ Args:
+ user_id: User ID
+ update_data: App settings update data
+
+ Returns:
+ Org: The updated organization
+
+ Raises:
+ OrgNotFoundError: If user has no current organization
+ OrgDatabaseError: If update fails
+ """
+ logger.info(
+ 'Updating organization app settings',
+ extra={'user_id': user_id},
+ )
+
+ org = OrgStore.get_current_org_from_keycloak_user_id(user_id)
+ if not org:
+ logger.warning(
+ 'Current organization not found for user',
+ extra={'user_id': user_id},
+ )
+ raise OrgNotFoundError('current')
+
+ update_dict = update_data.model_dump(exclude_unset=True)
+ if not update_dict:
+ logger.info(
+ 'No fields to update in app settings',
+ extra={'user_id': user_id, 'org_id': str(org.id)},
+ )
+ return org
+
+ updated_org = OrgStore.update_org(org.id, update_dict)
+ if not updated_org:
+ logger.error(
+ 'Failed to update organization app settings',
+ extra={'user_id': user_id, 'org_id': str(org.id)},
+ )
+ raise OrgDatabaseError('Failed to update organization app settings')
+
+ logger.info(
+ 'Successfully updated organization app settings',
+ extra={
+ 'user_id': user_id,
+ 'org_id': str(org.id),
+ 'updated_fields': list(update_dict.keys()),
+ },
+ )
+
+ return updated_org
diff --git a/enterprise/tests/unit/server/routes/test_orgs.py b/enterprise/tests/unit/server/routes/test_orgs.py
index 7016bed635..6a05b2a364 100644
--- a/enterprise/tests/unit/server/routes/test_orgs.py
+++ b/enterprise/tests/unit/server/routes/test_orgs.py
@@ -24,6 +24,8 @@ with patch('storage.database.engine', create=True), patch(
LastOwnerError,
LiteLLMIntegrationError,
MeResponse,
+ OrgAppSettingsResponse,
+ OrgAppSettingsUpdate,
OrgAuthorizationError,
OrgDatabaseError,
OrgMemberNotFoundError,
@@ -3424,3 +3426,421 @@ async def test_switch_org_database_error(mock_app_with_get_user_id):
# Assert
assert response.status_code == status.HTTP_500_INTERNAL_SERVER_ERROR
assert 'Failed to switch organization' in response.json()['detail']
+
+
+# =============================================================================
+# Tests for App Settings Endpoints
+# =============================================================================
+
+
+def mock_member_role():
+ """Create a mock member role for authorization tests."""
+ mock_role = MagicMock()
+ mock_role.name = 'member'
+ return mock_role
+
+
+async def test_get_org_app_settings_success(
+ mock_app_with_get_user_id, mock_member_role
+):
+ """
+ GIVEN: Authenticated user with MANAGE_APPLICATION_SETTINGS permission
+ WHEN: GET /api/organizations/app is called
+ THEN: App settings are returned with 200 status
+ """
+ # Arrange
+ mock_response = OrgAppSettingsResponse(
+ enable_proactive_conversation_starters=True,
+ enable_solvability_analysis=False,
+ max_budget_per_task=10.0,
+ )
+
+ with (
+ patch(
+ 'server.auth.authorization.get_user_org_role_async',
+ AsyncMock(return_value=mock_member_role),
+ ),
+ patch(
+ 'server.routes.orgs.OrgAppSettingsService.get_org_app_settings',
+ AsyncMock(return_value=mock_response),
+ ),
+ ):
+ client = TestClient(mock_app_with_get_user_id)
+
+ # Act
+ response = client.get('/api/organizations/app')
+
+ # Assert
+ assert response.status_code == status.HTTP_200_OK
+ response_data = response.json()
+ assert response_data['enable_proactive_conversation_starters'] is True
+ assert response_data['enable_solvability_analysis'] is False
+ assert response_data['max_budget_per_task'] == 10.0
+
+
+async def test_get_org_app_settings_with_null_values(
+ mock_app_with_get_user_id, mock_member_role
+):
+ """
+ GIVEN: Organization has null app settings values
+ WHEN: GET /api/organizations/app is called
+ THEN: Default values are returned where applicable
+ """
+ # Arrange
+ # OrgAppSettingsResponse.from_org() handles defaults, so we test the response model
+ mock_response = OrgAppSettingsResponse(
+ enable_proactive_conversation_starters=True, # Default when None in Org
+ enable_solvability_analysis=None,
+ max_budget_per_task=None,
+ )
+
+ with (
+ patch(
+ 'server.auth.authorization.get_user_org_role_async',
+ AsyncMock(return_value=mock_member_role),
+ ),
+ patch(
+ 'server.routes.orgs.OrgAppSettingsService.get_org_app_settings',
+ AsyncMock(return_value=mock_response),
+ ),
+ ):
+ client = TestClient(mock_app_with_get_user_id)
+
+ # Act
+ response = client.get('/api/organizations/app')
+
+ # Assert
+ assert response.status_code == status.HTTP_200_OK
+ response_data = response.json()
+ # enable_proactive_conversation_starters defaults to True when None
+ assert response_data['enable_proactive_conversation_starters'] is True
+ assert response_data['enable_solvability_analysis'] is None
+ assert response_data['max_budget_per_task'] is None
+
+
+async def test_get_org_app_settings_not_found(
+ mock_app_with_get_user_id, mock_member_role
+):
+ """
+ GIVEN: User has no current organization
+ WHEN: GET /api/organizations/app is called
+ THEN: 404 Not Found error is returned
+ """
+ # Arrange
+ with (
+ patch(
+ 'server.auth.authorization.get_user_org_role_async',
+ AsyncMock(return_value=mock_member_role),
+ ),
+ patch(
+ 'server.routes.orgs.OrgAppSettingsService.get_org_app_settings',
+ AsyncMock(side_effect=OrgNotFoundError('current')),
+ ),
+ ):
+ client = TestClient(mock_app_with_get_user_id)
+
+ # Act
+ response = client.get('/api/organizations/app')
+
+ # Assert
+ assert response.status_code == status.HTTP_404_NOT_FOUND
+ assert 'not found' in response.json()['detail'].lower()
+
+
+async def test_get_org_app_settings_user_not_member(mock_app_with_get_user_id):
+ """
+ GIVEN: User is not a member of any organization
+ WHEN: GET /api/organizations/app is called
+ THEN: 403 Forbidden error is returned
+ """
+ # Arrange - user has no role (not a member)
+ with patch(
+ 'server.auth.authorization.get_user_org_role_async',
+ AsyncMock(return_value=None),
+ ):
+ client = TestClient(mock_app_with_get_user_id)
+
+ # Act
+ response = client.get('/api/organizations/app')
+
+ # Assert
+ assert response.status_code == status.HTTP_403_FORBIDDEN
+ assert 'not a member' in response.json()['detail'].lower()
+
+
+async def test_update_org_app_settings_success(
+ mock_app_with_get_user_id, mock_member_role
+):
+ """
+ GIVEN: Valid update data and authenticated user
+ WHEN: POST /api/organizations/app is called
+ THEN: Updated app settings are returned with 200 status
+ """
+ # Arrange
+ mock_response = OrgAppSettingsResponse(
+ enable_proactive_conversation_starters=False,
+ enable_solvability_analysis=True,
+ max_budget_per_task=25.0,
+ )
+
+ with (
+ patch(
+ 'server.auth.authorization.get_user_org_role_async',
+ AsyncMock(return_value=mock_member_role),
+ ),
+ patch(
+ 'server.routes.orgs.OrgAppSettingsService.update_org_app_settings',
+ AsyncMock(return_value=mock_response),
+ ) as mock_update,
+ ):
+ client = TestClient(mock_app_with_get_user_id)
+
+ # Act
+ response = client.post(
+ '/api/organizations/app',
+ json={
+ 'enable_proactive_conversation_starters': False,
+ 'enable_solvability_analysis': True,
+ 'max_budget_per_task': 25.0,
+ },
+ )
+
+ # Assert
+ assert response.status_code == status.HTTP_200_OK
+ response_data = response.json()
+ assert response_data['enable_proactive_conversation_starters'] is False
+ assert response_data['enable_solvability_analysis'] is True
+ assert response_data['max_budget_per_task'] == 25.0
+ mock_update.assert_called_once()
+
+
+async def test_update_org_app_settings_partial_update(
+ mock_app_with_get_user_id, mock_member_role
+):
+ """
+ GIVEN: Partial update data (only some fields)
+ WHEN: POST /api/organizations/app is called
+ THEN: Only specified fields are updated
+ """
+ # Arrange
+ mock_response = OrgAppSettingsResponse(
+ enable_proactive_conversation_starters=False,
+ enable_solvability_analysis=True,
+ max_budget_per_task=10.0, # Unchanged
+ )
+
+ with (
+ patch(
+ 'server.auth.authorization.get_user_org_role_async',
+ AsyncMock(return_value=mock_member_role),
+ ),
+ patch(
+ 'server.routes.orgs.OrgAppSettingsService.update_org_app_settings',
+ AsyncMock(return_value=mock_response),
+ ) as mock_update,
+ ):
+ client = TestClient(mock_app_with_get_user_id)
+
+ # Act - only updating one field
+ response = client.post(
+ '/api/organizations/app',
+ json={'enable_proactive_conversation_starters': False},
+ )
+
+ # Assert
+ assert response.status_code == status.HTTP_200_OK
+ mock_update.assert_called_once()
+ # Verify the update data only contains the specified field
+ call_args = mock_update.call_args
+ update_data = call_args[0][0] # First positional argument (update_data)
+ assert isinstance(update_data, OrgAppSettingsUpdate)
+
+
+async def test_update_org_app_settings_set_null(
+ mock_app_with_get_user_id, mock_member_role
+):
+ """
+ GIVEN: Request to set max_budget_per_task to null
+ WHEN: POST /api/organizations/app is called
+ THEN: The field is set to null successfully
+ """
+ # Arrange
+ mock_response = OrgAppSettingsResponse(
+ enable_proactive_conversation_starters=True,
+ enable_solvability_analysis=True,
+ max_budget_per_task=None,
+ )
+
+ with (
+ patch(
+ 'server.auth.authorization.get_user_org_role_async',
+ AsyncMock(return_value=mock_member_role),
+ ),
+ patch(
+ 'server.routes.orgs.OrgAppSettingsService.update_org_app_settings',
+ AsyncMock(return_value=mock_response),
+ ),
+ ):
+ client = TestClient(mock_app_with_get_user_id)
+
+ # Act - explicitly setting max_budget_per_task to null
+ response = client.post(
+ '/api/organizations/app',
+ json={'max_budget_per_task': None},
+ )
+
+ # Assert
+ assert response.status_code == status.HTTP_200_OK
+ response_data = response.json()
+ assert response_data['max_budget_per_task'] is None
+
+
+async def test_update_org_app_settings_invalid_max_budget(
+ mock_app_with_get_user_id, mock_member_role
+):
+ """
+ GIVEN: Invalid max_budget_per_task value (zero or negative)
+ WHEN: POST /api/organizations/app is called
+ THEN: 422 Validation error is returned
+ """
+ # Arrange
+ with patch(
+ 'server.auth.authorization.get_user_org_role_async',
+ AsyncMock(return_value=mock_member_role),
+ ):
+ client = TestClient(mock_app_with_get_user_id)
+
+ # Act - negative value
+ response = client.post(
+ '/api/organizations/app',
+ json={'max_budget_per_task': -5.0},
+ )
+
+ # Assert
+ assert response.status_code == status.HTTP_422_UNPROCESSABLE_ENTITY
+
+
+async def test_update_org_app_settings_zero_max_budget(
+ mock_app_with_get_user_id, mock_member_role
+):
+ """
+ GIVEN: max_budget_per_task is set to zero
+ WHEN: POST /api/organizations/app is called
+ THEN: 422 Validation error is returned (must be greater than 0)
+ """
+ # Arrange
+ with patch(
+ 'server.auth.authorization.get_user_org_role_async',
+ AsyncMock(return_value=mock_member_role),
+ ):
+ client = TestClient(mock_app_with_get_user_id)
+
+ # Act - zero value
+ response = client.post(
+ '/api/organizations/app',
+ json={'max_budget_per_task': 0},
+ )
+
+ # Assert
+ assert response.status_code == status.HTTP_422_UNPROCESSABLE_ENTITY
+
+
+async def test_update_org_app_settings_not_found(
+ mock_app_with_get_user_id, mock_member_role
+):
+ """
+ GIVEN: User has no current organization
+ WHEN: POST /api/organizations/app is called
+ THEN: 404 Not Found error is returned
+ """
+ # Arrange
+ with (
+ patch(
+ 'server.auth.authorization.get_user_org_role_async',
+ AsyncMock(return_value=mock_member_role),
+ ),
+ patch(
+ 'server.routes.orgs.OrgAppSettingsService.update_org_app_settings',
+ AsyncMock(side_effect=OrgNotFoundError('current')),
+ ),
+ ):
+ client = TestClient(mock_app_with_get_user_id)
+
+ # Act
+ response = client.post(
+ '/api/organizations/app',
+ json={'enable_proactive_conversation_starters': False},
+ )
+
+ # Assert
+ assert response.status_code == status.HTTP_404_NOT_FOUND
+ assert 'not found' in response.json()['detail'].lower()
+
+
+async def test_update_org_app_settings_database_error(
+ mock_app_with_get_user_id, mock_member_role
+):
+ """
+ GIVEN: Database update fails
+ WHEN: POST /api/organizations/app is called
+ THEN: 500 Internal Server Error is returned
+ """
+ # Arrange
+ with (
+ patch(
+ 'server.auth.authorization.get_user_org_role_async',
+ AsyncMock(return_value=mock_member_role),
+ ),
+ patch(
+ 'server.routes.orgs.OrgAppSettingsService.update_org_app_settings',
+ AsyncMock(side_effect=Exception('Database connection failed')),
+ ),
+ ):
+ client = TestClient(mock_app_with_get_user_id)
+
+ # Act
+ response = client.post(
+ '/api/organizations/app',
+ json={'enable_proactive_conversation_starters': False},
+ )
+
+ # Assert
+ assert response.status_code == status.HTTP_500_INTERNAL_SERVER_ERROR
+ assert 'unexpected error' in response.json()['detail'].lower()
+
+
+async def test_update_org_app_settings_user_not_member(mock_app_with_get_user_id):
+ """
+ GIVEN: User is not a member of any organization
+ WHEN: POST /api/organizations/app is called
+ THEN: 403 Forbidden error is returned
+ """
+ # Arrange - user has no role (not a member)
+ with patch(
+ 'server.auth.authorization.get_user_org_role_async',
+ AsyncMock(return_value=None),
+ ):
+ client = TestClient(mock_app_with_get_user_id)
+
+ # Act
+ response = client.post(
+ '/api/organizations/app',
+ json={'enable_proactive_conversation_starters': False},
+ )
+
+ # Assert
+ assert response.status_code == status.HTTP_403_FORBIDDEN
+ assert 'not a member' in response.json()['detail'].lower()
diff --git a/enterprise/tests/unit/server/services/test_org_app_settings_service.py b/enterprise/tests/unit/server/services/test_org_app_settings_service.py
new file mode 100644
index 0000000000..e6cb748e77
--- /dev/null
+++ b/enterprise/tests/unit/server/services/test_org_app_settings_service.py
@@ -0,0 +1,173 @@
+"""
+Unit tests for OrgAppSettingsService.
+
+Tests the service layer for organization app settings operations.
+"""
+
+import uuid
+from unittest.mock import AsyncMock, MagicMock
+
+import pytest
+from server.routes.org_models import (
+ OrgAppSettingsResponse,
+ OrgAppSettingsUpdate,
+ OrgNotFoundError,
+)
+from server.services.org_app_settings_service import OrgAppSettingsService
+from storage.org import Org
+
+
+def user_id():
+ """Create a test user ID."""
+ return str(uuid.uuid4())
+
+
+def mock_org():
+ """Create a mock organization with app settings."""
+ org = MagicMock(spec=Org)
+ org.id = uuid.uuid4()
+ org.enable_proactive_conversation_starters = True
+ org.enable_solvability_analysis = False
+ org.max_budget_per_task = 25.0
+ return org
+
+
+def mock_store():
+ """Create a mock OrgAppSettingsStore."""
+ return MagicMock()
+
+
+def mock_user_context(user_id):
+ """Create a mock UserContext that returns the user_id."""
+ context = MagicMock()
+ context.get_user_id = AsyncMock(return_value=user_id)
+ return context
+
+
+async def test_get_org_app_settings_success(
+ user_id, mock_org, mock_store, mock_user_context
+):
+ """
+ GIVEN: A user's current organization exists
+ WHEN: get_org_app_settings is called
+ THEN: OrgAppSettingsResponse is returned with correct data
+ """
+ # Arrange
+ mock_store.get_current_org_by_user_id = AsyncMock(return_value=mock_org)
+ service = OrgAppSettingsService(store=mock_store, user_context=mock_user_context)
+
+ # Act
+ result = await service.get_org_app_settings()
+
+ # Assert
+ assert isinstance(result, OrgAppSettingsResponse)
+ assert result.enable_proactive_conversation_starters is True
+ assert result.enable_solvability_analysis is False
+ assert result.max_budget_per_task == 25.0
+ mock_store.get_current_org_by_user_id.assert_called_once_with(user_id)
+
+
+async def test_get_org_app_settings_org_not_found(
+ user_id, mock_store, mock_user_context
+):
+ """
+ GIVEN: A user has no current organization
+ WHEN: get_org_app_settings is called
+ THEN: OrgNotFoundError is raised
+ """
+ # Arrange
+ mock_store.get_current_org_by_user_id = AsyncMock(return_value=None)
+ service = OrgAppSettingsService(store=mock_store, user_context=mock_user_context)
+
+ # Act & Assert
+ with pytest.raises(OrgNotFoundError) as exc_info:
+ await service.get_org_app_settings()
+
+ assert 'current' in str(exc_info.value)
+
+
+async def test_update_org_app_settings_success(
+ user_id, mock_org, mock_store, mock_user_context
+):
+ """
+ GIVEN: A user's current organization exists
+ WHEN: update_org_app_settings is called with new values
+ THEN: OrgAppSettingsResponse is returned with updated data
+ """
+ # Arrange
+ mock_org.enable_proactive_conversation_starters = False
+ mock_org.max_budget_per_task = 50.0
+
+ update_data = OrgAppSettingsUpdate(
+ enable_proactive_conversation_starters=False,
+ max_budget_per_task=50.0,
+ )
+
+ mock_store.get_current_org_by_user_id = AsyncMock(return_value=mock_org)
+ mock_store.update_org_app_settings = AsyncMock(return_value=mock_org)
+ service = OrgAppSettingsService(store=mock_store, user_context=mock_user_context)
+
+ # Act
+ result = await service.update_org_app_settings(update_data)
+
+ # Assert
+ assert isinstance(result, OrgAppSettingsResponse)
+ assert result.enable_proactive_conversation_starters is False
+ assert result.max_budget_per_task == 50.0
+ mock_store.update_org_app_settings.assert_called_once_with(
+ org_id=mock_org.id, update_data=update_data
+ )
+
+
+async def test_update_org_app_settings_no_changes(
+ user_id, mock_org, mock_store, mock_user_context
+):
+ """
+ GIVEN: A user's current organization exists
+ WHEN: update_org_app_settings is called with no fields
+ THEN: Current settings are returned without calling update
+ """
+ # Arrange
+ update_data = OrgAppSettingsUpdate() # No fields set
+
+ mock_store.get_current_org_by_user_id = AsyncMock(return_value=mock_org)
+ mock_store.update_org_app_settings = AsyncMock()
+ service = OrgAppSettingsService(store=mock_store, user_context=mock_user_context)
+
+ # Act
+ result = await service.update_org_app_settings(update_data)
+
+ # Assert
+ assert isinstance(result, OrgAppSettingsResponse)
+ mock_store.get_current_org_by_user_id.assert_called_once_with(user_id)
+ mock_store.update_org_app_settings.assert_not_called()
+
+
+async def test_update_org_app_settings_org_not_found(
+ user_id, mock_store, mock_user_context
+):
+ """
+ GIVEN: A user has no current organization
+ WHEN: update_org_app_settings is called
+ THEN: OrgNotFoundError is raised
+ """
+ # Arrange
+ update_data = OrgAppSettingsUpdate(enable_proactive_conversation_starters=False)
+
+ mock_store.get_current_org_by_user_id = AsyncMock(return_value=None)
+ service = OrgAppSettingsService(store=mock_store, user_context=mock_user_context)
+
+ # Act & Assert
+ with pytest.raises(OrgNotFoundError) as exc_info:
+ await service.update_org_app_settings(update_data)
+
+ assert 'current' in str(exc_info.value)
diff --git a/enterprise/tests/unit/storage/test_org_app_settings_store.py b/enterprise/tests/unit/storage/test_org_app_settings_store.py
new file mode 100644
index 0000000000..16b088a025
--- /dev/null
+++ b/enterprise/tests/unit/storage/test_org_app_settings_store.py
@@ -0,0 +1,189 @@
+"""
+Unit tests for OrgAppSettingsStore.
+
+Tests the async database operations for organization app settings.
+"""
+
+import uuid
+from unittest.mock import patch
+
+import pytest
+from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker, create_async_engine
+from sqlalchemy.pool import StaticPool
+
+# Mock the database module before importing
+with patch('storage.database.engine', create=True), patch(
+ 'storage.database.a_engine', create=True
+):
+ from server.routes.org_models import OrgAppSettingsUpdate
+ from storage.base import Base
+ from storage.org import Org
+ from storage.org_app_settings_store import OrgAppSettingsStore
+ from storage.user import User
+
+
+async def async_engine():
+ """Create an async SQLite engine for testing."""
+ engine = create_async_engine(
+ 'sqlite+aiosqlite:///:memory:',
+ poolclass=StaticPool,
+ connect_args={'check_same_thread': False},
+ echo=False,
+ )
+ async with engine.begin() as conn:
+ await conn.run_sync(Base.metadata.create_all)
+ yield engine
+ await engine.dispose()
+
+
+async def async_session_maker(async_engine):
+ """Create an async session maker for testing."""
+ return async_sessionmaker(async_engine, class_=AsyncSession, expire_on_commit=False)
+
+
+async def test_get_current_org_by_user_id_success(async_session_maker):
+ """
+ GIVEN: A user exists with a current organization
+ WHEN: get_current_org_by_user_id is called with the user's ID
+ THEN: The organization is returned with correct data
+ """
+ # Arrange
+ async with async_session_maker() as session:
+ org = Org(
+ name='test-org',
+ enable_proactive_conversation_starters=True,
+ enable_solvability_analysis=False,
+ max_budget_per_task=25.0,
+ )
+ session.add(org)
+ await session.flush()
+
+ user = User(
+ id=uuid.uuid4(),
+ current_org_id=org.id,
+ )
+ session.add(user)
+ await session.commit()
+ user_id = str(user.id)
+
+ # Act
+ store = OrgAppSettingsStore(db_session=session)
+ result = await store.get_current_org_by_user_id(user_id)
+
+ # Assert
+ assert result is not None
+ assert result.name == 'test-org'
+ assert result.enable_proactive_conversation_starters is True
+ assert result.enable_solvability_analysis is False
+ assert result.max_budget_per_task == 25.0
+
+
+async def test_get_current_org_by_user_id_user_not_found(async_session_maker):
+ """
+ GIVEN: A user does not exist in the database
+ WHEN: get_current_org_by_user_id is called with a non-existent ID
+ THEN: None is returned
+ """
+ # Arrange
+ non_existent_id = str(uuid.uuid4())
+
+ # Act
+ async with async_session_maker() as session:
+ store = OrgAppSettingsStore(db_session=session)
+ result = await store.get_current_org_by_user_id(non_existent_id)
+
+ # Assert
+ assert result is None
+
+
+async def test_update_org_app_settings_success(async_session_maker):
+ """
+ GIVEN: An organization exists in the database
+ WHEN: update_org_app_settings is called with new values
+ THEN: The organization's settings are updated and returned
+ """
+ # Arrange
+ async with async_session_maker() as session:
+ org = Org(
+ name='test-org',
+ enable_proactive_conversation_starters=True,
+ enable_solvability_analysis=False,
+ max_budget_per_task=10.0,
+ )
+ session.add(org)
+ await session.commit()
+ org_id = org.id
+
+ update_data = OrgAppSettingsUpdate(
+ enable_proactive_conversation_starters=False,
+ enable_solvability_analysis=True,
+ max_budget_per_task=50.0,
+ )
+
+ # Act
+ store = OrgAppSettingsStore(db_session=session)
+ result = await store.update_org_app_settings(org_id, update_data)
+
+ # Assert
+ assert result is not None
+ assert result.enable_proactive_conversation_starters is False
+ assert result.enable_solvability_analysis is True
+ assert result.max_budget_per_task == 50.0
+
+
+async def test_update_org_app_settings_partial(async_session_maker):
+ """
+ GIVEN: An organization exists with existing settings
+ WHEN: update_org_app_settings is called with only some fields
+ THEN: Only the provided fields are updated, others remain unchanged
+ """
+ # Arrange
+ async with async_session_maker() as session:
+ org = Org(
+ name='test-org',
+ enable_proactive_conversation_starters=True,
+ enable_solvability_analysis=False,
+ max_budget_per_task=10.0,
+ )
+ session.add(org)
+ await session.commit()
+ org_id = org.id
+
+ # Only update max_budget_per_task
+ update_data = OrgAppSettingsUpdate(max_budget_per_task=100.0)
+
+ # Act
+ store = OrgAppSettingsStore(db_session=session)
+ result = await store.update_org_app_settings(org_id, update_data)
+
+ # Assert
+ assert result is not None
+ assert result.max_budget_per_task == 100.0
+ assert result.enable_proactive_conversation_starters is True # Unchanged
+ assert result.enable_solvability_analysis is False # Unchanged
+
+
+async def test_update_org_app_settings_org_not_found(async_session_maker):
+ """
+ GIVEN: An organization does not exist in the database
+ WHEN: update_org_app_settings is called
+ THEN: None is returned
+ """
+ # Arrange
+ non_existent_id = uuid.uuid4()
+ update_data = OrgAppSettingsUpdate(enable_proactive_conversation_starters=False)
+
+ # Act
+ async with async_session_maker() as session:
+ store = OrgAppSettingsStore(db_session=session)
+ result = await store.update_org_app_settings(non_existent_id, update_data)
+
+ # Assert
+ assert result is None
diff --git a/enterprise/tests/unit/test_org_service.py b/enterprise/tests/unit/test_org_service.py
index 47f7cd109a..61698ffb1e 100644
--- a/enterprise/tests/unit/test_org_service.py
+++ b/enterprise/tests/unit/test_org_service.py
@@ -2024,3 +2024,317 @@ async def test_switch_org_user_not_found():
await OrgService.switch_org(user_id, org_id)
assert 'User not found' in str(exc_info.value)
+
+
+# =============================================================================
+# Tests for App Settings Methods
+# =============================================================================
+
+
+def test_get_current_org_app_settings_success():
+ """
+ GIVEN: User has a current organization
+ WHEN: get_current_org_app_settings is called
+ THEN: Organization is returned with app settings
+ """
+ # Arrange
+ user_id = str(uuid.uuid4())
+ org_id = uuid.uuid4()
+ mock_org = Org(
+ id=org_id,
+ name='Test Organization',
+ enable_proactive_conversation_starters=True,
+ enable_solvability_analysis=False,
+ max_budget_per_task=10.0,
+ )
+
+ with patch(
+ 'storage.org_service.OrgStore.get_current_org_from_keycloak_user_id',
+ return_value=mock_org,
+ ):
+ # Act
+ result = OrgService.get_current_org_app_settings(user_id)
+
+ # Assert
+ assert result is not None
+ assert result.id == org_id
+ assert result.enable_proactive_conversation_starters is True
+ assert result.enable_solvability_analysis is False
+ assert result.max_budget_per_task == 10.0
+
+
+def test_get_current_org_app_settings_no_current_org():
+ """
+ GIVEN: User has no current organization
+ WHEN: get_current_org_app_settings is called
+ THEN: OrgNotFoundError is raised
+ """
+ # Arrange
+ user_id = str(uuid.uuid4())
+
+ with patch(
+ 'storage.org_service.OrgStore.get_current_org_from_keycloak_user_id',
+ return_value=None,
+ ):
+ # Act & Assert
+ with pytest.raises(OrgNotFoundError) as exc_info:
+ OrgService.get_current_org_app_settings(user_id)
+
+ assert 'current' in str(exc_info.value)
+
+
+def test_update_current_org_app_settings_success():
+ """
+ GIVEN: User has a current organization and valid update data
+ WHEN: update_current_org_app_settings is called
+ THEN: Organization is updated and returned
+ """
+ # Import here to avoid circular dependency in test setup
+ from server.routes.org_models import OrgAppSettingsUpdate
+
+ # Arrange
+ user_id = str(uuid.uuid4())
+ org_id = uuid.uuid4()
+ mock_org = Org(
+ id=org_id,
+ name='Test Organization',
+ enable_proactive_conversation_starters=True,
+ enable_solvability_analysis=None,
+ max_budget_per_task=None,
+ )
+ updated_org = Org(
+ id=org_id,
+ name='Test Organization',
+ enable_proactive_conversation_starters=False,
+ enable_solvability_analysis=True,
+ max_budget_per_task=5.0,
+ )
+
+ update_data = OrgAppSettingsUpdate(
+ enable_proactive_conversation_starters=False,
+ enable_solvability_analysis=True,
+ max_budget_per_task=5.0,
+ )
+
+ with (
+ patch(
+ 'storage.org_service.OrgStore.get_current_org_from_keycloak_user_id',
+ return_value=mock_org,
+ ),
+ patch(
+ 'storage.org_service.OrgStore.update_org',
+ return_value=updated_org,
+ ) as mock_update,
+ ):
+ # Act
+ result = OrgService.update_current_org_app_settings(user_id, update_data)
+
+ # Assert
+ assert result is not None
+ assert result.enable_proactive_conversation_starters is False
+ assert result.enable_solvability_analysis is True
+ assert result.max_budget_per_task == 5.0
+ mock_update.assert_called_once_with(
+ org_id,
+ {
+ 'enable_proactive_conversation_starters': False,
+ 'enable_solvability_analysis': True,
+ 'max_budget_per_task': 5.0,
+ },
+ )
+
+
+def test_update_current_org_app_settings_partial_update():
+ """
+ GIVEN: User updates only some app settings
+ WHEN: update_current_org_app_settings is called
+ THEN: Only specified fields are updated
+ """
+ from server.routes.org_models import OrgAppSettingsUpdate
+
+ # Arrange
+ user_id = str(uuid.uuid4())
+ org_id = uuid.uuid4()
+ mock_org = Org(
+ id=org_id,
+ name='Test Organization',
+ enable_proactive_conversation_starters=True,
+ enable_solvability_analysis=True,
+ max_budget_per_task=10.0,
+ )
+ updated_org = Org(
+ id=org_id,
+ name='Test Organization',
+ enable_proactive_conversation_starters=False,
+ enable_solvability_analysis=True,
+ max_budget_per_task=10.0,
+ )
+
+ # Only update one field
+ update_data = OrgAppSettingsUpdate(enable_proactive_conversation_starters=False)
+
+ with (
+ patch(
+ 'storage.org_service.OrgStore.get_current_org_from_keycloak_user_id',
+ return_value=mock_org,
+ ),
+ patch(
+ 'storage.org_service.OrgStore.update_org',
+ return_value=updated_org,
+ ) as mock_update,
+ ):
+ # Act
+ result = OrgService.update_current_org_app_settings(user_id, update_data)
+
+ # Assert
+ assert result is not None
+ assert result.enable_proactive_conversation_starters is False
+ # Only the specified field should be in the update dict
+ mock_update.assert_called_once_with(
+ org_id,
+ {'enable_proactive_conversation_starters': False},
+ )
+
+
+def test_update_current_org_app_settings_empty_update():
+ """
+ GIVEN: No fields are specified in update
+ WHEN: update_current_org_app_settings is called
+ THEN: Original org is returned without database update
+ """
+ from server.routes.org_models import OrgAppSettingsUpdate
+
+ # Arrange
+ user_id = str(uuid.uuid4())
+ org_id = uuid.uuid4()
+ mock_org = Org(
+ id=org_id,
+ name='Test Organization',
+ enable_proactive_conversation_starters=True,
+ enable_solvability_analysis=None,
+ max_budget_per_task=5.0,
+ )
+
+ update_data = OrgAppSettingsUpdate() # No fields set
+
+ with (
+ patch(
+ 'storage.org_service.OrgStore.get_current_org_from_keycloak_user_id',
+ return_value=mock_org,
+ ),
+ patch('storage.org_service.OrgStore.update_org') as mock_update,
+ ):
+ # Act
+ result = OrgService.update_current_org_app_settings(user_id, update_data)
+
+ # Assert
+ assert result is mock_org
+ mock_update.assert_not_called()
+
+
+def test_update_current_org_app_settings_set_to_null():
+ """
+ GIVEN: User explicitly sets max_budget_per_task to null
+ WHEN: update_current_org_app_settings is called
+ THEN: The field is set to null in the update
+ """
+ from server.routes.org_models import OrgAppSettingsUpdate
+
+ # Arrange
+ user_id = str(uuid.uuid4())
+ org_id = uuid.uuid4()
+ mock_org = Org(
+ id=org_id,
+ name='Test Organization',
+ enable_proactive_conversation_starters=True,
+ enable_solvability_analysis=True,
+ max_budget_per_task=5.0,
+ )
+ updated_org = Org(
+ id=org_id,
+ name='Test Organization',
+ enable_proactive_conversation_starters=True,
+ enable_solvability_analysis=True,
+ max_budget_per_task=None,
+ )
+
+ # Explicitly set max_budget_per_task to None
+ update_data = OrgAppSettingsUpdate.model_validate({'max_budget_per_task': None})
+
+ with (
+ patch(
+ 'storage.org_service.OrgStore.get_current_org_from_keycloak_user_id',
+ return_value=mock_org,
+ ),
+ patch(
+ 'storage.org_service.OrgStore.update_org',
+ return_value=updated_org,
+ ) as mock_update,
+ ):
+ # Act
+ result = OrgService.update_current_org_app_settings(user_id, update_data)
+
+ # Assert
+ assert result.max_budget_per_task is None
+ mock_update.assert_called_once_with(
+ org_id,
+ {'max_budget_per_task': None},
+ )
+
+
+def test_update_current_org_app_settings_no_current_org():
+ """
+ GIVEN: User has no current organization
+ WHEN: update_current_org_app_settings is called
+ THEN: OrgNotFoundError is raised
+ """
+ from server.routes.org_models import OrgAppSettingsUpdate
+
+ # Arrange
+ user_id = str(uuid.uuid4())
+ update_data = OrgAppSettingsUpdate(enable_proactive_conversation_starters=False)
+
+ with patch(
+ 'storage.org_service.OrgStore.get_current_org_from_keycloak_user_id',
+ return_value=None,
+ ):
+ # Act & Assert
+ with pytest.raises(OrgNotFoundError) as exc_info:
+ OrgService.update_current_org_app_settings(user_id, update_data)
+
+ assert 'current' in str(exc_info.value)
+
+
+def test_update_current_org_app_settings_database_failure():
+ """
+ GIVEN: Database update fails
+ WHEN: update_current_org_app_settings is called
+ THEN: OrgDatabaseError is raised
+ """
+ from server.routes.org_models import OrgAppSettingsUpdate
+
+ # Arrange
+ user_id = str(uuid.uuid4())
+ org_id = uuid.uuid4()
+ mock_org = Org(
+ id=org_id,
+ name='Test Organization',
+ enable_proactive_conversation_starters=True,
+ )
+ update_data = OrgAppSettingsUpdate(enable_proactive_conversation_starters=False)
+
+ with (
+ patch(
+ 'storage.org_service.OrgStore.get_current_org_from_keycloak_user_id',
+ return_value=mock_org,
+ ),
+ patch(
+ 'storage.org_service.OrgStore.update_org',
+ return_value=None,
+ ),
+ ):
+ # Act & Assert
+ with pytest.raises(OrgDatabaseError) as exc_info:
+ OrgService.update_current_org_app_settings(user_id, update_data)
+
+ assert 'Failed to update organization app settings' in str(exc_info.value)