301 lines
13 KiB
Python
301 lines
13 KiB
Python
# ================================================================
|
|
# 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") |