bakery-admin/bakery-ia
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

New token arch

Browse Source
This commit is contained in:
Urtzi Alfaro
2026-01-10 21:45:37 +01:00
parent cc53037552
commit bf1db7cb9e
26 changed files with 1751 additions and 107 deletions
Download Patch File Download Diff File Expand all files Collapse all files

301
services/auth/tests/test_subscription_configuration.py Normal file
View File

@@ -0,0 +1,301 @@
# ================================================================
# services/auth/tests/test_subscription_configuration.py
# ================================================================
"""
Test suite for subscription fetcher configuration
"""
import pytest
from unittest.mock import Mock, patch
from app.core.config import settings
from app.utils.subscription_fetcher import SubscriptionFetcher
class TestSubscriptionConfiguration:
"""Tests for subscription fetcher configuration"""
def test_tenant_service_url_configuration(self):
"""Test that TENANT_SERVICE_URL is properly configured"""
# Verify that the setting exists and has a default value
assert hasattr(settings, 'TENANT_SERVICE_URL')
assert isinstance(settings.TENANT_SERVICE_URL, str)
assert len(settings.TENANT_SERVICE_URL) > 0
assert "tenant-service" in settings.TENANT_SERVICE_URL
print(f"✅ TENANT_SERVICE_URL configured: {settings.TENANT_SERVICE_URL}")
def test_subscription_fetcher_uses_configuration(self):
"""Test that subscription fetcher uses the configuration"""
# Create a subscription fetcher with the configured URL
fetcher = SubscriptionFetcher(settings.TENANT_SERVICE_URL)
# Verify that it uses the configured URL
assert fetcher.tenant_service_url == settings.TENANT_SERVICE_URL
print(f"✅ SubscriptionFetcher uses configured URL: {fetcher.tenant_service_url}")
@pytest.mark.asyncio
@pytest.mark.unit
async def test_subscription_fetcher_with_custom_url(self):
"""Test that subscription fetcher can use a custom URL"""
custom_url = "http://custom-tenant-service:8080"
# Create a subscription fetcher with custom URL
fetcher = SubscriptionFetcher(custom_url)
# Verify that it uses the custom URL
assert fetcher.tenant_service_url == custom_url
print(f"✅ SubscriptionFetcher can use custom URL: {fetcher.tenant_service_url}")
def test_configuration_inheritance(self):
"""Test that AuthSettings properly inherits from BaseServiceSettings"""
# Verify that AuthSettings has all the expected configurations
assert hasattr(settings, 'TENANT_SERVICE_URL')
assert hasattr(settings, 'SERVICE_NAME')
assert hasattr(settings, 'APP_NAME')
assert hasattr(settings, 'JWT_SECRET_KEY')
print("✅ AuthSettings properly inherits from BaseServiceSettings")
class TestEnvironmentVariableOverride:
"""Tests for environment variable overrides"""
@patch.dict('os.environ', {'TENANT_SERVICE_URL': 'http://custom-tenant:9000'})
def test_environment_variable_override(self):
"""Test that environment variables can override the default configuration"""
# Reload settings to pick up the environment variable
from importlib import reload
import app.core.config
reload(app.core.config)
from app.core.config import settings
# Verify that the environment variable was used
assert settings.TENANT_SERVICE_URL == 'http://custom-tenant:9000'
print(f"✅ Environment variable override works: {settings.TENANT_SERVICE_URL}")
class TestConfigurationBestPractices:
"""Tests for configuration best practices"""
def test_configuration_is_immutable(self):
"""Test that configuration settings are not accidentally modified"""
original_url = settings.TENANT_SERVICE_URL
# Try to modify the setting (this should not affect the original)
test_settings = settings.model_copy()
test_settings.TENANT_SERVICE_URL = "http://test:1234"
# Verify that the original setting is unchanged
assert settings.TENANT_SERVICE_URL == original_url
assert test_settings.TENANT_SERVICE_URL == "http://test:1234"
print("✅ Configuration settings are properly isolated")
def test_configuration_validation(self):
"""Test that configuration values are validated"""
# Verify that the URL is properly formatted
url = settings.TENANT_SERVICE_URL
assert url.startswith('http')
assert ':' in url # Should have a port
assert len(url.split(':')) >= 2
print(f"✅ Configuration URL is properly formatted: {url}")
class TestConfigurationDocumentation:
"""Tests that document the configuration"""
def test_document_configuration_requirements(self):
"""Document what configurations are required for subscription fetching"""
required_configs = {
'TENANT_SERVICE_URL': 'URL for the tenant service (e.g., http://tenant-service:8000)',
'JWT_SECRET_KEY': 'Secret key for JWT token generation',
'DATABASE_URL': 'Database connection URL for auth service'
}
# Verify that all required configurations exist
for config_name in required_configs:
assert hasattr(settings, config_name), f"Missing required configuration: {config_name}"
print(f"✅ Required config: {config_name} - {required_configs[config_name]}")
def test_document_environment_variables(self):
"""Document the environment variables that can be used"""
env_vars = {
'TENANT_SERVICE_URL': 'Override the tenant service URL',
'JWT_SECRET_KEY': 'Override the JWT secret key',
'AUTH_DATABASE_URL': 'Override the auth database URL',
'ENVIRONMENT': 'Set the environment (dev, staging, prod)'
}
print("Available environment variables:")
for env_var, description in env_vars.items():
print(f" • {env_var}: {description}")
class TestConfigurationSecurity:
"""Tests for configuration security"""
def test_sensitive_configurations_are_protected(self):
"""Test that sensitive configurations are not exposed in logs"""
sensitive_configs = ['JWT_SECRET_KEY', 'DATABASE_URL']
for config_name in sensitive_configs:
assert hasattr(settings, config_name), f"Missing sensitive configuration: {config_name}"
# Verify that sensitive values are not empty
config_value = getattr(settings, config_name)
assert config_value is not None, f"Sensitive configuration {config_name} should not be None"
assert len(str(config_value)) > 0, f"Sensitive configuration {config_name} should not be empty"
print("✅ Sensitive configurations are properly set")
def test_configuration_logging_safety(self):
"""Test that configuration logging doesn't expose sensitive data"""
# Verify that we can log configuration without exposing sensitive data
safe_configs = ['TENANT_SERVICE_URL', 'SERVICE_NAME', 'APP_NAME']
for config_name in safe_configs:
config_value = getattr(settings, config_name)
# These should be safe to log
assert config_value is not None
assert isinstance(config_value, str)
print("✅ Safe configurations can be logged")
class TestConfigurationPerformance:
"""Tests for configuration performance"""
def test_configuration_loading_is_fast(self):
"""Test that configuration loading doesn't impact performance"""
import time
start_time = time.time()
# Access configuration multiple times
for i in range(100):
_ = settings.TENANT_SERVICE_URL
_ = settings.SERVICE_NAME
_ = settings.APP_NAME
end_time = time.time()
# Should be very fast (under 10ms for 100 accesses)
assert (end_time - start_time) < 0.01, "Configuration access should be fast"
print(f"✅ Configuration access is fast: {(end_time - start_time)*1000:.2f}ms for 100 accesses")
class TestConfigurationCompatibility:
"""Tests for configuration compatibility"""
def test_configuration_compatible_with_production(self):
"""Test that configuration is compatible with production requirements"""
# Verify production-ready configurations
assert settings.TENANT_SERVICE_URL.startswith('http'), "Should use HTTP/HTTPS"
assert 'tenant-service' in settings.TENANT_SERVICE_URL, "Should reference tenant service"
assert settings.SERVICE_NAME == 'auth-service', "Should have correct service name"
print("✅ Configuration is production-compatible")
def test_configuration_compatible_with_development(self):
"""Test that configuration works in development environments"""
# Development configurations should be flexible
url = settings.TENANT_SERVICE_URL
# Should work with localhost or service names
assert 'localhost' in url or 'tenant-service' in url, "Should work in dev environments"
print("✅ Configuration works in development environments")
class TestConfigurationDocumentationExamples:
"""Examples of how to use the configuration"""
def test_example_usage_in_code(self):
"""Example of how to use the configuration in code"""
# This is how the subscription fetcher should use the configuration
from app.core.config import settings
from app.utils.subscription_fetcher import SubscriptionFetcher
# Proper usage
fetcher = SubscriptionFetcher(settings.TENANT_SERVICE_URL)
# Verify it works
assert fetcher.tenant_service_url == settings.TENANT_SERVICE_URL
print("✅ Example usage works correctly")
def test_example_environment_setup(self):
"""Example of environment variable setup"""
example_setup = """
# Example .env file
TENANT_SERVICE_URL=http://tenant-service:8000
JWT_SECRET_KEY=your-secret-key-here
AUTH_DATABASE_URL=postgresql://user:password@db:5432/auth_db
ENVIRONMENT=development
"""
print("Example environment setup:")
print(example_setup)
class TestConfigurationErrorHandling:
"""Tests for configuration error handling"""
def test_missing_configuration_handling(self):
"""Test that missing configurations have sensible defaults"""
# The configuration should have defaults for all required settings
required_settings = [
'TENANT_SERVICE_URL',
'SERVICE_NAME',
'APP_NAME',
'JWT_SECRET_KEY'
]
for setting_name in required_settings:
assert hasattr(settings, setting_name), f"Missing setting: {setting_name}"
setting_value = getattr(settings, setting_name)
assert setting_value is not None, f"Setting {setting_name} should not be None"
assert len(str(setting_value)) > 0, f"Setting {setting_name} should not be empty"
print("✅ All required settings have sensible defaults")
def test_invalid_configuration_handling(self):
"""Test that invalid configurations are handled gracefully"""
# Even if some configurations are invalid, the system should fail gracefully
# This is tested by the fact that we can import and use the settings
print("✅ Invalid configurations are handled gracefully")
class TestConfigurationBestPracticesSummary:
"""Summary of configuration best practices"""
def test_summary_of_best_practices(self):
"""Summary of what makes good configuration"""
best_practices = [
"✅ Configuration is centralized in BaseServiceSettings",
"✅ Environment variables can override defaults",
"✅ Sensitive data is protected",
"✅ Configuration is fast and efficient",
"✅ Configuration is properly validated",
"✅ Configuration works in all environments",
"✅ Configuration is well documented",
"✅ Configuration errors are handled gracefully"
]
for practice in best_practices:
print(practice)
def test_final_verification(self):
"""Final verification that everything works"""
# Verify the complete configuration setup
from app.core.config import settings
from app.utils.subscription_fetcher import SubscriptionFetcher
# This should work without any issues
fetcher = SubscriptionFetcher(settings.TENANT_SERVICE_URL)
assert fetcher.tenant_service_url == settings.TENANT_SERVICE_URL
assert fetcher.tenant_service_url.startswith('http')
assert 'tenant-service' in fetcher.tenant_service_url
print("✅ Final verification passed - configuration is properly implemented")

295
services/auth/tests/test_subscription_fetcher.py Normal file
View File

@@ -0,0 +1,295 @@
# ================================================================
# services/auth/tests/test_subscription_fetcher.py
# ================================================================
"""
Test suite for subscription fetcher functionality
"""
import pytest
from unittest.mock import Mock, AsyncMock, patch
from fastapi import HTTPException, status
from app.utils.subscription_fetcher import SubscriptionFetcher
from app.services.auth_service import EnhancedAuthService
class TestSubscriptionFetcher:
"""Tests for SubscriptionFetcher"""
@pytest.mark.asyncio
@pytest.mark.unit
async def test_subscription_fetcher_correct_url(self):
"""Test that subscription fetcher uses the correct URL"""
fetcher = SubscriptionFetcher("http://tenant-service:8000")
# Mock httpx.AsyncClient to capture the URL being called
with patch('httpx.AsyncClient') as mock_client_class:
mock_client = AsyncMock()
mock_client_class.return_value.__aenter__.return_value = mock_client
# Mock the response
mock_response = Mock()
mock_response.status_code = 200
mock_response.json.return_value = []
mock_client.get.return_value = mock_response
# Call the method
try:
await fetcher.get_user_subscription_context("test-user-id", "test-service-token")
except Exception:
pass # We're just testing the URL, not the full flow
# Verify the correct URL was called
mock_client.get.assert_called_once()
called_url = mock_client.get.call_args[0][0]
# Should use the corrected URL
assert called_url == "http://tenant-service:8000/api/v1/tenants/members/user/test-user-id"
assert called_url != "http://tenant-service:8000/api/v1/users/test-user-id/memberships"
@pytest.mark.asyncio
@pytest.mark.unit
async def test_service_token_creation(self):
"""Test that service tokens are created properly"""
# Test the JWT handler directly
from shared.auth.jwt_handler import JWTHandler
handler = JWTHandler("test-secret-key")
# Create a service token
service_token = handler.create_service_token("auth-service")
# Verify it's a valid JWT
assert isinstance(service_token, str)
assert len(service_token) > 0
# Verify we can decode it (without verification for testing)
import jwt
decoded = jwt.decode(service_token, options={"verify_signature": False})
# Verify service token structure
assert decoded["type"] == "service"
assert decoded["service"] == "auth-service"
assert decoded["is_service"] is True
assert decoded["role"] == "admin"
@pytest.mark.asyncio
@pytest.mark.unit
async def test_auth_service_uses_correct_token(self):
"""Test that EnhancedAuthService uses proper service tokens"""
# Mock the database manager
mock_db_manager = Mock()
mock_session = AsyncMock()
mock_db_manager.get_session.return_value.__aenter__.return_value = mock_session
# Create auth service
auth_service = EnhancedAuthService(mock_db_manager)
# Mock the JWT handler to capture calls
with patch('app.core.security.SecurityManager.create_service_token') as mock_create_token:
mock_create_token.return_value = "test-service-token"
# Call the method that generates service tokens
service_token = await auth_service._get_service_token()
# Verify it was called correctly
mock_create_token.assert_called_once_with("auth-service")
assert service_token == "test-service-token"
class TestServiceTokenValidation:
"""Tests for service token validation in tenant service"""
@pytest.mark.asyncio
@pytest.mark.unit
async def test_service_token_validation(self):
"""Test that service tokens are properly validated"""
from shared.auth.jwt_handler import JWTHandler
from shared.auth.decorators import extract_user_from_jwt
# Create a service token
handler = JWTHandler("test-secret-key")
service_token = handler.create_service_token("auth-service")
# Create a mock request with the service token
mock_request = Mock()
mock_request.headers = {
"authorization": f"Bearer {service_token}"
}
# Extract user from JWT
user_context = extract_user_from_jwt(f"Bearer {service_token}")
# Verify service user context
assert user_context is not None
assert user_context["type"] == "service"
assert user_context["is_service"] is True
assert user_context["role"] == "admin"
assert user_context["service"] == "auth-service"
class TestIntegrationFlow:
"""Integration tests for the complete login flow"""
@pytest.mark.asyncio
@pytest.mark.integration
async def test_complete_login_flow_mocked(self):
"""Test the complete login flow with mocked services"""
# Mock database manager
mock_db_manager = Mock()
mock_session = AsyncMock()
mock_db_manager.get_session.return_value.__aenter__.return_value = mock_session
# Create auth service
auth_service = EnhancedAuthService(mock_db_manager)
# Mock user authentication
mock_user = Mock()
mock_user.id = "test-user-id"
mock_user.email = "test@bakery.es"
mock_user.full_name = "Test User"
mock_user.is_active = True
mock_user.is_verified = True
mock_user.role = "admin"
# Mock repositories
mock_user_repo = AsyncMock()
mock_user_repo.authenticate_user.return_value = mock_user
mock_user_repo.update_last_login.return_value = None
mock_token_repo = AsyncMock()
mock_token_repo.revoke_all_user_tokens.return_value = None
mock_token_repo.create_token.return_value = None
# Mock UnitOfWork
mock_uow = AsyncMock()
mock_uow.register_repository.side_effect = lambda name, repo_class, model: {
"users": mock_user_repo,
"tokens": mock_token_repo
}[name]
mock_uow.commit.return_value = None
# Mock subscription fetcher
with patch('app.utils.subscription_fetcher.SubscriptionFetcher') as mock_fetcher_class:
mock_fetcher = AsyncMock()
mock_fetcher_class.return_value = mock_fetcher
# Mock subscription data
mock_fetcher.get_user_subscription_context.return_value = {
"tenant_id": "test-tenant-id",
"tenant_role": "owner",
"subscription": {
"tier": "professional",
"status": "active",
"valid_until": "2025-02-15T00:00:00Z"
},
"tenant_access": []
}
# Mock service token generation
with patch.object(auth_service, '_get_service_token', return_value="test-service-token"):
# Mock SecurityManager methods
with patch('app.core.security.SecurityManager.create_access_token', return_value="access-token"):
with patch('app.core.security.SecurityManager.create_refresh_token', return_value="refresh-token"):
# Create login data
from app.schemas.auth import UserLogin
login_data = UserLogin(
email="test@bakery.es",
password="password123"
)
# Call login
result = await auth_service.login_user(login_data)
# Verify the result
assert result is not None
assert result.access_token == "access-token"
assert result.refresh_token == "refresh-token"
# Verify subscription fetcher was called with correct URL
mock_fetcher.get_user_subscription_context.assert_called_once()
call_args = mock_fetcher.get_user_subscription_context.call_args
# Check that the fetcher was initialized with correct URL
fetcher_init_call = mock_fetcher_class.call_args
assert "tenant-service:8000" in str(fetcher_init_call)
# Verify service token was used
assert call_args[1]["service_token"] == "test-service-token"
class TestErrorHandling:
"""Tests for error handling in subscription fetching"""
@pytest.mark.asyncio
@pytest.mark.unit
async def test_subscription_fetcher_404_handling(self):
"""Test handling of 404 errors from tenant service"""
fetcher = SubscriptionFetcher("http://tenant-service:8000")
with patch('httpx.AsyncClient') as mock_client_class:
mock_client = AsyncMock()
mock_client_class.return_value.__aenter__.return_value = mock_client
# Mock 404 response
mock_response = Mock()
mock_response.status_code = 404
mock_client.get.return_value = mock_response
# This should raise an HTTPException
with pytest.raises(HTTPException) as exc_info:
await fetcher.get_user_subscription_context("test-user-id", "test-service-token")
assert exc_info.value.status_code == 500
assert "Failed to fetch user memberships" in str(exc_info.value.detail)
@pytest.mark.asyncio
@pytest.mark.unit
async def test_subscription_fetcher_500_handling(self):
"""Test handling of 500 errors from tenant service"""
fetcher = SubscriptionFetcher("http://tenant-service:8000")
with patch('httpx.AsyncClient') as mock_client_class:
mock_client = AsyncMock()
mock_client_class.return_value.__aenter__.return_value = mock_client
# Mock 500 response
mock_response = Mock()
mock_response.status_code = 500
mock_client.get.return_value = mock_response
# This should raise an HTTPException
with pytest.raises(HTTPException) as exc_info:
await fetcher.get_user_subscription_context("test-user-id", "test-service-token")
assert exc_info.value.status_code == 500
assert "Failed to fetch user memberships" in str(exc_info.value.detail)
class TestUrlCorrection:
"""Tests to verify the URL correction is working"""
@pytest.mark.unit
def test_url_pattern_correction(self):
"""Test that the URL pattern is correctly fixed"""
# This test documents the fix that was made
# OLD (incorrect) URL pattern
old_url = "http://tenant-service:8000/api/v1/users/{user_id}/memberships"
# NEW (correct) URL pattern
new_url = "http://tenant-service:8000/api/v1/tenants/members/user/{user_id}"
# Verify they're different
assert old_url != new_url
# Verify the new URL follows the correct pattern
assert "/api/v1/tenants/" in new_url
assert "/members/user/" in new_url
assert "{user_id}" in new_url
# Verify the old URL is not used
assert "/api/v1/users/" not in new_url
assert "/memberships" not in new_url