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

backend/tests/test_packaging_service.py

@@ -0,0 +1,382 @@
+"""
+Tests for PackagingService.
+
+Tests cover:
+- Service initialization
+- CDG package creation
+- TXT package creation
+- Dry run mode
+- Error handling
+"""
+
+import os
+import zipfile
+import tempfile
+import pytest
+from unittest.mock import MagicMock, patch
+
+from backend.services.packaging_service import (
+    PackagingService,
+    get_packaging_service,
+)
+
+
+class TestPackagingServiceInit:
+    """Test service initialization."""
+
+    def test_init_default_values(self):
+        """Test default initialization."""
+        service = PackagingService()
+        assert service.cdg_styles is None
+        assert service.dry_run is False
+        assert service.non_interactive is False
+
+    def test_init_with_cdg_styles(self):
+        """Test initialization with CDG styles."""
+        styles = {"font_size": 24, "bg_color": "black"}
+        service = PackagingService(cdg_styles=styles)
+        assert service.cdg_styles == styles
+
+    def test_init_with_dry_run(self):
+        """Test initialization with dry run mode."""
+        service = PackagingService(dry_run=True)
+        assert service.dry_run is True
+
+    def test_init_with_non_interactive(self):
+        """Test initialization with non-interactive mode."""
+        service = PackagingService(non_interactive=True)
+        assert service.non_interactive is True
+
+
+class TestPackagingServiceCreateZipFromFiles:
+    """Test internal ZIP creation."""
+
+    def test_create_zip_from_files(self):
+        """Test creating a ZIP file from multiple files."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            # Create test files
+            file1 = os.path.join(tmpdir, "test1.txt")
+            file2 = os.path.join(tmpdir, "test2.txt")
+            zip_path = os.path.join(tmpdir, "output.zip")
+
+            with open(file1, "w") as f:
+                f.write("content1")
+            with open(file2, "w") as f:
+                f.write("content2")
+
+            service = PackagingService()
+            service._create_zip_from_files(
+                zip_path,
+                [(file1, "test1.txt"), (file2, "test2.txt")]
+            )
+
+            assert os.path.isfile(zip_path)
+            with zipfile.ZipFile(zip_path, "r") as zf:
+                names = zf.namelist()
+                assert "test1.txt" in names
+                assert "test2.txt" in names
+
+
+class TestPackagingServiceCDGPackage:
+    """Test CDG package creation."""
+
+    def test_create_cdg_package_missing_lrc_file(self):
+        """Test that missing LRC file raises FileNotFoundError."""
+        service = PackagingService()
+
+        with pytest.raises(FileNotFoundError) as exc_info:
+            service.create_cdg_package(
+                lrc_file="/nonexistent/file.lrc",
+                audio_file="/some/audio.flac",
+                output_zip_path="/output/test.zip",
+                artist="Test Artist",
+                title="Test Title",
+            )
+        assert "LRC file not found" in str(exc_info.value)
+
+    def test_create_cdg_package_missing_audio_file(self):
+        """Test that missing audio file raises FileNotFoundError."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            lrc_file = os.path.join(tmpdir, "test.lrc")
+            with open(lrc_file, "w") as f:
+                f.write("[00:00.00]Test lyrics")
+
+            service = PackagingService()
+
+            with pytest.raises(FileNotFoundError) as exc_info:
+                service.create_cdg_package(
+                    lrc_file=lrc_file,
+                    audio_file="/nonexistent/audio.flac",
+                    output_zip_path="/output/test.zip",
+                    artist="Test Artist",
+                    title="Test Title",
+                )
+            assert "Audio file not found" in str(exc_info.value)
+
+    def test_create_cdg_package_no_styles_raises(self):
+        """Test that CDG generation without styles raises ValueError."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            lrc_file = os.path.join(tmpdir, "test.lrc")
+            audio_file = os.path.join(tmpdir, "test.flac")
+            zip_path = os.path.join(tmpdir, "output.zip")
+
+            with open(lrc_file, "w") as f:
+                f.write("[00:00.00]Test lyrics")
+            with open(audio_file, "w") as f:
+                f.write("fake audio")
+
+            # Service without CDG styles
+            service = PackagingService(cdg_styles=None)
+
+            with pytest.raises(ValueError) as exc_info:
+                service.create_cdg_package(
+                    lrc_file=lrc_file,
+                    audio_file=audio_file,
+                    output_zip_path=zip_path,
+                    artist="Test Artist",
+                    title="Test Title",
+                )
+            assert "CDG styles configuration is required" in str(exc_info.value)
+
+    def test_create_cdg_package_dry_run(self):
+        """Test CDG package creation in dry run mode."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            lrc_file = os.path.join(tmpdir, "test.lrc")
+            audio_file = os.path.join(tmpdir, "test.flac")
+            zip_path = os.path.join(tmpdir, "output.zip")
+
+            with open(lrc_file, "w") as f:
+                f.write("[00:00.00]Test lyrics")
+            with open(audio_file, "w") as f:
+                f.write("fake audio")
+
+            service = PackagingService(dry_run=True)
+
+            result = service.create_cdg_package(
+                lrc_file=lrc_file,
+                audio_file=audio_file,
+                output_zip_path=zip_path,
+                artist="Test Artist",
+                title="Test Title",
+            )
+
+            # In dry run, ZIP should not be created
+            assert not os.path.isfile(zip_path)
+            assert result[0] == zip_path
+
+    def test_create_cdg_package_existing_files(self):
+        """Test CDG package creation with existing MP3 and CDG files."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            lrc_file = os.path.join(tmpdir, "test.lrc")
+            audio_file = os.path.join(tmpdir, "test.flac")
+            mp3_file = os.path.join(tmpdir, "test.mp3")
+            cdg_file = os.path.join(tmpdir, "test.cdg")
+            zip_path = os.path.join(tmpdir, "output.zip")
+
+            # Create all files
+            with open(lrc_file, "w") as f:
+                f.write("[00:00.00]Test lyrics")
+            with open(audio_file, "w") as f:
+                f.write("fake audio")
+            with open(mp3_file, "w") as f:
+                f.write("fake mp3")
+            with open(cdg_file, "w") as f:
+                f.write("fake cdg")
+
+            service = PackagingService()
+
+            result = service.create_cdg_package(
+                lrc_file=lrc_file,
+                audio_file=audio_file,
+                output_zip_path=zip_path,
+                artist="Test Artist",
+                title="Test Title",
+                output_mp3_path=mp3_file,
+                output_cdg_path=cdg_file,
+            )
+
+            # ZIP should be created from existing files
+            assert os.path.isfile(zip_path)
+            assert result[0] == zip_path
+            assert result[1] == mp3_file
+            assert result[2] == cdg_file
+
+    @patch("lyrics_transcriber.output.cdg.CDGGenerator")
+    def test_create_cdg_package_with_generator(self, mock_cdg_generator_class):
+        """Test CDG package creation using CDGGenerator."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            lrc_file = os.path.join(tmpdir, "test.lrc")
+            audio_file = os.path.join(tmpdir, "test.flac")
+            zip_path = os.path.join(tmpdir, "output.zip")
+            generated_zip = os.path.join(tmpdir, "generated.zip")
+
+            with open(lrc_file, "w") as f:
+                f.write("[00:00.00]Test lyrics")
+            with open(audio_file, "w") as f:
+                f.write("fake audio")
+
+            # Create the zip file that would be generated
+            with zipfile.ZipFile(generated_zip, "w") as zf:
+                zf.writestr("test.mp3", "fake mp3")
+                zf.writestr("test.cdg", "fake cdg")
+
+            mock_generator = MagicMock()
+            mock_generator.generate_cdg_from_lrc.return_value = (
+                "test.cdg", "test.mp3", generated_zip
+            )
+            mock_cdg_generator_class.return_value = mock_generator
+
+            styles = {"font_size": 24}
+            service = PackagingService(cdg_styles=styles)
+
+            result = service.create_cdg_package(
+                lrc_file=lrc_file,
+                audio_file=audio_file,
+                output_zip_path=zip_path,
+                artist="Test Artist",
+                title="Test Title",
+            )
+
+            mock_generator.generate_cdg_from_lrc.assert_called_once_with(
+                lrc_file=lrc_file,
+                audio_file=audio_file,
+                title="Test Title",
+                artist="Test Artist",
+                cdg_styles=styles,
+            )
+            assert os.path.isfile(zip_path)
+
+
+class TestPackagingServiceTXTPackage:
+    """Test TXT package creation."""
+
+    def test_create_txt_package_missing_lrc_file(self):
+        """Test that missing LRC file raises FileNotFoundError."""
+        service = PackagingService()
+
+        with pytest.raises(FileNotFoundError) as exc_info:
+            service.create_txt_package(
+                lrc_file="/nonexistent/file.lrc",
+                mp3_file="/some/audio.mp3",
+                output_zip_path="/output/test.zip",
+            )
+        assert "LRC file not found" in str(exc_info.value)
+
+    def test_create_txt_package_missing_mp3_file(self):
+        """Test that missing MP3 file raises FileNotFoundError."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            lrc_file = os.path.join(tmpdir, "test.lrc")
+            with open(lrc_file, "w") as f:
+                f.write("[00:00.00]Test lyrics")
+
+            service = PackagingService()
+
+            with pytest.raises(FileNotFoundError) as exc_info:
+                service.create_txt_package(
+                    lrc_file=lrc_file,
+                    mp3_file="/nonexistent/audio.mp3",
+                    output_zip_path="/output/test.zip",
+                )
+            assert "MP3 file not found" in str(exc_info.value)
+
+    def test_create_txt_package_dry_run(self):
+        """Test TXT package creation in dry run mode."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            lrc_file = os.path.join(tmpdir, "test.lrc")
+            mp3_file = os.path.join(tmpdir, "test.mp3")
+            zip_path = os.path.join(tmpdir, "output.zip")
+
+            with open(lrc_file, "w") as f:
+                f.write("[00:00.00]Test lyrics")
+            with open(mp3_file, "w") as f:
+                f.write("fake mp3")
+
+            service = PackagingService(dry_run=True)
+
+            result = service.create_txt_package(
+                lrc_file=lrc_file,
+                mp3_file=mp3_file,
+                output_zip_path=zip_path,
+            )
+
+            # In dry run, ZIP should not be created
+            assert not os.path.isfile(zip_path)
+            assert result[0] == zip_path
+
+    @patch("lyrics_converter.LyricsConverter")
+    def test_create_txt_package_success(self, mock_converter_class):
+        """Test successful TXT package creation."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            lrc_file = os.path.join(tmpdir, "test.lrc")
+            mp3_file = os.path.join(tmpdir, "test.mp3")
+            zip_path = os.path.join(tmpdir, "output.zip")
+            txt_path = os.path.join(tmpdir, "output.txt")
+
+            with open(lrc_file, "w") as f:
+                f.write("[00:00.00]Test lyrics")
+            with open(mp3_file, "w") as f:
+                f.write("fake mp3")
+
+            mock_converter = MagicMock()
+            mock_converter.convert_file.return_value = "Converted lyrics text"
+            mock_converter_class.return_value = mock_converter
+
+            service = PackagingService()
+
+            result = service.create_txt_package(
+                lrc_file=lrc_file,
+                mp3_file=mp3_file,
+                output_zip_path=zip_path,
+                output_txt_path=txt_path,
+            )
+
+            mock_converter_class.assert_called_once_with(
+                output_format="txt",
+                filepath=lrc_file
+            )
+            mock_converter.convert_file.assert_called_once()
+
+            assert os.path.isfile(zip_path)
+            assert os.path.isfile(txt_path)
+            assert result[0] == zip_path
+            assert result[1] == txt_path
+
+            # Verify ZIP contents
+            with zipfile.ZipFile(zip_path, "r") as zf:
+                names = zf.namelist()
+                assert "test.mp3" in names
+                assert "output.txt" in names
+
+
+class TestGetPackagingService:
+    """Test factory function."""
+
+    def test_get_service_creates_instance(self):
+        """Test that factory function creates a new instance."""
+        import backend.services.packaging_service as module
+        module._packaging_service = None
+
+        service = get_packaging_service()
+
+        assert service is not None
+        assert isinstance(service, PackagingService)
+
+    def test_get_service_with_cdg_styles(self):
+        """Test factory function with CDG styles."""
+        import backend.services.packaging_service as module
+        module._packaging_service = None
+
+        styles = {"font_size": 24}
+        service = get_packaging_service(cdg_styles=styles)
+
+        assert service.cdg_styles == styles
+
+    def test_get_service_with_options(self):
+        """Test factory function with additional options."""
+        import backend.services.packaging_service as module
+        module._packaging_service = None
+
+        service = get_packaging_service(dry_run=True, non_interactive=True)
+
+        assert service.dry_run is True
+        assert service.non_interactive is True

backend/tests/test_requests.py

@@ -0,0 +1,201 @@
+"""
+Unit tests for request models.
+
+These tests validate Pydantic request model validation and serialization.
+"""
+import pytest
+from pydantic import ValidationError
+
+from backend.models.requests import (
+    URLSubmissionRequest,
+    UploadSubmissionRequest,
+    CorrectionsSubmission,
+    InstrumentalSelection,
+    StartReviewRequest,
+    CancelJobRequest,
+    RetryJobRequest
+)
+
+
+class TestURLSubmissionRequest:
+    """Tests for URLSubmissionRequest model."""
+    
+    def test_valid_youtube_url(self):
+        """Test valid YouTube URL is accepted."""
+        request = URLSubmissionRequest(url="https://youtube.com/watch?v=test123")
+        assert str(request.url) == "https://youtube.com/watch?v=test123"
+    
+    def test_valid_youtube_short_url(self):
+        """Test valid YouTube short URL is accepted."""
+        request = URLSubmissionRequest(url="https://youtu.be/test123")
+        assert str(request.url) == "https://youtu.be/test123"
+    
+    def test_optional_artist_title(self):
+        """Test artist and title are optional."""
+        request = URLSubmissionRequest(url="https://youtube.com/watch?v=test")
+        assert request.artist is None
+        assert request.title is None
+    
+    def test_with_artist_title(self):
+        """Test request with artist and title."""
+        request = URLSubmissionRequest(
+            url="https://youtube.com/watch?v=test",
+            artist="Test Artist",
+            title="Test Song"
+        )
+        assert request.artist == "Test Artist"
+        assert request.title == "Test Song"
+    
+    def test_url_required(self):
+        """Test URL is required."""
+        with pytest.raises(ValidationError):
+            URLSubmissionRequest()
+    
+    def test_empty_url_rejected(self):
+        """Test empty URL is rejected."""
+        with pytest.raises(ValidationError):
+            URLSubmissionRequest(url="")
+
+
+class TestCorrectionsSubmission:
+    """Tests for CorrectionsSubmission model."""
+    
+    def test_valid_corrections(self):
+        """Test valid corrections submission."""
+        corrections = CorrectionsSubmission(
+            corrections={
+                "lines": [
+                    {"text": "Hello world", "start": 0.0, "end": 1.0}
+                ],
+                "metadata": {"source": "test"}
+            }
+        )
+        assert "lines" in corrections.corrections
+        assert "metadata" in corrections.corrections
+    
+    def test_missing_lines_rejected(self):
+        """Test corrections without 'lines' field is rejected."""
+        with pytest.raises(ValidationError):
+            CorrectionsSubmission(corrections={"metadata": {}})
+    
+    def test_missing_metadata_rejected(self):
+        """Test corrections without 'metadata' field is rejected."""
+        with pytest.raises(ValidationError):
+            CorrectionsSubmission(corrections={"lines": []})
+    
+    def test_corrections_required(self):
+        """Test corrections field is required."""
+        with pytest.raises(ValidationError):
+            CorrectionsSubmission()
+    
+    def test_with_user_notes(self):
+        """Test corrections with user notes."""
+        corrections = CorrectionsSubmission(
+            corrections={"lines": [], "metadata": {}},
+            user_notes="Fixed typo in line 3"
+        )
+        assert corrections.user_notes == "Fixed typo in line 3"
+
+
+class TestInstrumentalSelection:
+    """Tests for InstrumentalSelection model."""
+    
+    def test_valid_clean_selection(self):
+        """Test selecting clean instrumental."""
+        selection = InstrumentalSelection(selection="clean")
+        assert selection.selection == "clean"
+    
+    def test_valid_with_backing_selection(self):
+        """Test selecting instrumental with backing vocals."""
+        selection = InstrumentalSelection(selection="with_backing")
+        assert selection.selection == "with_backing"
+    
+    def test_selection_required(self):
+        """Test selection is required."""
+        with pytest.raises(ValidationError):
+            InstrumentalSelection()
+    
+    def test_invalid_selection_rejected(self):
+        """Test invalid selection values are rejected."""
+        with pytest.raises(ValidationError):
+            InstrumentalSelection(selection="invalid_option")
+
+
+class TestUploadSubmissionRequest:
+    """Tests for UploadSubmissionRequest model."""
+    
+    def test_valid_upload_request(self):
+        """Test valid upload submission."""
+        request = UploadSubmissionRequest(
+            artist="Test Artist",
+            title="Test Song"
+        )
+        assert request.artist == "Test Artist"
+        assert request.title == "Test Song"
+    
+    def test_artist_required(self):
+        """Test artist is required."""
+        with pytest.raises(ValidationError):
+            UploadSubmissionRequest(title="Test Song")
+    
+    def test_title_required(self):
+        """Test title is required."""
+        with pytest.raises(ValidationError):
+            UploadSubmissionRequest(artist="Test Artist")
+    
+    def test_default_options(self):
+        """Test default option values."""
+        request = UploadSubmissionRequest(artist="Test", title="Test")
+        # CDG/TXT disabled by default (requires style config)
+        assert request.enable_cdg is False
+        assert request.enable_txt is False
+        # YouTube upload default is None (use server default)
+        assert request.enable_youtube_upload is None
+
+
+class TestStartReviewRequest:
+    """Tests for StartReviewRequest model."""
+    
+    def test_valid_request(self):
+        """Test valid start review request."""
+        request = StartReviewRequest()
+        assert request is not None
+
+
+class TestCancelJobRequest:
+    """Tests for CancelJobRequest model."""
+    
+    def test_valid_request(self):
+        """Test valid cancel request."""
+        request = CancelJobRequest()
+        assert request is not None
+    
+    def test_with_reason(self):
+        """Test cancel with reason."""
+        request = CancelJobRequest(reason="User requested")
+        assert request.reason == "User requested"
+    
+    def test_reason_optional(self):
+        """Test reason is optional."""
+        request = CancelJobRequest()
+        assert request.reason is None
+
+
+class TestRetryJobRequest:
+    """Tests for RetryJobRequest model."""
+    
+    def test_valid_request(self):
+        """Test valid retry request."""
+        request = RetryJobRequest()
+        assert request is not None
+    
+    def test_with_from_stage(self):
+        """Test retry from specific stage."""
+        request = RetryJobRequest(from_stage="transcription")
+        assert request.from_stage == "transcription"
+    
+    def test_from_stage_optional(self):
+        """Test from_stage is optional."""
+        request = RetryJobRequest()
+        assert request.from_stage is None
+