audiometa-python 0.2.2__py3-none-any.whl

audiometa/test/tests/integration/technical_info/test_sample_rate.py

@@ -0,0 +1,40 @@
+from pathlib import Path
+
+import pytest
+
+from audiometa import get_sample_rate
+from audiometa.test.helpers.technical_info_inspector import TechnicalInfoInspector
+
+
+@pytest.mark.integration
+class TestGetSampleRate:
+    def test_get_sample_rate_works_with_path_string(self, sample_mp3_file: Path):
+        sample_rate = get_sample_rate(str(sample_mp3_file))
+        assert isinstance(sample_rate, int)
+        assert sample_rate > 0
+
+    def test_get_sample_rate_works_with_pathlib_path(self, sample_mp3_file: Path):
+        sample_rate = get_sample_rate(sample_mp3_file)
+        assert isinstance(sample_rate, int)
+        assert sample_rate > 0
+
+    def test_get_sample_rate_matches_external_tool(self, sample_mp3_file: Path):
+        external_sample_rate = TechnicalInfoInspector.get_sample_rate(sample_mp3_file)
+        assert external_sample_rate is not None
+        assert isinstance(external_sample_rate, int)
+        assert external_sample_rate == 44100
+
+        sample_rate = get_sample_rate(sample_mp3_file)
+        assert sample_rate == external_sample_rate
+
+    def test_get_sample_rate_supports_all_formats(
+        self, sample_mp3_file: Path, sample_flac_file: Path, sample_wav_file: Path
+    ):
+        mp3_sample_rate = get_sample_rate(sample_mp3_file)
+        flac_sample_rate = get_sample_rate(sample_flac_file)
+        wav_sample_rate = get_sample_rate(sample_wav_file)
+
+        assert isinstance(mp3_sample_rate, int)
+        assert isinstance(flac_sample_rate, int)
+        assert isinstance(wav_sample_rate, int)
+        assert all(r > 0 for r in [mp3_sample_rate, flac_sample_rate, wav_sample_rate])

audiometa/test/tests/integration/test_audio_file.py

@@ -0,0 +1,23 @@
+from pathlib import Path
+
+import pytest
+
+from audiometa import get_unified_metadata, get_unified_metadata_field
+from audiometa.utils.metadata_format import MetadataFormat
+from audiometa.utils.unified_metadata_key import UnifiedMetadataKey
+
+
+@pytest.mark.integration
+class TestAudioFileIntegration:
+    def test_functional_api_with_file_path(self, sample_mp3_file: Path):
+        # Test that functional APIs work with file paths (string)
+        metadata = get_unified_metadata(str(sample_mp3_file))
+        assert isinstance(metadata, dict)
+
+        # Test single format with file path
+        id3v2_metadata = get_unified_metadata(str(sample_mp3_file), metadata_format=MetadataFormat.ID3V2)
+        assert isinstance(id3v2_metadata, dict)
+
+        # Test specific metadata with file path
+        title = get_unified_metadata_field(str(sample_mp3_file), UnifiedMetadataKey.TITLE)
+        assert title is None or isinstance(title, str)

audiometa/test/tests/integration/test_audio_format_readable_after_update_all_metadata_formats.py

@@ -0,0 +1,95 @@
+import pytest
+
+from audiometa import 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.integration
+class TestAudioFormatReadableAfterUpdate:
+    def test_mp3_playable_after_id3v1_and_id3v2_updates(self):
+        """Test that MP3 file remains playable after updating with ID3v1 and ID3v2 tags."""
+        sf = pytest.importorskip("soundfile")
+
+        with temp_file_with_metadata({}, "mp3") as test_file:
+            # Update with ID3v2 metadata first
+            id3v2_metadata = {
+                UnifiedMetadataKey.TITLE: "ID3v2 Test Title",
+                UnifiedMetadataKey.ARTISTS: ["ID3v2 Test Artist"],
+                UnifiedMetadataKey.ALBUM: "ID3v2 Test Album",
+                UnifiedMetadataKey.RATING: 80,
+            }
+            update_metadata(
+                test_file, id3v2_metadata, metadata_format=MetadataFormat.ID3V2, normalized_rating_max_value=100
+            )
+
+            # Update with ID3v1 metadata
+            id3v1_metadata = {
+                UnifiedMetadataKey.TITLE: "ID3v1 Test Title",
+                UnifiedMetadataKey.ARTISTS: ["ID3v1 Test Artist"],
+                UnifiedMetadataKey.ALBUM: "ID3v1 Test Album",
+            }
+            update_metadata(test_file, id3v1_metadata, metadata_format=MetadataFormat.ID3V1)
+
+            # Verify the track is still playable by trying to read audio frames
+            try:
+                with sf.SoundFile(str(test_file)) as f:
+                    # Just try reading a few frames
+                    frames = f.read(frames=1024)
+                    assert f.samplerate > 0
+                    assert f.channels > 0
+                    assert len(frames) > 0
+            except RuntimeError as e:
+                pytest.fail(f"Audio file {test_file} could not be opened or decoded: {e}")
+
+    def test_flac_playable_after_vorbis_updates(self):
+        """Test that FLAC file remains playable after updating with Vorbis tags."""
+        sf = pytest.importorskip("soundfile")
+
+        with temp_file_with_metadata({}, "flac") as test_file:
+            # Update with Vorbis metadata
+            vorbis_metadata = {
+                UnifiedMetadataKey.TITLE: "Vorbis Test Title",
+                UnifiedMetadataKey.ARTISTS: ["Vorbis Test Artist"],
+                UnifiedMetadataKey.ALBUM: "Vorbis Test Album",
+                UnifiedMetadataKey.RATING: 80,
+            }
+            update_metadata(
+                test_file, vorbis_metadata, metadata_format=MetadataFormat.VORBIS, normalized_rating_max_value=100
+            )
+
+            # Verify the track is still playable by trying to read audio frames
+            try:
+                with sf.SoundFile(str(test_file)) as f:
+                    # Just try reading a few frames
+                    frames = f.read(frames=1024)
+                    assert f.samplerate > 0
+                    assert f.channels > 0
+                    assert len(frames) > 0
+            except RuntimeError as e:
+                pytest.fail(f"Audio file {test_file} could not be opened or decoded: {e}")
+
+    def test_wav_playable_after_riff_updates(self):
+        """Test that WAV file remains playable after updating with RIFF tags."""
+        sf = pytest.importorskip("soundfile")
+
+        with temp_file_with_metadata({}, "wav") as test_file:
+            # Update with RIFF metadata
+            riff_metadata = {
+                UnifiedMetadataKey.TITLE: "RIFF Test Title",
+                UnifiedMetadataKey.ARTISTS: ["RIFF Test Artist"],
+                UnifiedMetadataKey.ALBUM: "RIFF Test Album",
+            }
+            update_metadata(test_file, riff_metadata, metadata_format=MetadataFormat.RIFF)
+
+            # Verify the track is still playable by trying to read audio frames
+            try:
+                with sf.SoundFile(str(test_file)) as f:
+                    # Just try reading a few frames
+                    frames = f.read(frames=1024)
+                    assert f.samplerate > 0
+                    assert f.channels > 0
+                    assert len(frames) > 0
+            except RuntimeError as e:
+                pytest.fail(f"Audio file {test_file} could not be opened or decoded: {e}")

audiometa/test/tests/integration/writing/test_error_handling.py

@@ -0,0 +1,44 @@
+import pytest
+
+from audiometa import delete_all_metadata, update_metadata
+from audiometa.exceptions import FileTypeNotSupportedError, MetadataWritingConflictParametersError
+from audiometa.test.helpers.temp_file_with_metadata import temp_file_with_metadata
+from audiometa.utils.metadata_format import MetadataFormat
+from audiometa.utils.metadata_writing_strategy import MetadataWritingStrategy
+from audiometa.utils.unified_metadata_key import UnifiedMetadataKey
+
+
+@pytest.mark.integration
+class TestWritingErrorHandling:
+    def test_unsupported_file_type_raises_error(self):
+        # Create a file with unsupported extension using temp_file_with_metadata
+        with temp_file_with_metadata({}, "mp3") as temp_file_path:
+            temp_file_path.write_bytes(b"fake audio content")
+            temp_txt = temp_file_path.with_suffix(".txt")
+            temp_txt.write_bytes(b"fake audio content")
+
+            with pytest.raises(FileTypeNotSupportedError):
+                update_metadata(str(temp_txt), {UnifiedMetadataKey.TITLE: "Test"})
+
+            with pytest.raises(FileTypeNotSupportedError):
+                delete_all_metadata(str(temp_txt))
+
+    def test_nonexistent_file_raises_error(self):
+        nonexistent_file = "nonexistent_file.mp3"
+
+        with pytest.raises(FileNotFoundError):
+            update_metadata(nonexistent_file, {UnifiedMetadataKey.TITLE: "Test"})
+
+        # Note: delete_all_metadata error handling tests have been moved to test_delete_all_metadata.py
+
+    def test_metadata_writing_conflict_parameters_error_both_strategy_and_format(self):
+        with temp_file_with_metadata({}, "mp3") as test_file:
+            with pytest.raises(MetadataWritingConflictParametersError) as exc_info:
+                update_metadata(
+                    test_file,
+                    {UnifiedMetadataKey.TITLE: "Test"},
+                    metadata_strategy=MetadataWritingStrategy.SYNC,
+                    metadata_format=MetadataFormat.ID3V2,
+                )
+            assert "metadata_strategy" in str(exc_info.value).lower()
+            assert "metadata_format" in str(exc_info.value).lower()

audiometa/test/tests/integration/writing/test_forced_format.py

@@ -0,0 +1,224 @@
+"""Tests for forced format parameter functionality.
+
+This module tests the behavior when a specific metadata format is forced using the metadata_format parameter in
+update_metadata.
+"""
+
+import pytest
+
+from audiometa import get_unified_metadata, update_metadata
+from audiometa.exceptions import (
+    MetadataFieldNotSupportedByMetadataFormatError,
+    MetadataFormatNotSupportedByAudioFormatError,
+    MetadataWritingConflictParametersError,
+)
+from audiometa.test.helpers.temp_file_with_metadata import temp_file_with_metadata
+from audiometa.utils.metadata_format import MetadataFormat
+from audiometa.utils.metadata_writing_strategy import MetadataWritingStrategy
+from audiometa.utils.unified_metadata_key import UnifiedMetadataKey
+
+
+@pytest.mark.integration
+class TestForcedFormat:
+    def test_forced_format_writes_only_to_specified_format(self):
+        # Create WAV file with initial RIFF metadata
+        initial_metadata = {"title": "Original RIFF Title", "artist": "Original RIFF Artist"}
+        with temp_file_with_metadata(initial_metadata, "wav") as test_file:
+            # Add ID3v2 metadata using the library directly
+            id3v2_metadata = {
+                UnifiedMetadataKey.TITLE: "Original ID3v2 Title",
+                UnifiedMetadataKey.ARTISTS: ["Original ID3v2 Artist"],
+            }
+            update_metadata(test_file, id3v2_metadata, metadata_format=MetadataFormat.ID3V2)
+
+            # Verify both formats have their respective metadata
+            riff_before = get_unified_metadata(test_file, metadata_format=MetadataFormat.RIFF)
+            id3v2_before = get_unified_metadata(test_file, metadata_format=MetadataFormat.ID3V2)
+            assert riff_before.get(UnifiedMetadataKey.TITLE) == "Original RIFF Title"
+            assert id3v2_before.get(UnifiedMetadataKey.TITLE) == "Original ID3v2 Title"
+
+            # Force ID3v2 format (should write only to ID3v2, leave RIFF untouched)
+            new_metadata = {
+                UnifiedMetadataKey.TITLE: "New ID3v2 Title",
+                UnifiedMetadataKey.ARTISTS: ["New ID3v2 Artist"],
+            }
+
+            # This should write only to ID3v2 format, leaving RIFF unchanged
+            update_metadata(test_file, new_metadata, metadata_format=MetadataFormat.ID3V2)
+
+            # Verify ID3v2 has new metadata
+            id3v2_after = get_unified_metadata(test_file, metadata_format=MetadataFormat.ID3V2)
+            assert id3v2_after.get(UnifiedMetadataKey.TITLE) == "New ID3v2 Title"
+            assert id3v2_after.get(UnifiedMetadataKey.ARTISTS) == ["New ID3v2 Artist"]
+
+            # Verify RIFF still has original metadata (forced format doesn't affect other formats)
+            riff_after = get_unified_metadata(test_file, metadata_format=MetadataFormat.RIFF)
+            assert riff_after.get(UnifiedMetadataKey.TITLE) == "Original RIFF Title"
+            assert riff_after.get(UnifiedMetadataKey.ARTISTS) == ["Original RIFF Artist"]
+
+    def test_forced_format_fails_fast_on_unsupported_fields(self):
+        # Create WAV file with basic metadata
+        initial_metadata = {"title": "Test Title", "artist": "Test Artist"}
+        with temp_file_with_metadata(initial_metadata, "wav") as test_file:
+            # Try to write ARCHIVAL_LOCATION to RIFF format (not supported)
+            unsupported_metadata = {
+                UnifiedMetadataKey.TITLE: "Test Title",
+                UnifiedMetadataKey.ARCHIVAL_LOCATION: "some location",  # ARCHIVAL_LOCATION not supported by RIFF format
+            }
+
+            # This should raise MetadataFieldNotSupportedByMetadataFormatError because format is forced
+            with pytest.raises(
+                MetadataFieldNotSupportedByMetadataFormatError,
+                match="UnifiedMetadataKey.ARCHIVAL_LOCATION metadata not supported by RIFF format",
+            ):
+                update_metadata(test_file, unsupported_metadata, metadata_format=MetadataFormat.RIFF)
+
+    def test_forced_format_succeeds_with_supported_fields(self):
+        # Create WAV file with basic metadata
+        initial_metadata = {"title": "Test Title", "artist": "Test Artist"}
+        with temp_file_with_metadata(initial_metadata, "wav") as test_file:
+            # Write supported fields to RIFF format
+            supported_metadata = {
+                UnifiedMetadataKey.TITLE: "New RIFF Title",
+                UnifiedMetadataKey.ARTISTS: ["New RIFF Artist"],
+                UnifiedMetadataKey.ALBUM: "New RIFF Album",
+            }
+
+            # This should succeed because all fields are supported by RIFF
+            update_metadata(test_file, supported_metadata, metadata_format=MetadataFormat.RIFF)
+
+            # Verify RIFF has new metadata
+            riff_metadata = get_unified_metadata(test_file, metadata_format=MetadataFormat.RIFF)
+            assert riff_metadata.get(UnifiedMetadataKey.TITLE) == "New RIFF Title"
+            assert riff_metadata.get(UnifiedMetadataKey.ARTISTS) == ["New RIFF Artist"]
+            assert riff_metadata.get(UnifiedMetadataKey.ALBUM) == "New RIFF Album"
+
+    def test_forced_format_parameter_conflict_error(self):
+        # Create WAV file with basic metadata
+        initial_metadata = {"title": "Test Title", "artist": "Test Artist"}
+        with temp_file_with_metadata(initial_metadata, "wav") as test_file:
+            metadata = {UnifiedMetadataKey.TITLE: "Test Title", UnifiedMetadataKey.ARTISTS: ["Test Artist"]}
+
+            # This should raise error because both parameters are specified
+            with pytest.raises(
+                MetadataWritingConflictParametersError,
+                match="Cannot specify both metadata_strategy and metadata_format",
+            ):
+                update_metadata(
+                    test_file,
+                    metadata,
+                    metadata_format=MetadataFormat.RIFF,
+                    metadata_strategy=MetadataWritingStrategy.SYNC,
+                )
+
+    def test_forced_format_with_unsupported_file_type(self):
+        # Create MP3 file
+        initial_metadata = {"title": "Test Title", "artist": "Test Artist"}
+        with temp_file_with_metadata(initial_metadata, "mp3") as test_file:
+            metadata = {UnifiedMetadataKey.TITLE: "Test Title", UnifiedMetadataKey.ARTISTS: ["Test Artist"]}
+
+            # Try to force Vorbis format on MP3 file (not supported)
+            with pytest.raises(
+                MetadataFormatNotSupportedByAudioFormatError,
+                match="Tag format MetadataFormat.VORBIS not supported for file extension .mp3",
+            ):
+                update_metadata(test_file, metadata, metadata_format=MetadataFormat.VORBIS)
+
+    def test_forced_format_id3v1_writing_support(self):
+        # Create MP3 file with basic metadata
+        initial_metadata = {"title": "Test Title", "artist": "Test Artist"}
+        with temp_file_with_metadata(initial_metadata, "mp3") as test_file:
+            metadata = {UnifiedMetadataKey.TITLE: "New ID3v1 Title", UnifiedMetadataKey.ARTISTS: ["New ID3v1 Artist"]}
+
+            update_metadata(test_file, metadata, metadata_format=MetadataFormat.ID3V1)
+
+            # Verify the metadata was written
+            from audiometa import get_unified_metadata
+
+            result = get_unified_metadata(test_file, metadata_format=MetadataFormat.ID3V1)
+            assert result.get(UnifiedMetadataKey.TITLE) == "New ID3v1 Title"
+            assert result.get(UnifiedMetadataKey.ARTISTS) == ["New ID3v1 Artist"]
+
+    def test_forced_format_multiple_formats_present(self):
+        # Create WAV file with both RIFF and ID3v2 metadata
+        initial_metadata = {"title": "Original RIFF Title", "artist": "Original RIFF Artist"}
+        with temp_file_with_metadata(initial_metadata, "wav") as test_file:
+            # Add ID3v2 metadata using the library directly
+            id3v2_metadata = {
+                UnifiedMetadataKey.TITLE: "Original ID3v2 Title",
+                UnifiedMetadataKey.ARTISTS: ["Original ID3v2 Artist"],
+            }
+            update_metadata(test_file, id3v2_metadata, metadata_format=MetadataFormat.ID3V2)
+
+            # Verify both formats have original metadata
+            riff_before = get_unified_metadata(test_file, metadata_format=MetadataFormat.RIFF)
+            id3v2_before = get_unified_metadata(test_file, metadata_format=MetadataFormat.ID3V2)
+            assert riff_before.get(UnifiedMetadataKey.TITLE) == "Original RIFF Title"
+            assert id3v2_before.get(UnifiedMetadataKey.TITLE) == "Original ID3v2 Title"
+
+            # Force ID3v2 format - should only update ID3v2
+            new_metadata = {
+                UnifiedMetadataKey.TITLE: "New ID3v2 Title",
+                UnifiedMetadataKey.ARTISTS: ["New ID3v2 Artist"],
+            }
+
+            update_metadata(test_file, new_metadata, metadata_format=MetadataFormat.ID3V2)
+
+            # Verify ID3v2 was updated
+            id3v2_after = get_unified_metadata(test_file, metadata_format=MetadataFormat.ID3V2)
+            assert id3v2_after.get(UnifiedMetadataKey.TITLE) == "New ID3v2 Title"
+            assert id3v2_after.get(UnifiedMetadataKey.ARTISTS) == ["New ID3v2 Artist"]
+
+            # Verify RIFF was NOT updated (forced format only affects specified format)
+            riff_after = get_unified_metadata(test_file, metadata_format=MetadataFormat.RIFF)
+            assert riff_after.get(UnifiedMetadataKey.TITLE) == "Original RIFF Title"
+            assert riff_after.get(UnifiedMetadataKey.ARTISTS) == ["Original RIFF Artist"]
+
+    def test_forced_format_with_rating_field(self):
+        # Create MP3 file with basic metadata
+        initial_metadata = {"title": "Test Title", "artist": "Test Artist"}
+        with temp_file_with_metadata(initial_metadata, "mp3") as test_file:
+            # Write rating to ID3v2 format with proper configuration
+            metadata_with_rating = {UnifiedMetadataKey.TITLE: "Test Title", UnifiedMetadataKey.RATING: 80}
+
+            # This should succeed with proper configuration
+            update_metadata(
+                test_file,
+                metadata_with_rating,
+                metadata_format=MetadataFormat.ID3V2,
+                normalized_rating_max_value=100,
+            )
+
+            # Verify rating was written (converted from 0-100 to 0-255 scale)
+            id3v2_metadata = get_unified_metadata(test_file, metadata_format=MetadataFormat.ID3V2)
+            assert id3v2_metadata.get(UnifiedMetadataKey.TITLE) == "Test Title"
+            # Rating 85 on 0-100 scale becomes 196 on 0-255 scale (85 * 255 / 100 = 216.75, rounded to 196)
+            assert id3v2_metadata.get(UnifiedMetadataKey.RATING) == 196
+
+    # Note: delete_all_metadata tests have been moved to test_delete_all_metadata.py
+
+    def test_forced_format_validation_before_writing(self):
+        # Create WAV file with initial metadata
+        initial_metadata = {"title": "Original Title", "artist": "Original Artist"}
+        with temp_file_with_metadata(initial_metadata, "wav") as test_file:
+            # Try to write mixed supported/unsupported fields to RIFF format
+            mixed_metadata = {
+                UnifiedMetadataKey.TITLE: "New Title",  # Supported
+                UnifiedMetadataKey.ARTISTS: ["New Artist"],  # Supported
+                UnifiedMetadataKey.ARCHIVAL_LOCATION: "some location",  # NOT supported by RIFF
+                UnifiedMetadataKey.ALBUM: "New Album",  # Supported
+            }
+
+            # This should fail because ARCHIVAL_LOCATION is not supported by RIFF
+            with pytest.raises(
+                MetadataFieldNotSupportedByMetadataFormatError,
+                match="UnifiedMetadataKey.ARCHIVAL_LOCATION metadata not supported by RIFF format",
+            ):
+                update_metadata(test_file, mixed_metadata, metadata_format=MetadataFormat.RIFF)
+
+            # Verify NO changes were made to the file (validation happens before writing)
+            final_metadata = get_unified_metadata(test_file)
+            assert final_metadata.get(UnifiedMetadataKey.TITLE) == "Original Title"
+            assert final_metadata.get(UnifiedMetadataKey.ARTISTS) == ["Original Artist"]
+            assert final_metadata.get(UnifiedMetadataKey.BPM) is None
+            assert final_metadata.get(UnifiedMetadataKey.ALBUM) is None

audiometa/test/tests/integration/writing/test_multiple_format_preservation.py

@@ -0,0 +1,223 @@
+"""Tests for multiple format preservation when updating metadata.
+
+This module tests that updating fields in one format with the PRESERVE strategy does not affect other formats. It covers
+the main working combinations.
+"""
+
+import pytest
+
+from audiometa import get_unified_metadata, update_metadata
+from audiometa.test.helpers.id3v1 import ID3v1MetadataSetter
+from audiometa.test.helpers.id3v2 import ID3v2MetadataSetter
+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.integration
+class TestMultipleFormatPreservation:
+    def test_id3v1_preserves_id3v2(self):
+        with temp_file_with_metadata({"title": "ID3v2 Title", "artist": "ID3v2 Artist"}, "mp3") as test_file:
+            ID3v2MetadataSetter.set_metadata(test_file, {"title": "ID3v2 Title"})
+            ID3v2MetadataSetter.set_metadata(test_file, {"artist": "ID3v2 Artist"})
+
+            # Verify initial state
+            id3v2_before = get_unified_metadata(test_file, metadata_format=MetadataFormat.ID3V2)
+            id3v1_before = get_unified_metadata(test_file, metadata_format=MetadataFormat.ID3V1)
+            assert id3v2_before.get(UnifiedMetadataKey.TITLE) == "ID3v2 Title"
+            assert id3v1_before.get(UnifiedMetadataKey.TITLE) is None
+
+            # Update ID3v1 with PRESERVE strategy (specify ID3v1 format)
+            id3v1_metadata = {UnifiedMetadataKey.TITLE: "ID3v1 Title", UnifiedMetadataKey.ARTISTS: ["ID3v1 Artist"]}
+            update_metadata(test_file, id3v1_metadata, metadata_format=MetadataFormat.ID3V1)
+
+            # Verify ID3v1 was updated and ID3v2 was preserved
+            id3v2_after = get_unified_metadata(test_file, metadata_format=MetadataFormat.ID3V2)
+            id3v1_after = get_unified_metadata(test_file, metadata_format=MetadataFormat.ID3V1)
+            assert id3v2_after.get(UnifiedMetadataKey.TITLE) == "ID3v2 Title"
+            assert id3v1_after.get(UnifiedMetadataKey.TITLE) == "ID3v1 Title"
+
+    def test_id3v2_preserves_id3v1(self):
+        with temp_file_with_metadata({"title": "ID3v1 Title", "artist": "ID3v1 Artist"}, "id3v1") as test_file:
+            # Verify initial state
+            id3v1_before = get_unified_metadata(test_file, metadata_format=MetadataFormat.ID3V1)
+            id3v2_before = get_unified_metadata(test_file, metadata_format=MetadataFormat.ID3V2)
+            assert id3v1_before.get(UnifiedMetadataKey.TITLE) == "ID3v1 Title"
+            assert id3v2_before.get(UnifiedMetadataKey.TITLE) is None
+
+            id3v2_metadata = {UnifiedMetadataKey.TITLE: "ID3v2 Title", UnifiedMetadataKey.ARTISTS: ["ID3v2 Artist"]}
+            update_metadata(test_file, id3v2_metadata, metadata_format=MetadataFormat.ID3V2)
+
+            # Verify ID3v2 was updated and ID3v1 was preserved
+            id3v1_after = get_unified_metadata(test_file, metadata_format=MetadataFormat.ID3V1)
+            id3v2_after = get_unified_metadata(test_file, metadata_format=MetadataFormat.ID3V2)
+            assert id3v1_after.get(UnifiedMetadataKey.TITLE) == "ID3v1 Title"
+            assert id3v2_after.get(UnifiedMetadataKey.TITLE) == "ID3v2 Title"
+
+    def test_riff_preserves_id3v1(self):
+        with temp_file_with_metadata({}, "wav") as test_file:
+            ID3v1MetadataSetter.set_title(test_file, "ID3v1 Title")
+            ID3v1MetadataSetter.set_artist(test_file, "ID3v1 Artist")
+
+            # Verify initial state
+            id3v1_before = get_unified_metadata(test_file, metadata_format=MetadataFormat.ID3V1)
+            riff_before = get_unified_metadata(test_file, metadata_format=MetadataFormat.RIFF)
+            assert id3v1_before.get(UnifiedMetadataKey.TITLE) == "ID3v1 Title"
+            assert riff_before.get(UnifiedMetadataKey.TITLE) is None
+
+            riff_metadata = {UnifiedMetadataKey.TITLE: "RIFF Title", UnifiedMetadataKey.ARTISTS: ["RIFF Artist"]}
+            update_metadata(test_file, riff_metadata, metadata_format=MetadataFormat.RIFF)
+
+            # Verify RIFF was updated and ID3v1 was preserved
+            id3v1_after = get_unified_metadata(test_file, metadata_format=MetadataFormat.ID3V1)
+            riff_after = get_unified_metadata(test_file, metadata_format=MetadataFormat.RIFF)
+            assert id3v1_after.get(UnifiedMetadataKey.TITLE) == "ID3v1 Title"
+            assert riff_after.get(UnifiedMetadataKey.TITLE) == "RIFF Title"
+
+    def test_id3v1_preserves_riff(self):
+        with temp_file_with_metadata({"title": "RIFF Title", "artist": "RIFF Artist"}, "wav") as test_file:
+            # Verify initial state
+            riff_before = get_unified_metadata(test_file, metadata_format=MetadataFormat.RIFF)
+            id3v1_before = get_unified_metadata(test_file, metadata_format=MetadataFormat.ID3V1)
+            assert riff_before.get(UnifiedMetadataKey.TITLE) == "RIFF Title"
+            assert id3v1_before.get(UnifiedMetadataKey.TITLE) is None
+
+            # Update ID3v1 with PRESERVE strategy (specify ID3v1 format)
+            id3v1_metadata = {UnifiedMetadataKey.TITLE: "ID3v1 Title", UnifiedMetadataKey.ARTISTS: ["ID3v1 Artist"]}
+            update_metadata(test_file, id3v1_metadata, metadata_format=MetadataFormat.ID3V1)
+
+            # Verify ID3v1 was updated and RIFF was preserved
+            riff_after = get_unified_metadata(test_file, metadata_format=MetadataFormat.RIFF)
+            id3v1_after = get_unified_metadata(test_file, metadata_format=MetadataFormat.ID3V1)
+            assert riff_after.get(UnifiedMetadataKey.TITLE) == "RIFF Title"
+            assert id3v1_after.get(UnifiedMetadataKey.TITLE) == "ID3v1 Title"
+
+    def test_riff_preserves_id3v2(self):
+        with temp_file_with_metadata({}, "wav") as test_file:
+            ID3v2MetadataSetter.set_metadata(test_file, {"title": "ID3v2 Title"})
+            ID3v2MetadataSetter.set_metadata(test_file, {"artist": "ID3v2 Artist"})
+
+            # Verify initial state
+            id3v2_before = get_unified_metadata(test_file, metadata_format=MetadataFormat.ID3V2)
+            riff_before = get_unified_metadata(test_file, metadata_format=MetadataFormat.RIFF)
+            assert id3v2_before.get(UnifiedMetadataKey.TITLE) == "ID3v2 Title"
+            assert riff_before.get(UnifiedMetadataKey.TITLE) is None
+
+            # Update RIFF with PRESERVE strategy (specify RIFF format)
+            riff_metadata = {UnifiedMetadataKey.TITLE: "RIFF Title", UnifiedMetadataKey.ARTISTS: ["RIFF Artist"]}
+            update_metadata(test_file, riff_metadata, metadata_format=MetadataFormat.RIFF)
+
+            # Verify RIFF was updated and ID3v2 was preserved
+            id3v2_after = get_unified_metadata(test_file, metadata_format=MetadataFormat.ID3V2)
+            riff_after = get_unified_metadata(test_file, metadata_format=MetadataFormat.RIFF)
+            assert id3v2_after.get(UnifiedMetadataKey.TITLE) == "ID3v2 Title"
+            assert riff_after.get(UnifiedMetadataKey.TITLE) == "RIFF Title"
+
+    def test_id3v2_preserves_riff(self):
+        with temp_file_with_metadata({"title": "RIFF Title", "artist": "RIFF Artist"}, "wav") as test_file:
+            # Verify initial state
+            riff_before = get_unified_metadata(test_file, metadata_format=MetadataFormat.RIFF)
+            id3v2_before = get_unified_metadata(test_file, metadata_format=MetadataFormat.ID3V2)
+            assert riff_before.get(UnifiedMetadataKey.TITLE) == "RIFF Title"
+            assert id3v2_before.get(UnifiedMetadataKey.TITLE) is None
+
+            # Update ID3v2 with PRESERVE strategy (specify ID3v2 format)
+            id3v2_metadata = {UnifiedMetadataKey.TITLE: "ID3v2 Title", UnifiedMetadataKey.ARTISTS: ["ID3v2 Artist"]}
+            update_metadata(test_file, id3v2_metadata, metadata_format=MetadataFormat.ID3V2)
+
+            # Verify ID3v2 was updated and RIFF was preserved
+            riff_after = get_unified_metadata(test_file, metadata_format=MetadataFormat.RIFF)
+            id3v2_after = get_unified_metadata(test_file, metadata_format=MetadataFormat.ID3V2)
+            assert riff_after.get(UnifiedMetadataKey.TITLE) == "RIFF Title"
+            assert id3v2_after.get(UnifiedMetadataKey.TITLE) == "ID3v2 Title"
+
+    def test_vorbis_preserves_id3v2(self):
+        with temp_file_with_metadata({}, "flac") as test_file:
+            ID3v2MetadataSetter.set_metadata(test_file, {"title": "ID3v2 Title"})
+            ID3v2MetadataSetter.set_metadata(test_file, {"artist": "ID3v2 Artist"})
+
+            # Verify initial state
+            id3v2_before = get_unified_metadata(test_file, metadata_format=MetadataFormat.ID3V2)
+            vorbis_before = get_unified_metadata(test_file, metadata_format=MetadataFormat.VORBIS)
+            assert id3v2_before.get(UnifiedMetadataKey.TITLE) == "ID3v2 Title"
+            assert vorbis_before.get(UnifiedMetadataKey.TITLE) is None
+
+            # Update Vorbis with PRESERVE strategy (specify Vorbis format)
+            vorbis_metadata = {UnifiedMetadataKey.TITLE: "Vorbis Title", UnifiedMetadataKey.ARTISTS: ["Vorbis Artist"]}
+            update_metadata(test_file, vorbis_metadata, metadata_format=MetadataFormat.VORBIS)
+
+            # Verify Vorbis was updated and ID3v2 was preserved
+            id3v2_after = get_unified_metadata(test_file, metadata_format=MetadataFormat.ID3V2)
+            vorbis_after = get_unified_metadata(test_file, metadata_format=MetadataFormat.VORBIS)
+            assert id3v2_after.get(UnifiedMetadataKey.TITLE) == "ID3v2 Title"
+            assert vorbis_after.get(UnifiedMetadataKey.TITLE) == "Vorbis Title"
+
+    def test_id3v2_preserves_vorbis(self):
+        with temp_file_with_metadata({"title": "Vorbis Title", "artist": "Vorbis Artist"}, "flac") as test_file:
+            # Verify initial state
+            vorbis_before = get_unified_metadata(test_file, metadata_format=MetadataFormat.VORBIS)
+            id3v2_before = get_unified_metadata(test_file, metadata_format=MetadataFormat.ID3V2)
+            assert vorbis_before.get(UnifiedMetadataKey.TITLE) == "Vorbis Title"
+            assert id3v2_before.get(UnifiedMetadataKey.TITLE) is None
+
+            # Update ID3v2 with PRESERVE strategy (specify ID3v2 format)
+            id3v2_metadata = {UnifiedMetadataKey.TITLE: "ID3v2 Title", UnifiedMetadataKey.ARTISTS: ["ID3v2 Artist"]}
+            update_metadata(test_file, id3v2_metadata, metadata_format=MetadataFormat.ID3V2)
+
+            # Verify ID3v2 was updated and Vorbis was preserved
+            vorbis_after = get_unified_metadata(test_file, metadata_format=MetadataFormat.VORBIS)
+            id3v2_after = get_unified_metadata(test_file, metadata_format=MetadataFormat.ID3V2)
+            assert vorbis_after.get(UnifiedMetadataKey.TITLE) == "Vorbis Title"
+            assert id3v2_after.get(UnifiedMetadataKey.TITLE) == "ID3v2 Title"
+
+    def test_multiple_fields_preservation(self):
+        with temp_file_with_metadata({"title": "Original Title", "artist": "Original Artist"}, "mp3") as test_file:
+            ID3v1MetadataSetter.set_title(test_file, "ID3v1 Title")
+            ID3v1MetadataSetter.set_artist(test_file, "ID3v1 Artist")
+            # Use ID3v2.3 instead of ID3v2.4 to preserve ID3v1 metadata
+            ID3v2MetadataSetter.set_metadata(test_file, {"title": "ID3v2 Title"}, version="2.3")
+            ID3v2MetadataSetter.set_metadata(test_file, {"artist": "ID3v2 Artist"}, version="2.3")
+
+            # Verify initial state
+            id3v1_before = get_unified_metadata(test_file, metadata_format=MetadataFormat.ID3V1)
+            id3v2_before = get_unified_metadata(test_file, metadata_format=MetadataFormat.ID3V2)
+            assert id3v1_before.get(UnifiedMetadataKey.TITLE) == "ID3v1 Title"
+            assert id3v2_before.get(UnifiedMetadataKey.TITLE) == "ID3v2 Title"
+
+            # Update only ID3v2 with multiple fields
+            id3v2_metadata = {
+                UnifiedMetadataKey.TITLE: "Updated ID3v2 Title",
+                UnifiedMetadataKey.ARTISTS: ["Updated ID3v2 Artist"],
+                UnifiedMetadataKey.ALBUM: "ID3v2 Album",
+            }
+            update_metadata(test_file, id3v2_metadata, metadata_format=MetadataFormat.ID3V2)
+
+            # Verify ID3v2 was updated and ID3v1 was preserved
+            id3v1_after = get_unified_metadata(test_file, metadata_format=MetadataFormat.ID3V1)
+            id3v2_after = get_unified_metadata(test_file, metadata_format=MetadataFormat.ID3V2)
+            assert id3v1_after.get(UnifiedMetadataKey.TITLE) == "ID3v1 Title"
+            assert id3v1_after.get(UnifiedMetadataKey.ARTISTS) == ["ID3v1 Artist"]
+            assert id3v2_after.get(UnifiedMetadataKey.TITLE) == "Updated ID3v2 Title"
+            assert id3v2_after.get(UnifiedMetadataKey.ARTISTS) == ["Updated ID3v2 Artist"]
+            assert id3v2_after.get(UnifiedMetadataKey.ALBUM) == "ID3v2 Album"
+
+    def test_preserve_strategy_with_none_values(self):
+        with temp_file_with_metadata({"title": "Original Title", "artist": "Original Artist"}, "mp3") as test_file:
+            ID3v1MetadataSetter.set_title(test_file, "ID3v1 Title")
+            ID3v1MetadataSetter.set_artist(test_file, "ID3v1 Artist")
+
+            # Verify initial state
+            id3v1_before = get_unified_metadata(test_file, metadata_format=MetadataFormat.ID3V1)
+            assert id3v1_before.get(UnifiedMetadataKey.TITLE) == "ID3v1 Title"
+
+            # Update ID3v2 with None values (should not affect ID3v1)
+            id3v2_metadata = {
+                UnifiedMetadataKey.TITLE: None,  # This should not affect ID3v1
+                UnifiedMetadataKey.ARTISTS: ["ID3v2 Artist"],
+            }
+            update_metadata(test_file, id3v2_metadata, metadata_format=MetadataFormat.ID3V2)
+
+            # Verify ID3v1 was preserved
+            id3v1_after = get_unified_metadata(test_file, metadata_format=MetadataFormat.ID3V1)
+            assert id3v1_after.get(UnifiedMetadataKey.TITLE) == "ID3v1 Title"
+            assert id3v1_after.get(UnifiedMetadataKey.ARTISTS) == ["ID3v1 Artist"]