karaoke-gen 0.90.1__py3-none-any.whl → 0.99.3__py3-none-any.whl

backend/tests/test_audio_services.py

@@ -0,0 +1,378 @@
+"""
+Unit tests for audio analysis and editing services.
+
+These tests verify the backend service wrappers that use the shared
+karaoke_gen.instrumental_review module with GCS integration.
+
+NOTE: These tests require ffmpeg to be installed. They will be skipped
+if ffmpeg is not available (e.g., in CI environments without ffmpeg).
+"""
+
+import os
+import shutil
+import tempfile
+import pytest
+from unittest.mock import MagicMock, patch, ANY
+
+# Check if ffmpeg is available
+def _ffmpeg_available():
+    """Check if ffmpeg is available on the system."""
+    return shutil.which('ffmpeg') is not None
+
+# Skip all tests in this module if ffmpeg is not available
+pytestmark = pytest.mark.skipif(
+    not _ffmpeg_available(),
+    reason="ffmpeg not available - required for audio processing tests"
+)
+
+from pydub import AudioSegment
+from pydub.generators import Sine
+
+from karaoke_gen.instrumental_review import MuteRegion
+
+
+class TestAudioAnalysisService:
+    """Tests for AudioAnalysisService."""
+    
+    @pytest.fixture
+    def mock_storage_service(self):
+        """Create a mock storage service."""
+        mock = MagicMock()
+        return mock
+    
+    @pytest.fixture
+    def temp_audio_file(self, tmp_path):
+        """Create a temporary audio file for testing."""
+        audio_path = tmp_path / "test_audio.flac"
+        
+        # Create a simple sine wave audio
+        tone = Sine(440).to_audio_segment(duration=5000) - 15
+        tone.export(str(audio_path), format="flac")
+        
+        return str(audio_path)
+    
+    @pytest.fixture
+    def silent_audio_file(self, tmp_path):
+        """Create a silent audio file for testing."""
+        audio_path = tmp_path / "silent_audio.flac"
+        
+        audio = AudioSegment.silent(duration=5000, frame_rate=44100)
+        audio.export(str(audio_path), format="flac")
+        
+        return str(audio_path)
+    
+    def test_service_initialization(self, mock_storage_service):
+        """Test service initializes with default parameters."""
+        from backend.services.audio_analysis_service import AudioAnalysisService
+        
+        service = AudioAnalysisService(storage_service=mock_storage_service)
+        
+        assert service.storage_service == mock_storage_service
+        assert service.analyzer.silence_threshold_db == -40.0
+    
+    def test_service_custom_threshold(self, mock_storage_service):
+        """Test service accepts custom silence threshold."""
+        from backend.services.audio_analysis_service import AudioAnalysisService
+        
+        service = AudioAnalysisService(
+            storage_service=mock_storage_service,
+            silence_threshold_db=-35.0,
+        )
+        
+        assert service.analyzer.silence_threshold_db == -35.0
+    
+    def test_analyze_backing_vocals_downloads_file(
+        self, mock_storage_service, temp_audio_file
+    ):
+        """Test that analyze_backing_vocals downloads file from GCS."""
+        from backend.services.audio_analysis_service import AudioAnalysisService
+        
+        # Set up mock to copy the temp file to the download location
+        def mock_download(gcs_path, local_path):
+            import shutil
+            shutil.copy(temp_audio_file, local_path)
+            return local_path
+        
+        mock_storage_service.download_file.side_effect = mock_download
+        
+        service = AudioAnalysisService(storage_service=mock_storage_service)
+        result = service.analyze_backing_vocals(
+            gcs_audio_path="jobs/test/stems/backing_vocals.flac",
+            job_id="test-job",
+        )
+        
+        # Verify download was called
+        mock_storage_service.download_file.assert_called_once()
+        
+        # Verify result is valid
+        assert result is not None
+        assert hasattr(result, 'has_audible_content')
+    
+    def test_analyze_silent_audio_returns_no_audible(
+        self, mock_storage_service, silent_audio_file
+    ):
+        """Test that silent audio returns has_audible_content=False."""
+        from backend.services.audio_analysis_service import AudioAnalysisService
+        
+        def mock_download(gcs_path, local_path):
+            import shutil
+            shutil.copy(silent_audio_file, local_path)
+            return local_path
+        
+        mock_storage_service.download_file.side_effect = mock_download
+        
+        service = AudioAnalysisService(storage_service=mock_storage_service)
+        result = service.analyze_backing_vocals(
+            gcs_audio_path="jobs/test/stems/backing_vocals.flac",
+            job_id="test-job",
+        )
+        
+        assert result.has_audible_content is False
+        assert len(result.audible_segments) == 0
+    
+    def test_analyze_and_generate_waveform_uploads_image(
+        self, mock_storage_service, temp_audio_file
+    ):
+        """Test that analyze_and_generate_waveform uploads waveform to GCS."""
+        from backend.services.audio_analysis_service import AudioAnalysisService
+        
+        def mock_download(gcs_path, local_path):
+            import shutil
+            shutil.copy(temp_audio_file, local_path)
+            return local_path
+        
+        mock_storage_service.download_file.side_effect = mock_download
+        mock_storage_service.upload_file.return_value = "jobs/test/analysis/waveform.png"
+        
+        service = AudioAnalysisService(storage_service=mock_storage_service)
+        result, waveform_path = service.analyze_and_generate_waveform(
+            gcs_audio_path="jobs/test/stems/backing_vocals.flac",
+            job_id="test-job",
+            gcs_waveform_destination="jobs/test/analysis/waveform.png",
+        )
+        
+        # Verify upload was called
+        mock_storage_service.upload_file.assert_called_once()
+        
+        # Verify waveform path is returned
+        assert waveform_path == "jobs/test/analysis/waveform.png"
+    
+    def test_get_waveform_data_returns_amplitudes(
+        self, mock_storage_service, temp_audio_file
+    ):
+        """Test that get_waveform_data returns amplitude data."""
+        from backend.services.audio_analysis_service import AudioAnalysisService
+        
+        def mock_download(gcs_path, local_path):
+            import shutil
+            shutil.copy(temp_audio_file, local_path)
+            return local_path
+        
+        mock_storage_service.download_file.side_effect = mock_download
+        
+        service = AudioAnalysisService(storage_service=mock_storage_service)
+        amplitudes, duration = service.get_waveform_data(
+            gcs_audio_path="jobs/test/stems/backing_vocals.flac",
+            job_id="test-job",
+            num_points=100,
+        )
+        
+        # Verify we get amplitude data
+        assert isinstance(amplitudes, list)
+        assert len(amplitudes) > 0
+        assert all(isinstance(a, float) for a in amplitudes)
+        
+        # Verify duration is reasonable
+        assert duration > 0
+        assert duration <= 10  # Our test file is 5 seconds
+
+
+class TestAudioEditingService:
+    """Tests for AudioEditingService."""
+    
+    @pytest.fixture
+    def mock_storage_service(self):
+        """Create a mock storage service."""
+        mock = MagicMock()
+        return mock
+    
+    @pytest.fixture
+    def temp_audio_files(self, tmp_path):
+        """Create temporary audio files for testing."""
+        clean_path = tmp_path / "clean_instrumental.flac"
+        backing_path = tmp_path / "backing_vocals.flac"
+        
+        # Create clean instrumental (chord)
+        tone1 = Sine(220).to_audio_segment(duration=5000) - 15
+        tone2 = Sine(330).to_audio_segment(duration=5000) - 15
+        clean = tone1.overlay(tone2)
+        clean.export(str(clean_path), format="flac")
+        
+        # Create backing vocals
+        backing = Sine(440).to_audio_segment(duration=5000) - 20
+        backing.export(str(backing_path), format="flac")
+        
+        return str(clean_path), str(backing_path)
+    
+    def test_service_initialization(self, mock_storage_service):
+        """Test service initializes correctly."""
+        from backend.services.audio_editing_service import AudioEditingService
+        
+        service = AudioEditingService(storage_service=mock_storage_service)
+        
+        assert service.storage_service == mock_storage_service
+        assert service.editor.output_format == "flac"
+    
+    def test_create_custom_instrumental_downloads_files(
+        self, mock_storage_service, temp_audio_files
+    ):
+        """Test that create_custom_instrumental downloads input files."""
+        from backend.services.audio_editing_service import AudioEditingService
+        
+        clean_path, backing_path = temp_audio_files
+        
+        # Track which files were downloaded
+        downloaded_files = []
+        
+        def mock_download(gcs_path, local_path):
+            downloaded_files.append(gcs_path)
+            # Copy the appropriate test file
+            import shutil
+            if 'clean' in gcs_path:
+                shutil.copy(clean_path, local_path)
+            else:
+                shutil.copy(backing_path, local_path)
+            return local_path
+        
+        mock_storage_service.download_file.side_effect = mock_download
+        mock_storage_service.upload_file.return_value = "jobs/test/stems/custom.flac"
+        
+        service = AudioEditingService(storage_service=mock_storage_service)
+        
+        mute_regions = [MuteRegion(start_seconds=1.0, end_seconds=2.0)]
+        
+        result = service.create_custom_instrumental(
+            gcs_clean_instrumental_path="jobs/test/stems/clean.flac",
+            gcs_backing_vocals_path="jobs/test/stems/backing.flac",
+            mute_regions=mute_regions,
+            gcs_output_path="jobs/test/stems/custom.flac",
+            job_id="test-job",
+        )
+        
+        # Verify both files were downloaded
+        assert len(downloaded_files) == 2
+        assert mock_storage_service.upload_file.called
+    
+    def test_create_custom_instrumental_uploads_result(
+        self, mock_storage_service, temp_audio_files
+    ):
+        """Test that create_custom_instrumental uploads the result."""
+        from backend.services.audio_editing_service import AudioEditingService
+        
+        clean_path, backing_path = temp_audio_files
+        
+        def mock_download(gcs_path, local_path):
+            import shutil
+            if 'clean' in gcs_path:
+                shutil.copy(clean_path, local_path)
+            else:
+                shutil.copy(backing_path, local_path)
+            return local_path
+        
+        mock_storage_service.download_file.side_effect = mock_download
+        mock_storage_service.upload_file.return_value = "jobs/test/stems/custom.flac"
+        
+        service = AudioEditingService(storage_service=mock_storage_service)
+        
+        mute_regions = [MuteRegion(start_seconds=1.0, end_seconds=2.0)]
+        
+        result = service.create_custom_instrumental(
+            gcs_clean_instrumental_path="jobs/test/stems/clean.flac",
+            gcs_backing_vocals_path="jobs/test/stems/backing.flac",
+            mute_regions=mute_regions,
+            gcs_output_path="jobs/test/stems/custom.flac",
+            job_id="test-job",
+        )
+        
+        # Verify upload was called with correct destination
+        mock_storage_service.upload_file.assert_called_once()
+        call_args = mock_storage_service.upload_file.call_args
+        assert call_args[0][1] == "jobs/test/stems/custom.flac"
+        
+        # Verify result has correct path
+        assert result.output_path == "jobs/test/stems/custom.flac"
+    
+    def test_create_custom_instrumental_returns_statistics(
+        self, mock_storage_service, temp_audio_files
+    ):
+        """Test that create_custom_instrumental returns correct statistics."""
+        from backend.services.audio_editing_service import AudioEditingService
+        
+        clean_path, backing_path = temp_audio_files
+        
+        def mock_download(gcs_path, local_path):
+            import shutil
+            if 'clean' in gcs_path:
+                shutil.copy(clean_path, local_path)
+            else:
+                shutil.copy(backing_path, local_path)
+            return local_path
+        
+        mock_storage_service.download_file.side_effect = mock_download
+        mock_storage_service.upload_file.return_value = "jobs/test/stems/custom.flac"
+        
+        service = AudioEditingService(storage_service=mock_storage_service)
+        
+        mute_regions = [
+            MuteRegion(start_seconds=1.0, end_seconds=2.0),
+            MuteRegion(start_seconds=3.0, end_seconds=4.0),
+        ]
+        
+        result = service.create_custom_instrumental(
+            gcs_clean_instrumental_path="jobs/test/stems/clean.flac",
+            gcs_backing_vocals_path="jobs/test/stems/backing.flac",
+            mute_regions=mute_regions,
+            gcs_output_path="jobs/test/stems/custom.flac",
+            job_id="test-job",
+        )
+        
+        # Verify statistics
+        assert len(result.mute_regions_applied) == 2
+        assert result.total_muted_duration_seconds == 2.0  # 1s + 1s
+        assert result.output_duration_seconds > 0
+    
+    def test_validate_mute_regions_returns_errors_for_invalid(
+        self, mock_storage_service
+    ):
+        """Test that validate_mute_regions catches invalid regions."""
+        from backend.services.audio_editing_service import AudioEditingService
+        
+        service = AudioEditingService(storage_service=mock_storage_service)
+        
+        mute_regions = [
+            MuteRegion(start_seconds=0.0, end_seconds=1.0),  # Valid
+            MuteRegion(start_seconds=100.0, end_seconds=110.0),  # Beyond duration
+        ]
+        
+        errors = service.validate_mute_regions(mute_regions, total_duration_seconds=60.0)
+        
+        # Should have error for region exceeding duration
+        assert len(errors) == 1
+        assert "exceeds" in errors[0].lower()
+    
+    def test_validate_mute_regions_returns_empty_for_valid(
+        self, mock_storage_service
+    ):
+        """Test that validate_mute_regions returns empty for valid regions."""
+        from backend.services.audio_editing_service import AudioEditingService
+        
+        service = AudioEditingService(storage_service=mock_storage_service)
+        
+        mute_regions = [
+            MuteRegion(start_seconds=0.0, end_seconds=1.0),
+            MuteRegion(start_seconds=10.0, end_seconds=15.0),
+        ]
+        
+        errors = service.validate_mute_regions(mute_regions, total_duration_seconds=60.0)
+        
+        assert len(errors) == 0

backend/tests/test_auth_firestore.py

@@ -0,0 +1,231 @@
+"""
+Tests for AuthService and FirestoreService.
+
+These tests focus on the service initialization and basic operations.
+"""
+import pytest
+from datetime import datetime, UTC
+from unittest.mock import MagicMock, patch
+
+
+class TestAuthServiceBasics:
+    """Basic tests for AuthService."""
+    
+    def test_auth_service_can_import(self):
+        """Test AuthService can be imported."""
+        from backend.services.auth_service import AuthService
+        assert AuthService is not None
+    
+    def test_auth_service_initialization(self):
+        """Test AuthService initializes with mocked dependencies."""
+        mock_firestore = MagicMock()
+        
+        with patch('backend.services.auth_service.FirestoreService', return_value=mock_firestore), \
+             patch.dict('os.environ', {'ADMIN_TOKENS': 'test-token'}):
+            from backend.services.auth_service import AuthService
+            service = AuthService()
+            assert service is not None
+    
+    def test_auth_service_has_validate_method(self):
+        """Test AuthService has token validation method."""
+        from backend.services.auth_service import AuthService
+        assert hasattr(AuthService, 'validate_token') or hasattr(AuthService, 'verify_token')
+
+
+class TestFirestoreServiceBasics:
+    """Basic tests for FirestoreService."""
+    
+    def test_firestore_service_can_import(self):
+        """Test FirestoreService can be imported."""
+        from backend.services.firestore_service import FirestoreService
+        assert FirestoreService is not None
+    
+    def test_firestore_service_initialization(self):
+        """Test FirestoreService initializes with mocked client."""
+        mock_client = MagicMock()
+        
+        with patch('backend.services.firestore_service.firestore.Client', return_value=mock_client):
+            from backend.services.firestore_service import FirestoreService
+            service = FirestoreService()
+            assert service is not None
+    
+    def test_firestore_service_has_crud_methods(self):
+        """Test FirestoreService has CRUD methods."""
+        from backend.services.firestore_service import FirestoreService
+        assert hasattr(FirestoreService, 'create_job')
+        assert hasattr(FirestoreService, 'get_job')
+        assert hasattr(FirestoreService, 'update_job')
+        assert hasattr(FirestoreService, 'delete_job')
+
+
+class TestStorageServiceBasics:
+    """Basic tests for StorageService."""
+    
+    def test_storage_service_can_import(self):
+        """Test StorageService can be imported."""
+        from backend.services.storage_service import StorageService
+        assert StorageService is not None
+    
+    def test_storage_service_initialization(self):
+        """Test StorageService initializes with mocked client."""
+        mock_client = MagicMock()
+        mock_bucket = MagicMock()
+        mock_client.bucket.return_value = mock_bucket
+        
+        with patch('backend.services.storage_service.storage.Client', return_value=mock_client):
+            from backend.services.storage_service import StorageService
+            service = StorageService()
+            assert service is not None
+    
+    def test_storage_service_has_file_methods(self):
+        """Test StorageService has file operation methods."""
+        from backend.services.storage_service import StorageService
+        assert hasattr(StorageService, 'upload_file')
+        assert hasattr(StorageService, 'download_file')
+
+
+class TestWorkerServiceBasics:
+    """Basic tests for WorkerService."""
+    
+    def test_worker_service_can_import(self):
+        """Test WorkerService can be imported."""
+        from backend.services.worker_service import WorkerService
+        assert WorkerService is not None
+    
+    def test_worker_service_initialization(self):
+        """Test WorkerService initializes correctly."""
+        from backend.services.worker_service import WorkerService
+        service = WorkerService()
+        assert service is not None
+    
+    def test_worker_service_has_trigger_methods(self):
+        """Test WorkerService has trigger methods."""
+        from backend.services.worker_service import WorkerService
+        assert hasattr(WorkerService, 'trigger_audio_worker')
+        assert hasattr(WorkerService, 'trigger_lyrics_worker')
+        assert hasattr(WorkerService, 'trigger_screens_worker')
+        assert hasattr(WorkerService, 'trigger_video_worker')
+    
+    def test_worker_service_get_base_url(self):
+        """Test WorkerService constructs base URL."""
+        from backend.services.worker_service import WorkerService
+        service = WorkerService()
+        url = service._get_base_url()
+        assert 'http' in url
+
+
+class TestSessionTokenValidation:
+    """Tests for session token validation in AuthService.
+
+    PR #120: Fixed authentication to recognize session tokens from magic link auth.
+    Previously, validate_token() only checked admin tokens and auth_tokens collection.
+    Session tokens (created via magic link) are stored in the sessions collection,
+    so they were incorrectly rejected as "Invalid token".
+    """
+
+    def test_validate_token_checks_session_on_fallback(self):
+        """Test that validate_token falls back to checking session tokens."""
+        mock_firestore = MagicMock()
+        mock_firestore.get_token.return_value = None  # Token not in auth_tokens
+
+        mock_user = MagicMock()
+        mock_user.email = "test@example.com"
+        mock_user.credits = 5
+
+        mock_user_service = MagicMock()
+        mock_user_service.validate_session.return_value = (True, mock_user, "Valid session")
+
+        with patch('backend.services.auth_service.FirestoreService', return_value=mock_firestore), \
+             patch('backend.services.user_service.get_user_service', return_value=mock_user_service), \
+             patch.dict('os.environ', {'ADMIN_TOKENS': 'admin-token-123'}):
+            # Clear the cached instance to get fresh state
+            import backend.services.auth_service
+            backend.services.auth_service._auth_service = None
+            from backend.services.auth_service import AuthService, UserType
+
+            service = AuthService()
+            is_valid, user_type, remaining, msg = service.validate_token("session-token-xyz")
+
+            assert is_valid is True
+            assert user_type == UserType.STRIPE
+            assert remaining == 5  # User's credits
+            mock_user_service.validate_session.assert_called_once_with("session-token-xyz")
+
+    def test_validate_token_returns_invalid_when_session_invalid(self):
+        """Test that validate_token returns invalid when session validation fails."""
+        mock_firestore = MagicMock()
+        mock_firestore.get_token.return_value = None  # Token not in auth_tokens
+
+        mock_user_service = MagicMock()
+        mock_user_service.validate_session.return_value = (False, None, "Invalid session")
+
+        with patch('backend.services.auth_service.FirestoreService', return_value=mock_firestore), \
+             patch('backend.services.user_service.get_user_service', return_value=mock_user_service), \
+             patch.dict('os.environ', {'ADMIN_TOKENS': 'admin-token-123'}):
+            import backend.services.auth_service
+            backend.services.auth_service._auth_service = None
+            from backend.services.auth_service import AuthService, UserType
+
+            service = AuthService()
+            is_valid, user_type, remaining, msg = service.validate_token("invalid-session")
+
+            assert is_valid is False
+            assert remaining == 0
+            assert "Invalid token" in msg
+
+    def test_validate_token_returns_zero_credits_when_user_has_none(self):
+        """Test that validate_token handles users with 0 credits correctly."""
+        mock_firestore = MagicMock()
+        mock_firestore.get_token.return_value = None
+
+        mock_user = MagicMock()
+        mock_user.email = "test@example.com"
+        mock_user.credits = 0
+
+        mock_user_service = MagicMock()
+        mock_user_service.validate_session.return_value = (True, mock_user, "Valid session")
+
+        with patch('backend.services.auth_service.FirestoreService', return_value=mock_firestore), \
+             patch('backend.services.user_service.get_user_service', return_value=mock_user_service), \
+             patch.dict('os.environ', {'ADMIN_TOKENS': 'admin-token-123'}):
+            import backend.services.auth_service
+            backend.services.auth_service._auth_service = None
+            from backend.services.auth_service import AuthService, UserType
+
+            service = AuthService()
+            is_valid, user_type, remaining, msg = service.validate_token("session-token")
+
+            # User is authenticated but has no credits
+            assert is_valid is True
+            assert user_type == UserType.STRIPE
+            assert remaining == 0
+            assert "no credits" in msg.lower()
+
+
+class TestJobManagerBasics:
+    """Basic tests for JobManager."""
+
+    def test_job_manager_can_import(self):
+        """Test JobManager can be imported."""
+        from backend.services.job_manager import JobManager
+        assert JobManager is not None
+    
+    def test_job_manager_initialization(self):
+        """Test JobManager initializes with mocked services."""
+        mock_firestore = MagicMock()
+        mock_storage = MagicMock()
+        
+        with patch('backend.services.job_manager.FirestoreService', return_value=mock_firestore), \
+             patch('backend.services.job_manager.StorageService', return_value=mock_storage):
+            from backend.services.job_manager import JobManager
+            manager = JobManager()
+            assert manager is not None
+    
+    def test_job_manager_has_crud_methods(self):
+        """Test JobManager has CRUD methods."""
+        from backend.services.job_manager import JobManager
+        assert hasattr(JobManager, 'create_job')
+        assert hasattr(JobManager, 'get_job')
+        assert hasattr(JobManager, 'delete_job')
+        assert hasattr(JobManager, 'list_jobs')
+

backend/tests/test_config_extended.py

@@ -0,0 +1,68 @@
+"""
+Extended tests for config.py to improve coverage.
+"""
+import pytest
+import os
+from unittest.mock import patch
+
+
+class TestSettingsConfiguration:
+    """Tests for Settings configuration."""
+    
+    def test_settings_class_exists(self):
+        """Test Settings class exists."""
+        from backend.config import Settings
+        assert Settings is not None
+    
+    def test_settings_loads_defaults(self):
+        """Test Settings loads default values."""
+        from backend.config import Settings
+        settings = Settings()
+        assert settings is not None
+    
+    def test_gcs_bucket_name_from_env(self):
+        """Test GCS bucket name from environment."""
+        with patch.dict(os.environ, {'GCS_BUCKET_NAME': 'test-bucket'}):
+            from backend.config import Settings
+            settings = Settings()
+            assert settings.gcs_bucket_name == 'test-bucket'
+    
+    def test_firestore_collection_from_env(self):
+        """Test Firestore collection from environment."""
+        with patch.dict(os.environ, {'FIRESTORE_COLLECTION': 'test-jobs'}):
+            from backend.config import Settings
+            settings = Settings()
+            assert settings.firestore_collection == 'test-jobs'
+    
+    def test_environment_setting(self):
+        """Test environment setting."""
+        from backend.config import Settings
+        settings = Settings()
+        # Accept 'test' as well since pytest may set ENVIRONMENT=test
+        assert settings.environment in ['development', 'production', 'testing', 'test']
+    
+    def test_google_cloud_project(self):
+        """Test Google Cloud project setting."""
+        with patch.dict(os.environ, {'GOOGLE_CLOUD_PROJECT': 'test-project'}):
+            from backend.config import Settings
+            settings = Settings()
+            # Should either use the env var or have a default
+
+
+class TestGetSettings:
+    """Tests for get_settings function."""
+    
+    def test_get_settings_returns_settings(self):
+        """Test get_settings returns Settings instance."""
+        from backend.config import get_settings
+        settings = get_settings()
+        assert settings is not None
+    
+    def test_get_settings_returns_same_instance(self):
+        """Test get_settings returns cached instance."""
+        from backend.config import get_settings
+        settings1 = get_settings()
+        settings2 = get_settings()
+        # Should be same cached instance
+        assert settings1 is settings2
+