π OpenHands: AI-Driven Development
[Refactor]: Modularize settings storage logic (#7868)
Rohit Malhotrab2a4b4ed90fe
diff --git a/openhands/server/routes/settings.py b/openhands/server/routes/settings.pyindex a44a5614cc..b3660c0275 100644--- a/openhands/server/routes/settings.py+++ b/openhands/server/routes/settings.py@@ -134,12 +134,10 @@ async def reset_settings(request: Request) -> JSONResponse:)[email protected]('/settings', response_model=dict[str, str])-async def store_settings(- request: Request,- settings: POSTSettingsModel,-) -> JSONResponse:- # Check provider tokens are valid++async def check_provider_tokens(request: Request,+ settings: POSTSettingsModel) -> str:+if settings.provider_tokens:# Remove extraneous token typesprovider_types = [provider.value for provider in ProviderType]@@ -154,12 +152,84 @@ async def store_settings(SecretStr(token_value))if not confirmed_token_type or confirmed_token_type.value != token_type:- return JSONResponse(- status_code=status.HTTP_401_UNAUTHORIZED,- content={- 'error': f'Invalid token. Please make sure it is a valid {token_type} token.'- },- )+ return f"Invalid token. Please make sure it is a valid {token_type} token."+++ return ""++++async def store_provider_tokens(request: Request, settings: POSTSettingsModel):+ settings_store = await SettingsStoreImpl.get_instance(+ config, get_user_id(request)+ )+ existing_settings = await settings_store.load()+ if existing_settings:+ if settings.provider_tokens:+ if existing_settings.secrets_store:+ existing_providers = [+ provider.value+ for provider in existing_settings.secrets_store.provider_tokens+ ]++ # Merge incoming settings store with the existing one+ for provider, token_value in list(settings.provider_tokens.items()):+ if provider in existing_providers and not token_value:+ provider_type = ProviderType(provider)+ existing_token = (+ existing_settings.secrets_store.provider_tokens.get(+ provider_type+ )+ )+ if existing_token and existing_token.token:+ settings.provider_tokens[provider] = (+ existing_token.token.get_secret_value()+ )+ else: # nothing passed in means keep current settings+ provider_tokens = existing_settings.secrets_store.provider_tokens+ settings.provider_tokens = {+ provider.value: data.token.get_secret_value()+ if data.token+ else None+ for provider, data in provider_tokens.items()+ }++ return settings+++async def store_llm_settings(request: Request, settings: POSTSettingsModel) -> POSTSettingsModel:+ settings_store = await SettingsStoreImpl.get_instance(+ config, get_user_id(request)+ )+ existing_settings = await settings_store.load()++ # Convert to Settings model and merge with existing settings+ if existing_settings:+ # Keep existing LLM settings if not provided+ if settings.llm_api_key is None:+ settings.llm_api_key = existing_settings.llm_api_key+ if settings.llm_model is None:+ settings.llm_model = existing_settings.llm_model+ if settings.llm_base_url is None:+ settings.llm_base_url = existing_settings.llm_base_url++ return settings+[email protected]('/settings', response_model=dict[str, str])+async def store_settings(+ request: Request,+ settings: POSTSettingsModel,+) -> JSONResponse:+ # Check provider tokens are valid+ provider_err_msg = await check_provider_tokens(request, settings)+ if provider_err_msg:+ return JSONResponse(+ status_code=status.HTTP_401_UNAUTHORIZED,+ content={+ 'error': provider_err_msg+ },+ )+try:settings_store = await SettingsStoreImpl.get_instance(@@ -169,13 +239,7 @@ async def store_settings(# Convert to Settings model and merge with existing settingsif existing_settings:- # Keep existing LLM settings if not provided- if settings.llm_api_key is None:- settings.llm_api_key = existing_settings.llm_api_key- if settings.llm_model is None:- settings.llm_model = existing_settings.llm_model- if settings.llm_base_url is None:- settings.llm_base_url = existing_settings.llm_base_url+ settings = await store_llm_settings(request, settings)# Keep existing analytics consent if not providedif settings.user_consents_to_analytics is None:@@ -183,35 +247,8 @@ async def store_settings(existing_settings.user_consents_to_analytics)- # Only merge if not unsetting tokens- if settings.provider_tokens:- if existing_settings.secrets_store:- existing_providers = [- provider.value- for provider in existing_settings.secrets_store.provider_tokens- ]-- # Merge incoming settings store with the existing one- for provider, token_value in settings.provider_tokens.items():- if provider in existing_providers and not token_value:- provider_type = ProviderType(provider)- existing_token = (- existing_settings.secrets_store.provider_tokens.get(- provider_type- )- )- if existing_token and existing_token.token:- settings.provider_tokens[provider] = (- existing_token.token.get_secret_value()- )- else: # nothing passed in means keep current settings- provider_tokens = existing_settings.secrets_store.provider_tokens- settings.provider_tokens = {- provider.value: data.token.get_secret_value()- if data.token- else None- for provider, data in provider_tokens.items()- }+ settings = await store_provider_tokens(request, settings)+# Update sandbox config with new settingsif settings.remote_runtime_resource_factor is not None:diff --git a/tests/unit/test_settings_store_functions.py b/tests/unit/test_settings_store_functions.pynew file mode 100644index 0000000000..e357ee117c--- /dev/null+++ b/tests/unit/test_settings_store_functions.py@@ -0,0 +1,261 @@+from unittest.mock import AsyncMock, MagicMock, patch++import pytest+from pydantic import SecretStr++from openhands.integrations.provider import ProviderToken, SecretStore+from openhands.integrations.service_types import ProviderType+from openhands.server.routes.settings import (+ check_provider_tokens,+ store_llm_settings,+ store_provider_tokens,+)+from openhands.server.settings import POSTSettingsModel, Settings+++# Mock functions to simulate the actual functions in settings.py+async def get_settings_store(request):+ """Mock function to get settings store."""+ return MagicMock()+++# Tests for check_provider_tokens+async def test_check_provider_tokens_valid():+ """Test check_provider_tokens with valid tokens."""+ mock_request = MagicMock()+ settings = POSTSettingsModel(provider_tokens={'github': 'valid-token'})++ # Mock the validate_provider_token function to return GITHUB for valid tokens+ with patch(+ 'openhands.server.routes.settings.validate_provider_token'+ ) as mock_validate:+ mock_validate.return_value = ProviderType.GITHUB++ result = await check_provider_tokens(mock_request, settings)++ # Should return empty string for valid token+ assert result == ''+ mock_validate.assert_called_once()+++async def test_check_provider_tokens_invalid():+ """Test check_provider_tokens with invalid tokens."""+ mock_request = MagicMock()+ settings = POSTSettingsModel(provider_tokens={'github': 'invalid-token'})++ # Mock the validate_provider_token function to return None for invalid tokens+ with patch(+ 'openhands.server.routes.settings.validate_provider_token'+ ) as mock_validate:+ mock_validate.return_value = None++ result = await check_provider_tokens(mock_request, settings)++ # Should return error message for invalid token+ assert 'Invalid token' in result+ mock_validate.assert_called_once()+++async def test_check_provider_tokens_wrong_type():+ """Test check_provider_tokens with unsupported provider type."""+ mock_request = MagicMock()+ settings = POSTSettingsModel(provider_tokens={'unsupported': 'some-token'})++ result = await check_provider_tokens(mock_request, settings)++ # Should return empty string for unsupported provider+ assert result == ''+++async def test_check_provider_tokens_no_tokens():+ """Test check_provider_tokens with no tokens."""+ mock_request = MagicMock()+ settings = POSTSettingsModel(provider_tokens={})++ result = await check_provider_tokens(mock_request, settings)++ # Should return empty string when no tokens provided+ assert result == ''+++# Tests for store_llm_settings+async def test_store_llm_settings_new_settings():+ """Test store_llm_settings with new settings."""+ mock_request = MagicMock()+ settings = POSTSettingsModel(+ llm_model='gpt-4',+ llm_api_key='test-api-key',+ llm_base_url='https://api.example.com',+ )++ # Mock the settings store+ with patch(+ 'openhands.server.routes.settings.SettingsStoreImpl.get_instance'+ ) as mock_get_store:+ mock_store = MagicMock()+ mock_store.load = AsyncMock(return_value=None) # No existing settings+ mock_get_store.return_value = mock_store++ result = await store_llm_settings(mock_request, settings)++ # Should return settings with the provided values+ assert result.llm_model == 'gpt-4'+ assert result.llm_api_key.get_secret_value() == 'test-api-key'+ assert result.llm_base_url == 'https://api.example.com'+++async def test_store_llm_settings_update_existing():+ """Test store_llm_settings updates existing settings."""+ mock_request = MagicMock()+ settings = POSTSettingsModel(+ llm_model='gpt-4',+ llm_api_key='new-api-key',+ llm_base_url='https://new.example.com',+ )++ # Mock the settings store+ with patch(+ 'openhands.server.routes.settings.SettingsStoreImpl.get_instance'+ ) as mock_get_store:+ mock_store = MagicMock()++ # Create existing settings+ existing_settings = Settings(+ llm_model='gpt-3.5',+ llm_api_key=SecretStr('old-api-key'),+ llm_base_url='https://old.example.com',+ )++ mock_store.load = AsyncMock(return_value=existing_settings)+ mock_get_store.return_value = mock_store++ result = await store_llm_settings(mock_request, settings)++ # Should return settings with the updated values+ assert result.llm_model == 'gpt-4'+ assert result.llm_api_key.get_secret_value() == 'new-api-key'+ assert result.llm_base_url == 'https://new.example.com'+++async def test_store_llm_settings_partial_update():+ """Test store_llm_settings with partial update."""+ mock_request = MagicMock()+ settings = POSTSettingsModel(+ llm_model='gpt-4' # Only updating model+ )++ # Mock the settings store+ with patch(+ 'openhands.server.routes.settings.SettingsStoreImpl.get_instance'+ ) as mock_get_store:+ mock_store = MagicMock()++ # Create existing settings+ existing_settings = Settings(+ llm_model='gpt-3.5',+ llm_api_key=SecretStr('existing-api-key'),+ llm_base_url='https://existing.example.com',+ )++ mock_store.load = AsyncMock(return_value=existing_settings)+ mock_get_store.return_value = mock_store++ result = await store_llm_settings(mock_request, settings)++ # Should return settings with updated model but keep other values+ assert result.llm_model == 'gpt-4'+ # For SecretStr objects, we need to compare the secret value+ assert result.llm_api_key.get_secret_value() == 'existing-api-key'+ assert result.llm_base_url == 'https://existing.example.com'+++# Tests for store_provider_tokens+async def test_store_provider_tokens_new_tokens():+ """Test store_provider_tokens with new tokens."""+ mock_request = MagicMock()+ settings = POSTSettingsModel(provider_tokens={'github': 'new-token'})++ # Mock the settings store+ with patch(+ 'openhands.server.routes.settings.SettingsStoreImpl.get_instance'+ ) as mock_get_store:+ mock_store = MagicMock()+ mock_store.load = AsyncMock(return_value=None) # No existing settings+ mock_get_store.return_value = mock_store++ result = await store_provider_tokens(mock_request, settings)++ # Should return settings with the provided tokens+ assert result.provider_tokens == {'github': 'new-token'}+++async def test_store_provider_tokens_update_existing():+ """Test store_provider_tokens updates existing tokens."""+ mock_request = MagicMock()+ settings = POSTSettingsModel(provider_tokens={'github': 'updated-token'})++ # Mock the settings store+ with patch(+ 'openhands.server.routes.settings.SettingsStoreImpl.get_instance'+ ) as mock_get_store:+ mock_store = MagicMock()++ # Create existing settings with a GitHub token+ github_token = ProviderToken(token=SecretStr('old-token'))+ provider_tokens = {ProviderType.GITHUB: github_token}++ # Create a SecretStore with the provider tokens+ secrets_store = SecretStore(provider_tokens=provider_tokens)++ # Create existing settings with the secrets store+ existing_settings = Settings(secrets_store=secrets_store)++ mock_store.load = AsyncMock(return_value=existing_settings)+ mock_get_store.return_value = mock_store++ result = await store_provider_tokens(mock_request, settings)++ # Should return settings with the updated tokens+ assert result.provider_tokens == {'github': 'updated-token'}+++async def test_store_provider_tokens_keep_existing():+ """Test store_provider_tokens keeps existing tokens when empty string provided."""+ mock_request = MagicMock()+ settings = POSTSettingsModel(+ provider_tokens={'github': ''} # Empty string should keep existing token+ )++ # Mock the settings store+ with patch(+ 'openhands.server.routes.settings.SettingsStoreImpl.get_instance'+ ) as mock_get_store:+ mock_store = MagicMock()++ # Create existing settings with a GitHub token+ github_token = ProviderToken(token=SecretStr('existing-token'))+ provider_tokens = {ProviderType.GITHUB: github_token}++ # Create a SecretStore with the provider tokens+ secrets_store = SecretStore(provider_tokens=provider_tokens)++ # Create existing settings with the secrets store+ existing_settings = Settings(secrets_store=secrets_store)++ mock_store.load = AsyncMock(return_value=existing_settings)+ mock_get_store.return_value = mock_store++ result = await store_provider_tokens(mock_request, settings)++ # Should return settings with the existing token preserved+ assert result.provider_tokens == {'github': 'existing-token'}