audiometa-python 0.6.0__py3-none-any.whl

audiometa/test/tests/integration/writing/writing_strategies/test_sync_strategy.py

@@ -0,0 +1,215 @@
+"""Tests for SYNC metadata writing strategy.
+
+This module tests the SYNC strategy which writes to native format and synchronizes other metadata formats that are
+already present.
+"""
+
+import pytest
+
+from audiometa import get_unified_metadata, update_metadata
+from audiometa.test.helpers.id3v1.id3v1_metadata_setter import ID3v1MetadataSetter
+from audiometa.test.helpers.id3v2.id3v2_metadata_setter import ID3v2MetadataSetter
+from audiometa.test.helpers.riff.riff_metadata_setter import RIFFMetadataSetter
+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 TestSyncStrategy:
+    def test_sync_strategy_wav(self):
+        # Create WAV file with initial RIFF metadata
+        with temp_file_with_metadata(
+            {"title": "Initial Title", "artist": "Initial Artist", "album": "Initial Album"}, "wav"
+        ) as test_file:
+            # Verify initial RIFF metadata was written
+            riff_initial = get_unified_metadata(test_file, metadata_format=MetadataFormat.RIFF)
+            assert riff_initial.get(UnifiedMetadataKey.TITLE) == "Initial Title"
+
+            # Now write RIFF metadata with SYNC strategy
+            # For WAV files, SYNC strategy should only affect RIFF metadata
+            sync_metadata = {
+                UnifiedMetadataKey.TITLE: "Synced Title",
+                UnifiedMetadataKey.ARTISTS: ["Synced Artist"],
+                UnifiedMetadataKey.ALBUM: "Synced Album",
+            }
+            update_metadata(test_file, sync_metadata, metadata_strategy=MetadataWritingStrategy.SYNC)
+
+            # Verify RIFF metadata has the synced values
+            riff_after = get_unified_metadata(test_file, metadata_format=MetadataFormat.RIFF)
+            assert riff_after.get(UnifiedMetadataKey.TITLE) == "Synced Title"
+            assert riff_after.get(UnifiedMetadataKey.ARTISTS) == ["Synced Artist"]
+            assert riff_after.get(UnifiedMetadataKey.ALBUM) == "Synced Album"
+
+            # Verify merged metadata prefers RIFF (WAV native format)
+            merged = get_unified_metadata(test_file)
+            assert merged.get(UnifiedMetadataKey.TITLE) == "Synced Title"
+
+    def test_default_strategy_is_sync(self):
+        # Create WAV file with initial RIFF metadata
+        with temp_file_with_metadata({}, "wav") as test_file:
+            # First, add RIFF metadata using external tools
+            RIFFMetadataSetter.set_title(test_file, "Initial RIFF Title")
+            RIFFMetadataSetter.set_artists(test_file, ["Initial RIFF Artist"])
+
+            # Now write RIFF metadata without specifying strategy (should default to SYNC)
+            riff_metadata = {UnifiedMetadataKey.TITLE: "RIFF Title", UnifiedMetadataKey.ARTISTS: ["RIFF Artist"]}
+            update_metadata(test_file, riff_metadata)
+
+            # Verify RIFF metadata has the new values (SYNC strategy)
+            riff_after = get_unified_metadata(test_file, metadata_format=MetadataFormat.RIFF)
+            assert riff_after.get(UnifiedMetadataKey.TITLE) == "RIFF Title"
+
+            # Merged metadata should prefer RIFF (WAV native format)
+            merged = get_unified_metadata(test_file)
+            assert merged.get(UnifiedMetadataKey.TITLE) == "RIFF Title"
+
+    def test_id3v1_not_preserved_with_sync_strategy(self):
+        # Create test file with ID3v1 metadata using external tools
+        with temp_file_with_metadata({}, "mp3") as test_file:
+            # Add ID3v1 metadata using external tools
+            ID3v1MetadataSetter.set_metadata(
+                test_file, {"title": "ID3v1 Title", "artist": "ID3v1 Artist", "album": "ID3v1 Album"}
+            )
+
+            # Verify ID3v1 metadata was written
+            id3v1_result = get_unified_metadata(test_file, metadata_format=MetadataFormat.ID3V1)
+            assert id3v1_result.get(UnifiedMetadataKey.TITLE) == "ID3v1 Title"
+
+            # Now write ID3v2 metadata with SYNC strategy
+            id3v2_metadata = {
+                UnifiedMetadataKey.TITLE: "Synced Title",
+                UnifiedMetadataKey.ARTISTS: ["Synced Artist"],
+                UnifiedMetadataKey.ALBUM: "Synced Album",
+            }
+            update_metadata(test_file, id3v2_metadata, metadata_strategy=MetadataWritingStrategy.SYNC)
+
+            # Verify ID3v1 metadata behavior with different strategies
+            # When ID3v2 is written, it overwrites the ID3v1 tag
+            id3v1_after = get_unified_metadata(test_file, metadata_format=MetadataFormat.ID3V1)
+            assert id3v1_after.get(UnifiedMetadataKey.TITLE) == "Synced Title"  # ID3v1 was overwritten
+
+            # Verify ID3v2 metadata was written with synced values
+            id3v2_after = get_unified_metadata(test_file, metadata_format=MetadataFormat.ID3V2)
+            assert id3v2_after.get(UnifiedMetadataKey.TITLE) == "Synced Title"
+
+            # Merged metadata should prefer ID3v2 (higher precedence)
+            merged = get_unified_metadata(test_file)
+            assert merged.get(UnifiedMetadataKey.TITLE) == "Synced Title"
+
+    def test_id3v1_modification_success(self):
+        # Create test file with ID3v1 metadata using external tools
+        with temp_file_with_metadata({}, "mp3") as test_file:
+            # Add ID3v1 metadata using external tools
+            ID3v1MetadataSetter.set_metadata(
+                test_file, {"title": "ID3v1 Title", "artist": "ID3v1 Artist", "album": "ID3v1 Album"}
+            )
+
+            # Verify ID3v1 metadata was written
+            id3v1_result = get_unified_metadata(test_file, metadata_format=MetadataFormat.ID3V1)
+            assert id3v1_result.get(UnifiedMetadataKey.TITLE) == "ID3v1 Title"
+
+            # Modify ID3v1 metadata directly should succeed
+            update_metadata(test_file, {UnifiedMetadataKey.TITLE: "New Title"}, metadata_format=MetadataFormat.ID3V1)
+
+            # Verify the modification was successful
+            updated_id3v1_result = get_unified_metadata(test_file, metadata_format=MetadataFormat.ID3V1)
+            assert updated_id3v1_result.get(UnifiedMetadataKey.TITLE) == "New Title"
+
+    def test_sync_strategy_wav_with_field_length_limits(self):
+        # Create WAV file with initial RIFF metadata
+        with temp_file_with_metadata({}, "wav") as test_file:
+            # Add initial RIFF metadata using external tools
+            RIFFMetadataSetter.set_title(test_file, "Short Title")
+            RIFFMetadataSetter.set_artists(test_file, ["Short Artist"])
+            RIFFMetadataSetter.set_album(test_file, "Short Album")
+
+            # Verify initial RIFF metadata was written
+            riff_initial = get_unified_metadata(test_file, metadata_format=MetadataFormat.RIFF)
+            assert riff_initial.get(UnifiedMetadataKey.TITLE) == "Short Title"
+
+            # Now test SYNC strategy with long title
+            long_title = "This is a Very Long Title That Tests RIFF Metadata Handling"
+            sync_metadata = {
+                UnifiedMetadataKey.TITLE: long_title,
+                UnifiedMetadataKey.ARTISTS: ["Long Artist Name That Tests RIFF Handling"],
+                UnifiedMetadataKey.ALBUM: "Long Album Name That Tests RIFF Handling",
+            }
+            update_metadata(test_file, sync_metadata, metadata_strategy=MetadataWritingStrategy.SYNC)
+
+            # Verify RIFF metadata has full values (RIFF supports longer fields than ID3v1)
+            riff_after = get_unified_metadata(test_file, metadata_format=MetadataFormat.RIFF)
+            assert riff_after.get(UnifiedMetadataKey.TITLE) == long_title
+            assert riff_after.get(UnifiedMetadataKey.ARTISTS) == ["Long Artist Name That Tests RIFF Handling"]
+            assert riff_after.get(UnifiedMetadataKey.ALBUM) == "Long Album Name That Tests RIFF Handling"
+
+            # Merged metadata should prefer RIFF (WAV native format has higher precedence)
+            merged = get_unified_metadata(test_file)
+            assert merged.get(UnifiedMetadataKey.TITLE) == long_title  # Full title from RIFF
+            assert merged.get(UnifiedMetadataKey.ARTISTS) == ["Long Artist Name That Tests RIFF Handling"]
+
+    def test_sync_strategy_mp3(self):
+        with temp_file_with_metadata({}, "mp3") as test_file:
+            # Add ID3v1 metadata using external tools
+            ID3v1MetadataSetter.set_metadata(
+                test_file, {"title": "ID3v1 Title", "artist": "ID3v1 Artist", "album": "ID3v1 Album"}
+            )
+
+            # Verify ID3v1 metadata was written
+            id3v1_result = get_unified_metadata(test_file, metadata_format=MetadataFormat.ID3V1)
+            assert id3v1_result.get(UnifiedMetadataKey.TITLE) == "ID3v1 Title"
+
+            # Now write ID3v2 metadata with SYNC strategy
+            id3v2_metadata = {
+                UnifiedMetadataKey.TITLE: "Synced Title",
+                UnifiedMetadataKey.ARTISTS: ["Synced Artist"],
+                UnifiedMetadataKey.ALBUM: "Synced Album",
+            }
+            update_metadata(test_file, id3v2_metadata, metadata_strategy=MetadataWritingStrategy.SYNC)
+
+            # Verify ID3v1 metadata behavior with different strategies
+            # When ID3v2 is written, it overwrites the ID3v1 tag
+            id3v1_after = get_unified_metadata(test_file, metadata_format=MetadataFormat.ID3V1)
+            assert id3v1_after.get(UnifiedMetadataKey.TITLE) == "Synced Title"  # ID3v1 was overwritten
+
+            # Verify ID3v2 metadata was written with synced values
+            id3v2_after = get_unified_metadata(test_file, metadata_format=MetadataFormat.ID3V2)
+            assert id3v2_after.get(UnifiedMetadataKey.TITLE) == "Synced Title"
+
+    def test_sync_strategy_flac(self):
+        with temp_file_with_metadata({}, "flac") as test_file:
+            ID3v1MetadataSetter.set_metadata(
+                test_file, {"title": "ID3v1 Title", "artist": "ID3v1 Artist", "album": "ID3v1 Album"}
+            )
+
+            # Verify ID3v1 metadata was written
+            id3v1_result = get_unified_metadata(test_file, metadata_format=MetadataFormat.ID3V1)
+            assert id3v1_result.get(UnifiedMetadataKey.TITLE) == "ID3v1 Title"
+
+            ID3v2MetadataSetter.set_metadata(
+                test_file,
+                {"title": "ID3v2 Title", "artist": "ID3v2 Artist", "album": "ID3v2 Album"},
+                version="2.3",
+            )
+            id3v2_result = get_unified_metadata(test_file, metadata_format=MetadataFormat.ID3V2)
+            assert id3v2_result.get(UnifiedMetadataKey.TITLE) == "ID3v2 Title"
+
+            # Now write Vorbis metadata with SYNC strategy
+            vorbis_metadata = {
+                UnifiedMetadataKey.TITLE: "Synced Title",
+                UnifiedMetadataKey.ARTISTS: ["Synced Artist"],
+                UnifiedMetadataKey.ALBUM: "Synced Album",
+            }
+            update_metadata(test_file, vorbis_metadata, metadata_strategy=MetadataWritingStrategy.SYNC)
+
+            # Verify ID3v1 metadata behavior with different strategies
+            # When Vorbis is written, it overwrites the ID3v1 tag
+            id3v1_after = get_unified_metadata(test_file, metadata_format=MetadataFormat.ID3V1)
+            assert id3v1_after.get(UnifiedMetadataKey.TITLE) == "Synced Title"  # ID3v1 was overwritten
+
+            id3v2_after = get_unified_metadata(test_file, metadata_format=MetadataFormat.ID3V2)
+            assert id3v2_after.get(UnifiedMetadataKey.TITLE) == "Synced Title"
+
+            vorbis_after = get_unified_metadata(test_file, metadata_format=MetadataFormat.VORBIS)
+            assert vorbis_after.get(UnifiedMetadataKey.TITLE) == "Synced Title"

audiometa/test/tests/integration/writing/writing_strategies/unsupported_fields/test_fail_behavior.py

@@ -0,0 +1,42 @@
+import warnings
+
+import pytest
+
+from audiometa import get_unified_metadata, update_metadata
+from audiometa.exceptions import MetadataFieldNotSupportedByMetadataFormatError
+from audiometa.test.helpers.temp_file_with_metadata import temp_file_with_metadata
+from audiometa.utils.unified_metadata_key import UnifiedMetadataKey
+
+
+@pytest.mark.integration
+class TestFailBehavior:
+    def test_fail_on_unsupported_field_enabled(self):
+        with temp_file_with_metadata({"title": "Test"}, "wav") as test_file:
+            test_metadata = {
+                UnifiedMetadataKey.TITLE: "Test Title",
+                UnifiedMetadataKey.REPLAYGAIN: "89 dB",  # REPLAYGAIN is not supported by RIFF format
+            }
+
+            with pytest.raises(MetadataFieldNotSupportedByMetadataFormatError) as exc_info:
+                update_metadata(test_file, test_metadata, fail_on_unsupported_field=True)
+
+            assert "Fields not supported by riff format" in str(exc_info.value)
+            assert "REPLAYGAIN" in str(exc_info.value)
+
+    def test_fail_on_unsupported_field_disabled_graceful_default(self):
+        with temp_file_with_metadata({"title": "Test"}, "wav") as test_file:
+            test_metadata = {
+                UnifiedMetadataKey.TITLE: "Test Title",
+                UnifiedMetadataKey.REPLAYGAIN: "89 dB",  # REPLAYGAIN is not supported by RIFF format
+            }
+
+            with warnings.catch_warnings(record=True) as w:
+                warnings.simplefilter("always")
+                update_metadata(test_file, test_metadata)  # fail_on_unsupported_field=False by default
+
+                assert len(w) > 0
+                warning_messages = [str(warning.message) for warning in w]
+                assert any("unsupported" in msg.lower() or "not supported" in msg.lower() for msg in warning_messages)
+
+            metadata = get_unified_metadata(test_file)
+            assert metadata.get(UnifiedMetadataKey.TITLE) == "Test Title"

audiometa/test/tests/integration/writing/writing_strategies/unsupported_fields/test_no_writing_on_failure.py

@@ -0,0 +1,93 @@
+import pytest
+
+from audiometa import get_unified_metadata, update_metadata
+from audiometa.exceptions import MetadataFieldNotSupportedByMetadataFormatError
+from audiometa.test.helpers.temp_file_with_metadata import temp_file_with_metadata
+from audiometa.utils.unified_metadata_key import UnifiedMetadataKey
+
+
+@pytest.mark.integration
+class TestNoWritingOnFailure:
+    def test_fail_on_unsupported_field_no_changes_wav_only(self):
+        initial_metadata = {"title": "Original Title", "artist": "Original Artist"}
+        with temp_file_with_metadata(initial_metadata, "wav") as test_file:
+            initial_read = get_unified_metadata(test_file)
+            assert initial_read.get(UnifiedMetadataKey.TITLE) == "Original Title"
+            assert initial_read.get(UnifiedMetadataKey.ARTISTS) == ["Original Artist"]
+
+            test_metadata = {
+                UnifiedMetadataKey.TITLE: "New Title",  # This should NOT be written
+                UnifiedMetadataKey.ARTISTS: ["New Artist"],  # This should NOT be written
+                UnifiedMetadataKey.REPLAYGAIN: "89 dB",  # REPLAYGAIN is not supported by RIFF format
+            }
+
+            with pytest.raises(MetadataFieldNotSupportedByMetadataFormatError):
+                update_metadata(test_file, test_metadata, fail_on_unsupported_field=True)
+
+            final_read = get_unified_metadata(test_file)
+            assert final_read.get(UnifiedMetadataKey.TITLE) == "Original Title"  # Should be unchanged
+            assert final_read.get(UnifiedMetadataKey.ARTISTS) == ["Original Artist"]  # Should be unchanged
+            assert final_read.get(UnifiedMetadataKey.REPLAYGAIN) is None
+
+    def test_fail_on_unsupported_field_no_changes_id3v2_only(self):
+        initial_metadata = {"title": "Original MP3 Title", "artist": "Original MP3 Artist"}
+        with temp_file_with_metadata(initial_metadata, "mp3") as test_file:
+            initial_read = get_unified_metadata(test_file)
+            assert initial_read.get(UnifiedMetadataKey.TITLE) == "Original MP3 Title"
+            assert initial_read.get(UnifiedMetadataKey.ARTISTS) == ["Original MP3 Artist"]
+
+            test_metadata = {
+                UnifiedMetadataKey.TITLE: "New MP3 Title",  # Should NOT be written
+                UnifiedMetadataKey.ARTISTS: ["New MP3 Artist"],  # Should NOT be written
+                UnifiedMetadataKey.ARCHIVAL_LOCATION: "some location",  # This field is not supported by any format
+            }
+
+            with pytest.raises(MetadataFieldNotSupportedByMetadataFormatError):
+                update_metadata(test_file, test_metadata, fail_on_unsupported_field=True)
+
+            final_read = get_unified_metadata(test_file)
+            assert final_read.get(UnifiedMetadataKey.TITLE) == "Original MP3 Title"  # Should be unchanged
+            assert final_read.get(UnifiedMetadataKey.ARTISTS) == ["Original MP3 Artist"]  # Should be unchanged
+            assert final_read.get(UnifiedMetadataKey.ARCHIVAL_LOCATION) is None  # Should not exist
+
+    def test_fail_on_unsupported_field_no_changes_vorbis_only(self):
+        initial_metadata = {"title": "Original FLAC Title", "artist": "Original FLAC Artist"}
+        with temp_file_with_metadata(initial_metadata, "flac") as test_file:
+            initial_read = get_unified_metadata(test_file)
+            assert initial_read.get(UnifiedMetadataKey.TITLE) == "Original FLAC Title"
+            assert initial_read.get(UnifiedMetadataKey.ARTISTS) == ["Original FLAC Artist"]
+
+            test_metadata = {
+                UnifiedMetadataKey.TITLE: "New FLAC Title",  # Should NOT be written
+                UnifiedMetadataKey.ARTISTS: ["New FLAC Artist"],  # Should NOT be written
+                UnifiedMetadataKey.ARCHIVAL_LOCATION: "some location",  # This field is not supported by any format
+            }
+
+            with pytest.raises(MetadataFieldNotSupportedByMetadataFormatError):
+                update_metadata(test_file, test_metadata, fail_on_unsupported_field=True)
+
+            final_read = get_unified_metadata(test_file)
+            assert final_read.get(UnifiedMetadataKey.TITLE) == "Original FLAC Title"  # Should be unchanged
+            assert final_read.get(UnifiedMetadataKey.ARTISTS) == ["Original FLAC Artist"]  # Should be unchanged
+            assert final_read.get(UnifiedMetadataKey.ARCHIVAL_LOCATION) is None  # Should not exist
+
+    def test_fail_on_unsupported_field_no_changes_riff_only(self):
+        initial_metadata = {"title": "Original WAV Title", "artist": "Original WAV Artist"}
+        with temp_file_with_metadata(initial_metadata, "wav") as test_file:
+            initial_read = get_unified_metadata(test_file)
+            assert initial_read.get(UnifiedMetadataKey.TITLE) == "Original WAV Title"
+            assert initial_read.get(UnifiedMetadataKey.ARTISTS) == ["Original WAV Artist"]
+
+            test_metadata = {
+                UnifiedMetadataKey.TITLE: "New WAV Title",  # TITLE is supported by RIFF format
+                UnifiedMetadataKey.ARTISTS: ["New WAV Artist"],  # ARTISTS is supported by RIFF format
+                UnifiedMetadataKey.REPLAYGAIN: "89 dB",  # REPLAYGAIN is not supported by any format
+            }
+
+            with pytest.raises(MetadataFieldNotSupportedByMetadataFormatError):
+                update_metadata(test_file, test_metadata, fail_on_unsupported_field=True)
+
+            final_read = get_unified_metadata(test_file)
+            assert final_read.get(UnifiedMetadataKey.TITLE) == "Original WAV Title"  # Should be unchanged
+            assert final_read.get(UnifiedMetadataKey.ARTISTS) == ["Original WAV Artist"]  # Should be unchanged
+            assert final_read.get(UnifiedMetadataKey.REPLAYGAIN) is None  # Should not exist

audiometa/test/tests/integration/writing/writing_strategies/unsupported_fields/test_strategy_specific.py

@@ -0,0 +1,99 @@
+import pytest
+
+from audiometa import get_unified_metadata, update_metadata
+from audiometa.exceptions import MetadataFieldNotSupportedByMetadataFormatError
+from audiometa.test.helpers.temp_file_with_metadata import temp_file_with_metadata
+from audiometa.utils.metadata_writing_strategy import MetadataWritingStrategy
+from audiometa.utils.unified_metadata_key import UnifiedMetadataKey
+
+
+@pytest.mark.integration
+class TestStrategySpecific:
+    def test_fail_on_unsupported_field_preserve_strategy(self):
+        initial_metadata = {"title": "Original WAV Title", "artist": "Original WAV Artist"}
+        with temp_file_with_metadata(initial_metadata, "wav") as test_file:
+            initial_read = get_unified_metadata(test_file)
+            assert initial_read.get(UnifiedMetadataKey.TITLE) == "Original WAV Title"
+            assert initial_read.get(UnifiedMetadataKey.ARTISTS) == ["Original WAV Artist"]
+
+            test_metadata = {
+                UnifiedMetadataKey.TITLE: "New WAV Title",  # Should NOT be written
+                UnifiedMetadataKey.ARTISTS: ["New WAV Artist"],  # Should NOT be written
+                UnifiedMetadataKey.REPLAYGAIN: "89 dB",  # Not supported by RIFF format
+            }
+
+            with pytest.raises(MetadataFieldNotSupportedByMetadataFormatError) as exc_info:
+                update_metadata(
+                    test_file,
+                    test_metadata,
+                    metadata_strategy=MetadataWritingStrategy.PRESERVE,
+                    fail_on_unsupported_field=True,
+                )
+
+            assert "Fields not supported by riff format" in str(exc_info.value)
+            assert "REPLAYGAIN" in str(exc_info.value)
+
+            final_read = get_unified_metadata(test_file)
+            assert final_read.get(UnifiedMetadataKey.TITLE) == "Original WAV Title"  # Should be unchanged
+            assert final_read.get(UnifiedMetadataKey.ARTISTS) == ["Original WAV Artist"]  # Should be unchanged
+            assert final_read.get(UnifiedMetadataKey.REPLAYGAIN) is None  # Should not exist
+
+    def test_fail_on_unsupported_field_cleanup_strategy(self):
+        initial_metadata = {"title": "Original WAV Title", "artist": "Original WAV Artist"}
+        with temp_file_with_metadata(initial_metadata, "wav") as test_file:
+            initial_read = get_unified_metadata(test_file)
+            assert initial_read.get(UnifiedMetadataKey.TITLE) == "Original WAV Title"
+            assert initial_read.get(UnifiedMetadataKey.ARTISTS) == ["Original WAV Artist"]
+
+            test_metadata = {
+                UnifiedMetadataKey.TITLE: "New WAV Title",  # Should NOT be written
+                UnifiedMetadataKey.ARTISTS: ["New WAV Artist"],  # Should NOT be written
+                UnifiedMetadataKey.REPLAYGAIN: "89 dB",  # Not supported by RIFF format
+            }
+
+            with pytest.raises(MetadataFieldNotSupportedByMetadataFormatError) as exc_info:
+                update_metadata(
+                    test_file,
+                    test_metadata,
+                    metadata_strategy=MetadataWritingStrategy.CLEANUP,
+                    fail_on_unsupported_field=True,
+                )
+
+            assert "Fields not supported by riff format" in str(exc_info.value)
+            assert "REPLAYGAIN" in str(exc_info.value)
+
+            final_read = get_unified_metadata(test_file)
+            assert final_read.get(UnifiedMetadataKey.TITLE) == "Original WAV Title"  # Should be unchanged
+            assert final_read.get(UnifiedMetadataKey.ARTISTS) == ["Original WAV Artist"]  # Should be unchanged
+            assert final_read.get(UnifiedMetadataKey.REPLAYGAIN) is None  # Should not exist
+
+    def test_fail_on_unsupported_field_sync_strategy(self):
+        initial_metadata = {"title": "Original WAV Title", "artist": "Original WAV Artist"}
+        with temp_file_with_metadata(initial_metadata, "wav") as test_file:
+            initial_read = get_unified_metadata(test_file)
+            assert initial_read.get(UnifiedMetadataKey.TITLE) == "Original WAV Title"
+            assert initial_read.get(UnifiedMetadataKey.ARTISTS) == ["Original WAV Artist"]
+
+            test_metadata = {
+                UnifiedMetadataKey.TITLE: "New WAV Title",  # Should be written to RIFF (supported)
+                UnifiedMetadataKey.ARTISTS: ["New WAV Artist"],  # Should be written to RIFF (supported)
+                UnifiedMetadataKey.REPLAYGAIN: "89 dB",  # Not supported by RIFF format - should cause failure
+            }
+
+            with pytest.raises(MetadataFieldNotSupportedByMetadataFormatError) as exc_info:
+                update_metadata(
+                    test_file,
+                    test_metadata,
+                    metadata_strategy=MetadataWritingStrategy.SYNC,
+                    fail_on_unsupported_field=True,
+                )
+
+            assert "Fields not supported by riff format" in str(exc_info.value)
+            assert "REPLAYGAIN" in str(exc_info.value)
+
+            # With fail_on_unsupported_field=True, the operation should be atomic
+            # No writing should occur, so file should remain unchanged
+            final_read = get_unified_metadata(test_file)
+            assert final_read.get(UnifiedMetadataKey.TITLE) == "Original WAV Title"  # Should be unchanged
+            assert final_read.get(UnifiedMetadataKey.ARTISTS) == ["Original WAV Artist"]  # Should be unchanged
+            assert final_read.get(UnifiedMetadataKey.REPLAYGAIN) is None  # Should not exist

audiometa/test/tests/unit/audio_file/technical_info/test_bitrate.py

@@ -0,0 +1,26 @@
+from pathlib import Path
+
+import pytest
+
+from audiometa._audio_file import _AudioFile
+
+
+@pytest.mark.unit
+class TestAudioFileBitrate:
+    def test_get_bitrate_mp3(self, sample_mp3_file: Path):
+        audio_file = _AudioFile(sample_mp3_file)
+        bitrate = audio_file.get_bitrate()
+        assert isinstance(bitrate, int)
+        assert bitrate > 0
+
+    def test_get_bitrate_flac(self, sample_flac_file: Path):
+        audio_file = _AudioFile(sample_flac_file)
+        bitrate = audio_file.get_bitrate()
+        assert isinstance(bitrate, int)
+        assert bitrate > 0
+
+    def test_get_bitrate_wav(self, sample_wav_file: Path):
+        audio_file = _AudioFile(sample_wav_file)
+        bitrate = audio_file.get_bitrate()
+        assert isinstance(bitrate, int)
+        assert bitrate > 0

audiometa/test/tests/unit/audio_file/technical_info/test_channels.py

@@ -0,0 +1,31 @@
+from pathlib import Path
+
+import pytest
+
+from audiometa._audio_file import _AudioFile
+
+
+@pytest.mark.unit
+class TestAudioFileChannels:
+    def test_get_channels_mp3(self, sample_mp3_file: Path):
+        audio_file = _AudioFile(sample_mp3_file)
+        channels = audio_file.get_channels()
+        assert isinstance(channels, int)
+        assert channels > 0
+
+    def test_get_channels_flac(self, sample_flac_file: Path):
+        audio_file = _AudioFile(sample_flac_file)
+        channels = audio_file.get_channels()
+        assert isinstance(channels, int)
+        assert channels > 0
+
+    def test_get_channels_wav(self, sample_wav_file: Path):
+        audio_file = _AudioFile(sample_wav_file)
+        channels = audio_file.get_channels()
+        assert isinstance(channels, int)
+        assert channels > 0
+
+    def test_get_channels_returns_int(self, sample_mp3_file: Path):
+        audio_file = _AudioFile(sample_mp3_file)
+        channels = audio_file.get_channels()
+        assert isinstance(channels, int)

audiometa/test/tests/unit/audio_file/technical_info/test_duration_in_sec.py

@@ -0,0 +1,38 @@
+from pathlib import Path
+
+import pytest
+
+from audiometa._audio_file import _AudioFile
+
+
+@pytest.mark.unit
+class TestAudioFileDurationInSec:
+    def test_get_duration_in_sec_mp3(self, sample_mp3_file: Path):
+        audio_file = _AudioFile(sample_mp3_file)
+        duration = audio_file.get_duration_in_sec()
+        assert isinstance(duration, float)
+        assert duration > 0
+        assert duration < 1000  # Reasonable bounds check
+
+    def test_get_duration_in_sec_flac(self, sample_flac_file: Path):
+        audio_file = _AudioFile(sample_flac_file)
+        duration = audio_file.get_duration_in_sec()
+        assert isinstance(duration, float)
+        assert duration > 0
+
+    def test_get_duration_in_sec_wav(self, sample_wav_file: Path):
+        audio_file = _AudioFile(sample_wav_file)
+        duration = audio_file.get_duration_in_sec()
+        assert isinstance(duration, float)
+        assert duration > 0
+
+    def test_get_duration_in_sec_long_file(self, duration_182s_mp3: Path):
+        audio_file = _AudioFile(duration_182s_mp3)
+        duration = audio_file.get_duration_in_sec()
+        assert isinstance(duration, float)
+        assert duration > 100
+
+    def test_get_duration_in_sec_returns_float(self, sample_mp3_file: Path):
+        audio_file = _AudioFile(sample_mp3_file)
+        duration = audio_file.get_duration_in_sec()
+        assert isinstance(duration, float)