audiometa-python 0.6.0__py3-none-any.whl

audiometa/test/tests/integration/metadata_field/rating/writing/test_comprehensive.py

@@ -0,0 +1,192 @@
+import pytest
+
+from audiometa import get_unified_metadata_field, 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 TestComprehensiveRatingWriting:
+    def test_write_read_with_different_max_values(self):
+        basic_metadata = {"title": "Test Title", "artist": "Test Artist"}
+
+        with temp_file_with_metadata(basic_metadata, "mp3") as test_file:
+            # Write with base 100
+            test_metadata = {UnifiedMetadataKey.RATING: 50}  # 2.5 stars
+            update_metadata(
+                test_file, test_metadata, normalized_rating_max_value=100, metadata_format=MetadataFormat.ID3V2
+            )
+
+            # Read back with base 100
+            rating_100 = get_unified_metadata_field(
+                test_file, UnifiedMetadataKey.RATING, normalized_rating_max_value=100
+            )
+            assert rating_100 == 50
+
+            # Read back with base 255 (should be normalized)
+            rating_255 = get_unified_metadata_field(
+                test_file, UnifiedMetadataKey.RATING, normalized_rating_max_value=255
+            )
+            assert rating_255 is not None
+            assert isinstance(rating_255, int | float)
+            assert rating_255 > 0
+
+    def test_cross_metadata_format_rating_consistency(self):
+        basic_metadata = {"title": "Test Title", "artist": "Test Artist"}
+        test_rating = 70
+
+        # Test ID3v2 metadata format
+        with temp_file_with_metadata(basic_metadata, "mp3") as test_file:
+            test_metadata = {UnifiedMetadataKey.RATING: test_rating}
+            update_metadata(
+                test_file, test_metadata, normalized_rating_max_value=100, metadata_format=MetadataFormat.ID3V2
+            )
+            rating = get_unified_metadata_field(test_file, UnifiedMetadataKey.RATING, normalized_rating_max_value=100)
+            assert rating is not None
+            assert isinstance(rating, int | float)
+            assert rating > 0
+
+        # Test RIFF metadata format
+        with temp_file_with_metadata(basic_metadata, "wav") as test_file:
+            test_metadata = {UnifiedMetadataKey.RATING: test_rating}
+            update_metadata(
+                test_file, test_metadata, normalized_rating_max_value=100, metadata_format=MetadataFormat.RIFF
+            )
+            rating = get_unified_metadata_field(test_file, UnifiedMetadataKey.RATING, normalized_rating_max_value=100)
+            assert rating is not None
+            assert isinstance(rating, int | float)
+            assert rating > 0
+
+        # Test Vorbis metadata format
+        with temp_file_with_metadata(basic_metadata, "flac") as test_file:
+            test_metadata = {UnifiedMetadataKey.RATING: test_rating}
+            update_metadata(
+                test_file, test_metadata, normalized_rating_max_value=100, metadata_format=MetadataFormat.VORBIS
+            )
+            rating = get_unified_metadata_field(test_file, UnifiedMetadataKey.RATING, normalized_rating_max_value=100)
+            assert rating is not None
+            assert isinstance(rating, int | float)
+            assert rating > 0
+
+    def test_metadata_format_specific_rating_profiles(self):
+        basic_metadata = {"title": "Test Title", "artist": "Test Artist"}
+
+        # Test ID3v2 with base 255 non-proportional values
+        with temp_file_with_metadata(basic_metadata, "mp3") as test_file:
+            test_values = [0, 1, 64, 128, 196, 255]
+            for value in test_values:
+                test_metadata = {UnifiedMetadataKey.RATING: value}
+                update_metadata(
+                    test_file, test_metadata, normalized_rating_max_value=255, metadata_format=MetadataFormat.ID3V2
+                )
+                rating = get_unified_metadata_field(
+                    test_file, UnifiedMetadataKey.RATING, normalized_rating_max_value=255
+                )
+                assert rating is not None
+                assert isinstance(rating, int | float)
+                assert 0 <= rating <= 255
+
+        # Test Vorbis with base 100 proportional values
+        with temp_file_with_metadata(basic_metadata, "flac") as test_file:
+            test_values = [0, 20, 40, 60, 80, 100]
+            for value in test_values:
+                test_metadata = {UnifiedMetadataKey.RATING: value}
+                update_metadata(
+                    test_file,
+                    test_metadata,
+                    normalized_rating_max_value=100,
+                    metadata_format=MetadataFormat.VORBIS,
+                )
+                rating = get_unified_metadata_field(
+                    test_file, UnifiedMetadataKey.RATING, normalized_rating_max_value=100
+                )
+                assert rating is not None
+                assert rating == value
+
+    def test_rating_removal_consistency_across_formats(self):
+        basic_metadata = {"title": "Test Title", "artist": "Test Artist"}
+
+        # Test rating removal behavior across all formats
+        for format_type, file_ext in [
+            (MetadataFormat.ID3V2, "mp3"),
+            (MetadataFormat.RIFF, "wav"),
+            (MetadataFormat.VORBIS, "flac"),
+        ]:
+            with temp_file_with_metadata(basic_metadata, file_ext) as test_file:
+                # First write a rating
+                test_metadata = {UnifiedMetadataKey.RATING: 80}
+                update_metadata(test_file, test_metadata, normalized_rating_max_value=100, metadata_format=format_type)
+                rating = get_unified_metadata_field(
+                    test_file, UnifiedMetadataKey.RATING, normalized_rating_max_value=100
+                )
+                assert rating == 80
+
+                # Then remove it with None
+                test_metadata = {UnifiedMetadataKey.RATING: None}
+                update_metadata(test_file, test_metadata, normalized_rating_max_value=100, metadata_format=format_type)
+                rating = get_unified_metadata_field(
+                    test_file, UnifiedMetadataKey.RATING, normalized_rating_max_value=100
+                )
+                # Rating removal behavior may vary - check if it's None or 0
+                assert rating is None or rating == 0
+
+    def test_write_float_rating_values_normalized_mode(self):
+        basic_metadata = {"title": "Test Title", "artist": "Test Artist"}
+
+        # Test float values with max=10 (half-star ratings)
+        with temp_file_with_metadata(basic_metadata, "mp3") as test_file:
+            test_values = [1.5, 2.5, 3.5, 4.5, 7.5]
+            for value in test_values:
+                test_metadata = {UnifiedMetadataKey.RATING: value}
+                update_metadata(
+                    test_file, test_metadata, normalized_rating_max_value=10, metadata_format=MetadataFormat.ID3V2
+                )
+                rating = get_unified_metadata_field(
+                    test_file, UnifiedMetadataKey.RATING, normalized_rating_max_value=10
+                )
+                assert rating is not None
+                assert isinstance(rating, int | float)
+                assert rating > 0
+
+        # Test float values with max=100
+        with temp_file_with_metadata(basic_metadata, "flac") as test_file:
+            test_values = [1.5, 7.5, 15.0, 25.5, 50.0]
+            for value in test_values:
+                test_metadata = {UnifiedMetadataKey.RATING: value}
+                update_metadata(
+                    test_file,
+                    test_metadata,
+                    normalized_rating_max_value=100,
+                    metadata_format=MetadataFormat.VORBIS,
+                )
+                rating = get_unified_metadata_field(
+                    test_file, UnifiedMetadataKey.RATING, normalized_rating_max_value=100
+                )
+                assert rating is not None
+                assert isinstance(rating, int | float)
+                assert rating >= 0
+
+    @pytest.mark.parametrize("rating_value", [1.5, 75.7, 128.5])
+    def test_write_float_rating_values_raw_mode(self, rating_value):
+        basic_metadata = {"title": "Test Title", "artist": "Test Artist"}
+
+        # Test fractional float values in raw mode (no normalization) - should raise error
+        from audiometa.exceptions import InvalidRatingValueError
+
+        with temp_file_with_metadata(basic_metadata, "mp3") as test_file:
+            test_metadata = {UnifiedMetadataKey.RATING: rating_value}
+            with pytest.raises(InvalidRatingValueError) as exc_info:
+                update_metadata(test_file, test_metadata, metadata_format=MetadataFormat.ID3V2)
+            assert "In raw mode, float values must be whole numbers" in str(exc_info.value)
+
+    @pytest.mark.parametrize("rating_value", [0.0, 128.0, 196.0, 255.0])
+    def test_write_whole_number_float_rating_values_raw_mode(self, rating_value):
+        basic_metadata = {"title": "Test Title", "artist": "Test Artist"}
+
+        # Test whole-number float values in raw mode (no normalization) - should be accepted and converted to int
+        with temp_file_with_metadata(basic_metadata, "mp3") as test_file:
+            test_metadata = {UnifiedMetadataKey.RATING: rating_value}
+            update_metadata(test_file, test_metadata, metadata_format=MetadataFormat.ID3V2)
+            rating = get_unified_metadata_field(test_file, UnifiedMetadataKey.RATING)
+            assert rating == int(rating_value)

audiometa/test/tests/integration/metadata_field/release_date/test_deleting.py

@@ -0,0 +1,74 @@
+import pytest
+
+from audiometa import get_unified_metadata_field, 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 TestReleaseDateDeleting:
+    def test_delete_release_date_id3v2(self):
+        with temp_file_with_metadata({}, "mp3") as test_file:
+            update_metadata(
+                test_file, {UnifiedMetadataKey.RELEASE_DATE: "2023-01-01"}, metadata_format=MetadataFormat.ID3V2
+            )
+            assert get_unified_metadata_field(test_file, UnifiedMetadataKey.RELEASE_DATE) == "2023-01-01"
+
+            update_metadata(test_file, {UnifiedMetadataKey.RELEASE_DATE: None}, metadata_format=MetadataFormat.ID3V2)
+            assert get_unified_metadata_field(test_file, UnifiedMetadataKey.RELEASE_DATE) is None
+
+    def test_delete_release_date_id3v1(self):
+        with temp_file_with_metadata({}, "mp3") as test_file:
+            update_metadata(test_file, {UnifiedMetadataKey.RELEASE_DATE: "2023"}, metadata_format=MetadataFormat.ID3V1)
+            assert get_unified_metadata_field(test_file, UnifiedMetadataKey.RELEASE_DATE) == "2023"
+
+            update_metadata(test_file, {UnifiedMetadataKey.RELEASE_DATE: None}, metadata_format=MetadataFormat.ID3V1)
+            assert get_unified_metadata_field(test_file, UnifiedMetadataKey.RELEASE_DATE) is None
+
+    def test_delete_release_date_riff(self):
+        with temp_file_with_metadata({}, "wav") as test_file:
+            update_metadata(
+                test_file, {UnifiedMetadataKey.RELEASE_DATE: "2023-01-01"}, metadata_format=MetadataFormat.RIFF
+            )
+            assert get_unified_metadata_field(test_file, UnifiedMetadataKey.RELEASE_DATE) == "2023-01-01"
+
+            update_metadata(test_file, {UnifiedMetadataKey.RELEASE_DATE: None}, metadata_format=MetadataFormat.RIFF)
+            assert get_unified_metadata_field(test_file, UnifiedMetadataKey.RELEASE_DATE) is None
+
+    def test_delete_release_date_vorbis(self):
+        with temp_file_with_metadata({}, "flac") as test_file:
+            update_metadata(
+                test_file, {UnifiedMetadataKey.RELEASE_DATE: "2023-01-01"}, metadata_format=MetadataFormat.VORBIS
+            )
+            assert get_unified_metadata_field(test_file, UnifiedMetadataKey.RELEASE_DATE) == "2023-01-01"
+
+            update_metadata(test_file, {UnifiedMetadataKey.RELEASE_DATE: None}, metadata_format=MetadataFormat.VORBIS)
+            assert get_unified_metadata_field(test_file, UnifiedMetadataKey.RELEASE_DATE) is None
+
+    def test_delete_release_date_preserves_other_fields(self):
+        with temp_file_with_metadata({}, "mp3") as test_file:
+            update_metadata(
+                test_file,
+                {
+                    UnifiedMetadataKey.RELEASE_DATE: "2023-01-01",
+                    UnifiedMetadataKey.TITLE: "Test Title",
+                    UnifiedMetadataKey.ARTISTS: ["Test Artist"],
+                },
+            )
+
+            update_metadata(test_file, {UnifiedMetadataKey.RELEASE_DATE: None})
+
+            assert get_unified_metadata_field(test_file, UnifiedMetadataKey.RELEASE_DATE) is None
+            assert get_unified_metadata_field(test_file, UnifiedMetadataKey.TITLE) == "Test Title"
+            assert get_unified_metadata_field(test_file, UnifiedMetadataKey.ARTISTS) == ["Test Artist"]
+
+    def test_delete_release_date_already_none(self):
+        with temp_file_with_metadata({}, "mp3") as test_file:
+            update_metadata(test_file, {UnifiedMetadataKey.RELEASE_DATE: None})
+            assert get_unified_metadata_field(test_file, UnifiedMetadataKey.RELEASE_DATE) is None
+
+    def test_delete_release_date_empty_string(self):
+        with temp_file_with_metadata({}, "mp3") as test_file:
+            update_metadata(test_file, {UnifiedMetadataKey.RELEASE_DATE: ""}, metadata_format=MetadataFormat.ID3V2)
+            assert get_unified_metadata_field(test_file, UnifiedMetadataKey.RELEASE_DATE) is None

audiometa/test/tests/integration/metadata_field/release_date/test_error_handling.py

@@ -0,0 +1,82 @@
+import pytest
+
+from audiometa import update_metadata
+from audiometa.exceptions import InvalidMetadataFieldFormatError
+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 TestReleaseDateErrorHandling:
+    def test_invalid_format_wrong_separator_mp3(self):
+        with temp_file_with_metadata({}, "mp3") as test_file:
+            invalid_dates = [
+                "2024/01/01",
+                "2024.01.01",
+                "2024 01 01",
+            ]
+            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
+
+    def test_invalid_format_single_digit_mp3(self):
+        with temp_file_with_metadata({}, "mp3") as test_file:
+            invalid_dates = [
+                "2024-1-1",
+                "2024-1-01",
+                "2024-01-1",
+            ]
+            for invalid_date in invalid_dates:
+                with pytest.raises(InvalidMetadataFieldFormatError):
+                    update_metadata(test_file, {UnifiedMetadataKey.RELEASE_DATE: invalid_date})
+
+    def test_invalid_format_short_year_mp3(self):
+        with temp_file_with_metadata({}, "mp3") as test_file:
+            invalid_dates = ["24", "024", "999"]
+            for invalid_date in invalid_dates:
+                with pytest.raises(InvalidMetadataFieldFormatError):
+                    update_metadata(test_file, {UnifiedMetadataKey.RELEASE_DATE: invalid_date})
+
+    def test_invalid_format_non_numeric_mp3(self):
+        with temp_file_with_metadata({}, "mp3") as test_file:
+            invalid_dates = [
+                "not-a-date",
+                "2024-abc-01",
+                "abcd-01-01",
+            ]
+            for invalid_date in invalid_dates:
+                with pytest.raises(InvalidMetadataFieldFormatError):
+                    update_metadata(test_file, {UnifiedMetadataKey.RELEASE_DATE: invalid_date})
+
+    def test_invalid_format_wrong_separator_flac(self):
+        with temp_file_with_metadata({}, "flac") as test_file, pytest.raises(InvalidMetadataFieldFormatError):
+            update_metadata(test_file, {UnifiedMetadataKey.RELEASE_DATE: "2024/01/01"})
+
+    def test_invalid_format_wrong_separator_wav(self):
+        with temp_file_with_metadata({}, "wav") as test_file, pytest.raises(InvalidMetadataFieldFormatError):
+            update_metadata(test_file, {UnifiedMetadataKey.RELEASE_DATE: "2024/01/01"})
+
+    def test_valid_format_yyyy_passes(self):
+        with temp_file_with_metadata({}, "mp3") as test_file:
+            update_metadata(test_file, {UnifiedMetadataKey.RELEASE_DATE: "2024"})
+
+    def test_valid_format_yyyy_mm_dd_passes(self):
+        with temp_file_with_metadata({}, "mp3") as test_file:
+            update_metadata(test_file, {UnifiedMetadataKey.RELEASE_DATE: "2024-01-01"})
+
+    def test_none_value_allowed(self):
+        with temp_file_with_metadata({}, "mp3") as test_file:
+            update_metadata(test_file, {UnifiedMetadataKey.RELEASE_DATE: None})
+
+    def test_invalid_format_with_multiple_fields(self):
+        with temp_file_with_metadata({}, "mp3") as test_file, pytest.raises(InvalidMetadataFieldFormatError):
+            update_metadata(
+                test_file,
+                {
+                    UnifiedMetadataKey.TITLE: "Valid Title",
+                    UnifiedMetadataKey.RELEASE_DATE: "2024/01/01",
+                },
+            )

audiometa/test/tests/integration/metadata_field/release_date/test_reading.py

@@ -0,0 +1,59 @@
+import pytest
+
+from audiometa import get_unified_metadata_field
+from audiometa.test.helpers.id3v1.id3v1_metadata_setter import ID3v1MetadataSetter
+from audiometa.test.helpers.id3v2.id3v2_metadata_getter import ID3v2MetadataGetter
+from audiometa.test.helpers.id3v2.id3v2_metadata_setter import ID3v2MetadataSetter
+from audiometa.test.helpers.riff.riff_metadata_getter import RIFFMetadataGetter
+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.test.helpers.vorbis.vorbis_metadata_getter import VorbisMetadataGetter
+from audiometa.test.helpers.vorbis.vorbis_metadata_setter import VorbisMetadataSetter
+from audiometa.utils.unified_metadata_key import UnifiedMetadataKey
+
+
+@pytest.mark.integration
+class TestReleaseDateReading:
+    def test_id3v1(self):
+        with temp_file_with_metadata({"title": "Test Song"}, "id3v1") as test_file:
+            ID3v1MetadataSetter.set_max_metadata(test_file)
+
+            release_date = get_unified_metadata_field(test_file, UnifiedMetadataKey.RELEASE_DATE)
+            assert release_date == "9999"
+
+    def test_id3v2_3(self):
+        with temp_file_with_metadata({"title": "Test Song"}, "mp3") as test_file:
+            ID3v2MetadataSetter.set_release_date(test_file, "9999-12-31", version="2.3")
+            raw_metadata = ID3v2MetadataGetter.get_raw_metadata(test_file, version="2.3")
+            assert raw_metadata["TDAT"] == ["3112"]
+            assert raw_metadata["TYER"] == ["9999"]
+
+            release_date = get_unified_metadata_field(test_file, UnifiedMetadataKey.RELEASE_DATE)
+            assert release_date == "9999-12-31"
+
+    def test_id3v2_4(self):
+        with temp_file_with_metadata({"title": "Test Song"}, "mp3") as test_file:
+            ID3v2MetadataSetter.set_release_date(test_file, "9999-12-31", version="2.4")
+            raw_metadata = ID3v2MetadataGetter.get_raw_metadata(test_file, version="2.4")
+            assert raw_metadata["TDRC"] == ["9999-12-31"]
+
+            release_date = get_unified_metadata_field(test_file, UnifiedMetadataKey.RELEASE_DATE)
+            assert release_date == "9999-12-31"
+
+    def test_vorbis(self):
+        with temp_file_with_metadata({"title": "Test Song"}, "flac") as test_file:
+            VorbisMetadataSetter.set_release_date(test_file, "9999-12-31")
+            raw_metadata = VorbisMetadataGetter.get_raw_metadata(test_file)
+            assert "DATE=9999-12-31" in raw_metadata
+
+            release_date = get_unified_metadata_field(test_file, UnifiedMetadataKey.RELEASE_DATE)
+            assert release_date == "9999-12-31"
+
+    def test_riff(self):
+        with temp_file_with_metadata({"title": "Test Song"}, "wav") as test_file:
+            RIFFMetadataSetter.set_release_date(test_file, "9999-12-31")
+            raw_metadata = RIFFMetadataGetter.get_raw_metadata(test_file)
+            assert "TAG:date=9999-12-31" in raw_metadata
+
+            release_date = get_unified_metadata_field(test_file, UnifiedMetadataKey.RELEASE_DATE)
+            assert release_date == "9999-12-31"

audiometa/test/tests/integration/metadata_field/release_date/test_writing.py

@@ -0,0 +1,49 @@
+import pytest
+
+from audiometa import get_unified_metadata_field, 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 TestReleaseDateWriting:
+    def test_id3v2(self):
+        with temp_file_with_metadata({}, "mp3") as test_file:
+            test_release_date = "2024-01-01"
+            test_metadata = {UnifiedMetadataKey.RELEASE_DATE: test_release_date}
+            update_metadata(test_file, test_metadata, metadata_format=MetadataFormat.ID3V2)
+            release_date = get_unified_metadata_field(test_file, UnifiedMetadataKey.RELEASE_DATE)
+            assert release_date == test_release_date
+
+    def test_riff(self):
+        with temp_file_with_metadata({}, "wav") as test_file:
+            test_release_date = "2024-02-01"
+            test_metadata = {UnifiedMetadataKey.RELEASE_DATE: test_release_date}
+            update_metadata(test_file, test_metadata, metadata_format=MetadataFormat.RIFF)
+            release_date = get_unified_metadata_field(test_file, UnifiedMetadataKey.RELEASE_DATE)
+            assert release_date == test_release_date
+
+    def test_vorbis(self):
+        with temp_file_with_metadata({}, "flac") as test_file:
+            test_release_date = "2024-03-01"
+            test_metadata = {UnifiedMetadataKey.RELEASE_DATE: test_release_date}
+            update_metadata(test_file, test_metadata, metadata_format=MetadataFormat.VORBIS)
+            release_date = get_unified_metadata_field(test_file, UnifiedMetadataKey.RELEASE_DATE)
+            assert release_date == test_release_date
+
+    def test_id3v1(self):
+        with temp_file_with_metadata({}, "mp3") as test_file:
+            test_release_date = "2024"
+            test_metadata = {UnifiedMetadataKey.RELEASE_DATE: test_release_date}
+            update_metadata(test_file, test_metadata, metadata_format=MetadataFormat.ID3V1)
+            release_date = get_unified_metadata_field(test_file, UnifiedMetadataKey.RELEASE_DATE)
+            assert release_date == test_release_date
+
+    def test_invalid_type_raises(self):
+        from audiometa.exceptions import InvalidMetadataFieldTypeError
+
+        with temp_file_with_metadata({}, "mp3") as test_file:
+            bad_metadata = {UnifiedMetadataKey.RELEASE_DATE: 20240101}
+            with pytest.raises(InvalidMetadataFieldTypeError):
+                update_metadata(test_file, bad_metadata)

audiometa/test/tests/integration/metadata_field/test_metadata_field_validation.py

@@ -0,0 +1,135 @@
+from pathlib import Path
+
+import pytest
+
+from audiometa import UnifiedMetadataKey, get_unified_metadata_field, update_metadata
+from audiometa.exceptions import (
+    InvalidMetadataFieldTypeError,
+    MetadataFieldNotSupportedByLibError,
+    MetadataFieldNotSupportedByMetadataFormatError,
+)
+from audiometa.test.helpers.temp_file_with_metadata import temp_file_with_metadata
+from audiometa.utils.metadata_format import MetadataFormat
+
+
+@pytest.mark.integration
+class TestMetadataFieldValidation:
+    """Test that get_unified_metadata_field raises MetadataFieldNotSupportedByMetadataFormatError when a field is not
+    supported by the specified format.
+    """
+
+    def test_replaygain_not_supported_by_riff(self, sample_wav_file: Path):
+        with pytest.raises(
+            MetadataFieldNotSupportedByMetadataFormatError,
+            match="UnifiedMetadataKey.REPLAYGAIN metadata not supported by RIFF format",
+        ):
+            get_unified_metadata_field(
+                sample_wav_file, UnifiedMetadataKey.REPLAYGAIN, metadata_format=MetadataFormat.RIFF
+            )
+
+    def test_replaygain_not_supported_by_id3v1(self, sample_mp3_file: Path):
+        with pytest.raises(
+            MetadataFieldNotSupportedByMetadataFormatError,
+            match="UnifiedMetadataKey.REPLAYGAIN metadata not supported by ID3v1 format",
+        ):
+            get_unified_metadata_field(
+                sample_mp3_file, UnifiedMetadataKey.REPLAYGAIN, metadata_format=MetadataFormat.ID3V1
+            )
+
+    def test_album_artists_not_supported_by_id3v1(self, sample_mp3_file: Path):
+        with pytest.raises(
+            MetadataFieldNotSupportedByMetadataFormatError,
+            match="UnifiedMetadataKey.ALBUM_ARTISTS metadata not supported by ID3v1 format",
+        ):
+            get_unified_metadata_field(
+                sample_mp3_file, UnifiedMetadataKey.ALBUM_ARTISTS, metadata_format=MetadataFormat.ID3V1
+            )
+
+    def test_supported_field_works_with_riff(self, sample_wav_file: Path):
+        title = get_unified_metadata_field(
+            sample_wav_file, UnifiedMetadataKey.TITLE, metadata_format=MetadataFormat.RIFF
+        )
+        assert title is None or isinstance(title, str)
+
+    def test_supported_field_works_with_id3v1(self, sample_mp3_file: Path):
+        title = get_unified_metadata_field(
+            sample_mp3_file, UnifiedMetadataKey.TITLE, metadata_format=MetadataFormat.ID3V1
+        )
+        assert title is None or isinstance(title, str)
+
+    def test_unsupported_field_without_format_specification(self, sample_wav_file: Path):
+        bpm = get_unified_metadata_field(sample_wav_file, UnifiedMetadataKey.BPM)
+        assert bpm is None or isinstance(bpm, int)
+
+    def test_rating_supported_by_riff_indirectly(self, sample_wav_file: Path):
+        rating = get_unified_metadata_field(
+            sample_wav_file, UnifiedMetadataKey.RATING, metadata_format=MetadataFormat.RIFF
+        )
+        assert rating is None or isinstance(rating, int)
+
+    def test_field_not_supported_by_lib_exception_exists(self):
+        msg = "Test field not supported by library"
+        with pytest.raises(MetadataFieldNotSupportedByLibError, match="Test field not supported by library"):
+            raise MetadataFieldNotSupportedByLibError(msg)
+
+    def test_field_not_supported_by_lib_concept(self):
+        with (
+            temp_file_with_metadata({}, "wav") as test_file,
+            pytest.raises(MetadataFieldNotSupportedByLibError, match="Test field not supported by library"),
+        ):
+            get_unified_metadata_field(test_file, "Test field not supported by library")
+
+    def test_valid_string_key_works(self, sample_mp3_file: Path):
+        """Test that passing a string matching a UnifiedMetadataKey enum value works."""
+        # Test various string values that match enum values
+        title = get_unified_metadata_field(sample_mp3_file, "title")
+        assert title is None or isinstance(title, str)
+
+        artists = get_unified_metadata_field(sample_mp3_file, "artists")
+        assert artists is None or isinstance(artists, list)
+
+        rating = get_unified_metadata_field(sample_mp3_file, "rating")
+        assert rating is None or isinstance(rating, int)
+
+        # Verify it works the same as enum
+        title_enum = get_unified_metadata_field(sample_mp3_file, UnifiedMetadataKey.TITLE)
+        assert title == title_enum
+
+    def test_invalid_string_key_raises_error(self, sample_mp3_file: Path):
+        """Test that passing an invalid string raises MetadataFieldNotSupportedByLibError."""
+        with pytest.raises(
+            MetadataFieldNotSupportedByLibError, match="invalid_field metadata not supported by the library"
+        ):
+            get_unified_metadata_field(sample_mp3_file, "invalid_field")
+
+    def test_all_valid_enum_values_work(self, sample_mp3_file: Path):
+        """Test that all valid UnifiedMetadataKey enum values are accepted (not rejected as invalid enum values)."""
+        for key in UnifiedMetadataKey:
+            # Should not raise MetadataFieldNotSupportedByLibError for invalid enum value
+            # (it's okay if it raises for "not supported by any format" - that's different)
+            try:
+                result = get_unified_metadata_field(sample_mp3_file, key)
+                # Result can be None if field is not present, which is valid
+                assert result is None or isinstance(result, str | int | float | list)
+            except MetadataFieldNotSupportedByLibError as e:
+                # Only fail if the error message indicates invalid enum value
+                # It's okay if it raises for "not supported by any format" - that's different
+                if "not supported by any format" not in str(e):
+                    raise
+
+    def test_invalid_metadata_field_type_error_wrong_type_for_list_field(self):
+        with temp_file_with_metadata({}, "mp3") as test_file:
+            with pytest.raises(InvalidMetadataFieldTypeError) as exc_info:
+                update_metadata(test_file, {UnifiedMetadataKey.ARTISTS: "should be list"})
+            error = exc_info.value
+            assert error.field == UnifiedMetadataKey.ARTISTS.value
+            assert "list" in error.expected_type.lower()
+            assert error.value == "should be list"
+
+    def test_invalid_metadata_field_type_error_wrong_type_for_string_field(self):
+        with temp_file_with_metadata({}, "mp3") as test_file:
+            with pytest.raises(InvalidMetadataFieldTypeError) as exc_info:
+                update_metadata(test_file, {UnifiedMetadataKey.TITLE: 12345})
+            error = exc_info.value
+            assert error.field == UnifiedMetadataKey.TITLE.value
+            assert error.value == 12345