karaoke-gen 0.101.0__py3-none-any.whl → 0.105.4__py3-none-any.whl

backend/tests/test_email_validation_service.py

@@ -0,0 +1,298 @@
+"""
+Unit tests for EmailValidationService.
+
+Tests email normalization, disposable domain detection, and blocklist management.
+"""
+
+import pytest
+from unittest.mock import Mock, MagicMock, patch
+
+# Mock Google Cloud before imports
+import sys
+sys.modules['google.cloud.firestore'] = MagicMock()
+sys.modules['google.cloud.storage'] = MagicMock()
+
+
+class TestEmailNormalization:
+    """Test email normalization logic."""
+
+    @pytest.fixture
+    def mock_db(self):
+        """Create a mock Firestore client."""
+        mock = MagicMock()
+        # Default: empty blocklist config
+        mock_doc = Mock()
+        mock_doc.exists = False
+        mock.collection.return_value.document.return_value.get.return_value = mock_doc
+        return mock
+
+    @pytest.fixture
+    def email_service(self, mock_db):
+        """Create EmailValidationService instance with mocks."""
+        from backend.services.email_validation_service import EmailValidationService
+        service = EmailValidationService(db=mock_db)
+        return service
+
+    # =========================================================================
+    # Gmail Normalization Tests
+    # =========================================================================
+
+    def test_normalize_gmail_removes_dots(self, email_service):
+        """Test that dots are removed from Gmail local part."""
+        result = email_service.normalize_email("j.o.h.n@gmail.com")
+        assert result == "john@gmail.com"
+
+    def test_normalize_gmail_removes_plus_suffix(self, email_service):
+        """Test that +tag is removed from Gmail local part."""
+        result = email_service.normalize_email("john+spam@gmail.com")
+        assert result == "john@gmail.com"
+
+    def test_normalize_gmail_removes_dots_and_plus(self, email_service):
+        """Test both dots and +tag are removed from Gmail."""
+        result = email_service.normalize_email("j.o.h.n+newsletter@gmail.com")
+        assert result == "john@gmail.com"
+
+    def test_normalize_googlemail_treated_like_gmail(self, email_service):
+        """Test that googlemail.com is normalized like gmail.com."""
+        result = email_service.normalize_email("j.o.h.n+test@googlemail.com")
+        assert result == "john@googlemail.com"
+
+    def test_normalize_gmail_to_lowercase(self, email_service):
+        """Test Gmail addresses are lowercased."""
+        result = email_service.normalize_email("JOHN.DOE+Test@GMAIL.COM")
+        assert result == "johndoe@gmail.com"
+
+    # =========================================================================
+    # Non-Gmail Normalization Tests
+    # =========================================================================
+
+    def test_normalize_non_gmail_preserves_dots(self, email_service):
+        """Test dots are preserved for non-Gmail domains."""
+        result = email_service.normalize_email("j.o.h.n@example.com")
+        assert result == "j.o.h.n@example.com"
+
+    def test_normalize_non_gmail_preserves_plus(self, email_service):
+        """Test +tag is preserved for non-Gmail domains."""
+        result = email_service.normalize_email("john+tag@company.com")
+        assert result == "john+tag@company.com"
+
+    def test_normalize_non_gmail_to_lowercase(self, email_service):
+        """Test non-Gmail addresses are lowercased."""
+        result = email_service.normalize_email("John.Doe@Example.Com")
+        assert result == "john.doe@example.com"
+
+    def test_normalize_strips_whitespace(self, email_service):
+        """Test whitespace is stripped."""
+        result = email_service.normalize_email("  john@example.com  ")
+        assert result == "john@example.com"
+
+    # =========================================================================
+    # Edge Cases
+    # =========================================================================
+
+    def test_normalize_empty_string(self, email_service):
+        """Test empty string returns empty."""
+        result = email_service.normalize_email("")
+        assert result == ""
+
+    def test_normalize_none_returns_empty(self, email_service):
+        """Test None returns empty string."""
+        result = email_service.normalize_email(None)
+        assert result == ""
+
+    def test_normalize_invalid_no_at_sign(self, email_service):
+        """Test email without @ is returned as-is (lowercase)."""
+        result = email_service.normalize_email("notanemail")
+        assert result == "notanemail"
+
+
+class TestDisposableDomainDetection:
+    """Test disposable domain detection."""
+
+    @pytest.fixture
+    def mock_db(self):
+        """Create a mock Firestore client."""
+        mock = MagicMock()
+        mock_doc = Mock()
+        mock_doc.exists = False
+        mock.collection.return_value.document.return_value.get.return_value = mock_doc
+        return mock
+
+    @pytest.fixture
+    def email_service(self, mock_db):
+        """Create EmailValidationService instance with mocks."""
+        from backend.services.email_validation_service import EmailValidationService
+        # Clear any cached blocklist
+        EmailValidationService._blocklist_cache = None
+        EmailValidationService._blocklist_cache_time = None
+        service = EmailValidationService(db=mock_db)
+        return service
+
+    def test_detect_known_disposable_domain(self, email_service):
+        """Test known disposable domains are detected."""
+        # These are in DEFAULT_DISPOSABLE_DOMAINS
+        assert email_service.is_disposable_domain("user@tempmail.com") is True
+        assert email_service.is_disposable_domain("user@mailinator.com") is True
+        assert email_service.is_disposable_domain("user@guerrillamail.com") is True
+
+    def test_detect_legitimate_domain(self, email_service):
+        """Test legitimate domains are not flagged."""
+        assert email_service.is_disposable_domain("user@gmail.com") is False
+        assert email_service.is_disposable_domain("user@yahoo.com") is False
+        assert email_service.is_disposable_domain("user@company.com") is False
+
+    def test_detect_case_insensitive(self, email_service):
+        """Test domain detection is case-insensitive."""
+        assert email_service.is_disposable_domain("user@TEMPMAIL.COM") is True
+        assert email_service.is_disposable_domain("user@TempMail.Com") is True
+
+    def test_detect_invalid_email_returns_false(self, email_service):
+        """Test invalid email returns False."""
+        assert email_service.is_disposable_domain("notanemail") is False
+        assert email_service.is_disposable_domain("") is False
+
+
+class TestBlocklistManagement:
+    """Test blocklist management functionality."""
+
+    @pytest.fixture
+    def mock_db(self):
+        """Create a mock Firestore client with blocklist."""
+        mock = MagicMock()
+        mock_doc = Mock()
+        mock_doc.exists = True
+        mock_doc.to_dict.return_value = {
+            "disposable_domains": ["custom-temp.com"],
+            "blocked_emails": ["spammer@example.com"],
+            "blocked_ips": ["192.168.1.100"],
+        }
+        mock.collection.return_value.document.return_value.get.return_value = mock_doc
+        return mock
+
+    @pytest.fixture
+    def email_service(self, mock_db):
+        """Create EmailValidationService instance with mocks."""
+        from backend.services.email_validation_service import EmailValidationService
+        # Clear any cached blocklist
+        EmailValidationService._blocklist_cache = None
+        EmailValidationService._blocklist_cache_time = None
+        service = EmailValidationService(db=mock_db)
+        return service
+
+    def test_is_email_blocked(self, email_service):
+        """Test blocked email detection."""
+        assert email_service.is_email_blocked("spammer@example.com") is True
+        assert email_service.is_email_blocked("legitimate@example.com") is False
+
+    def test_is_email_blocked_case_insensitive(self, email_service):
+        """Test blocked email detection is case-insensitive."""
+        assert email_service.is_email_blocked("SPAMMER@example.com") is True
+        assert email_service.is_email_blocked("Spammer@Example.Com") is True
+
+    def test_is_ip_blocked(self, email_service):
+        """Test blocked IP detection."""
+        assert email_service.is_ip_blocked("192.168.1.100") is True
+        assert email_service.is_ip_blocked("10.0.0.1") is False
+
+    def test_custom_disposable_domain_added(self, email_service):
+        """Test custom disposable domains from Firestore are included."""
+        assert email_service.is_disposable_domain("user@custom-temp.com") is True
+
+    def test_blocklist_caching(self, email_service, mock_db):
+        """Test blocklist is cached."""
+        # First call
+        email_service.is_disposable_domain("user@test.com")
+        # Second call should use cache
+        email_service.is_disposable_domain("user@test2.com")
+
+        # Should only call Firestore once due to caching
+        assert mock_db.collection.return_value.document.return_value.get.call_count == 1
+
+
+class TestBetaEnrollmentValidation:
+    """Test beta enrollment validation."""
+
+    @pytest.fixture
+    def mock_db(self):
+        """Create a mock Firestore client."""
+        mock = MagicMock()
+        mock_doc = Mock()
+        mock_doc.exists = True
+        mock_doc.to_dict.return_value = {
+            "disposable_domains": [],
+            "blocked_emails": ["blocked@example.com"],
+            "blocked_ips": [],
+        }
+        mock.collection.return_value.document.return_value.get.return_value = mock_doc
+        return mock
+
+    @pytest.fixture
+    def email_service(self, mock_db):
+        """Create EmailValidationService instance with mocks."""
+        from backend.services.email_validation_service import EmailValidationService
+        EmailValidationService._blocklist_cache = None
+        EmailValidationService._blocklist_cache_time = None
+        service = EmailValidationService(db=mock_db)
+        return service
+
+    def test_validate_legitimate_email(self, email_service):
+        """Test legitimate email passes validation."""
+        is_valid, error = email_service.validate_email_for_beta("user@gmail.com")
+        assert is_valid is True
+        assert error == ""
+
+    def test_validate_disposable_email_rejected(self, email_service):
+        """Test disposable email is rejected."""
+        is_valid, error = email_service.validate_email_for_beta("user@tempmail.com")
+        assert is_valid is False
+        assert "Disposable email" in error
+
+    def test_validate_blocked_email_rejected(self, email_service):
+        """Test blocked email is rejected."""
+        is_valid, error = email_service.validate_email_for_beta("blocked@example.com")
+        assert is_valid is False
+        assert "not allowed" in error
+
+    def test_validate_invalid_format_rejected(self, email_service):
+        """Test invalid email format is rejected."""
+        is_valid, error = email_service.validate_email_for_beta("notanemail")
+        assert is_valid is False
+        assert "Invalid email format" in error
+
+    def test_validate_empty_email_rejected(self, email_service):
+        """Test empty email is rejected."""
+        is_valid, error = email_service.validate_email_for_beta("")
+        assert is_valid is False
+
+
+class TestIPHashing:
+    """Test IP address hashing."""
+
+    @pytest.fixture
+    def email_service(self):
+        """Create EmailValidationService instance with mocks."""
+        mock_db = MagicMock()
+        mock_doc = Mock()
+        mock_doc.exists = False
+        mock_db.collection.return_value.document.return_value.get.return_value = mock_doc
+
+        from backend.services.email_validation_service import EmailValidationService
+        return EmailValidationService(db=mock_db)
+
+    def test_hash_ip_consistent(self, email_service):
+        """Test IP hashing produces consistent results."""
+        hash1 = email_service.hash_ip("192.168.1.1")
+        hash2 = email_service.hash_ip("192.168.1.1")
+        assert hash1 == hash2
+
+    def test_hash_ip_different_for_different_ips(self, email_service):
+        """Test different IPs produce different hashes."""
+        hash1 = email_service.hash_ip("192.168.1.1")
+        hash2 = email_service.hash_ip("192.168.1.2")
+        assert hash1 != hash2
+
+    def test_hash_ip_is_sha256(self, email_service):
+        """Test IP hash is SHA-256 (64 hex chars)."""
+        hash_result = email_service.hash_ip("192.168.1.1")
+        assert len(hash_result) == 64
+        assert all(c in "0123456789abcdef" for c in hash_result)

backend/tests/test_file_upload.py

@@ -1681,17 +1681,19 @@ class TestUploadEndpointThemeSupport:
         )
 
     def test_upload_endpoint_uses_resolve_cdg_txt_defaults(self):
-        """Verify the upload endpoint uses _resolve_cdg_txt_defaults for theme-based defaults."""
+        """Verify the upload endpoint uses resolve_cdg_txt_defaults for theme-based defaults."""
+        import inspect
         from backend.api.routes import file_upload as file_upload_module
 
-        with open(file_upload_module.__file__, 'r') as f:
-            source_code = f.read()
+        source_code = inspect.getsource(file_upload_module)
 
-        has_resolve_call = '_resolve_cdg_txt_defaults(' in source_code
+        # Check for the centralized resolve_cdg_txt_defaults function (imported from job_defaults_service)
+        has_resolve_call = 'resolve_cdg_txt_defaults(' in source_code
 
         assert has_resolve_call, (
-            "file_upload.py does not call _resolve_cdg_txt_defaults(). "
-            "When theme_id is set, enable_cdg and enable_txt should default to True."
+            "file_upload.py does not call resolve_cdg_txt_defaults(). "
+            "Theme-driven CDG/TXT defaults (controlled by DEFAULT_ENABLE_CDG/DEFAULT_ENABLE_TXT "
+            "settings) must be applied via the centralized job_defaults_service."
         )
 
     def test_upload_endpoint_has_optional_cdg_txt_params(self):

backend/tests/test_gce_encoding_worker.py

@@ -0,0 +1,229 @@
+"""
+Tests for GCE Encoding Worker (gce_encoding/main.py).
+
+These tests verify the file-finding logic in the GCE encoding worker,
+particularly ensuring that instrumental selection is respected.
+
+NOTE: This test file is self-contained and doesn't import the full app
+to avoid dependency issues in CI/CD environments.
+"""
+
+import pytest
+from pathlib import Path
+
+
+# Copy the find_file function here to test it in isolation
+# This avoids importing the full gce_encoding module which has GCS dependencies
+def find_file(work_dir: Path, *patterns):
+    '''Find a file matching any of the given glob patterns.'''
+    for pattern in patterns:
+        matches = list(work_dir.glob(f"**/{pattern}"))
+        if matches:
+            return matches[0]
+    return None
+
+
+class TestFindFile:
+    """Test the find_file function used to locate input files."""
+
+    def test_find_file_single_match(self, tmp_path):
+        """Test finding a file with a single match."""
+        # Create test file
+        test_file = tmp_path / "test_instrumental.flac"
+        test_file.touch()
+
+        result = find_file(tmp_path, "*instrumental*.flac")
+        assert result is not None
+        assert result.name == "test_instrumental.flac"
+
+    def test_find_file_no_match(self, tmp_path):
+        """Test finding a file with no matches returns None."""
+        result = find_file(tmp_path, "*nonexistent*.flac")
+        assert result is None
+
+    def test_find_file_priority_order(self, tmp_path):
+        """Test that find_file returns first matching pattern."""
+        # Create multiple files that match different patterns
+        first = tmp_path / "first_pattern.flac"
+        second = tmp_path / "second_pattern.flac"
+        first.touch()
+        second.touch()
+
+        # First pattern should win
+        result = find_file(tmp_path, "*first*.flac", "*second*.flac")
+        assert result.name == "first_pattern.flac"
+
+
+class TestInstrumentalSelection:
+    """Test that instrumental selection is properly respected."""
+
+    def test_clean_instrumental_prioritized_when_selected(self, tmp_path):
+        """Test that clean instrumental is found when 'clean' is selected.
+
+        When both instrumentals exist and 'clean' is selected,
+        the clean version should be found.
+        """
+        # Create both instrumental files (as they exist in GCS)
+        clean = tmp_path / "Artist - Title (Instrumental Clean).flac"
+        backing = tmp_path / "Artist - Title (Instrumental Backing).flac"
+        clean.touch()
+        backing.touch()
+
+        # Simulate finding instrumental with 'clean' selection
+        # (mimics the logic in run_encoding when instrumental_selection == 'clean')
+        result = find_file(
+            tmp_path,
+            "*instrumental_clean*.flac", "*Instrumental Clean*.flac",
+            "*instrumental*.flac", "*Instrumental*.flac",
+            "*instrumental*.wav"
+        )
+
+        assert result is not None
+        assert "Clean" in result.name
+
+    def test_backing_instrumental_prioritized_when_selected(self, tmp_path):
+        """Test that backing instrumental is found when 'with_backing' is selected.
+
+        When both instrumentals exist and 'with_backing' is selected,
+        the backing version should be found.
+
+        This test would have caught the bug where the GCE worker always
+        used the clean instrumental regardless of user selection.
+        """
+        # Create both instrumental files (as they exist in GCS)
+        clean = tmp_path / "Artist - Title (Instrumental Clean).flac"
+        backing = tmp_path / "Artist - Title (Instrumental Backing).flac"
+        clean.touch()
+        backing.touch()
+
+        # Simulate finding instrumental with 'with_backing' selection
+        # (mimics the logic in run_encoding when instrumental_selection == 'with_backing')
+        result = find_file(
+            tmp_path,
+            "*instrumental_with_backing*.flac", "*Instrumental Backing*.flac",
+            "*with_backing*.flac", "*Backing*.flac",
+            "*instrumental*.flac", "*Instrumental*.flac",
+            "*instrumental*.wav"
+        )
+
+        assert result is not None
+        assert "Backing" in result.name
+
+    def test_backing_instrumental_with_stem_naming(self, tmp_path):
+        """Test finding backing instrumental with GCS stem naming convention.
+
+        In GCS, stems are named like 'stems/instrumental_with_backing.flac'
+        """
+        stems_dir = tmp_path / "stems"
+        stems_dir.mkdir()
+
+        clean = stems_dir / "instrumental_clean.flac"
+        backing = stems_dir / "instrumental_with_backing.flac"
+        clean.touch()
+        backing.touch()
+
+        # Simulate finding instrumental with 'with_backing' selection
+        result = find_file(
+            tmp_path,
+            "*instrumental_with_backing*.flac", "*Instrumental Backing*.flac",
+            "*with_backing*.flac", "*Backing*.flac",
+            "*instrumental*.flac", "*Instrumental*.flac",
+            "*instrumental*.wav"
+        )
+
+        assert result is not None
+        assert "with_backing" in result.name
+
+    def test_fallback_to_generic_when_specific_not_found(self, tmp_path):
+        """Test fallback to generic pattern when specific not found."""
+        # Only create a generically named instrumental
+        generic = tmp_path / "instrumental.flac"
+        generic.touch()
+
+        # Both clean and backing selections should fall back
+        for selection in ["clean", "with_backing"]:
+            if selection == "with_backing":
+                patterns = (
+                    "*instrumental_with_backing*.flac", "*Instrumental Backing*.flac",
+                    "*with_backing*.flac", "*Backing*.flac",
+                    "*instrumental*.flac", "*Instrumental*.flac",
+                    "*instrumental*.wav"
+                )
+            else:
+                patterns = (
+                    "*instrumental_clean*.flac", "*Instrumental Clean*.flac",
+                    "*instrumental*.flac", "*Instrumental*.flac",
+                    "*instrumental*.wav"
+                )
+
+            result = find_file(tmp_path, *patterns)
+            assert result is not None
+            assert result.name == "instrumental.flac"
+
+
+class TestInstrumentalSelectionRegression:
+    """Regression tests for instrumental selection bug.
+
+    Bug: User selected 'with_backing' instrumental in the UI but the final
+    video used the clean instrumental instead.
+
+    Root cause: The GCE worker's find_file() always prioritized
+    '*instrumental_clean*' patterns before generic patterns, ignoring
+    the user's selection.
+    """
+
+    def test_bug_scenario_both_instrumentals_present(self, tmp_path):
+        """Recreate the exact bug scenario where both instrumentals exist.
+
+        This is the key regression test. When both instrumentals are downloaded
+        from GCS (which happens with the GCE worker), the correct one must
+        be selected based on the user's choice.
+        """
+        # Setup: Both instrumentals in stems/ (as downloaded from GCS)
+        stems = tmp_path / "stems"
+        stems.mkdir()
+
+        (stems / "instrumental_clean.flac").touch()
+        (stems / "instrumental_with_backing.flac").touch()
+
+        # Also have properly named versions in the root (from _setup_working_directory)
+        (tmp_path / "Artist - Song (Instrumental Clean).flac").touch()
+        (tmp_path / "Artist - Song (Instrumental Backing).flac").touch()
+
+        # When user selected 'with_backing', the backing version MUST be found
+        backing_patterns = (
+            "*instrumental_with_backing*.flac", "*Instrumental Backing*.flac",
+            "*with_backing*.flac", "*Backing*.flac",
+            "*instrumental*.flac", "*Instrumental*.flac",
+            "*instrumental*.wav"
+        )
+        result = find_file(tmp_path, *backing_patterns)
+
+        assert result is not None
+        # Must find a backing-related file, not the clean one
+        name = result.name.lower()
+        assert "backing" in name or "with_backing" in name, \
+            f"Expected backing instrumental but found: {result.name}"
+
+    def test_clean_selection_still_works(self, tmp_path):
+        """Verify clean selection still works correctly after the fix."""
+        stems = tmp_path / "stems"
+        stems.mkdir()
+
+        (stems / "instrumental_clean.flac").touch()
+        (stems / "instrumental_with_backing.flac").touch()
+
+        (tmp_path / "Artist - Song (Instrumental Clean).flac").touch()
+        (tmp_path / "Artist - Song (Instrumental Backing).flac").touch()
+
+        # When user selected 'clean', the clean version must be found
+        clean_patterns = (
+            "*instrumental_clean*.flac", "*Instrumental Clean*.flac",
+            "*instrumental*.flac", "*Instrumental*.flac",
+            "*instrumental*.wav"
+        )
+        result = find_file(tmp_path, *clean_patterns)
+
+        assert result is not None
+        name = result.name.lower()
+        assert "clean" in name, f"Expected clean instrumental but found: {result.name}"

backend/tests/test_impersonation.py

@@ -11,6 +11,7 @@ from fastapi import FastAPI
 from backend.api.routes.admin import router
 from backend.api.dependencies import require_admin
 from backend.services.user_service import get_user_service
+from backend.services.auth_service import AuthResult, UserType
 from backend.models.user import User, Session
 
 
@@ -20,15 +21,29 @@ app.include_router(router, prefix="/api")
 
 
 def get_mock_admin():
-    """Override for require_admin dependency - returns admin user."""
-    return ("admin@nomadkaraoke.com", "admin", 1)
+    """Override for require_admin dependency - returns admin AuthResult."""
+    return AuthResult(
+        is_valid=True,
+        user_type=UserType.ADMIN,
+        remaining_uses=-1,
+        message="Admin session valid",
+        user_email="admin@nomadkaraoke.com",
+        is_admin=True,
+    )
 
 
 def get_mock_regular_user():
     """Override for require_admin dependency - returns regular user (should fail)."""
     # This simulates what happens when a non-admin tries to access
     # In reality, require_admin raises 403, but we test the logic
-    return ("user@example.com", "user", 0)
+    return AuthResult(
+        is_valid=True,
+        user_type=UserType.LIMITED,
+        remaining_uses=5,
+        message="User session valid",
+        user_email="user@example.com",
+        is_admin=False,
+    )
 
 
 @pytest.fixture

backend/tests/test_made_for_you.py

@@ -1503,6 +1503,8 @@ class TestMadeForYouDistributionSettings:
         settings.default_brand_prefix = "NOMAD"
         settings.default_discord_webhook_url = None
         settings.default_youtube_description = None
+        settings.default_enable_cdg = True
+        settings.default_enable_txt = True
         return settings
 
     @pytest.mark.asyncio
@@ -1522,7 +1524,7 @@ class TestMadeForYouDistributionSettings:
              patch('backend.services.audio_search_service.get_audio_search_service') as mock_get_audio, \
              patch('backend.services.storage_service.StorageService'), \
              patch('backend.api.routes.users.get_theme_service', return_value=mock_theme_service), \
-             patch('backend.config.get_settings', return_value=mock_settings):
+             patch('backend.services.job_defaults_service.get_settings', return_value=mock_settings):
 
             from backend.services.audio_search_service import NoResultsError
             mock_audio_service = MagicMock()
@@ -1558,7 +1560,7 @@ class TestMadeForYouDistributionSettings:
              patch('backend.services.audio_search_service.get_audio_search_service') as mock_get_audio, \
              patch('backend.services.storage_service.StorageService'), \
              patch('backend.api.routes.users.get_theme_service', return_value=mock_theme_service), \
-             patch('backend.config.get_settings', return_value=mock_settings):
+             patch('backend.services.job_defaults_service.get_settings', return_value=mock_settings):
 
             from backend.services.audio_search_service import NoResultsError
             mock_audio_service = MagicMock()
@@ -1594,7 +1596,7 @@ class TestMadeForYouDistributionSettings:
              patch('backend.services.audio_search_service.get_audio_search_service') as mock_get_audio, \
              patch('backend.services.storage_service.StorageService'), \
              patch('backend.api.routes.users.get_theme_service', return_value=mock_theme_service), \
-             patch('backend.config.get_settings', return_value=mock_settings):
+             patch('backend.services.job_defaults_service.get_settings', return_value=mock_settings):
 
             from backend.services.audio_search_service import NoResultsError
             mock_audio_service = MagicMock()
@@ -1628,7 +1630,7 @@ class TestMadeForYouDistributionSettings:
              patch('backend.services.audio_search_service.get_audio_search_service') as mock_get_audio, \
              patch('backend.services.storage_service.StorageService'), \
              patch('backend.api.routes.users.get_theme_service', return_value=mock_theme_service), \
-             patch('backend.config.get_settings', return_value=mock_settings):
+             patch('backend.services.job_defaults_service.get_settings', return_value=mock_settings):
 
             from backend.services.audio_search_service import NoResultsError
             mock_audio_service = MagicMock()