audiometa-python 0.2.2__py3-none-any.whl

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

@@ -0,0 +1,318 @@
+"""End-to-end tests for metadata deletion workflows.
+
+These tests verify complete deletion workflows that real users would perform, including full metadata deletion, partial
+deletion, and cross-format deletion.
+"""
+
+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.metadata_format import MetadataFormat
+from audiometa.utils.unified_metadata_key import UnifiedMetadataKey
+
+
+@pytest.mark.e2e
+class TestDeletionWorkflows:
+    def test_complete_metadata_deletion_workflow_mp3(self):
+        # Complete e2e deletion workflow for MP3
+        initial_metadata = {
+            "title": "Original Title",
+            "artist": "Original Artist",
+            "album": "Original Album",
+            "year": "2023",
+            "genre": "Rock",
+            "comment": "Original comment",
+        }
+
+        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) == "Original Title"
+            assert initial_metadata_result.get(UnifiedMetadataKey.ARTISTS) == ["Original Artist"]
+            assert initial_metadata_result.get(UnifiedMetadataKey.ALBUM) == "Original Album"
+
+            # 2. Add more metadata using app's function
+            additional_metadata = {
+                UnifiedMetadataKey.RATING: 80,
+                UnifiedMetadataKey.BPM: 120,
+                UnifiedMetadataKey.COMMENT: "Updated comment",
+            }
+            update_metadata(test_file, additional_metadata, normalized_rating_max_value=100)
+
+            # 3. Verify metadata was added
+            updated_metadata = get_unified_metadata(test_file, normalized_rating_max_value=100)
+            assert updated_metadata.get(UnifiedMetadataKey.RATING) == 80
+            assert updated_metadata.get(UnifiedMetadataKey.BPM) == 120
+
+            # 4. Delete all metadata
+            delete_result = delete_all_metadata(test_file)
+            assert delete_result is True
+
+            # 5. Verify all metadata was deleted
+            deleted_metadata = get_unified_metadata(test_file)
+            assert (
+                deleted_metadata.get(UnifiedMetadataKey.TITLE) is None
+                or deleted_metadata.get(UnifiedMetadataKey.TITLE) != "Original Title"
+            )
+            assert deleted_metadata.get(UnifiedMetadataKey.ARTISTS) is None or deleted_metadata.get(
+                UnifiedMetadataKey.ARTISTS
+            ) != ["Original Artist"]
+            assert (
+                deleted_metadata.get(UnifiedMetadataKey.ALBUM) is None
+                or deleted_metadata.get(UnifiedMetadataKey.ALBUM) != "Original Album"
+            )
+            assert deleted_metadata.get(UnifiedMetadataKey.RATING) is None
+            assert deleted_metadata.get(UnifiedMetadataKey.BPM) is None
+
+    def test_complete_metadata_deletion_workflow_flac(self):
+        # Complete e2e deletion workflow for FLAC
+        initial_metadata = {
+            "title": "FLAC Original Title",
+            "artist": "FLAC Original Artist",
+            "album": "FLAC Original Album",
+        }
+
+        with temp_file_with_metadata(initial_metadata, "flac") as test_file:
+            # 1. Verify initial metadata exists
+            initial_metadata_result = get_unified_metadata(test_file)
+            assert initial_metadata_result.get(UnifiedMetadataKey.TITLE) == "FLAC Original Title"
+
+            # 2. Add more metadata
+            additional_metadata = {
+                UnifiedMetadataKey.RATING: 90,
+                UnifiedMetadataKey.BPM: 140,
+                UnifiedMetadataKey.COMMENT: "FLAC comment",
+            }
+            update_metadata(test_file, additional_metadata, normalized_rating_max_value=100)
+
+            # 3. Delete all metadata
+            delete_result = delete_all_metadata(test_file)
+            assert delete_result is True
+
+            # 4. Verify all metadata was deleted
+            deleted_metadata = get_unified_metadata(test_file)
+            assert (
+                deleted_metadata.get(UnifiedMetadataKey.TITLE) is None
+                or deleted_metadata.get(UnifiedMetadataKey.TITLE) != "FLAC Original Title"
+            )
+            assert deleted_metadata.get(UnifiedMetadataKey.RATING) is None
+
+    def test_complete_metadata_deletion_workflow_wav(self):
+        # Complete e2e deletion workflow for WAV
+        initial_metadata = {
+            "title": "WAV Original Title",
+            "artist": "WAV Original Artist",
+            "album": "WAV Original Album",
+        }
+
+        with temp_file_with_metadata(initial_metadata, "wav") as test_file:
+            # 1. Verify initial metadata exists
+            initial_metadata_result = get_unified_metadata(test_file)
+            assert initial_metadata_result.get(UnifiedMetadataKey.TITLE) == "WAV Original Title"
+
+            # 2. Add more metadata (WAV doesn't support rating/BPM)
+            additional_metadata = {UnifiedMetadataKey.COMMENT: "WAV comment"}
+            update_metadata(test_file, additional_metadata)
+
+            # 3. Delete all metadata
+            delete_result = delete_all_metadata(test_file)
+            assert delete_result is True
+
+            # 4. Verify all metadata was deleted
+            deleted_metadata = get_unified_metadata(test_file)
+            assert (
+                deleted_metadata.get(UnifiedMetadataKey.TITLE) is None
+                or deleted_metadata.get(UnifiedMetadataKey.TITLE) != "WAV Original Title"
+            )
+
+    def test_partial_metadata_deletion_workflow(self):
+        # E2e test for deleting specific metadata fields
+        initial_metadata = {
+            "title": "Partial Deletion Title",
+            "artist": "Partial Deletion Artist",
+            "album": "Partial Deletion Album",
+            "year": "2023",
+            "genre": "Jazz",
+        }
+
+        with temp_file_with_metadata(initial_metadata, "mp3") as test_file:
+            # 1. Verify initial metadata
+            initial_metadata_result = get_unified_metadata(test_file)
+            assert initial_metadata_result.get(UnifiedMetadataKey.TITLE) == "Partial Deletion Title"
+            assert initial_metadata_result.get(UnifiedMetadataKey.ARTISTS) == ["Partial Deletion Artist"]
+            assert initial_metadata_result.get(UnifiedMetadataKey.ALBUM) == "Partial Deletion Album"
+
+            # 2. Delete specific fields by setting them to None
+            deletion_metadata = {UnifiedMetadataKey.TITLE: None, UnifiedMetadataKey.ARTISTS: None}
+            update_metadata(test_file, deletion_metadata)
+
+            # 3. Verify specific fields were deleted while others remain
+            updated_metadata = get_unified_metadata(test_file)
+            assert updated_metadata.get(UnifiedMetadataKey.TITLE) is None
+            assert updated_metadata.get(UnifiedMetadataKey.ARTISTS) is None
+            assert updated_metadata.get(UnifiedMetadataKey.ALBUM) == "Partial Deletion Album"  # Should remain
+
+            # 4. Delete remaining metadata
+            remaining_deletion = {
+                UnifiedMetadataKey.ALBUM: None,
+                UnifiedMetadataKey.RELEASE_DATE: None,
+                UnifiedMetadataKey.GENRES_NAMES: None,
+            }
+            update_metadata(test_file, remaining_deletion)
+
+            # 5. Verify all metadata is now deleted
+            final_metadata = get_unified_metadata(test_file)
+            assert final_metadata.get(UnifiedMetadataKey.ALBUM) is None
+            assert final_metadata.get(UnifiedMetadataKey.RELEASE_DATE) is None
+            assert final_metadata.get(UnifiedMetadataKey.GENRES_NAMES) is None
+
+    def test_cross_format_deletion_consistency(self, sample_mp3_file, sample_flac_file, sample_wav_file):
+        # E2e test for deletion consistency across formats
+        test_metadata = {
+            UnifiedMetadataKey.TITLE: "Cross Format Deletion 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 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 Test"
+
+                # Delete all metadata
+                delete_result = delete_all_metadata(test_file)
+                assert delete_result is True
+
+                # Verify metadata was deleted consistently across formats
+                deleted_metadata = get_unified_metadata(test_file)
+                assert (
+                    deleted_metadata.get(UnifiedMetadataKey.TITLE) is None
+                    or deleted_metadata.get(UnifiedMetadataKey.TITLE) != "Cross Format Deletion Test"
+                )
+
+    def test_format_specific_deletion_workflow(self):
+        # E2e test for deleting specific metadata formats
+        initial_metadata = {"title": "Format Specific Deletion", "artist": "Format Specific Artist"}
+
+        with temp_file_with_metadata(initial_metadata, "mp3") as test_file:
+            # 1. Add metadata in different formats
+            id3v2_metadata = {UnifiedMetadataKey.TITLE: "ID3v2 Title", UnifiedMetadataKey.ARTISTS: ["ID3v2 Artist"]}
+            update_metadata(test_file, id3v2_metadata, metadata_format=MetadataFormat.ID3V2)
+
+            id3v1_metadata = {UnifiedMetadataKey.ALBUM: "ID3v1 Album"}
+            update_metadata(test_file, id3v1_metadata, metadata_format=MetadataFormat.ID3V1)
+
+            # 2. Verify both formats have metadata
+            combined_metadata = get_unified_metadata(test_file)
+            assert combined_metadata.get(UnifiedMetadataKey.TITLE) == "ID3v2 Title"
+            assert combined_metadata.get(UnifiedMetadataKey.ALBUM) == "ID3v1 Album"
+
+            # 3. Delete only ID3v2 metadata
+            id3v2_deletion = {UnifiedMetadataKey.TITLE: None, UnifiedMetadataKey.ARTISTS: None}
+            update_metadata(test_file, id3v2_deletion, metadata_format=MetadataFormat.ID3V2)
+
+            # 4. Verify ID3v2 metadata is deleted but ID3v1 remains
+            after_id3v2_deletion = get_unified_metadata(test_file)
+            assert (
+                after_id3v2_deletion.get(UnifiedMetadataKey.TITLE) is None
+                or after_id3v2_deletion.get(UnifiedMetadataKey.TITLE) != "ID3v2 Title"
+            )
+            assert after_id3v2_deletion.get(UnifiedMetadataKey.ALBUM) == "ID3v1 Album"  # Should remain
+
+            # 5. Delete ID3v1 metadata
+            id3v1_deletion = {UnifiedMetadataKey.ALBUM: None}
+            update_metadata(test_file, id3v1_deletion, metadata_format=MetadataFormat.ID3V1)
+
+            # 6. Verify all metadata is now deleted
+            final_metadata = get_unified_metadata(test_file)
+            assert final_metadata.get(UnifiedMetadataKey.ALBUM) is None
+
+    def test_deletion_error_handling_workflow(self):
+        # E2e test for deletion error scenarios
+        # Create a file with unsupported extension
+        with temp_file_with_metadata({}, "mp3") as temp_audio_file_path:
+            test_file = temp_audio_file_path.with_suffix(".txt")
+            test_file.write_bytes(b"fake audio content")
+
+            # All deletion operations should raise appropriate errors
+            from audiometa.exceptions import FileTypeNotSupportedError
+
+            with pytest.raises(FileTypeNotSupportedError):
+                delete_all_metadata(str(test_file))
+
+            with pytest.raises(FileTypeNotSupportedError):
+                update_metadata(str(test_file), {UnifiedMetadataKey.TITLE: None})
+
+    def test_deletion_with_rating_normalization_workflow(self):
+        # E2e test for deletion with rating normalization
+        initial_metadata = {"title": "Rating Deletion Test", "artist": "Rating Artist"}
+
+        with temp_file_with_metadata(initial_metadata, "mp3") as test_file:
+            # 1. Add rating with normalization
+            rating_metadata = {UnifiedMetadataKey.RATING: 80}
+            update_metadata(test_file, rating_metadata, normalized_rating_max_value=100)
+
+            # 2. Verify rating was added
+            metadata_with_rating = get_unified_metadata(test_file, normalized_rating_max_value=100)
+            assert metadata_with_rating.get(UnifiedMetadataKey.RATING) == 80
+
+            # 3. Delete rating
+            rating_deletion = {UnifiedMetadataKey.RATING: None}
+            update_metadata(test_file, rating_deletion, normalized_rating_max_value=100)
+
+            # 4. Verify rating was deleted
+            metadata_after_deletion = get_unified_metadata(test_file, normalized_rating_max_value=100)
+            assert metadata_after_deletion.get(UnifiedMetadataKey.RATING) is None
+
+    def test_batch_deletion_workflow(self, sample_mp3_file, sample_flac_file, sample_wav_file):
+        # E2e test for batch deletion operations
+        sample_files = [(sample_mp3_file, "mp3"), (sample_flac_file, "flac"), (sample_wav_file, "wav")]
+
+        results = []
+
+        for _file_path, format_type in sample_files:
+            try:
+                # Set up metadata using external script
+                initial_metadata = {"title": f"Batch Deletion Test {format_type.upper()}", "artist": "Batch Artist"}
+                with temp_file_with_metadata(initial_metadata, format_type) as test_file:
+                    # Add more metadata using app's function
+                    additional_metadata = {
+                        UnifiedMetadataKey.ALBUM: f"Batch Album {format_type.upper()}",
+                        UnifiedMetadataKey.COMMENT: f"Batch comment for {format_type}",
+                    }
+                    update_metadata(test_file, additional_metadata)
+
+                    # Verify metadata was added
+                    added_metadata = get_unified_metadata(test_file)
+                    assert added_metadata.get(UnifiedMetadataKey.TITLE) == f"Batch Deletion Test {format_type.upper()}"
+
+                    # Delete all metadata
+                    delete_result = delete_all_metadata(test_file)
+                    assert delete_result is True
+
+                    # Verify deletion worked
+                    deleted_metadata = get_unified_metadata(test_file)
+                    assert (
+                        deleted_metadata.get(UnifiedMetadataKey.TITLE) is None
+                        or deleted_metadata.get(UnifiedMetadataKey.TITLE)
+                        != f"Batch Deletion Test {format_type.upper()}"
+                    )
+
+                    results.append(("success", format_type))
+
+            except Exception as e:
+                results.append(("error", format_type, str(e)))
+
+        # Verify all files were processed successfully
+        assert len(results) == len(sample_files)
+        success_count = sum(1 for result in results if result[0] == "success")
+        assert success_count == len(sample_files)  # All should succeed

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

@@ -0,0 +1,165 @@
+"""End-to-end tests for error handling and recovery workflows.
+
+These tests verify that the system handles errors gracefully and recovers properly from various error conditions in
+real-world scenarios.
+"""
+
+import pytest
+
+from audiometa import delete_all_metadata, get_bitrate, get_duration_in_sec, get_unified_metadata, update_metadata
+from audiometa.exceptions import InvalidMetadataFieldFormatError, InvalidRatingValueError
+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 TestErrorHandlingWorkflows:
+    def test_error_recovery_workflow(self):
+        # E2E test for error scenarios and recovery
+        initial_metadata = {"title": "Original Title", "artist": "Original Artist"}
+        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) == "Original Title"
+
+            # 2. Test invalid rating operation - should raise InvalidRatingValueError
+            # Using normalized mode with invalid value (110 is over the max value and results in invalid star rating
+            # index > 10)
+            with pytest.raises(InvalidRatingValueError) as exc_info:
+                update_metadata(test_file, {UnifiedMetadataKey.RATING: 110}, normalized_rating_max_value=100)
+            assert "out of range" in str(exc_info.value) or "invalid star rating index" in str(exc_info.value)
+
+            # 3. Test recovery after error - verify the file is still usable
+            # The file should still have its original metadata intact
+            metadata_after_error = get_unified_metadata(test_file)
+            assert metadata_after_error.get(UnifiedMetadataKey.TITLE) == "Original Title"
+
+            # 4. Test successful operation after error - should work normally
+            recovery_metadata = {UnifiedMetadataKey.TITLE: "Recovery Test"}
+            update_metadata(test_file, recovery_metadata)
+
+            # 5. Verify recovery worked - file is fully functional
+            final_metadata = get_unified_metadata(test_file)
+            assert final_metadata.get(UnifiedMetadataKey.TITLE) == "Recovery Test"
+
+    def test_error_handling_workflow(self):
+        # Create a file with unsupported extension
+        with temp_file_with_metadata({}, "mp3") as temp_audio_file_path:
+            temp_audio_file_path.write_bytes(b"fake audio content")
+            test_file = temp_audio_file_path.with_suffix(".txt")
+            test_file.write_bytes(b"fake audio content")
+
+            # All operations should raise FileTypeNotSupportedError
+            from audiometa.exceptions import FileTypeNotSupportedError
+
+            with pytest.raises(FileTypeNotSupportedError):
+                get_unified_metadata(str(test_file))
+
+            with pytest.raises(FileTypeNotSupportedError):
+                update_metadata(str(test_file), {UnifiedMetadataKey.TITLE: "Test"})
+
+            with pytest.raises(FileTypeNotSupportedError):
+                delete_all_metadata(str(test_file))
+
+            with pytest.raises(FileTypeNotSupportedError):
+                get_bitrate(str(test_file))
+
+            with pytest.raises(FileTypeNotSupportedError):
+                get_duration_in_sec(str(test_file))
+
+    def test_deletion_error_recovery_workflow(self):
+        # E2E test for deletion error scenarios and recovery
+        initial_metadata = {"title": "Deletion Error Test", "artist": "Deletion Error Artist"}
+
+        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) == "Deletion Error Test"
+
+            # 2. Test deletion on file that doesn't exist
+            non_existent_file = test_file.parent / "non_existent.mp3"
+            with pytest.raises(FileNotFoundError):
+                delete_all_metadata(str(non_existent_file))
+
+            # 3. Test deletion on directory instead of file
+            from audiometa.exceptions import FileTypeNotSupportedError
+
+            with pytest.raises(FileTypeNotSupportedError):
+                delete_all_metadata(str(test_file.parent))
+
+            # 4. Verify original file is still usable after errors
+            metadata_after_errors = get_unified_metadata(test_file)
+            assert metadata_after_errors.get(UnifiedMetadataKey.TITLE) == "Deletion Error Test"
+
+            # 5. Successfully delete metadata from original file
+            delete_result = delete_all_metadata(test_file)
+            assert delete_result is True
+
+            # 6. Verify deletion worked
+            deleted_metadata = get_unified_metadata(test_file)
+            assert (
+                deleted_metadata.get(UnifiedMetadataKey.TITLE) is None
+                or deleted_metadata.get(UnifiedMetadataKey.TITLE) != "Deletion Error Test"
+            )
+
+    def test_deletion_with_corrupted_metadata_workflow(self):
+        # E2E test for deletion when metadata might be corrupted
+        initial_metadata = {"title": "Corrupted Metadata Test", "artist": "Corrupted Artist"}
+
+        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) == "Corrupted Metadata Test"
+
+            # 2. Try to delete metadata - should work even if some metadata is corrupted
+            delete_result = delete_all_metadata(test_file)
+            assert delete_result is True
+
+            # 3. Verify deletion worked
+            deleted_metadata = get_unified_metadata(test_file)
+            assert (
+                deleted_metadata.get(UnifiedMetadataKey.TITLE) is None
+                or deleted_metadata.get(UnifiedMetadataKey.TITLE) != "Corrupted Metadata Test"
+            )
+
+            # 4. Verify file is still usable after deletion
+            # Try to add new metadata
+            new_metadata = {UnifiedMetadataKey.TITLE: "New Title After Deletion"}
+            update_metadata(test_file, new_metadata)
+
+            # 5. Verify new metadata was added successfully
+            new_metadata_result = get_unified_metadata(test_file)
+            assert new_metadata_result.get(UnifiedMetadataKey.TITLE) == "New Title After Deletion"
+
+    def test_date_format_validation_workflow(self):
+        initial_metadata = {"title": "Date Validation Test", "artist": "Date Test Artist"}
+
+        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) == "Date Validation Test"
+
+            # 2. Test invalid date formats - should raise InvalidMetadataFieldFormatError
+            invalid_dates = [
+                "2024/01/01",
+                "2024-1-1",
+                "not-a-date",
+                "24",
+            ]
+
+            for invalid_date in invalid_dates:
+                with pytest.raises(InvalidMetadataFieldFormatError) as exc_info:
+                    update_metadata(test_file, {UnifiedMetadataKey.RELEASE_DATE: invalid_date})
+                error = exc_info.value
+                assert error.field == UnifiedMetadataKey.RELEASE_DATE.value
+                assert error.value == invalid_date
+
+            # 3. Verify file is still usable after validation errors (validation happens before file write)
+            metadata_after_errors = get_unified_metadata(test_file)
+            assert metadata_after_errors.get(UnifiedMetadataKey.TITLE) == "Date Validation Test"
+
+            # 4. Test valid date format - should succeed
+            # Update with valid YYYY-MM-DD format
+            update_metadata(test_file, {UnifiedMetadataKey.RELEASE_DATE: "2024-01-01"})
+            updated_metadata = get_unified_metadata(test_file)
+            assert updated_metadata.get(UnifiedMetadataKey.RELEASE_DATE) == "2024-01-01"

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

@@ -0,0 +1,129 @@
+"""End-to-end tests for format-specific metadata workflows.
+
+These tests verify that the system works correctly with different audio formats (MP3, FLAC, WAV) and their specific
+capabilities and limitations.
+"""
+
+import pytest
+
+from audiometa import 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 TestFormatSpecificWorkflows:
+    def test_complete_metadata_workflow_mp3(self):
+        # Use external script to set initial metadata
+        initial_metadata = {"title": "Initial MP3 Title", "artist": "Initial MP3 Artist", "album": "Initial MP3 Album"}
+        with temp_file_with_metadata(initial_metadata, "mp3") as test_file:
+            # 1. Read initial metadata
+            initial_metadata_result = get_unified_metadata(test_file)
+            assert isinstance(initial_metadata_result, dict)
+
+            # 2. Update metadata using app's function (this is what we're testing)
+            test_metadata = {
+                UnifiedMetadataKey.TITLE: "Integration Test Title",
+                UnifiedMetadataKey.ARTISTS: ["Integration Test Artist"],
+                UnifiedMetadataKey.ALBUM: "Integration Test Album",
+                UnifiedMetadataKey.RATING: 90,
+                UnifiedMetadataKey.BPM: 130,
+            }
+            update_metadata(test_file, test_metadata, normalized_rating_max_value=100)
+
+            # 3. Verify metadata was updated
+            updated_metadata = get_unified_metadata(test_file, normalized_rating_max_value=100)
+            assert updated_metadata.get(UnifiedMetadataKey.TITLE) == "Integration Test Title"
+            assert updated_metadata.get(UnifiedMetadataKey.ARTISTS) == ["Integration Test Artist"]
+            assert updated_metadata.get(UnifiedMetadataKey.ALBUM) == "Integration Test Album"
+            assert updated_metadata.get(UnifiedMetadataKey.RATING) == 90
+            assert updated_metadata.get(UnifiedMetadataKey.BPM) == 130
+
+            # 4. Test technical information
+            bitrate = get_bitrate(test_file)
+            duration = get_duration_in_sec(test_file)
+            assert isinstance(bitrate, int)
+            assert isinstance(duration, float)
+            assert bitrate > 0
+            assert duration > 0
+
+            # 5. Delete metadata
+            delete_result = delete_all_metadata(test_file)
+            assert delete_result is True
+
+            # 6. Verify metadata was deleted
+            deleted_metadata = get_unified_metadata(test_file)
+            # After deletion, metadata should be empty or minimal
+            assert (
+                UnifiedMetadataKey.TITLE not in deleted_metadata
+                or deleted_metadata.get(UnifiedMetadataKey.TITLE) != "Integration Test Title"
+            )
+
+    def test_complete_metadata_workflow_flac(self):
+        # Use external script to set initial metadata
+        initial_metadata = {
+            "title": "Initial FLAC Title",
+            "artist": "Initial FLAC Artist",
+            "album": "Initial FLAC Album",
+        }
+        with temp_file_with_metadata(initial_metadata, "flac") as test_file:
+            # 1. Read initial metadata
+            initial_metadata_result = get_unified_metadata(test_file)
+            assert isinstance(initial_metadata_result, dict)
+
+            # 2. Update metadata using app's function (this is what we're testing)
+            test_metadata = {
+                UnifiedMetadataKey.TITLE: "FLAC Integration Test Title",
+                UnifiedMetadataKey.ARTISTS: ["FLAC Integration Test Artist"],
+                UnifiedMetadataKey.ALBUM: "FLAC Integration Test Album",
+                UnifiedMetadataKey.RATING: 80,
+                UnifiedMetadataKey.BPM: 140,
+            }
+            update_metadata(test_file, test_metadata, normalized_rating_max_value=100)
+
+            # 3. Verify metadata was updated
+            updated_metadata = get_unified_metadata(test_file, normalized_rating_max_value=100)
+            assert updated_metadata.get(UnifiedMetadataKey.TITLE) == "FLAC Integration Test Title"
+            assert updated_metadata.get(UnifiedMetadataKey.ARTISTS) == ["FLAC Integration Test Artist"]
+            assert updated_metadata.get(UnifiedMetadataKey.ALBUM) == "FLAC Integration Test Album"
+            assert updated_metadata.get(UnifiedMetadataKey.RATING) == 80
+            assert updated_metadata.get(UnifiedMetadataKey.BPM) == 140
+
+            # 4. Test technical information
+            bitrate = get_bitrate(test_file)
+            duration = get_duration_in_sec(test_file)
+            assert isinstance(bitrate, int)
+            assert isinstance(duration, float)
+            assert bitrate > 0
+            assert duration > 0
+
+    def test_complete_metadata_workflow_wav(self):
+        # Use external script to set initial metadata
+        initial_metadata = {"title": "Initial WAV Title", "artist": "Initial WAV Artist", "album": "Initial WAV Album"}
+        with temp_file_with_metadata(initial_metadata, "wav") as test_file:
+            # 1. Read initial metadata
+            initial_metadata_result = get_unified_metadata(test_file)
+            assert isinstance(initial_metadata_result, dict)
+
+            # 2. Update metadata using app's function (this is what we're testing)
+            # WAV doesn't support rating or BPM
+            test_metadata = {
+                UnifiedMetadataKey.TITLE: "WAV Integration Test Title",
+                UnifiedMetadataKey.ARTISTS: ["WAV Integration Test Artist"],
+                UnifiedMetadataKey.ALBUM: "WAV Integration Test Album",
+            }
+            update_metadata(test_file, test_metadata)
+
+            # 3. Verify metadata was updated
+            updated_metadata = get_unified_metadata(test_file)
+            assert updated_metadata.get(UnifiedMetadataKey.TITLE) == "WAV Integration Test Title"
+            assert updated_metadata.get(UnifiedMetadataKey.ARTISTS) == ["WAV Integration Test Artist"]
+            assert updated_metadata.get(UnifiedMetadataKey.ALBUM) == "WAV Integration Test Album"
+
+            # 4. Test technical information
+            bitrate = get_bitrate(test_file)
+            duration = get_duration_in_sec(test_file)
+            assert isinstance(bitrate, int)
+            assert isinstance(duration, float)
+            assert bitrate > 0
+            assert duration > 0