audiometa-python 0.6.0__py3-none-any.whl

audiometa/test/tests/e2e/cli/write/test_string_fields.py

@@ -0,0 +1,54 @@
+import subprocess
+import sys
+
+import pytest
+
+from audiometa import get_unified_metadata
+from audiometa.test.helpers.temp_file_with_metadata import temp_file_with_metadata
+from audiometa.utils.unified_metadata_key import UnifiedMetadataKey
+
+
+@pytest.mark.e2e
+class TestCLIWriteStringFields:
+    def test_cli_write_all_string_fields(self):
+        with temp_file_with_metadata({}, "mp3") as test_file:
+            result = subprocess.run(
+                [
+                    sys.executable,
+                    "-m",
+                    "audiometa",
+                    "write",
+                    str(test_file),
+                    "--title",
+                    "Test Title",
+                    "--language",
+                    "eng",
+                    "--publisher",
+                    "Test Publisher",
+                    "--copyright",
+                    "© 2024 Test",
+                    "--lyrics",
+                    "Test lyrics text",
+                    "--comment",
+                    "Test comment",
+                    "--replaygain",
+                    "+2.5 dB",
+                    "--archival-location",
+                    "Archive Location",
+                ],
+                capture_output=True,
+                text=True,
+                check=False,
+            )
+            assert result.returncode == 0
+
+            metadata = get_unified_metadata(test_file)
+            assert metadata.get(UnifiedMetadataKey.TITLE) == "Test Title"
+            assert metadata.get(UnifiedMetadataKey.LANGUAGE) == "eng"
+            assert metadata.get(UnifiedMetadataKey.PUBLISHER) == "Test Publisher"
+            assert metadata.get(UnifiedMetadataKey.COPYRIGHT) == "© 2024 Test"
+            assert metadata.get(UnifiedMetadataKey.UNSYNCHRONIZED_LYRICS) == "Test lyrics text"
+            assert metadata.get(UnifiedMetadataKey.COMMENT) == "Test comment"
+            assert metadata.get(UnifiedMetadataKey.REPLAYGAIN) == "+2.5 dB"
+            # ARCHIVAL_LOCATION is not supported by ID3v2 format (MP3)
+            # It's only supported by Vorbis (FLAC)

audiometa/test/tests/e2e/cli/write/test_validation.py

@@ -0,0 +1,85 @@
+import subprocess
+import sys
+
+import pytest
+
+from audiometa.test.helpers.temp_file_with_metadata import temp_file_with_metadata
+
+
+@pytest.mark.e2e
+class TestCLIWriteValidation:
+    def test_cli_write_negative_disc_number_error(self):
+        with temp_file_with_metadata({}, "mp3") as test_file:
+            result = subprocess.run(
+                [
+                    sys.executable,
+                    "-m",
+                    "audiometa",
+                    "write",
+                    str(test_file),
+                    "--disc-number",
+                    "-1",
+                ],
+                capture_output=True,
+                text=True,
+                check=False,
+            )
+            assert result.returncode != 0
+            assert "cannot be negative" in result.stderr.lower()
+
+    def test_cli_write_negative_disc_total_error(self):
+        with temp_file_with_metadata({}, "mp3") as test_file:
+            result = subprocess.run(
+                [
+                    sys.executable,
+                    "-m",
+                    "audiometa",
+                    "write",
+                    str(test_file),
+                    "--disc-total",
+                    "-1",
+                ],
+                capture_output=True,
+                text=True,
+                check=False,
+            )
+            assert result.returncode != 0
+            assert "cannot be negative" in result.stderr.lower()
+
+    def test_cli_write_negative_bpm_error(self):
+        with temp_file_with_metadata({}, "mp3") as test_file:
+            result = subprocess.run(
+                [
+                    sys.executable,
+                    "-m",
+                    "audiometa",
+                    "write",
+                    str(test_file),
+                    "--bpm",
+                    "-1",
+                ],
+                capture_output=True,
+                text=True,
+                check=False,
+            )
+            assert result.returncode != 0
+            assert "cannot be negative" in result.stderr.lower()
+
+    def test_cli_write_negative_year_error(self):
+        with temp_file_with_metadata({}, "mp3") as test_file:
+            result = subprocess.run(
+                [
+                    sys.executable,
+                    "-m",
+                    "audiometa",
+                    "write",
+                    str(test_file),
+                    "--year",
+                    "-1",
+                ],
+                capture_output=True,
+                text=True,
+                check=False,
+            )
+            assert result.returncode != 0
+            assert "cannot be negative" in result.stderr.lower()

audiometa/test/tests/e2e/scenarios/test_user_scenarios.py

@@ -0,0 +1,166 @@
+"""End-to-end tests for real user scenarios using external scripts.
+
+This refactored version uses external scripts to set up test data instead of the app's update functions, preventing
+circular dependencies.
+
+These tests simulate how actual users would interact with the library in real-world applications.
+"""
+
+import pytest
+
+from audiometa import delete_all_metadata, get_unified_metadata, update_metadata
+from audiometa.test.helpers.temp_file_with_metadata import temp_file_with_metadata
+from audiometa.utils.unified_metadata_key import UnifiedMetadataKey
+
+
+@pytest.mark.e2e
+class TestUserScenarios:
+    def test_music_library_organization(self, sample_mp3_file, sample_flac_file, sample_wav_file):
+        # Simulate a user organizing their music library
+
+        sample_files = [(sample_mp3_file, "mp3"), (sample_flac_file, "flac"), (sample_wav_file, "wav")]
+
+        for i, (_file_path, format_type) in enumerate(sample_files[:3]):  # Test with first 3 files
+            # Set basic metadata using external script
+            basic_metadata = {"title": f"Original Track {i + 1}", "artist": "Original Artist"}
+            with temp_file_with_metadata(basic_metadata, format_type) as test_file:
+                # Set consistent metadata for organization using app's function (this is what we're testing)
+                test_metadata = {
+                    UnifiedMetadataKey.ALBUM: "My Music Library",
+                    UnifiedMetadataKey.TITLE: f"Track {i + 1}",
+                }
+                update_metadata(test_file, test_metadata)
+
+                # Verify the organization worked
+                metadata = get_unified_metadata(test_file)
+                assert metadata.get(UnifiedMetadataKey.ALBUM) == "My Music Library"
+                assert metadata.get(UnifiedMetadataKey.TITLE) == f"Track {i + 1}"
+
+    def test_metadata_import_export_workflow(self):
+        # Simulate a user importing metadata from external source
+        # Use external script to set initial metadata
+        initial_metadata = {"title": "Original Title", "artist": "Original Artist", "album": "Original Album"}
+        with temp_file_with_metadata(initial_metadata, "mp3") as test_file:
+            # Export current metadata
+            current_metadata = get_unified_metadata(test_file)
+            metadata = {
+                "title": current_metadata.get(UnifiedMetadataKey.TITLE),
+                "artist": current_metadata.get(UnifiedMetadataKey.ARTISTS),
+                "album": current_metadata.get(UnifiedMetadataKey.ALBUM),
+            }
+
+            # Simulate external metadata update
+            metadata["title"] = "Updated Title"
+            metadata["artist"] = ["Updated Artist"]
+
+            # Apply updated metadata using app's function (this is what we're testing)
+            test_metadata = {
+                UnifiedMetadataKey.TITLE: metadata["title"],
+                UnifiedMetadataKey.ARTISTS: metadata["artist"],
+                UnifiedMetadataKey.ALBUM: metadata["album"],
+            }
+            update_metadata(test_file, test_metadata)
+
+            # Verify the import worked
+            updated_metadata = get_unified_metadata(test_file)
+            assert updated_metadata.get(UnifiedMetadataKey.TITLE) == "Updated Title"
+            assert updated_metadata.get(UnifiedMetadataKey.ARTISTS) == ["Updated Artist"]
+
+    def test_metadata_privacy_cleanup_workflow(self):
+        # Simulate a user cleaning up metadata for privacy before sharing files
+        initial_metadata = {
+            "title": "Personal Music Track",
+            "artist": "Personal Artist",
+            "album": "Personal Album",
+            "comment": "Personal comment with sensitive info",
+        }
+
+        with temp_file_with_metadata(initial_metadata, "mp3") as test_file:
+            # 1. Verify initial metadata exists
+            initial_metadata_result = get_unified_metadata(test_file)
+            assert initial_metadata_result.get(UnifiedMetadataKey.TITLE) == "Personal Music Track"
+            assert initial_metadata_result.get(UnifiedMetadataKey.COMMENT) == "Personal comment with sensitive info"
+
+            # 2. User decides to clean up sensitive metadata
+            cleanup_metadata = {
+                UnifiedMetadataKey.COMMENT: None,  # Remove personal comment
+                UnifiedMetadataKey.ALBUM: "Generic Album",  # Replace personal album
+            }
+            update_metadata(test_file, cleanup_metadata)
+
+            # 3. Verify sensitive data was removed
+            cleaned_metadata = get_unified_metadata(test_file)
+            assert cleaned_metadata.get(UnifiedMetadataKey.COMMENT) is None
+            assert cleaned_metadata.get(UnifiedMetadataKey.ALBUM) == "Generic Album"
+            assert cleaned_metadata.get(UnifiedMetadataKey.TITLE) == "Personal Music Track"  # Title remains
+
+            # 4. User decides to remove all metadata for complete privacy
+            delete_result = delete_all_metadata(test_file)
+            assert delete_result is True
+
+            # 5. Verify all metadata is removed
+            final_metadata = get_unified_metadata(test_file)
+            assert (
+                final_metadata.get(UnifiedMetadataKey.TITLE) is None
+                or final_metadata.get(UnifiedMetadataKey.TITLE) != "Personal Music Track"
+            )
+            assert final_metadata.get(UnifiedMetadataKey.COMMENT) is None
+
+    def test_metadata_correction_workflow(self):
+        # Simulate a user correcting incorrect metadata
+        initial_metadata = {"title": "Wrong Title", "artist": "Wrong Artist", "album": "Wrong Album"}
+
+        with temp_file_with_metadata(initial_metadata, "mp3") as test_file:
+            # 1. Verify initial incorrect metadata
+            initial_metadata_result = get_unified_metadata(test_file)
+            assert initial_metadata_result.get(UnifiedMetadataKey.TITLE) == "Wrong Title"
+
+            # 2. User realizes the metadata is wrong and wants to start fresh
+            # Delete all metadata first
+            delete_result = delete_all_metadata(test_file)
+            assert delete_result is True
+
+            # 3. Verify metadata was deleted
+            deleted_metadata = get_unified_metadata(test_file)
+            assert (
+                deleted_metadata.get(UnifiedMetadataKey.TITLE) is None
+                or deleted_metadata.get(UnifiedMetadataKey.TITLE) != "Wrong Title"
+            )
+
+            # 4. Add correct metadata
+            correct_metadata = {
+                UnifiedMetadataKey.TITLE: "Correct Title",
+                UnifiedMetadataKey.ARTISTS: ["Correct Artist"],
+                UnifiedMetadataKey.ALBUM: "Correct Album",
+            }
+            update_metadata(test_file, correct_metadata)
+
+            # 5. Verify correct metadata was added
+            final_metadata = get_unified_metadata(test_file)
+            assert final_metadata.get(UnifiedMetadataKey.TITLE) == "Correct Title"
+            assert final_metadata.get(UnifiedMetadataKey.ARTISTS) == ["Correct Artist"]
+            assert final_metadata.get(UnifiedMetadataKey.ALBUM) == "Correct Album"
+
+    def test_cross_format_compatibility(self, sample_mp3_file, sample_flac_file, sample_wav_file):
+        # Test that metadata works consistently across MP3, FLAC, etc.
+
+        test_metadata = {
+            UnifiedMetadataKey.TITLE: "Cross Format Test",
+            UnifiedMetadataKey.ARTISTS: ["Test Artist"],
+            UnifiedMetadataKey.ALBUM: "Test Album",
+        }
+
+        sample_files = [(sample_mp3_file, "mp3"), (sample_flac_file, "flac"), (sample_wav_file, "wav")]
+
+        for _file_path, format_type in sample_files:
+            # Set basic metadata using external script
+            basic_metadata = {"title": "Original Title", "artist": "Original Artist"}
+            with temp_file_with_metadata(basic_metadata, format_type) as test_file:
+                # Set metadata using app's function (this is what we're testing)
+                update_metadata(test_file, test_metadata)
+
+                # Verify metadata was set correctly
+                metadata = get_unified_metadata(test_file)
+                assert metadata.get(UnifiedMetadataKey.TITLE) == test_metadata[UnifiedMetadataKey.TITLE]
+                assert metadata.get(UnifiedMetadataKey.ARTISTS) == test_metadata[UnifiedMetadataKey.ARTISTS]
+                assert metadata.get(UnifiedMetadataKey.ALBUM) == test_metadata[UnifiedMetadataKey.ALBUM]

audiometa/test/tests/e2e/workflows/test_core_workflows.py

@@ -0,0 +1,166 @@
+"""End-to-end tests for core metadata editing workflows.
+
+These tests verify the basic functionality of the entire system for real users, including file I/O and complete metadata
+editing workflows.
+"""
+
+from pathlib import Path
+
+import pytest
+
+from audiometa import (
+    _AudioFile,
+    delete_all_metadata,
+    get_bitrate,
+    get_duration_in_sec,
+    get_unified_metadata,
+    update_metadata,
+)
+from audiometa.test.helpers.temp_file_with_metadata import temp_file_with_metadata
+from audiometa.utils.unified_metadata_key import UnifiedMetadataKey
+
+
+@pytest.mark.e2e
+class TestCoreWorkflows:
+    def test_complete_metadata_editing_workflow(self):
+        # This is an e2e test - it tests the entire user journey
+        # 1. Load a file
+        # 2. Read existing metadata
+        # 3. Edit multiple fields
+        # 4. Save changes
+        # 5. Verify persistence
+
+        # Use external script to set initial metadata
+        initial_metadata = {"title": "Original Title", "artist": "Original Artist", "album": "Original Album"}
+
+        with temp_file_with_metadata(initial_metadata, "mp3") as test_file:
+            # Edit metadata using app's function (this is what we're testing)
+            test_metadata = {
+                UnifiedMetadataKey.TITLE: "New Title",
+                UnifiedMetadataKey.ARTISTS: ["New Artist"],
+                UnifiedMetadataKey.ALBUM: "New Album",
+                UnifiedMetadataKey.GENRES_NAMES: ["Rock"],
+                UnifiedMetadataKey.COMMENT: "Test comment",
+            }
+
+            # Save changes
+            update_metadata(test_file, test_metadata)
+
+            # Verify persistence by reloading
+            metadata = get_unified_metadata(test_file)
+            assert metadata.get(UnifiedMetadataKey.TITLE) == "New Title"
+            assert metadata.get(UnifiedMetadataKey.ARTISTS) == ["New Artist"]
+            assert metadata.get(UnifiedMetadataKey.ALBUM) == "New Album"
+            assert metadata.get(UnifiedMetadataKey.GENRES_NAMES) == ["Rock"]
+            assert metadata.get(UnifiedMetadataKey.COMMENT) == "Test comment"
+
+    def test_batch_metadata_processing(self, sample_mp3_file, sample_flac_file, sample_wav_file):
+        # E2E test for batch operations
+        results = []
+
+        sample_files = [(sample_mp3_file, "mp3"), (sample_flac_file, "flac"), (sample_wav_file, "wav")]
+
+        for file_path, format_type in sample_files:
+            try:
+                # Set initial metadata using external script
+                initial_metadata = {"title": "Batch Test Title", "artist": "Batch Test Artist"}
+                with temp_file_with_metadata(initial_metadata, format_type) as test_file:
+                    # Update metadata using functional API (this is what we're testing)
+                    test_metadata = {
+                        UnifiedMetadataKey.ALBUM: "Batch Album",
+                        UnifiedMetadataKey.COMMENT: "Batch processing test",
+                    }
+                    update_metadata(test_file, test_metadata)
+                    results.append(("success", file_path))
+            except Exception as e:
+                results.append(("error", file_path, str(e)))
+
+        # Verify all files were processed
+        assert len(results) == len(sample_files)
+        success_count = sum(1 for result in results if result[0] == "success")
+        assert success_count > 0
+
+    def test_audio_file_context_manager(self, sample_mp3_file: Path):
+        with _AudioFile(sample_mp3_file) as audio_file:
+            # Test that we can read metadata within context using file path
+            metadata = get_unified_metadata(audio_file.file_path)
+            assert isinstance(metadata, dict)
+
+            # Test that we can get technical info within context using file path
+            bitrate = get_bitrate(audio_file.file_path)
+            duration = get_duration_in_sec(audio_file.file_path)
+            assert isinstance(bitrate, int)
+            assert isinstance(duration, float)
+
+    def test_cross_format_deletion_workflow(self, sample_mp3_file, sample_flac_file, sample_wav_file):
+        # E2E test for deletion across multiple formats
+        test_metadata = {
+            UnifiedMetadataKey.TITLE: "Cross Format Deletion",
+            UnifiedMetadataKey.ARTISTS: ["Cross Format Artist"],
+            UnifiedMetadataKey.ALBUM: "Cross Format Album",
+        }
+
+        sample_files = [(sample_mp3_file, "mp3"), (sample_flac_file, "flac"), (sample_wav_file, "wav")]
+
+        for _file_path, format_type in sample_files:
+            # Set up metadata using external script
+            initial_metadata = {"title": "Original Title", "artist": "Original Artist"}
+            with temp_file_with_metadata(initial_metadata, format_type) as test_file:
+                # Add metadata using app's function
+                update_metadata(test_file, test_metadata)
+
+                # Verify metadata was added
+                added_metadata = get_unified_metadata(test_file)
+                assert added_metadata.get(UnifiedMetadataKey.TITLE) == "Cross Format Deletion"
+
+                # Delete all metadata
+                delete_result = delete_all_metadata(test_file)
+                assert delete_result is True
+
+                # Verify metadata was deleted
+                deleted_metadata = get_unified_metadata(test_file)
+                assert (
+                    deleted_metadata.get(UnifiedMetadataKey.TITLE) is None
+                    or deleted_metadata.get(UnifiedMetadataKey.TITLE) != "Cross Format Deletion"
+                )
+
+    def test_metadata_cleanup_workflow(self):
+        # E2E test for complete metadata cleanup workflow
+        initial_metadata = {
+            "title": "Cleanup Test Title",
+            "artist": "Cleanup Test Artist",
+            "album": "Cleanup Test Album",
+            "year": "2023",
+            "genre": "Electronic",
+        }
+
+        with temp_file_with_metadata(initial_metadata, "mp3") as test_file:
+            # 1. Verify initial metadata exists
+            initial_metadata_result = get_unified_metadata(test_file)
+            assert initial_metadata_result.get(UnifiedMetadataKey.TITLE) == "Cleanup Test Title"
+
+            # 2. Add more metadata
+            additional_metadata = {
+                UnifiedMetadataKey.RATING: 80,
+                UnifiedMetadataKey.BPM: 128,
+                UnifiedMetadataKey.COMMENT: "Cleanup test comment",
+            }
+            update_metadata(test_file, additional_metadata, normalized_rating_max_value=100)
+
+            # 3. Verify all metadata exists
+            full_metadata = get_unified_metadata(test_file, normalized_rating_max_value=100)
+            assert full_metadata.get(UnifiedMetadataKey.RATING) == 80
+            assert full_metadata.get(UnifiedMetadataKey.BPM) == 128
+
+            # 4. Complete cleanup - delete all metadata
+            delete_result = delete_all_metadata(test_file)
+            assert delete_result is True
+
+            # 5. Verify complete cleanup
+            cleaned_metadata = get_unified_metadata(test_file)
+            assert (
+                cleaned_metadata.get(UnifiedMetadataKey.TITLE) is None
+                or cleaned_metadata.get(UnifiedMetadataKey.TITLE) != "Cleanup Test Title"
+            )
+            assert cleaned_metadata.get(UnifiedMetadataKey.RATING) is None
+            assert cleaned_metadata.get(UnifiedMetadataKey.BPM) is None