507 lines
19 KiB
Python
507 lines
19 KiB
Python
"""Unit tests for Settings configuration and validation.
|
|
|
|
Tests cover:
|
|
- Environment variable parsing
|
|
- Default values application
|
|
- Settings validation
|
|
- CORS origins parsing
|
|
- Secret generation
|
|
- Configuration properties
|
|
"""
|
|
import os
|
|
from unittest.mock import patch
|
|
|
|
import pytest
|
|
from pydantic import ValidationError
|
|
|
|
from src.config.settings import Settings, settings
|
|
|
|
|
|
class TestSettingsDefaults:
|
|
"""Tests for default settings values."""
|
|
|
|
def test_jwt_secret_key_generated(self):
|
|
"""Test that JWT secret key is auto-generated if not provided."""
|
|
s = Settings()
|
|
assert s.jwt_secret_key is not None
|
|
assert len(s.jwt_secret_key) > 0
|
|
|
|
def test_jwt_secret_key_unique(self):
|
|
"""Test that each Settings instance gets unique JWT key."""
|
|
s1 = Settings()
|
|
s2 = Settings()
|
|
assert s1.jwt_secret_key != s2.jwt_secret_key
|
|
|
|
def test_password_salt_default(self):
|
|
"""Test default password salt."""
|
|
s = Settings()
|
|
assert s.password_salt == "default-salt"
|
|
|
|
def test_master_password_hash_default_none(self):
|
|
"""Test master password hash defaults to None."""
|
|
s = Settings()
|
|
assert s.master_password_hash is None
|
|
|
|
def test_master_password_default_none(self):
|
|
"""Test master password defaults to None."""
|
|
s = Settings()
|
|
assert s.master_password is None
|
|
|
|
def test_token_expiry_hours_default(self):
|
|
"""Test default token expiry hours."""
|
|
s = Settings()
|
|
assert s.token_expiry_hours == 24
|
|
|
|
def test_anime_directory_default(self):
|
|
"""Test anime directory defaults to empty string."""
|
|
s = Settings()
|
|
assert s.anime_directory == ""
|
|
|
|
def test_log_level_default(self):
|
|
"""Test default log level."""
|
|
s = Settings()
|
|
assert s.log_level == "INFO"
|
|
|
|
def test_database_url_default(self):
|
|
"""Test default database URL."""
|
|
s = Settings()
|
|
assert s.database_url == "sqlite:///./data/aniworld.db"
|
|
|
|
def test_cors_origins_default(self):
|
|
"""Test default CORS origins."""
|
|
s = Settings()
|
|
assert s.cors_origins == "http://localhost:3000"
|
|
|
|
def test_api_rate_limit_default(self):
|
|
"""Test default API rate limit."""
|
|
s = Settings()
|
|
assert s.api_rate_limit == 100
|
|
|
|
def test_default_provider_default(self):
|
|
"""Test default provider."""
|
|
s = Settings()
|
|
assert s.default_provider == "aniworld.to"
|
|
|
|
def test_provider_timeout_default(self):
|
|
"""Test default provider timeout."""
|
|
s = Settings()
|
|
assert s.provider_timeout == 30
|
|
|
|
def test_retry_attempts_default(self):
|
|
"""Test default retry attempts."""
|
|
s = Settings()
|
|
assert s.retry_attempts == 3
|
|
|
|
|
|
class TestNFOSettingsDefaults:
|
|
"""Tests for NFO-related settings defaults."""
|
|
|
|
def test_tmdb_api_key_default_none(self):
|
|
"""Test TMDB API key defaults to None."""
|
|
s = Settings()
|
|
assert s.tmdb_api_key is None
|
|
|
|
def test_nfo_auto_create_default(self):
|
|
"""Test NFO auto-create defaults to False."""
|
|
s = Settings()
|
|
assert s.nfo_auto_create is False
|
|
|
|
def test_nfo_update_on_scan_default(self):
|
|
"""Test NFO update on scan defaults to False."""
|
|
s = Settings()
|
|
assert s.nfo_update_on_scan is False
|
|
|
|
def test_nfo_download_poster_default(self):
|
|
"""Test NFO download poster defaults to True."""
|
|
s = Settings()
|
|
assert s.nfo_download_poster is True
|
|
|
|
def test_nfo_download_logo_default(self):
|
|
"""Test NFO download logo defaults to True."""
|
|
s = Settings()
|
|
assert s.nfo_download_logo is True
|
|
|
|
def test_nfo_download_fanart_default(self):
|
|
"""Test NFO download fanart defaults to True."""
|
|
s = Settings()
|
|
assert s.nfo_download_fanart is True
|
|
|
|
def test_nfo_image_size_default(self):
|
|
"""Test NFO image size defaults to 'original'."""
|
|
s = Settings()
|
|
assert s.nfo_image_size == "original"
|
|
|
|
def test_nfo_prefer_fsk_rating_default(self):
|
|
"""Test NFO prefer FSK rating defaults to True."""
|
|
s = Settings()
|
|
assert s.nfo_prefer_fsk_rating is True
|
|
|
|
|
|
class TestEnvironmentVariableParsing:
|
|
"""Tests for environment variable parsing."""
|
|
|
|
def test_jwt_secret_key_from_env(self):
|
|
"""Test loading JWT secret key from environment."""
|
|
with patch.dict(os.environ, {"JWT_SECRET_KEY": "test-secret-key"}):
|
|
s = Settings()
|
|
assert s.jwt_secret_key == "test-secret-key"
|
|
|
|
def test_password_salt_from_env(self):
|
|
"""Test loading password salt from environment."""
|
|
with patch.dict(os.environ, {"PASSWORD_SALT": "custom-salt"}):
|
|
s = Settings()
|
|
assert s.password_salt == "custom-salt"
|
|
|
|
def test_master_password_hash_from_env(self):
|
|
"""Test loading master password hash from environment."""
|
|
with patch.dict(os.environ, {"MASTER_PASSWORD_HASH": "hash123"}):
|
|
s = Settings()
|
|
assert s.master_password_hash == "hash123"
|
|
|
|
def test_master_password_from_env(self):
|
|
"""Test loading master password from environment."""
|
|
with patch.dict(os.environ, {"MASTER_PASSWORD": "dev-password"}):
|
|
s = Settings()
|
|
assert s.master_password == "dev-password"
|
|
|
|
def test_token_expiry_hours_from_env(self):
|
|
"""Test loading token expiry from environment."""
|
|
with patch.dict(os.environ, {"SESSION_TIMEOUT_HOURS": "48"}):
|
|
s = Settings()
|
|
assert s.token_expiry_hours == 48
|
|
|
|
def test_anime_directory_from_env(self):
|
|
"""Test loading anime directory from environment."""
|
|
with patch.dict(os.environ, {"ANIME_DIRECTORY": "/media/anime"}):
|
|
s = Settings()
|
|
assert s.anime_directory == "/media/anime"
|
|
|
|
def test_log_level_from_env(self):
|
|
"""Test loading log level from environment."""
|
|
with patch.dict(os.environ, {"LOG_LEVEL": "DEBUG"}):
|
|
s = Settings()
|
|
assert s.log_level == "DEBUG"
|
|
|
|
def test_database_url_from_env(self):
|
|
"""Test loading database URL from environment."""
|
|
with patch.dict(os.environ, {"DATABASE_URL": "postgresql://localhost/aniworld"}):
|
|
s = Settings()
|
|
assert s.database_url == "postgresql://localhost/aniworld"
|
|
|
|
def test_cors_origins_from_env(self):
|
|
"""Test loading CORS origins from environment."""
|
|
with patch.dict(os.environ, {"CORS_ORIGINS": "http://example.com"}):
|
|
s = Settings()
|
|
assert s.cors_origins == "http://example.com"
|
|
|
|
def test_api_rate_limit_from_env(self):
|
|
"""Test loading API rate limit from environment."""
|
|
with patch.dict(os.environ, {"API_RATE_LIMIT": "200"}):
|
|
s = Settings()
|
|
assert s.api_rate_limit == 200
|
|
|
|
def test_default_provider_from_env(self):
|
|
"""Test loading default provider from environment."""
|
|
with patch.dict(os.environ, {"DEFAULT_PROVIDER": "custom.provider"}):
|
|
s = Settings()
|
|
assert s.default_provider == "custom.provider"
|
|
|
|
def test_provider_timeout_from_env(self):
|
|
"""Test loading provider timeout from environment."""
|
|
with patch.dict(os.environ, {"PROVIDER_TIMEOUT": "60"}):
|
|
s = Settings()
|
|
assert s.provider_timeout == 60
|
|
|
|
def test_retry_attempts_from_env(self):
|
|
"""Test loading retry attempts from environment."""
|
|
with patch.dict(os.environ, {"RETRY_ATTEMPTS": "5"}):
|
|
s = Settings()
|
|
assert s.retry_attempts == 5
|
|
|
|
def test_tmdb_api_key_from_env(self):
|
|
"""Test loading TMDB API key from environment."""
|
|
with patch.dict(os.environ, {"TMDB_API_KEY": "tmdb-key-123"}):
|
|
s = Settings()
|
|
assert s.tmdb_api_key == "tmdb-key-123"
|
|
|
|
|
|
class TestNFOEnvironmentVariables:
|
|
"""Tests for NFO settings from environment."""
|
|
|
|
def test_nfo_auto_create_from_env_true(self):
|
|
"""Test loading NFO auto create as true from environment."""
|
|
with patch.dict(os.environ, {"NFO_AUTO_CREATE": "true"}):
|
|
s = Settings()
|
|
assert s.nfo_auto_create is True
|
|
|
|
def test_nfo_auto_create_from_env_false(self):
|
|
"""Test loading NFO auto create as false from environment."""
|
|
with patch.dict(os.environ, {"NFO_AUTO_CREATE": "false"}):
|
|
s = Settings()
|
|
assert s.nfo_auto_create is False
|
|
|
|
def test_nfo_update_on_scan_from_env(self):
|
|
"""Test loading NFO update on scan from environment."""
|
|
with patch.dict(os.environ, {"NFO_UPDATE_ON_SCAN": "true"}):
|
|
s = Settings()
|
|
assert s.nfo_update_on_scan is True
|
|
|
|
def test_nfo_download_poster_from_env_false(self):
|
|
"""Test loading NFO download poster as false."""
|
|
with patch.dict(os.environ, {"NFO_DOWNLOAD_POSTER": "false"}):
|
|
s = Settings()
|
|
assert s.nfo_download_poster is False
|
|
|
|
def test_nfo_download_logo_from_env_false(self):
|
|
"""Test loading NFO download logo as false."""
|
|
with patch.dict(os.environ, {"NFO_DOWNLOAD_LOGO": "false"}):
|
|
s = Settings()
|
|
assert s.nfo_download_logo is False
|
|
|
|
def test_nfo_download_fanart_from_env_false(self):
|
|
"""Test loading NFO download fanart as false."""
|
|
with patch.dict(os.environ, {"NFO_DOWNLOAD_FANART": "false"}):
|
|
s = Settings()
|
|
assert s.nfo_download_fanart is False
|
|
|
|
def test_nfo_image_size_from_env(self):
|
|
"""Test loading NFO image size from environment."""
|
|
with patch.dict(os.environ, {"NFO_IMAGE_SIZE": "w500"}):
|
|
s = Settings()
|
|
assert s.nfo_image_size == "w500"
|
|
|
|
def test_nfo_prefer_fsk_rating_from_env_false(self):
|
|
"""Test loading NFO prefer FSK rating as false."""
|
|
with patch.dict(os.environ, {"NFO_PREFER_FSK_RATING": "false"}):
|
|
s = Settings()
|
|
assert s.nfo_prefer_fsk_rating is False
|
|
|
|
|
|
class TestAllowedOriginsProperty:
|
|
"""Tests for allowed_origins property."""
|
|
|
|
def test_allowed_origins_single(self):
|
|
"""Test parsing single CORS origin."""
|
|
with patch.dict(os.environ, {"CORS_ORIGINS": "http://localhost:3000"}):
|
|
s = Settings()
|
|
origins = s.allowed_origins
|
|
assert origins == ["http://localhost:3000"]
|
|
|
|
def test_allowed_origins_multiple(self):
|
|
"""Test parsing multiple CORS origins."""
|
|
with patch.dict(os.environ, {"CORS_ORIGINS": "http://localhost:3000,http://example.com"}):
|
|
s = Settings()
|
|
origins = s.allowed_origins
|
|
assert len(origins) == 2
|
|
assert "http://localhost:3000" in origins
|
|
assert "http://example.com" in origins
|
|
|
|
def test_allowed_origins_with_spaces(self):
|
|
"""Test parsing CORS origins with extra spaces."""
|
|
with patch.dict(os.environ, {"CORS_ORIGINS": "http://localhost:3000 , http://example.com "}):
|
|
s = Settings()
|
|
origins = s.allowed_origins
|
|
assert len(origins) == 2
|
|
assert "http://localhost:3000" in origins
|
|
assert "http://example.com" in origins
|
|
|
|
def test_allowed_origins_wildcard_safe_fallback(self):
|
|
"""Test that wildcard falls back to safe defaults."""
|
|
with patch.dict(os.environ, {"CORS_ORIGINS": "*"}):
|
|
s = Settings()
|
|
origins = s.allowed_origins
|
|
assert "http://localhost:3000" in origins
|
|
assert "http://localhost:8000" in origins
|
|
# Should not allow all origins
|
|
assert "*" not in origins
|
|
|
|
def test_allowed_origins_empty_string(self):
|
|
"""Test parsing empty CORS origins."""
|
|
with patch.dict(os.environ, {"CORS_ORIGINS": ""}):
|
|
s = Settings()
|
|
origins = s.allowed_origins
|
|
assert origins == []
|
|
|
|
def test_allowed_origins_whitespace_only(self):
|
|
"""Test parsing whitespace-only CORS origins."""
|
|
with patch.dict(os.environ, {"CORS_ORIGINS": " "}):
|
|
s = Settings()
|
|
origins = s.allowed_origins
|
|
assert origins == []
|
|
|
|
def test_allowed_origins_filters_empty_items(self):
|
|
"""Test that empty items are filtered from comma-separated list."""
|
|
with patch.dict(os.environ, {"CORS_ORIGINS": "http://localhost:3000,,http://example.com,"}):
|
|
s = Settings()
|
|
origins = s.allowed_origins
|
|
assert len(origins) == 2
|
|
assert "http://localhost:3000" in origins
|
|
assert "http://example.com" in origins
|
|
|
|
|
|
class TestSettingsValidation:
|
|
"""Tests for settings validation."""
|
|
|
|
def test_invalid_token_expiry_hours_type(self):
|
|
"""Test that invalid token expiry type raises validation error."""
|
|
with patch.dict(os.environ, {"SESSION_TIMEOUT_HOURS": "not-a-number"}):
|
|
with pytest.raises(ValidationError):
|
|
Settings()
|
|
|
|
def test_invalid_api_rate_limit_type(self):
|
|
"""Test that invalid rate limit type raises validation error."""
|
|
with patch.dict(os.environ, {"API_RATE_LIMIT": "not-a-number"}):
|
|
with pytest.raises(ValidationError):
|
|
Settings()
|
|
|
|
def test_invalid_provider_timeout_type(self):
|
|
"""Test that invalid timeout type raises validation error."""
|
|
with patch.dict(os.environ, {"PROVIDER_TIMEOUT": "not-a-number"}):
|
|
with pytest.raises(ValidationError):
|
|
Settings()
|
|
|
|
def test_invalid_retry_attempts_type(self):
|
|
"""Test that invalid retry attempts type raises validation error."""
|
|
with patch.dict(os.environ, {"RETRY_ATTEMPTS": "not-a-number"}):
|
|
with pytest.raises(ValidationError):
|
|
Settings()
|
|
|
|
def test_invalid_boolean_value(self):
|
|
"""Test that invalid boolean raises validation error."""
|
|
with patch.dict(os.environ, {"NFO_AUTO_CREATE": "not-a-boolean"}):
|
|
with pytest.raises(ValidationError):
|
|
Settings()
|
|
|
|
|
|
class TestGlobalSettingsInstance:
|
|
"""Tests for global settings instance."""
|
|
|
|
def test_settings_instance_exists(self):
|
|
"""Test that global settings instance is created."""
|
|
assert settings is not None
|
|
assert isinstance(settings, Settings)
|
|
|
|
def test_settings_has_jwt_secret_key(self):
|
|
"""Test that global settings has JWT secret key."""
|
|
assert settings.jwt_secret_key is not None
|
|
assert len(settings.jwt_secret_key) > 0
|
|
|
|
def test_settings_has_default_database_url(self):
|
|
"""Test that global settings has default database URL."""
|
|
# Will be default unless overridden
|
|
assert settings.database_url is not None
|
|
|
|
|
|
class TestSettingsExtraIgnored:
|
|
"""Tests for extra fields handling."""
|
|
|
|
def test_unknown_env_vars_ignored(self):
|
|
"""Test that unknown environment variables are ignored."""
|
|
with patch.dict(os.environ, {"UNKNOWN_SETTING": "value", "JWT_SECRET_KEY": "test-key"}):
|
|
s = Settings()
|
|
assert s.jwt_secret_key == "test-key"
|
|
# Should not raise error for unknown setting
|
|
assert not hasattr(s, "UNKNOWN_SETTING")
|
|
assert not hasattr(s, "unknown_setting")
|
|
|
|
|
|
class TestSettingsEdgeCases:
|
|
"""Tests for edge cases in settings."""
|
|
|
|
def test_numeric_string_values(self):
|
|
"""Test that numeric strings are correctly parsed."""
|
|
with patch.dict(os.environ, {
|
|
"API_RATE_LIMIT": "250",
|
|
"PROVIDER_TIMEOUT": "45",
|
|
"RETRY_ATTEMPTS": "7"
|
|
}):
|
|
s = Settings()
|
|
assert s.api_rate_limit == 250
|
|
assert s.provider_timeout == 45
|
|
assert s.retry_attempts == 7
|
|
|
|
def test_boolean_string_variations(self):
|
|
"""Test different boolean string representations."""
|
|
# Test true variations
|
|
with patch.dict(os.environ, {"NFO_AUTO_CREATE": "1"}):
|
|
s = Settings()
|
|
assert s.nfo_auto_create is True
|
|
|
|
with patch.dict(os.environ, {"NFO_AUTO_CREATE": "yes"}):
|
|
s = Settings()
|
|
assert s.nfo_auto_create is True
|
|
|
|
# Test false variations
|
|
with patch.dict(os.environ, {"NFO_AUTO_CREATE": "0"}):
|
|
s = Settings()
|
|
assert s.nfo_auto_create is False
|
|
|
|
with patch.dict(os.environ, {"NFO_AUTO_CREATE": "no"}):
|
|
s = Settings()
|
|
assert s.nfo_auto_create is False
|
|
|
|
def test_empty_anime_directory_valid(self):
|
|
"""Test that empty anime directory is valid."""
|
|
with patch.dict(os.environ, {"ANIME_DIRECTORY": ""}):
|
|
s = Settings()
|
|
assert s.anime_directory == ""
|
|
|
|
def test_path_with_spaces(self):
|
|
"""Test that paths with spaces are preserved."""
|
|
with patch.dict(os.environ, {"ANIME_DIRECTORY": "/media/my anime"}):
|
|
s = Settings()
|
|
assert s.anime_directory == "/media/my anime"
|
|
|
|
def test_url_formats(self):
|
|
"""Test various database URL formats."""
|
|
urls = [
|
|
"sqlite:///./data/aniworld.db",
|
|
"postgresql://user:pass@localhost/db",
|
|
"mysql://localhost:3306/aniworld",
|
|
]
|
|
|
|
for url in urls:
|
|
with patch.dict(os.environ, {"DATABASE_URL": url}):
|
|
s = Settings()
|
|
assert s.database_url == url
|
|
|
|
def test_log_level_case_insensitive(self):
|
|
"""Test that log level accepts different cases."""
|
|
levels = ["DEBUG", "debug", "Info", "WARNING", "ERROR"]
|
|
|
|
for level in levels:
|
|
with patch.dict(os.environ, {"LOG_LEVEL": level}):
|
|
s = Settings()
|
|
assert s.log_level == level
|
|
|
|
|
|
class TestSecurityConsiderations:
|
|
"""Tests for security-related settings behavior."""
|
|
|
|
def test_jwt_secret_is_different_each_time(self):
|
|
"""Test that JWT secret is not predictable."""
|
|
secrets_generated = set()
|
|
|
|
for _ in range(10):
|
|
s = Settings()
|
|
secrets_generated.add(s.jwt_secret_key)
|
|
|
|
# All should be unique
|
|
assert len(secrets_generated) == 10
|
|
|
|
def test_master_password_warning_documented(self):
|
|
"""Test that master_password field has warning documentation."""
|
|
# Check that the field metadata includes warning
|
|
field_info = Settings.model_fields["master_password"]
|
|
description = field_info.description
|
|
assert description is not None
|
|
assert "DEVELOPMENT ONLY" in description
|
|
assert "NEVER" in description.upper()
|
|
|
|
def test_both_password_fields_can_be_none(self):
|
|
"""Test that both password fields being None is valid."""
|
|
s = Settings()
|
|
assert s.master_password is None
|
|
assert s.master_password_hash is None
|
|
# This is valid - password will be set during setup
|