audiometa-python 0.6.0__py3-none-any.whl

audiometa/test/tests/integration/multiple_values/reading/test_smart_parsing_scenarios.py

@@ -0,0 +1,198 @@
+import pytest
+
+from audiometa import get_unified_metadata_field
+from audiometa.test.helpers.id3v1.id3v1_metadata_getter import ID3v1MetadataGetter
+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.metadata_format import MetadataFormat
+from audiometa.utils.unified_metadata_key import UnifiedMetadataKey
+
+
+@pytest.mark.integration
+class TestSmartParsingScenarios:
+    """Test the smart parsing scenarios described in the README:
+
+    - Modern formats (ID3v2, Vorbis) + Multiple entries: No separator parsing
+    - Modern formats (ID3v2, Vorbis) + Single entry: Applies separator parsing
+    - Legacy formats (RIFF, ID3v1): Always applies separator parsing
+    """
+
+    def test_scenario_1_multiple_entries_no_parsing_id3v2_3(self):
+        """Scenario 1: ID3v2.3 uses single frame with separators - gets parsed on read."""
+        with temp_file_with_metadata({"title": "Test Song"}, "id3v2.3") as test_file:
+            ID3v2MetadataSetter.set_artists(
+                test_file,
+                ["Artist One", "Artist; with; semicolons", "Artist Three"],
+                version="2.3",
+                in_separate_frames=True,
+            )
+            raw_metadata = ID3v2MetadataGetter.get_raw_metadata(test_file, version="2.3")
+            assert raw_metadata["TPE1"] == ["Artist One", "Artist; with; semicolons", "Artist Three"]
+
+            # Read metadata
+            artists = get_unified_metadata_field(
+                test_file,
+                UnifiedMetadataKey.ARTISTS,
+                metadata_format=MetadataFormat.ID3V2,
+                id3v2_version=(2, 3, 0),
+            )
+            assert artists == ["Artist One", "Artist; with; semicolons", "Artist Three"]
+
+    def test_scenario_1_multiple_entries_no_parsing_id3v2_4(self):
+        """Scenario 1: ID3v2.4 uses single frame with separators - gets parsed on read."""
+        with temp_file_with_metadata({"title": "Test Song"}, "id3v2.4") as test_file:
+            # Set multiple separate artist entries (ID3v2.4 will concatenate them)
+            ID3v2MetadataSetter.set_artists(
+                test_file,
+                ["Artist One", "Artist; with; semicolons", "Artist Three"],
+                version="2.4",
+                in_separate_frames=True,
+            )
+            raw_metadata = ID3v2MetadataGetter.get_raw_metadata(test_file, version="2.4")
+            assert raw_metadata["TPE1"] == ["Artist One", "Artist; with; semicolons", "Artist Three"]
+
+            # Read metadata
+            artists = get_unified_metadata_field(
+                test_file,
+                UnifiedMetadataKey.ARTISTS,
+                metadata_format=MetadataFormat.ID3V2,
+                id3v2_version=(2, 4, 0),
+            )
+            assert artists == ["Artist One", "Artist; with; semicolons", "Artist Three"]
+
+    def test_scenario_1_multiple_entries_no_parsing_vorbis(self):
+        """Scenario 1: Modern file with separate entries - separators preserved (Vorbis)."""
+        with temp_file_with_metadata({"title": "Test Song"}, "flac") as test_file:
+            # Set multiple separate artist entries (modern format)
+            VorbisMetadataSetter.set_artists(test_file, ["Artist One", "Artist; with; semicolons", "Artist Three"])
+            raw_metadata = VorbisMetadataGetter.get_raw_metadata(test_file)
+            assert "ARTIST=Artist One" in raw_metadata
+            assert "ARTIST=Artist; with; semicolons" in raw_metadata
+            assert "ARTIST=Artist Three" in raw_metadata
+
+            # Read metadata
+            artists = get_unified_metadata_field(
+                test_file, UnifiedMetadataKey.ARTISTS, metadata_format=MetadataFormat.VORBIS
+            )
+            assert artists == ["Artist One", "Artist; with; semicolons", "Artist Three"]
+
+    def test_scenario_1_multiple_entries_no_parsing_riff(self):
+        """Scenario 1: Modern file with separate entries - separators preserved (RIFF)."""
+        with temp_file_with_metadata({"title": "Test Song"}, "wav") as test_file:
+            # Set multiple separate artist entries (modern format)
+            RIFFMetadataSetter.set_artists(
+                test_file, ["Artist One", "Artist; with; semicolons", "Artist Three"], in_separate_frames=True
+            )
+            raw_metadata = RIFFMetadataGetter.get_raw_metadata(test_file)
+            assert "TAG:artist=Artist One" in raw_metadata
+            assert "TAG:artist=Artist; with; semicolons" in raw_metadata
+            assert "TAG:artist=Artist Three" in raw_metadata
+
+            artists = get_unified_metadata_field(
+                test_file, UnifiedMetadataKey.ARTISTS, metadata_format=MetadataFormat.RIFF
+            )
+            assert artists == ["Artist One", "Artist; with; semicolons", "Artist Three"]
+
+    def test_scenario_2_single_entry_parsed_id3v2_3(self):
+        """Scenario 2: Legacy data in modern format - single entry gets parsed (ID3v2.3)."""
+        with temp_file_with_metadata({"title": "Test Song"}, "id3v2.3") as test_file:
+            # Set single artist entry with semicolons (legacy data in modern format)
+            ID3v2MetadataSetter.set_artists(
+                test_file, ["Artist One;Artist Two;Artist Three"], version="2.3", in_separate_frames=False
+            )
+
+            raw_metadata = ID3v2MetadataGetter.get_raw_metadata(test_file, version="2.3")
+            assert raw_metadata["TPE1"] == ["Artist One;Artist Two;Artist Three"]
+
+            # Read metadata
+            artists = get_unified_metadata_field(
+                test_file, UnifiedMetadataKey.ARTISTS, metadata_format=MetadataFormat.ID3V2
+            )
+            assert artists == ["Artist One", "Artist Two", "Artist Three"]
+
+    def test_scenario_2_single_entry_parsed_id3v2_4(self):
+        """Scenario 2: Legacy data in modern format - single entry gets parsed (ID3v2.4)."""
+        with temp_file_with_metadata({"title": "Test Song"}, "id3v2.4") as test_file:
+            # Set single artist entry with semicolons (legacy data in modern format)
+            ID3v2MetadataSetter.set_artists(
+                test_file, ["Artist One;Artist Two;Artist Three"], version="2.4", in_separate_frames=False
+            )
+
+            raw_metadata = ID3v2MetadataGetter.get_raw_metadata(test_file, version="2.4")
+            assert raw_metadata["TPE1"] == ["Artist One;Artist Two;Artist Three"]
+
+            # Read metadata
+            artists = get_unified_metadata_field(
+                test_file, UnifiedMetadataKey.ARTISTS, metadata_format=MetadataFormat.ID3V2
+            )
+            assert artists == ["Artist One", "Artist Two", "Artist Three"]
+
+    def test_scenario_2_single_entry_parsed_vorbis(self):
+        """Scenario 2: Legacy data in modern format - single entry gets parsed (Vorbis)."""
+        with temp_file_with_metadata({"title": "Test Song"}, "flac") as test_file:
+            # Set single artist entry with semicolons (legacy data in modern format)
+            VorbisMetadataSetter.set_artists(test_file, ["Artist One;Artist Two;Artist Three"])
+            raw_metadata = VorbisMetadataGetter.get_raw_metadata(test_file)
+            assert "ARTIST=Artist One;Artist Two;Artist Three" in raw_metadata
+
+            # Read metadata
+            artists = get_unified_metadata_field(
+                test_file, UnifiedMetadataKey.ARTISTS, metadata_format=MetadataFormat.VORBIS
+            )
+            assert artists == ["Artist One", "Artist Two", "Artist Three"]
+
+    def test_scenario_2_single_entry_parsed_riff(self):
+        """Scenario 3: Legacy format (RIFF) - always applies separator parsing."""
+        with temp_file_with_metadata({"title": "Test Song"}, "wav") as test_file:
+            # Set single artist entry with semicolons in RIFF format
+            RIFFMetadataSetter.set_artists(test_file, ["Artist One;Artist Two"], in_separate_frames=False)
+            raw_metadata = RIFFMetadataGetter.get_raw_metadata(test_file)
+            assert "TAG:artist=Artist One;Artist Two" in raw_metadata
+
+            # Read metadata
+            artists = get_unified_metadata_field(
+                test_file, UnifiedMetadataKey.ARTISTS, metadata_format=MetadataFormat.RIFF
+            )
+            assert artists == ["Artist One", "Artist Two"]
+
+    def test_scenario_3_legacy_format_always_parses_id3v1(self):
+        """Scenario 3: Legacy format (ID3v1) - always applies separator parsing."""
+        with temp_file_with_metadata({"title": "Test Song"}, "mp3") as test_file:
+            # Set single artist entry with semicolons in ID3v1 format
+            ID3v1MetadataSetter.set_artist(test_file, "Artist One;Artist Two")
+            raw_metadata = ID3v1MetadataGetter.get_raw_metadata(test_file)
+            assert "Artist One;Artist Two" in raw_metadata.get("artist", "")
+
+            # Read metadata
+            artists = get_unified_metadata_field(
+                test_file, UnifiedMetadataKey.ARTISTS, metadata_format=MetadataFormat.ID3V1
+            )
+            assert artists == ["Artist One", "Artist Two"]
+
+    def test_mixed_scenario_modern_format_with_both_patterns(self):
+        """Test mixed scenario: ID3v2 concatenates multiple entries, single entries get parsed."""
+        with temp_file_with_metadata({"title": "Test Song"}, "id3v2.3") as test_file:
+            # Set artists as multiple separate entries (ID3v2 will concatenate them)
+            ID3v2MetadataSetter.set_artists(
+                test_file,
+                ["Artist One", "Artist; with; semicolons", "Artist Three"],
+                version="2.3",
+                in_separate_frames=True,
+            )
+            raw_metadata = ID3v2MetadataGetter.get_raw_metadata(test_file, version="2.3")
+            assert raw_metadata["TPE1"] == ["Artist One", "Artist; with; semicolons", "Artist Three"]
+
+            # Read metadata
+            artists = get_unified_metadata_field(
+                test_file,
+                UnifiedMetadataKey.ARTISTS,
+                metadata_format=MetadataFormat.ID3V2,
+                id3v2_version=(2, 3, 0),
+            )
+            assert artists == ["Artist One", "Artist; with; semicolons", "Artist Three"]

audiometa/test/tests/integration/multiple_values/reading/test_unicode_handling.py

@@ -0,0 +1,24 @@
+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_setter import VorbisMetadataSetter
+from audiometa.utils.metadata_format import MetadataFormat
+from audiometa.utils.unified_metadata_key import UnifiedMetadataKey
+
+
+@pytest.mark.integration
+class TestUnicodeHandling:
+    def test_unicode_characters(self):
+        with temp_file_with_metadata({"title": "Test Song"}, "flac") as test_file:
+            VorbisMetadataSetter.set_artists(test_file, ["Artist Café", "Artist 音乐", "Artist 🎵"])
+
+            artists = get_unified_metadata_field(
+                test_file, UnifiedMetadataKey.ARTISTS, metadata_format=MetadataFormat.VORBIS
+            )
+
+            assert isinstance(artists, list)
+            assert len(artists) == 3
+            assert "Artist Café" in artists
+            assert "Artist 音乐" in artists
+            assert "Artist 🎵" in artists

audiometa/test/tests/integration/multiple_values/writing/__init__.py

@@ -0,0 +1 @@
+"""Tests for writing multiple entries for the same tag."""

audiometa/test/tests/integration/multiple_values/writing/metadata_format/__init__.py

@@ -0,0 +1 @@
+"""Tests for writing multiple entries for the same tag in different metadata formats."""

audiometa/test/tests/integration/multiple_values/writing/metadata_format/test_id3v1.py

@@ -0,0 +1,62 @@
+import pytest
+
+from audiometa import update_metadata
+from audiometa.test.helpers.id3v1.id3v1_metadata_getter import ID3v1MetadataGetter
+from audiometa.test.helpers.id3v1.id3v1_metadata_setter import ID3v1MetadataSetter
+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 TestMultipleValuesId3v1:
+    def test_id3v1_artists_concatenation_default_comma(self):
+        initial_metadata = {"title": "Test Song"}
+        with temp_file_with_metadata(initial_metadata, "mp3") as test_file:
+            metadata = {UnifiedMetadataKey.ARTISTS: ["Artist 1", "Artist 2"]}
+
+            update_metadata(test_file, metadata, metadata_format=MetadataFormat.ID3V1)
+
+            # Use helper to check the created ID3v1 artist field directly
+            raw_metadata = ID3v1MetadataGetter.get_raw_metadata(test_file)
+            artists = raw_metadata.get("artist", "")
+            assert "Artist 1,Artist 2" in artists or "Artist 2,Artist 1" in artists
+
+    def test_with_existing_artists_field(self):
+        with temp_file_with_metadata({}, "mp3") as test_file:
+            ID3v1MetadataSetter.set_artist(test_file, "Existing 1; Existing 2")
+            raw_metadata = ID3v1MetadataGetter.get_raw_metadata(test_file)
+            assert "Existing 1; Existing 2" in raw_metadata.get("artist", "")
+
+            # Now update with multiple artists
+            metadata = {UnifiedMetadataKey.ARTISTS: ["Existing 1", "New 2"]}
+            update_metadata(test_file, metadata, metadata_format=MetadataFormat.ID3V1)
+            raw_metadata = ID3v1MetadataGetter.get_raw_metadata(test_file)
+            artists = raw_metadata.get("artist", "")
+            assert "Existing 1" in artists
+            assert "New 2" in artists
+            assert "Existing 2" not in artists
+
+    def test_id3v1_separator_priority(self):
+        # Each test case: values, expected separator
+        test_cases = [
+            (["A1", "A2", "A3"], ","),
+            (["A,1", "A2", "A3"], ";"),
+            (["A,1", "A;2", "A3"], "|"),
+            (["A,1", "A;2", "A|3"], "·"),
+            (["A,1", "A;2", "A|3", "A·4"], "/"),
+            (["A,1", "A;2", "A|3", "A·4", "A/5"], ","),
+        ]
+        for values, expected_sep in test_cases:
+            initial_metadata = {"title": "Test Song"}
+            with temp_file_with_metadata(initial_metadata, "mp3") as test_file:
+                metadata = {UnifiedMetadataKey.ARTISTS: values}
+                update_metadata(test_file, metadata, metadata_format=MetadataFormat.ID3V1)
+                raw_metadata = ID3v1MetadataGetter.get_raw_metadata(test_file)
+                artists = raw_metadata.get("artist", "")
+
+                # Check that the expected separator is used
+                assert expected_sep in artists
+                # Check that all values are present as substrings
+                for v in values:
+                    assert v in artists

audiometa/test/tests/integration/multiple_values/writing/metadata_format/test_id3v2_3.py

@@ -0,0 +1,36 @@
+import pytest
+
+from audiometa import update_metadata
+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.utils.metadata_format import MetadataFormat
+from audiometa.utils.unified_metadata_key import UnifiedMetadataKey
+
+
+@pytest.mark.integration
+class TestMultipleValuesId3v23:
+    def test_artists_concatenation(self):
+        initial_metadata = {"title": "Test Song"}
+        with temp_file_with_metadata(initial_metadata, "id3v2.3") as test_file:
+            metadata = {UnifiedMetadataKey.ARTISTS: ["Artist 1", "Artist 2", "Artist 3"]}
+
+            update_metadata(test_file, metadata, metadata_format=MetadataFormat.ID3V2, id3v2_version=(2, 3, 0))
+
+            raw_metadata = ID3v2MetadataGetter.get_raw_metadata(test_file, version="2.3")
+            assert raw_metadata["TPE1"] == ["Artist 1//Artist 2//Artist 3"]
+
+    def test_with_existing_artists_field(self):
+        # Start with an existing artist field
+        initial_metadata = {"artist": "Existing Artist"}
+        with temp_file_with_metadata(initial_metadata, "id3v2.3") as test_file:
+            ID3v2MetadataSetter.set_artists(test_file, "Existing 1; Existing 2", version="2.3")
+            raw_metadata = ID3v2MetadataGetter.get_raw_metadata(test_file, version="2.3")
+            assert raw_metadata["TPE1"] == ["Existing 1; Existing 2"]
+
+            metadata = {UnifiedMetadataKey.ARTISTS: ["Existing 1", "New 2"]}
+            update_metadata(test_file, metadata, metadata_format=MetadataFormat.ID3V2, id3v2_version=(2, 3, 0))
+
+            raw_metadata = ID3v2MetadataGetter.get_raw_metadata(test_file, version="2.3")
+
+            assert raw_metadata["TPE1"] == ["Existing 1//New 2"]

audiometa/test/tests/integration/multiple_values/writing/metadata_format/test_id3v2_4.py

@@ -0,0 +1,34 @@
+import pytest
+
+from audiometa import update_metadata
+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.utils.metadata_format import MetadataFormat
+from audiometa.utils.unified_metadata_key import UnifiedMetadataKey
+
+
+@pytest.mark.integration
+class TestMultipleValuesId3v24:
+    def test_write_multiple_artists(self):
+        with temp_file_with_metadata({"title": "Test Song"}, "id3v2.4") as test_file:
+            metadata = {UnifiedMetadataKey.ARTISTS: ["Artist One", "Artist Two"]}
+
+            update_metadata(test_file, metadata, metadata_format=MetadataFormat.ID3V2, id3v2_version=(2, 4, 0))
+
+            raw_metadata = ID3v2MetadataGetter.get_raw_metadata(test_file, version="2.4")
+
+            assert raw_metadata["TPE1"] == ["Artist One\x00Artist Two"]
+
+    def test_write_on_existing_artists_field(self):
+        with temp_file_with_metadata({}, "id3v2.4") as test_file:
+            ID3v2MetadataSetter.set_artists(test_file, ["Existing A\x00Existing B"], version="2.4")
+            raw_metadata = ID3v2MetadataGetter.get_raw_metadata(test_file, version="2.4")
+
+            assert raw_metadata["TPE1"] == ["Existing A\x00Existing B"]
+
+            metadata = {UnifiedMetadataKey.ARTISTS: ["Existing A", "New B"]}
+            update_metadata(test_file, metadata, metadata_format=MetadataFormat.ID3V2, id3v2_version=(2, 4, 0))
+
+            raw_metadata = ID3v2MetadataGetter.get_raw_metadata(test_file, version="2.4")
+            assert raw_metadata["TPE1"] == ["Existing A\x00New B"]

audiometa/test/tests/integration/multiple_values/writing/metadata_format/test_riff.py

@@ -0,0 +1,32 @@
+import pytest
+
+from audiometa import update_metadata
+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.utils.metadata_format import MetadataFormat
+from audiometa.utils.unified_metadata_key import UnifiedMetadataKey
+
+
+@pytest.mark.integration
+class TestMultipleValuesRiff:
+    def test_artists_concatenation(self):
+        initial_metadata = {"title": "Test Song"}
+        with temp_file_with_metadata(initial_metadata, "wav") as test_file:
+            metadata = {UnifiedMetadataKey.ARTISTS: ["Artist 1", "Artist 2", "Artist 3"]}
+            update_metadata(test_file, metadata, metadata_format=MetadataFormat.RIFF)
+
+            raw_metadata = RIFFMetadataGetter.get_raw_metadata(test_file)
+            assert "TAG:artist=Artist 1//Artist 2//Artist 3" in raw_metadata
+
+    def test_with_existing_artists_field(self):
+        with temp_file_with_metadata({}, "wav") as test_file:
+            RIFFMetadataSetter.set_artists(test_file, ["Existing 1;Existing 2"])
+            raw_metadata = RIFFMetadataGetter.get_raw_metadata(test_file)
+            assert "TAG:artist=Existing 1;Existing 2" in raw_metadata
+
+            metadata = {UnifiedMetadataKey.ARTISTS: ["Existing 1", "New 2"]}
+            update_metadata(test_file, metadata, metadata_format=MetadataFormat.RIFF)
+
+            raw_metadata = RIFFMetadataGetter.get_raw_metadata(test_file)
+            assert "TAG:artist=Existing 1//New 2" in raw_metadata

audiometa/test/tests/integration/multiple_values/writing/metadata_format/test_vorbis.py

@@ -0,0 +1,54 @@
+import pytest
+
+from audiometa import update_metadata
+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.metadata_format import MetadataFormat
+from audiometa.utils.unified_metadata_key import UnifiedMetadataKey
+
+
+@pytest.mark.integration
+class TestMultipleValuesVorbis:
+    def test_write_multiple_artists(self):
+        with temp_file_with_metadata({}, "flac") as test_file:
+            # Write multiple artists using update_metadata
+            metadata = {UnifiedMetadataKey.ARTISTS: ["Artist One", "Artist Two", "Artist Three"]}
+
+            update_metadata(test_file, metadata, metadata_format=MetadataFormat.VORBIS)
+            VorbisMetadataSetter.add_title(test_file, "Test Song")
+            raw_metadata = VorbisMetadataGetter.get_raw_metadata(test_file)
+            assert "ARTIST=Artist One" in raw_metadata
+            assert "ARTIST=Artist Two" in raw_metadata
+            assert "ARTIST=Artist Three" in raw_metadata
+
+    def test_with_existing_artists_fields(self):
+        # Start with an existing artist field
+        with temp_file_with_metadata({}, "flac") as test_file:
+            # create an existing value using setter
+            VorbisMetadataSetter.set_artists(test_file, ["Existing 1; Existing 2"])
+            raw_metadata = VorbisMetadataGetter.get_raw_metadata(test_file)
+            assert "Existing 1; Existing 2" in raw_metadata
+
+            metadata = {UnifiedMetadataKey.ARTISTS: ["Existing 1", "New 2"]}
+            update_metadata(test_file, metadata, metadata_format=MetadataFormat.VORBIS)
+
+            raw_metadata = VorbisMetadataGetter.get_raw_metadata(test_file)
+            assert "Existing 1" in raw_metadata
+            assert "New 2" in raw_metadata
+            assert "Existing 2" not in raw_metadata
+
+    def test_with_existing_artists_fields_with_lower_case_key(self):
+        # Start with an existing artist field in lower case
+        with temp_file_with_metadata({}, "flac") as test_file:
+            # create an existing value using setter
+            VorbisMetadataSetter.set_artists(test_file, ["ExistingLower 1; ExistingLower 2"], key_lower_case=True)
+            raw_output = VorbisMetadataGetter.get_raw_metadata(test_file)
+            assert "artist=ExistingLower 1; ExistingLower 2" in raw_output
+
+            metadata = {UnifiedMetadataKey.ARTISTS: ["ExistingLower 1", "New 2"]}
+            update_metadata(test_file, metadata, metadata_format=MetadataFormat.VORBIS)
+
+            raw_output = VorbisMetadataGetter.get_raw_metadata(test_file)
+            assert "ARTIST=ExistingLower 1" in raw_output
+            assert "ARTIST=New 2" in raw_output

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

@@ -0,0 +1,42 @@
+import pytest
+
+from audiometa import get_unified_metadata_field, update_metadata
+from audiometa.exceptions import InvalidMetadataFieldTypeError
+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 TestMultipleValuesErrorHandling:
+    def test_write_invalid_data_types_in_list(self):
+        # Test with invalid data types in multiple value lists
+        with temp_file_with_metadata({}, "mp3") as temp_audio_file_path:
+            metadata = {UnifiedMetadataKey.ARTISTS: [1, 2, 3]}  # Numbers instead of strings
+            with pytest.raises(InvalidMetadataFieldTypeError):
+                update_metadata(temp_audio_file_path, metadata)
+
+    def test_write_mixed_data_types_in_list(self):
+        # Test with mixed data types in multiple value lists
+        with temp_file_with_metadata({}, "mp3") as temp_audio_file_path:
+            metadata = {UnifiedMetadataKey.ARTISTS: ["Artist One", 123, None, "Artist Two"]}
+            with pytest.raises(InvalidMetadataFieldTypeError):
+                update_metadata(temp_audio_file_path, metadata)
+
+    def test_write_list_with_none_values_are_filtered(self):
+        # Test that None values in lists are automatically filtered out
+        # If all values are None, the field should be removed entirely
+        with temp_file_with_metadata({}, "mp3") as temp_audio_file_path:
+            metadata = {UnifiedMetadataKey.ARTISTS: [None, None]}
+            update_metadata(temp_audio_file_path, metadata)
+            # Field should be removed (None) since all values were filtered out
+            artists = get_unified_metadata_field(temp_audio_file_path, UnifiedMetadataKey.ARTISTS)
+            assert artists is None
+
+    def test_write_list_with_mixed_none_and_valid_values(self):
+        # Test that None values are filtered but valid values remain
+        with temp_file_with_metadata({}, "mp3") as temp_audio_file_path:
+            metadata = {UnifiedMetadataKey.ARTISTS: ["Artist One", None, "Artist Two", None, "Artist Three"]}
+            update_metadata(temp_audio_file_path, metadata)
+            # None values should be filtered out, only valid artists remain
+            artists = get_unified_metadata_field(temp_audio_file_path, UnifiedMetadataKey.ARTISTS)
+            assert artists == ["Artist One", "Artist Two", "Artist Three"]

audiometa/test/tests/integration/multiple_values/writing/test_large_values.py

@@ -0,0 +1,98 @@
+import time
+
+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 TestMultipleValuesBoundaryConditions:
+    def test_write_large_number_of_multiple_values_per_field(self):
+        with temp_file_with_metadata({"title": "Test Song"}, "flac") as test_file:
+            # Test with very large number of values per field
+            large_values_number = 1000
+            large_artist_list = [f"Artist {i:04d}" for i in range(large_values_number)]
+
+            metadata = {
+                UnifiedMetadataKey.ARTISTS: large_artist_list,
+            }
+
+            start_time = time.time()
+            update_metadata(test_file, metadata, metadata_format=MetadataFormat.VORBIS)
+            write_time = time.time() - start_time
+
+            artists = get_unified_metadata_field(
+                test_file, UnifiedMetadataKey.ARTISTS, metadata_format=MetadataFormat.VORBIS
+            )
+
+            assert isinstance(artists, list)
+            assert len(artists) == large_values_number
+
+            # Performance should be reasonable
+            assert write_time < 10.0, f"Write took too long: {write_time:.2f}s"
+
+    def test_write_extremely_long_individual_values(self):
+        with temp_file_with_metadata({"title": "Test Song"}, "flac") as test_file:
+            # Test with extremely long individual values
+            very_long_string = "A" * 50000  # 50KB string
+            metadata = {
+                UnifiedMetadataKey.ARTISTS: [very_long_string, "Normal Artist"],
+                UnifiedMetadataKey.COMMENT: very_long_string,
+            }
+
+            update_metadata(test_file, metadata, metadata_format=MetadataFormat.VORBIS)
+
+            artists = get_unified_metadata_field(
+                test_file, UnifiedMetadataKey.ARTISTS, metadata_format=MetadataFormat.VORBIS
+            )
+            assert isinstance(artists, list)
+            assert len(artists) == 2
+            assert very_long_string in artists
+            assert "Normal Artist" in artists
+
+    def test_write_mixed_length_values(self):
+        with temp_file_with_metadata({"title": "Test Song"}, "flac") as test_file:
+            # Test with mixed length values
+            mixed_lengths = [
+                "A",  # 1 character
+                "AB",  # 2 characters
+                "ABC",  # 3 characters
+                "A" * 100,  # 100 characters
+                "A" * 1000,  # 1000 characters
+                "A" * 10000,  # 10000 characters
+            ]
+            metadata = {UnifiedMetadataKey.ARTISTS: mixed_lengths}
+            update_metadata(test_file, metadata, metadata_format=MetadataFormat.VORBIS)
+
+            artists = get_unified_metadata_field(test_file, UnifiedMetadataKey.ARTISTS)
+
+            assert isinstance(artists, list)
+            assert len(artists) == 6
+            for value in mixed_lengths:
+                assert value in artists
+
+    def test_write_very_large_metadata_dict(self):
+        with temp_file_with_metadata({"title": "Test Song"}, "flac") as test_file:
+            # Test with very large metadata dictionary
+            large_metadata = {}
+
+            # Add multiple values for each supported multiple-value field
+            # Actual implementation of Vorbis metadata cannot support more than 50 values per field
+            for i in range(50):
+                large_metadata[UnifiedMetadataKey.ARTISTS] = [f"Artist {i:04d}" for i in range(50)]
+            start_time = time.time()
+            update_metadata(test_file, large_metadata, metadata_format=MetadataFormat.VORBIS)
+            write_time = time.time() - start_time
+
+            artists = get_unified_metadata_field(
+                test_file, UnifiedMetadataKey.ARTISTS, metadata_format=MetadataFormat.VORBIS
+            )
+
+            assert isinstance(artists, list)
+            assert len(artists) == 50
+
+            # Performance should be reasonable
+            assert write_time < 15.0, f"Write took too long: {write_time:.2f}s"

audiometa/test/tests/integration/reading/__init__.py

@@ -0,0 +1 @@
+"""Integration tests for reading metadata."""