audiometa-python 0.6.0__py3-none-any.whl

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

@@ -0,0 +1,39 @@
+import pytest
+
+from audiometa import get_unified_metadata_field
+from audiometa.test.helpers.id3v1 import ID3v1MetadataSetter
+from audiometa.test.helpers.id3v2 import ID3v2MetadataSetter
+from audiometa.test.helpers.riff import RIFFMetadataSetter
+from audiometa.test.helpers.riff.riff_metadata_getter import RIFFMetadataGetter
+from audiometa.test.helpers.temp_file_with_metadata import temp_file_with_metadata
+from audiometa.test.helpers.vorbis import VorbisMetadataSetter
+from audiometa.utils.unified_metadata_key import UnifiedMetadataKey
+
+
+@pytest.mark.integration
+class TestLanguageReading:
+    def test_id3v1(self):
+        with temp_file_with_metadata({"title": "Test Song"}, "id3v1") as test_file:
+            ID3v1MetadataSetter.set_max_metadata(test_file)
+            language = get_unified_metadata_field(test_file, UnifiedMetadataKey.LANGUAGE)
+            assert language is None
+
+    def test_id3v2(self):
+        with temp_file_with_metadata({"title": "Test Song"}, "mp3") as test_file:
+            ID3v2MetadataSetter.set_max_metadata(test_file)
+            language = get_unified_metadata_field(test_file, UnifiedMetadataKey.LANGUAGE)
+            assert language == "a" * 1000
+
+    def test_vorbis(self):
+        with temp_file_with_metadata({"title": "Test Song"}, "flac") as test_file:
+            VorbisMetadataSetter.set_max_metadata(test_file)
+            language = get_unified_metadata_field(test_file, UnifiedMetadataKey.LANGUAGE)
+            assert language == "a" * 1000
+
+    def test_riff(self):
+        with temp_file_with_metadata({"title": "Test Song"}, "wav") as test_file:
+            RIFFMetadataSetter.set_language(test_file, "en")
+            assert "TAG:language=en" in RIFFMetadataGetter.get_raw_metadata(test_file)
+
+            language = get_unified_metadata_field(test_file, UnifiedMetadataKey.LANGUAGE)
+            assert language == "en"

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

@@ -0,0 +1,43 @@
+import pytest
+
+from audiometa import get_unified_metadata_field, update_metadata
+from audiometa.test.helpers.riff.riff_metadata_getter import RIFFMetadataGetter
+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 TestLanguageWriting:
+    def test_id3v2(self):
+        with temp_file_with_metadata({}, "mp3") as test_file:
+            test_language = "en"
+            test_metadata = {UnifiedMetadataKey.LANGUAGE: test_language}
+            update_metadata(test_file, test_metadata, metadata_format=MetadataFormat.ID3V2)
+            language = get_unified_metadata_field(test_file, UnifiedMetadataKey.LANGUAGE)
+            assert language == test_language
+
+    def test_riff(self):
+        with temp_file_with_metadata({}, "wav") as test_file:
+            test_language = "fr"
+            test_metadata = {UnifiedMetadataKey.LANGUAGE: test_language}
+            update_metadata(test_file, test_metadata, metadata_format=MetadataFormat.RIFF)
+
+            raw_metadata = RIFFMetadataGetter.get_raw_metadata(test_file)
+            assert "TAG:language=fr" in raw_metadata
+
+    def test_vorbis(self):
+        with temp_file_with_metadata({}, "flac") as test_file:
+            test_language = "de"
+            test_metadata = {UnifiedMetadataKey.LANGUAGE: test_language}
+            update_metadata(test_file, test_metadata, metadata_format=MetadataFormat.VORBIS)
+            language = get_unified_metadata_field(test_file, UnifiedMetadataKey.LANGUAGE)
+            assert language == test_language
+
+    def test_invalid_type_raises(self):
+        from audiometa.exceptions import InvalidMetadataFieldTypeError
+
+        with temp_file_with_metadata({}, "mp3") as test_file:
+            bad_metadata = {UnifiedMetadataKey.LANGUAGE: 123}
+            with pytest.raises(InvalidMetadataFieldTypeError):
+                update_metadata(test_file, bad_metadata)

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

@@ -0,0 +1,129 @@
+import pytest
+
+from audiometa import update_metadata
+from audiometa.exceptions import MetadataFieldNotSupportedByMetadataFormatError
+from audiometa.test.helpers.id3v2.id3v2_metadata_getter import ID3v2MetadataGetter
+from audiometa.test.helpers.id3v2.id3v2_metadata_setter import ID3v2MetadataSetter
+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.utils.metadata_format import MetadataFormat
+from audiometa.utils.unified_metadata_key import UnifiedMetadataKey
+
+
+@pytest.mark.integration
+class TestLyricsDeleting:
+    def test_delete_lyrics_id3v1(self):
+        with (
+            temp_file_with_metadata({}, "mp3") as test_file,
+            pytest.raises(
+                MetadataFieldNotSupportedByMetadataFormatError,
+                match="UnifiedMetadataKey.UNSYNCHRONIZED_LYRICS metadata not supported by ID3v1 format",
+            ),
+        ):
+            update_metadata(
+                test_file,
+                {UnifiedMetadataKey.UNSYNCHRONIZED_LYRICS: "Test lyrics"},
+                metadata_format=MetadataFormat.ID3V1,
+            )
+
+    def test_delete_lyrics_id3v2_3(self):
+        with temp_file_with_metadata({}, "id3v2.3") as test_file:
+            ID3v2MetadataSetter.set_lyrics(test_file, "Test lyrics", version="2.3")
+            raw_metadata = ID3v2MetadataGetter.get_raw_metadata(test_file, version="2.3")
+            # 4 null bytes because of missing language
+            assert raw_metadata["USLT"] == ["\x00\x00\x00\x00Test lyrics"]
+
+            update_metadata(
+                test_file,
+                {UnifiedMetadataKey.UNSYNCHRONIZED_LYRICS: None},
+                metadata_format=MetadataFormat.ID3V2,
+                id3v2_version=(2, 3, 0),
+            )
+
+            raw_metadata = ID3v2MetadataGetter.get_raw_metadata(test_file, version="2.3")
+            assert raw_metadata.get("USLT") is None
+
+    def test_delete_lyrics_id3v2_4(self):
+        with temp_file_with_metadata({}, "id3v2.4") as test_file:
+            ID3v2MetadataSetter.set_lyrics(test_file, "Test lyrics", version="2.4")
+            raw_metadata = ID3v2MetadataGetter.get_raw_metadata(test_file, version="2.4")
+            assert raw_metadata["USLT"] == ["eng\x00Test lyrics"]
+
+            update_metadata(
+                test_file,
+                {UnifiedMetadataKey.UNSYNCHRONIZED_LYRICS: None},
+                metadata_format=MetadataFormat.ID3V2,
+                id3v2_version=(2, 4, 0),
+            )
+
+            raw_metadata = ID3v2MetadataGetter.get_raw_metadata(test_file, version="2.4")
+            assert raw_metadata.get("USLT") is None
+
+    def test_delete_lyrics_riff(self):
+        with temp_file_with_metadata({}, "wav") as test_file:
+            from audiometa.test.helpers.riff.riff_metadata_getter import RIFFMetadataGetter
+            from audiometa.test.helpers.riff.riff_metadata_setter import RIFFMetadataSetter
+
+            RIFFMetadataSetter.set_lyrics(test_file, "Test lyrics")
+            raw_metadata = RIFFMetadataGetter.get_raw_metadata(test_file)
+            assert "TAG:lyrics=Test lyrics" in raw_metadata
+
+            update_metadata(
+                test_file, {UnifiedMetadataKey.UNSYNCHRONIZED_LYRICS: None}, metadata_format=MetadataFormat.RIFF
+            )
+
+            raw_metadata = RIFFMetadataGetter.get_raw_metadata(test_file)
+            assert "TAG:lyrics=" not in raw_metadata
+
+    def test_delete_lyrics_vorbis(self):
+        with temp_file_with_metadata({}, "flac") as test_file:
+            from audiometa.test.helpers.vorbis.vorbis_metadata_setter import VorbisMetadataSetter
+
+            VorbisMetadataSetter.set_lyrics(test_file, "Test lyrics")
+            raw_metadata = VorbisMetadataGetter.get_raw_metadata(test_file)
+            assert "LYRICS=Test lyrics" in raw_metadata
+
+            update_metadata(
+                test_file, {UnifiedMetadataKey.UNSYNCHRONIZED_LYRICS: None}, metadata_format=MetadataFormat.VORBIS
+            )
+
+            raw_metadata = VorbisMetadataGetter.get_raw_metadata(test_file)
+            assert "LYRICS=" not in raw_metadata
+
+    def test_delete_lyrics_preserves_other_fields(self):
+        with temp_file_with_metadata({}, "mp3") as test_file:
+            # Set multiple metadata fields using helper methods
+            ID3v2MetadataSetter.set_lyrics(test_file, "Test lyrics")
+            ID3v2MetadataSetter.set_title(test_file, "Test Title")
+            ID3v2MetadataSetter.set_artists(test_file, "Test Artist")
+
+            # Delete only lyrics using library API
+            update_metadata(
+                test_file, {UnifiedMetadataKey.UNSYNCHRONIZED_LYRICS: None}, metadata_format=MetadataFormat.ID3V2
+            )
+
+            raw_metadata = ID3v2MetadataGetter.get_raw_metadata(test_file)
+            assert raw_metadata is None
+
+    def test_delete_lyrics_already_none(self):
+        with temp_file_with_metadata({}, "flac") as test_file:
+            # Try to delete lyrics that don't exist
+            raw_metadata = VorbisMetadataGetter.get_raw_metadata(test_file)
+            assert "LYRICS=" not in raw_metadata
+
+            update_metadata(
+                test_file, {UnifiedMetadataKey.UNSYNCHRONIZED_LYRICS: None}, metadata_format=MetadataFormat.VORBIS
+            )
+
+            raw_metadata = VorbisMetadataGetter.get_raw_metadata(test_file)
+            assert "LYRICS=" not in raw_metadata
+
+    def test_delete_lyrics_empty_string(self):
+        from audiometa import get_unified_metadata_field
+
+        with temp_file_with_metadata({}, "mp3") as test_file:
+            update_metadata(
+                test_file, {UnifiedMetadataKey.UNSYNCHRONIZED_LYRICS: ""}, metadata_format=MetadataFormat.ID3V2
+            )
+            lyrics = get_unified_metadata_field(test_file, UnifiedMetadataKey.UNSYNCHRONIZED_LYRICS)
+            assert lyrics is None

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

@@ -0,0 +1,57 @@
+import pytest
+
+from audiometa import get_unified_metadata_field
+from audiometa.exceptions import MetadataFieldNotSupportedByMetadataFormatError
+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.test.helpers.vorbis.vorbis_metadata_setter import VorbisMetadataSetter
+from audiometa.utils.metadata_format import MetadataFormat
+from audiometa.utils.unified_metadata_key import UnifiedMetadataKey
+
+
+@pytest.mark.integration
+class TestLyricsReading:
+    def test_id3v1(self):
+        with (
+            temp_file_with_metadata({"title": "Test Song"}, "id3v1") as test_file,
+            pytest.raises(
+                MetadataFieldNotSupportedByMetadataFormatError,
+                match="UnifiedMetadataKey.UNSYNCHRONIZED_LYRICS metadata not supported by ID3v1 format",
+            ),
+        ):
+            get_unified_metadata_field(
+                test_file, UnifiedMetadataKey.UNSYNCHRONIZED_LYRICS, metadata_format=MetadataFormat.ID3V1
+            )
+
+    def test_id3v2_3(self):
+        with temp_file_with_metadata({"title": "Test Song"}, "id3v2.3") as test_file:
+            ID3v2MetadataSetter.set_lyrics(test_file, "a" * 4000, version="2.3")
+            lyrics = get_unified_metadata_field(
+                test_file, UnifiedMetadataKey.UNSYNCHRONIZED_LYRICS, metadata_format=MetadataFormat.ID3V2
+            )
+            assert lyrics == "a" * 4000
+
+    def test_id3v2_4(self):
+        with temp_file_with_metadata({"title": "Test Song"}, "id3v2.4") as test_file:
+            ID3v2MetadataSetter.set_lyrics(test_file, "a" * 4000, version="2.4")
+            lyrics = get_unified_metadata_field(
+                test_file, UnifiedMetadataKey.UNSYNCHRONIZED_LYRICS, metadata_format=MetadataFormat.ID3V2
+            )
+            assert lyrics == "a" * 4000
+
+    def test_vorbis(self):
+        with temp_file_with_metadata({"title": "Test Song"}, "flac") as test_file:
+            VorbisMetadataSetter.set_lyrics(test_file, "a" * 4000)
+            lyrics = get_unified_metadata_field(
+                test_file, UnifiedMetadataKey.UNSYNCHRONIZED_LYRICS, metadata_format=MetadataFormat.VORBIS
+            )
+            assert lyrics == "a" * 4000
+
+    def test_riff(self):
+        with temp_file_with_metadata({"title": "Test Song"}, "wav") as test_file:
+            RIFFMetadataSetter.set_lyrics(test_file, "a" * 4000)
+            lyrics = get_unified_metadata_field(
+                test_file, UnifiedMetadataKey.UNSYNCHRONIZED_LYRICS, metadata_format=MetadataFormat.RIFF
+            )
+            assert lyrics == "a" * 4000

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

@@ -0,0 +1,59 @@
+import pytest
+
+from audiometa import update_metadata
+from audiometa.test.helpers.id3v2.id3v2_header_verifier import ID3v2HeaderVerifier
+from audiometa.test.helpers.id3v2.id3v2_metadata_getter import ID3v2MetadataGetter
+from audiometa.test.helpers.riff.riff_metadata_getter import RIFFMetadataGetter
+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 TestLyricsWriting:
+    def test_id3v2_3_default_en(self):
+        with temp_file_with_metadata({}, "mp3") as test_file:
+            test_lyrics = "These are test lyrics\nWith multiple lines\nFor testing purposes"
+            test_metadata = {UnifiedMetadataKey.UNSYNCHRONIZED_LYRICS: test_lyrics}
+            update_metadata(test_file, test_metadata, metadata_format=MetadataFormat.ID3V2, id3v2_version=(2, 3, 0))
+
+            raw_metadata = ID3v2MetadataGetter.get_raw_metadata(test_file, version="2.3")
+            assert [f"eng\x00{test_lyrics}"] == raw_metadata["USLT"]
+
+    def test_id3v2_4_default_en(self):
+        with temp_file_with_metadata({}, "mp3") as test_file:
+            test_lyrics = "These are test lyrics\nWith multiple lines\nFor testing purposes"
+            test_metadata = {UnifiedMetadataKey.UNSYNCHRONIZED_LYRICS: test_lyrics}
+            update_metadata(test_file, test_metadata, metadata_format=MetadataFormat.ID3V2, id3v2_version=(2, 4, 0))
+
+            assert ID3v2HeaderVerifier.get_id3v2_version(test_file) == (2, 4, 0)
+            raw_metadata = ID3v2MetadataGetter.get_raw_metadata(test_file, version="2.4")
+            assert [f"eng\x00{test_lyrics}"] == raw_metadata["USLT"]
+
+    def test_riff(self):
+        with temp_file_with_metadata({}, "wav") as test_file:
+            test_lyrics = "RIFF test lyrics\nWith multiple lines\nFor testing purposes"
+            test_metadata = {UnifiedMetadataKey.UNSYNCHRONIZED_LYRICS: test_lyrics}
+            update_metadata(test_file, test_metadata, metadata_format=MetadataFormat.RIFF)
+
+            raw_metadata = RIFFMetadataGetter.get_raw_metadata(test_file)
+            assert f"TAG:lyrics={test_lyrics}" in raw_metadata
+
+    def test_vorbis(self):
+        from audiometa.test.helpers.vorbis.vorbis_metadata_getter import VorbisMetadataGetter
+
+        with temp_file_with_metadata({}, "flac") as test_file:
+            test_lyrics = "Vorbis test lyrics\nWith multiple lines\nFor testing purposes"
+            test_metadata = {UnifiedMetadataKey.UNSYNCHRONIZED_LYRICS: test_lyrics}
+            update_metadata(test_file, test_metadata, metadata_format=MetadataFormat.VORBIS)
+
+            raw_metadata = VorbisMetadataGetter.get_raw_metadata(test_file)
+            assert f"LYRICS={test_lyrics}" in raw_metadata
+
+    def test_invalid_type_raises(self):
+        from audiometa.exceptions import InvalidMetadataFieldTypeError
+
+        with temp_file_with_metadata({}, "mp3") as test_file:
+            bad_metadata = {UnifiedMetadataKey.UNSYNCHRONIZED_LYRICS: 12345}
+            with pytest.raises(InvalidMetadataFieldTypeError):
+                update_metadata(test_file, bad_metadata)

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

@@ -0,0 +1,88 @@
+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 TestPublisherDeleting:
+    def test_delete_publisher_id3v2(self):
+        with temp_file_with_metadata({}, "mp3") as test_file:
+            update_metadata(
+                test_file, {UnifiedMetadataKey.PUBLISHER: "Test Publisher"}, metadata_format=MetadataFormat.ID3V2
+            )
+            assert get_unified_metadata_field(test_file, UnifiedMetadataKey.PUBLISHER) == "Test Publisher"
+
+            update_metadata(test_file, {UnifiedMetadataKey.PUBLISHER: None}, metadata_format=MetadataFormat.ID3V2)
+            assert get_unified_metadata_field(test_file, UnifiedMetadataKey.PUBLISHER) is None
+
+    def test_delete_publisher_id3v1(self):
+        from audiometa.exceptions import MetadataFieldNotSupportedByMetadataFormatError
+
+        with (
+            temp_file_with_metadata({}, "mp3") as test_file,
+            pytest.raises(
+                MetadataFieldNotSupportedByMetadataFormatError,
+                match="UnifiedMetadataKey.PUBLISHER metadata not supported by ID3v1 format",
+            ),
+        ):
+            update_metadata(
+                test_file,
+                {UnifiedMetadataKey.PUBLISHER: "Test Publisher"},
+                metadata_format=MetadataFormat.ID3V1,
+            )
+
+    def test_delete_publisher_riff(self):
+        from audiometa.exceptions import MetadataFieldNotSupportedByMetadataFormatError
+
+        with (
+            temp_file_with_metadata({}, "wav") as test_file,
+            pytest.raises(
+                MetadataFieldNotSupportedByMetadataFormatError,
+                match="UnifiedMetadataKey.PUBLISHER metadata not supported by RIFF format",
+            ),
+        ):
+            update_metadata(
+                test_file,
+                {UnifiedMetadataKey.PUBLISHER: "Test Publisher"},
+                metadata_format=MetadataFormat.RIFF,
+            )
+
+    def test_delete_publisher_vorbis(self):
+        with temp_file_with_metadata({}, "flac") as test_file:
+            update_metadata(
+                test_file, {UnifiedMetadataKey.PUBLISHER: "Test Publisher"}, metadata_format=MetadataFormat.VORBIS
+            )
+            assert get_unified_metadata_field(test_file, UnifiedMetadataKey.PUBLISHER) == "Test Publisher"
+
+            update_metadata(test_file, {UnifiedMetadataKey.PUBLISHER: None}, metadata_format=MetadataFormat.VORBIS)
+            assert get_unified_metadata_field(test_file, UnifiedMetadataKey.PUBLISHER) is None
+
+    def test_delete_publisher_preserves_other_fields(self):
+        with temp_file_with_metadata({}, "mp3") as test_file:
+            update_metadata(
+                test_file,
+                {
+                    UnifiedMetadataKey.PUBLISHER: "Test Publisher",
+                    UnifiedMetadataKey.TITLE: "Test Title",
+                    UnifiedMetadataKey.ARTISTS: ["Test Artist"],
+                },
+            )
+
+            update_metadata(test_file, {UnifiedMetadataKey.PUBLISHER: None})
+
+            assert get_unified_metadata_field(test_file, UnifiedMetadataKey.PUBLISHER) 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_publisher_already_none(self):
+        with temp_file_with_metadata({}, "mp3") as test_file:
+            update_metadata(test_file, {UnifiedMetadataKey.PUBLISHER: None})
+            assert get_unified_metadata_field(test_file, UnifiedMetadataKey.PUBLISHER) is None
+
+    def test_delete_publisher_empty_string(self):
+        with temp_file_with_metadata({}, "mp3") as test_file:
+            update_metadata(test_file, {UnifiedMetadataKey.PUBLISHER: ""}, metadata_format=MetadataFormat.ID3V2)
+            assert get_unified_metadata_field(test_file, UnifiedMetadataKey.PUBLISHER) is None

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

@@ -0,0 +1,32 @@
+import pytest
+
+from audiometa import get_unified_metadata_field
+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.utils.unified_metadata_key import UnifiedMetadataKey
+
+
+@pytest.mark.integration
+class TestPublisherReading:
+    def test_id3v1(self):
+        with temp_file_with_metadata({"title": "Test Song"}, "id3v1") as test_file:
+            publisher = get_unified_metadata_field(test_file, UnifiedMetadataKey.PUBLISHER)
+            assert publisher is None
+
+    def test_id3v2(self):
+        with temp_file_with_metadata({"title": "Test Song", "publisher": "Test Publisher"}, "mp3") as test_file:
+            publisher = get_unified_metadata_field(test_file, UnifiedMetadataKey.PUBLISHER)
+            assert publisher == "Test Publisher"
+
+    def test_vorbis(self):
+        with temp_file_with_metadata({"title": "Test Song", "publisher": "Test Publisher"}, "flac") as test_file:
+            raw_metadata = VorbisMetadataGetter.get_raw_metadata(test_file)
+            assert "PUBLISHER=Test Publisher" in raw_metadata
+
+            publisher = get_unified_metadata_field(test_file, UnifiedMetadataKey.PUBLISHER)
+            assert publisher == "Test Publisher"
+
+    def test_riff(self):
+        with temp_file_with_metadata({"title": "Test Song"}, "wav") as test_file:
+            publisher = get_unified_metadata_field(test_file, UnifiedMetadataKey.PUBLISHER)
+            assert publisher is None

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

@@ -0,0 +1,47 @@
+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 TestPublisherWriting:
+    def test_id3v2(self):
+        with temp_file_with_metadata({}, "mp3") as test_file:
+            test_publisher = "Test Publisher ID3v2"
+            test_metadata = {UnifiedMetadataKey.PUBLISHER: test_publisher}
+            update_metadata(test_file, test_metadata, metadata_format=MetadataFormat.ID3V2)
+            publisher = get_unified_metadata_field(test_file, UnifiedMetadataKey.PUBLISHER)
+            assert publisher == test_publisher
+
+    def test_riff(self):
+        from audiometa.exceptions import MetadataFieldNotSupportedByMetadataFormatError
+
+        with temp_file_with_metadata({}, "wav") as test_file:
+            test_publisher = "Test Publisher RIFF"
+            test_metadata = {UnifiedMetadataKey.PUBLISHER: test_publisher}
+
+            # RIFF format raises exception for unsupported metadata
+            with pytest.raises(
+                MetadataFieldNotSupportedByMetadataFormatError,
+                match="UnifiedMetadataKey.PUBLISHER metadata not supported by RIFF format",
+            ):
+                update_metadata(test_file, test_metadata, metadata_format=MetadataFormat.RIFF)
+
+    def test_vorbis(self):
+        with temp_file_with_metadata({}, "flac") as test_file:
+            test_publisher = "Test Publisher Vorbis"
+            test_metadata = {UnifiedMetadataKey.PUBLISHER: test_publisher}
+            update_metadata(test_file, test_metadata, metadata_format=MetadataFormat.VORBIS)
+            publisher = get_unified_metadata_field(test_file, UnifiedMetadataKey.PUBLISHER)
+            assert publisher == test_publisher
+
+    def test_invalid_type_raises(self):
+        from audiometa.exceptions import InvalidMetadataFieldTypeError
+
+        with temp_file_with_metadata({}, "mp3") as test_file:
+            bad_metadata = {UnifiedMetadataKey.PUBLISHER: 123}
+            with pytest.raises(InvalidMetadataFieldTypeError):
+                update_metadata(test_file, bad_metadata)

audiometa/test/tests/integration/metadata_field/rating/reading/test_base_100_proportional.py

@@ -0,0 +1,81 @@
+from pathlib import Path
+
+import pytest
+
+from audiometa import get_unified_metadata
+from audiometa.utils.unified_metadata_key import UnifiedMetadataKey
+
+
+@pytest.mark.integration
+class TestBase100Proportional:
+    @pytest.mark.parametrize(
+        ("star_rating", "expected_normalized_rating"),
+        [
+            (0, 0),
+            (0.5, 10),
+            (1, 20),
+            (1.5, 30),
+            (2, 40),
+            (2.5, 50),
+            (3, 60),
+            (3.5, 70),
+            (4, 80),
+            (4.5, 90),
+            (5, 100),
+        ],
+    )
+    def test_vorbis(self, assets_dir: Path, star_rating, expected_normalized_rating):
+        file_path = assets_dir / f"rating_vorbis={star_rating} star.flac"
+        metadata = get_unified_metadata(file_path, normalized_rating_max_value=100)
+        rating = metadata.get(UnifiedMetadataKey.RATING)
+        assert rating is not None
+        assert isinstance(rating, int | float)
+        assert rating == expected_normalized_rating
+
+    @pytest.mark.parametrize(
+        ("star_rating", "expected_normalized_rating"),
+        [
+            (0, 0),
+            (0.5, 10),
+            (1, 20),
+            (1.5, 30),
+            (2, 40),
+            (2.5, 50),
+            (3, 60),
+            (3.5, 70),
+            (4, 80),
+            (4.5, 90),
+            (5, 100),
+        ],
+    )
+    def test_id3v2(self, assets_dir: Path, star_rating, expected_normalized_rating):
+        file_path = assets_dir / f"rating_id3v2_base 100={star_rating} star.wav"
+        metadata = get_unified_metadata(file_path, normalized_rating_max_value=100)
+        rating = metadata.get(UnifiedMetadataKey.RATING)
+        assert rating is not None
+        assert isinstance(rating, int | float)
+        assert rating == expected_normalized_rating
+
+    @pytest.mark.parametrize(
+        ("star_rating", "expected_normalized_rating"),
+        [
+            (1, 20),
+            (2, 40),
+            (3, 60),
+            (4, 80),
+            (5, 100),
+        ],
+    )
+    def test_wav_riff(self, assets_dir: Path, star_rating, expected_normalized_rating):
+        file_path = assets_dir / f"rating_riff_base 100_kid3={star_rating} star.wav"
+        metadata = get_unified_metadata(file_path, normalized_rating_max_value=100)
+        rating = metadata.get(UnifiedMetadataKey.RATING)
+        assert rating is not None
+        assert isinstance(rating, int | float)
+        assert rating == expected_normalized_rating
+
+    def test_none_rating_wav_riff(self, assets_dir: Path):
+        file_path = assets_dir / "rating_riff_kid3=none.wav"
+        metadata = get_unified_metadata(file_path, normalized_rating_max_value=100)
+        rating = metadata.get(UnifiedMetadataKey.RATING)
+        assert rating is None

audiometa/test/tests/integration/metadata_field/rating/reading/test_base_255_non_proportional.py

@@ -0,0 +1,33 @@
+from pathlib import Path
+
+import pytest
+
+from audiometa import get_unified_metadata
+from audiometa.utils.unified_metadata_key import UnifiedMetadataKey
+
+
+@pytest.mark.integration
+class TestBase255NonProportional:
+    @pytest.mark.parametrize(
+        ("star_rating", "expected_normalized_rating"),
+        [
+            (0, 0),
+            (0.5, 10),
+            (1, 20),
+            (1.5, 30),
+            (2, 40),
+            (2.5, 50),
+            (3, 60),
+            (3.5, 70),
+            (4, 80),
+            (4.5, 90),
+            (5, 100),
+        ],
+    )
+    def test_id3v2_mp3(self, assets_dir: Path, star_rating, expected_normalized_rating):
+        file_path = assets_dir / f"rating_id3v2={star_rating} star.mp3"
+        metadata = get_unified_metadata(file_path, normalized_rating_max_value=100)
+        rating = metadata.get(UnifiedMetadataKey.RATING)
+        assert rating is not None
+        assert isinstance(rating, int | float)
+        assert rating == expected_normalized_rating