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

backend/tests/test_spacy_preloader.py

@@ -0,0 +1,119 @@
+"""Tests for SpaCy preloader service."""
+
+import pytest
+from unittest.mock import patch, MagicMock
+
+from backend.services.spacy_preloader import (
+    preload_spacy_model,
+    get_preloaded_model,
+    is_model_preloaded,
+    clear_preloaded_models,
+)
+
+
+class TestSpacyPreloader:
+    """Tests for SpaCy preloading functionality."""
+
+    def setup_method(self):
+        """Clear preloaded models before each test."""
+        clear_preloaded_models()
+
+    def teardown_method(self):
+        """Clear preloaded models after each test."""
+        clear_preloaded_models()
+
+    def test_preload_spacy_model_loads_and_stores(self):
+        """GIVEN no preloaded models
+        WHEN preload_spacy_model is called
+        THEN model should be loaded and stored in singleton."""
+        mock_nlp = MagicMock()
+
+        with patch("spacy.load", return_value=mock_nlp) as mock_load:
+            preload_spacy_model("en_core_web_sm")
+
+            mock_load.assert_called_once_with("en_core_web_sm")
+            assert is_model_preloaded("en_core_web_sm")
+            assert get_preloaded_model("en_core_web_sm") is mock_nlp
+
+    def test_preload_is_idempotent(self):
+        """GIVEN a model already preloaded
+        WHEN preload_spacy_model is called again
+        THEN model should not be reloaded."""
+        mock_nlp = MagicMock()
+
+        with patch("spacy.load", return_value=mock_nlp) as mock_load:
+            preload_spacy_model("en_core_web_sm")
+            preload_spacy_model("en_core_web_sm")  # Second call
+
+            # Should only load once
+            assert mock_load.call_count == 1
+
+    def test_get_preloaded_model_returns_none_if_not_loaded(self):
+        """GIVEN no preloaded models
+        WHEN get_preloaded_model is called
+        THEN should return None."""
+        assert get_preloaded_model("en_core_web_sm") is None
+        assert not is_model_preloaded("en_core_web_sm")
+
+    def test_preload_different_models(self):
+        """GIVEN no preloaded models
+        WHEN preload_spacy_model is called with different model names
+        THEN each model should be loaded and stored separately."""
+        mock_nlp_sm = MagicMock(name="en_core_web_sm")
+        mock_nlp_md = MagicMock(name="en_core_web_md")
+
+        def mock_load(model_name):
+            if model_name == "en_core_web_sm":
+                return mock_nlp_sm
+            elif model_name == "en_core_web_md":
+                return mock_nlp_md
+            raise ValueError(f"Unknown model: {model_name}")
+
+        with patch("spacy.load", side_effect=mock_load):
+            preload_spacy_model("en_core_web_sm")
+            preload_spacy_model("en_core_web_md")
+
+            assert is_model_preloaded("en_core_web_sm")
+            assert is_model_preloaded("en_core_web_md")
+            assert get_preloaded_model("en_core_web_sm") is mock_nlp_sm
+            assert get_preloaded_model("en_core_web_md") is mock_nlp_md
+
+    def test_clear_preloaded_models(self):
+        """GIVEN preloaded models
+        WHEN clear_preloaded_models is called
+        THEN all models should be removed."""
+        mock_nlp = MagicMock()
+
+        with patch("spacy.load", return_value=mock_nlp):
+            preload_spacy_model("en_core_web_sm")
+            assert is_model_preloaded("en_core_web_sm")
+
+            clear_preloaded_models()
+            assert not is_model_preloaded("en_core_web_sm")
+            assert get_preloaded_model("en_core_web_sm") is None
+
+    def test_preload_failure_raises_exception(self):
+        """GIVEN spacy.load raises an exception
+        WHEN preload_spacy_model is called
+        THEN exception should be propagated."""
+        with patch(
+            "spacy.load",
+            side_effect=OSError("Model not found"),
+        ):
+            with pytest.raises(OSError, match="Model not found"):
+                preload_spacy_model("nonexistent_model")
+
+            # Model should not be marked as preloaded
+            assert not is_model_preloaded("nonexistent_model")
+
+    def test_preload_uses_default_model_name(self):
+        """GIVEN no model name specified
+        WHEN preload_spacy_model is called without arguments
+        THEN should use en_core_web_sm as default."""
+        mock_nlp = MagicMock()
+
+        with patch("spacy.load", return_value=mock_nlp) as mock_load:
+            preload_spacy_model()
+
+            mock_load.assert_called_once_with("en_core_web_sm")
+            assert is_model_preloaded("en_core_web_sm")

backend/tests/test_storage_service.py

@@ -0,0 +1,448 @@
+"""
+Tests for storage_service.py - Google Cloud Storage operations.
+
+These tests mock the GCS client to verify:
+- Upload operations (file, fileobj, JSON)
+- Download operations (file, JSON)
+- Signed URL generation
+- File operations (delete, list, exists)
+"""
+import json
+import pytest
+from unittest.mock import Mock, MagicMock, patch
+from io import BytesIO
+
+from backend.services.storage_service import StorageService
+
+
+class TestStorageServiceInit:
+    """Test StorageService initialization."""
+    
+    @patch("backend.services.storage_service.storage.Client")
+    @patch("backend.services.storage_service.settings")
+    def test_init_creates_client_and_bucket(self, mock_settings, mock_client_class):
+        """Test initialization creates GCS client and gets bucket."""
+        mock_settings.google_cloud_project = "test-project"
+        mock_settings.gcs_bucket_name = "test-bucket"
+        
+        mock_client = Mock()
+        mock_bucket = Mock()
+        mock_client.bucket.return_value = mock_bucket
+        mock_client_class.return_value = mock_client
+        
+        service = StorageService()
+        
+        mock_client_class.assert_called_once_with(project="test-project")
+        mock_client.bucket.assert_called_once_with("test-bucket")
+        assert service.client == mock_client
+        assert service.bucket == mock_bucket
+
+
+class TestStorageServiceUpload:
+    """Test upload operations."""
+    
+    @patch("backend.services.storage_service.storage.Client")
+    @patch("backend.services.storage_service.settings")
+    def test_upload_file(self, mock_settings, mock_client_class):
+        """Test uploading a file to GCS."""
+        mock_settings.google_cloud_project = "test-project"
+        mock_settings.gcs_bucket_name = "test-bucket"
+        
+        mock_blob = Mock()
+        mock_bucket = Mock()
+        mock_bucket.blob.return_value = mock_blob
+        mock_client = Mock()
+        mock_client.bucket.return_value = mock_bucket
+        mock_client_class.return_value = mock_client
+        
+        service = StorageService()
+        result = service.upload_file("/local/path/file.flac", "uploads/job123/file.flac")
+        
+        mock_bucket.blob.assert_called_once_with("uploads/job123/file.flac")
+        mock_blob.upload_from_filename.assert_called_once_with("/local/path/file.flac")
+        assert result == "uploads/job123/file.flac"
+    
+    @patch("backend.services.storage_service.storage.Client")
+    @patch("backend.services.storage_service.settings")
+    def test_upload_file_raises_on_error(self, mock_settings, mock_client_class):
+        """Test upload_file raises exception on GCS error."""
+        mock_settings.google_cloud_project = "test-project"
+        mock_settings.gcs_bucket_name = "test-bucket"
+        
+        mock_blob = Mock()
+        mock_blob.upload_from_filename.side_effect = Exception("GCS error")
+        mock_bucket = Mock()
+        mock_bucket.blob.return_value = mock_blob
+        mock_client = Mock()
+        mock_client.bucket.return_value = mock_bucket
+        mock_client_class.return_value = mock_client
+        
+        service = StorageService()
+        
+        with pytest.raises(Exception) as exc_info:
+            service.upload_file("/local/path/file.flac", "dest/file.flac")
+        
+        assert "GCS error" in str(exc_info.value)
+    
+    @patch("backend.services.storage_service.storage.Client")
+    @patch("backend.services.storage_service.settings")
+    def test_upload_fileobj(self, mock_settings, mock_client_class):
+        """Test uploading a file object to GCS."""
+        mock_settings.google_cloud_project = "test-project"
+        mock_settings.gcs_bucket_name = "test-bucket"
+        
+        mock_blob = Mock()
+        mock_bucket = Mock()
+        mock_bucket.blob.return_value = mock_blob
+        mock_client = Mock()
+        mock_client.bucket.return_value = mock_bucket
+        mock_client_class.return_value = mock_client
+        
+        service = StorageService()
+        file_obj = BytesIO(b"test content")
+        
+        result = service.upload_fileobj(file_obj, "uploads/test.txt", content_type="text/plain")
+        
+        mock_bucket.blob.assert_called_once_with("uploads/test.txt")
+        assert mock_blob.content_type == "text/plain"
+        mock_blob.upload_from_file.assert_called_once_with(file_obj, rewind=True)
+        assert result == "uploads/test.txt"
+    
+    @patch("backend.services.storage_service.storage.Client")
+    @patch("backend.services.storage_service.settings")
+    def test_upload_json(self, mock_settings, mock_client_class):
+        """Test uploading JSON data to GCS."""
+        mock_settings.google_cloud_project = "test-project"
+        mock_settings.gcs_bucket_name = "test-bucket"
+        
+        mock_blob = Mock()
+        mock_bucket = Mock()
+        mock_bucket.blob.return_value = mock_blob
+        mock_client = Mock()
+        mock_client.bucket.return_value = mock_bucket
+        mock_client_class.return_value = mock_client
+        
+        service = StorageService()
+        data = {"key": "value", "nested": {"data": True}}
+        
+        result = service.upload_json("data/config.json", data)
+        
+        mock_bucket.blob.assert_called_once_with("data/config.json")
+        assert mock_blob.content_type == "application/json"
+        # Check the uploaded content
+        call_args = mock_blob.upload_from_string.call_args
+        uploaded_content = call_args[0][0]
+        assert json.loads(uploaded_content) == data
+        assert result == "data/config.json"
+
+
+class TestStorageServiceDownload:
+    """Test download operations."""
+    
+    @patch("backend.services.storage_service.storage.Client")
+    @patch("backend.services.storage_service.settings")
+    def test_download_file(self, mock_settings, mock_client_class):
+        """Test downloading a file from GCS."""
+        mock_settings.google_cloud_project = "test-project"
+        mock_settings.gcs_bucket_name = "test-bucket"
+        
+        mock_blob = Mock()
+        mock_bucket = Mock()
+        mock_bucket.blob.return_value = mock_blob
+        mock_client = Mock()
+        mock_client.bucket.return_value = mock_bucket
+        mock_client_class.return_value = mock_client
+        
+        service = StorageService()
+        result = service.download_file("uploads/job123/file.flac", "/local/path/file.flac")
+        
+        mock_bucket.blob.assert_called_once_with("uploads/job123/file.flac")
+        mock_blob.download_to_filename.assert_called_once_with("/local/path/file.flac")
+        assert result == "/local/path/file.flac"
+    
+    @patch("backend.services.storage_service.storage.Client")
+    @patch("backend.services.storage_service.settings")
+    def test_download_file_raises_on_error(self, mock_settings, mock_client_class):
+        """Test download_file raises exception on GCS error."""
+        mock_settings.google_cloud_project = "test-project"
+        mock_settings.gcs_bucket_name = "test-bucket"
+        
+        mock_blob = Mock()
+        mock_blob.download_to_filename.side_effect = Exception("File not found")
+        mock_bucket = Mock()
+        mock_bucket.blob.return_value = mock_blob
+        mock_client = Mock()
+        mock_client.bucket.return_value = mock_bucket
+        mock_client_class.return_value = mock_client
+        
+        service = StorageService()
+        
+        with pytest.raises(Exception) as exc_info:
+            service.download_file("missing/file.flac", "/local/path")
+        
+        assert "File not found" in str(exc_info.value)
+    
+    @patch("backend.services.storage_service.storage.Client")
+    @patch("backend.services.storage_service.settings")
+    def test_download_json(self, mock_settings, mock_client_class):
+        """Test downloading and parsing JSON from GCS."""
+        mock_settings.google_cloud_project = "test-project"
+        mock_settings.gcs_bucket_name = "test-bucket"
+        
+        mock_blob = Mock()
+        mock_blob.download_as_text.return_value = '{"key": "value", "count": 42}'
+        mock_bucket = Mock()
+        mock_bucket.blob.return_value = mock_blob
+        mock_client = Mock()
+        mock_client.bucket.return_value = mock_bucket
+        mock_client_class.return_value = mock_client
+        
+        service = StorageService()
+        result = service.download_json("data/config.json")
+        
+        assert result == {"key": "value", "count": 42}
+
+
+class TestStorageServiceDelete:
+    """Test delete operations."""
+    
+    @patch("backend.services.storage_service.storage.Client")
+    @patch("backend.services.storage_service.settings")
+    def test_delete_file(self, mock_settings, mock_client_class):
+        """Test deleting a single file from GCS."""
+        mock_settings.google_cloud_project = "test-project"
+        mock_settings.gcs_bucket_name = "test-bucket"
+        
+        mock_blob = Mock()
+        mock_bucket = Mock()
+        mock_bucket.blob.return_value = mock_blob
+        mock_client = Mock()
+        mock_client.bucket.return_value = mock_bucket
+        mock_client_class.return_value = mock_client
+        
+        service = StorageService()
+        service.delete_file("uploads/job123/file.flac")
+        
+        mock_bucket.blob.assert_called_once_with("uploads/job123/file.flac")
+        mock_blob.delete.assert_called_once()
+    
+    @patch("backend.services.storage_service.storage.Client")
+    @patch("backend.services.storage_service.settings")
+    def test_delete_folder(self, mock_settings, mock_client_class):
+        """Test deleting all files with a prefix (folder)."""
+        mock_settings.google_cloud_project = "test-project"
+        mock_settings.gcs_bucket_name = "test-bucket"
+        
+        # Create mock blobs
+        mock_blob1 = Mock()
+        mock_blob1.name = "uploads/job123/file1.flac"
+        mock_blob2 = Mock()
+        mock_blob2.name = "uploads/job123/file2.flac"
+        mock_blob3 = Mock()
+        mock_blob3.name = "uploads/job123/subdir/file3.flac"
+        
+        mock_bucket = Mock()
+        mock_bucket.list_blobs.return_value = [mock_blob1, mock_blob2, mock_blob3]
+        mock_client = Mock()
+        mock_client.bucket.return_value = mock_bucket
+        mock_client_class.return_value = mock_client
+        
+        service = StorageService()
+        count = service.delete_folder("uploads/job123/")
+        
+        mock_bucket.list_blobs.assert_called_once_with(prefix="uploads/job123/")
+        mock_blob1.delete.assert_called_once()
+        mock_blob2.delete.assert_called_once()
+        mock_blob3.delete.assert_called_once()
+        assert count == 3
+    
+    @patch("backend.services.storage_service.storage.Client")
+    @patch("backend.services.storage_service.settings")
+    def test_delete_folder_handles_errors_gracefully(self, mock_settings, mock_client_class):
+        """Test delete_folder continues even if some deletes fail."""
+        mock_settings.google_cloud_project = "test-project"
+        mock_settings.gcs_bucket_name = "test-bucket"
+        
+        mock_blob1 = Mock()
+        mock_blob1.name = "file1.flac"
+        mock_blob2 = Mock()
+        mock_blob2.name = "file2.flac"
+        mock_blob2.delete.side_effect = Exception("Permission denied")
+        mock_blob3 = Mock()
+        mock_blob3.name = "file3.flac"
+        
+        mock_bucket = Mock()
+        mock_bucket.list_blobs.return_value = [mock_blob1, mock_blob2, mock_blob3]
+        mock_client = Mock()
+        mock_client.bucket.return_value = mock_bucket
+        mock_client_class.return_value = mock_client
+        
+        service = StorageService()
+        count = service.delete_folder("uploads/")
+        
+        # Should have deleted 2 files (blob2 failed)
+        assert count == 2
+
+
+class TestStorageServiceFileOperations:
+    """Test file listing and existence checks."""
+    
+    @patch("backend.services.storage_service.storage.Client")
+    @patch("backend.services.storage_service.settings")
+    def test_list_files(self, mock_settings, mock_client_class):
+        """Test listing files with a prefix."""
+        mock_settings.google_cloud_project = "test-project"
+        mock_settings.gcs_bucket_name = "test-bucket"
+        
+        mock_blob1 = Mock()
+        mock_blob1.name = "uploads/job123/audio.flac"
+        mock_blob2 = Mock()
+        mock_blob2.name = "uploads/job123/lyrics.txt"
+        
+        mock_bucket = Mock()
+        mock_bucket.list_blobs.return_value = [mock_blob1, mock_blob2]
+        mock_client = Mock()
+        mock_client.bucket.return_value = mock_bucket
+        mock_client_class.return_value = mock_client
+        
+        service = StorageService()
+        files = service.list_files("uploads/job123/")
+        
+        assert files == ["uploads/job123/audio.flac", "uploads/job123/lyrics.txt"]
+    
+    @patch("backend.services.storage_service.storage.Client")
+    @patch("backend.services.storage_service.settings")
+    def test_file_exists_returns_true(self, mock_settings, mock_client_class):
+        """Test file_exists returns True for existing file."""
+        mock_settings.google_cloud_project = "test-project"
+        mock_settings.gcs_bucket_name = "test-bucket"
+        
+        mock_blob = Mock()
+        mock_blob.exists.return_value = True
+        mock_bucket = Mock()
+        mock_bucket.blob.return_value = mock_blob
+        mock_client = Mock()
+        mock_client.bucket.return_value = mock_bucket
+        mock_client_class.return_value = mock_client
+        
+        service = StorageService()
+        result = service.file_exists("uploads/job123/file.flac")
+        
+        assert result is True
+    
+    @patch("backend.services.storage_service.storage.Client")
+    @patch("backend.services.storage_service.settings")
+    def test_file_exists_returns_false(self, mock_settings, mock_client_class):
+        """Test file_exists returns False for missing file."""
+        mock_settings.google_cloud_project = "test-project"
+        mock_settings.gcs_bucket_name = "test-bucket"
+        
+        mock_blob = Mock()
+        mock_blob.exists.return_value = False
+        mock_bucket = Mock()
+        mock_bucket.blob.return_value = mock_blob
+        mock_client = Mock()
+        mock_client.bucket.return_value = mock_bucket
+        mock_client_class.return_value = mock_client
+        
+        service = StorageService()
+        result = service.file_exists("missing/file.flac")
+        
+        assert result is False
+
+
+class TestStorageServiceSignedUrls:
+    """Test signed URL generation."""
+    
+    @patch("backend.services.storage_service.storage.Client")
+    @patch("backend.services.storage_service.settings")
+    def test_generate_signed_url(self, mock_settings, mock_client_class):
+        """Test generating a signed download URL."""
+        mock_settings.google_cloud_project = "test-project"
+        mock_settings.gcs_bucket_name = "test-bucket"
+        
+        mock_blob = Mock()
+        mock_blob.generate_signed_url.return_value = "https://storage.googleapis.com/signed-url"
+        mock_bucket = Mock()
+        mock_bucket.blob.return_value = mock_blob
+        mock_client = Mock()
+        mock_client.bucket.return_value = mock_bucket
+        mock_client_class.return_value = mock_client
+        
+        # Mock google.auth.default to return credentials without service_account_email
+        with patch("google.auth.default") as mock_auth_default:
+            mock_credentials = Mock(spec=[])  # No service_account_email attr
+            mock_auth_default.return_value = (mock_credentials, "test-project")
+            
+            service = StorageService()
+            url = service.generate_signed_url("uploads/file.flac", expiration_minutes=30)
+        
+        assert url == "https://storage.googleapis.com/signed-url"
+        mock_blob.generate_signed_url.assert_called_once()
+        call_kwargs = mock_blob.generate_signed_url.call_args.kwargs
+        assert call_kwargs["method"] == "GET"
+        assert call_kwargs["version"] == "v4"
+    
+    @patch("backend.services.storage_service.storage.Client")
+    @patch("backend.services.storage_service.settings")
+    def test_generate_signed_upload_url(self, mock_settings, mock_client_class):
+        """Test generating a signed upload URL."""
+        mock_settings.google_cloud_project = "test-project"
+        mock_settings.gcs_bucket_name = "test-bucket"
+        
+        mock_blob = Mock()
+        mock_blob.generate_signed_url.return_value = "https://storage.googleapis.com/signed-upload-url"
+        mock_bucket = Mock()
+        mock_bucket.blob.return_value = mock_blob
+        mock_client = Mock()
+        mock_client.bucket.return_value = mock_bucket
+        mock_client_class.return_value = mock_client
+        
+        with patch("google.auth.default") as mock_auth_default:
+            mock_credentials = Mock(spec=[])
+            mock_auth_default.return_value = (mock_credentials, "test-project")
+            
+            service = StorageService()
+            url = service.generate_signed_upload_url(
+                "uploads/file.flac",
+                content_type="audio/flac",
+                expiration_minutes=15
+            )
+        
+        assert url == "https://storage.googleapis.com/signed-upload-url"
+        call_kwargs = mock_blob.generate_signed_url.call_args.kwargs
+        assert call_kwargs["method"] == "PUT"
+        assert call_kwargs["headers"] == {"Content-Type": "audio/flac"}
+    
+    @patch("backend.services.storage_service.storage.Client")
+    @patch("backend.services.storage_service.settings")
+    def test_signed_url_with_service_account(self, mock_settings, mock_client_class):
+        """Test signed URL generation with service account credentials."""
+        mock_settings.google_cloud_project = "test-project"
+        mock_settings.gcs_bucket_name = "test-bucket"
+        
+        mock_blob = Mock()
+        mock_blob.generate_signed_url.return_value = "https://storage.googleapis.com/signed-url"
+        mock_bucket = Mock()
+        mock_bucket.blob.return_value = mock_blob
+        mock_client = Mock()
+        mock_client.bucket.return_value = mock_bucket
+        mock_client_class.return_value = mock_client
+        
+        with patch("google.auth.default") as mock_auth_default:
+            with patch("google.auth.transport.requests.Request") as mock_request:
+                # Mock credentials with service_account_email
+                mock_credentials = Mock()
+                mock_credentials.service_account_email = "sa@project.iam.gserviceaccount.com"
+                mock_credentials.token = "access-token-123"
+                mock_auth_default.return_value = (mock_credentials, "test-project")
+                
+                service = StorageService()
+                url = service.generate_signed_url("uploads/file.flac")
+        
+        # Should have refreshed credentials and used IAM signing
+        mock_credentials.refresh.assert_called_once()
+        call_kwargs = mock_blob.generate_signed_url.call_args.kwargs
+        assert call_kwargs["service_account_email"] == "sa@project.iam.gserviceaccount.com"
+        assert call_kwargs["access_token"] == "access-token-123"
+