audiometa-python 0.6.0__py3-none-any.whl

audiometa/test/tests/integration/metadata_field/genre/reading/test_smart_reading.py

@@ -0,0 +1,191 @@
+import pytest
+
+from audiometa import get_unified_metadata_field
+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.test.helpers.vorbis.vorbis_metadata_setter import VorbisMetadataSetter
+from audiometa.utils.unified_metadata_key import UnifiedMetadataKey
+
+
+@pytest.mark.integration
+class TestGenreSmartReading:
+    def test_single_entry_text_with_codes_and_separators_and_without_parentheses(self):
+        """Test single genre entry with text with codes and separators without parentheses:
+
+        '17/6' -> ['Rock', 'Grunge']
+        """
+        with temp_file_with_metadata({"title": "Test Song"}, "id3v2.4") as test_file:
+            # Set genre with text with codes and separators without parentheses
+            ID3v2MetadataSetter.set_genres(test_file, ["17/6"], version="2.4")
+
+            # Read via API
+            genres = get_unified_metadata_field(test_file, UnifiedMetadataKey.GENRES_NAMES)
+            assert genres == ["Rock", "Grunge"]
+
+    def test_single_entry_codes_without_separators_id3v2(self):
+        """Test single genre entry with codes without separators: '(17)(6)' -> ['Rock', 'Grunge']."""
+        with temp_file_with_metadata({"title": "Test Song"}, "id3v2.4") as test_file:
+            # Set genre with codes without separators
+            ID3v2MetadataSetter.set_genres(test_file, ["(17)(6)"], version="2.4")
+
+            # Validate raw metadata
+            raw_metadata = ID3v2MetadataGetter.get_raw_metadata(test_file)
+            assert "(17)(6)" in raw_metadata["TCON"]
+
+            # Read via API
+            genres = get_unified_metadata_field(test_file, UnifiedMetadataKey.GENRES_NAMES)
+
+            assert genres == ["Rock", "Grunge"]
+
+    def test_single_entry_codes_without_separators_vorbis(self):
+        """Test single genre entry with codes without separators in Vorbis: '(17)(6)' -> ['Rock', 'Grunge']."""
+        with temp_file_with_metadata({"title": "Test Song"}, "flac") as test_file:
+            # Set genre with codes without separators
+            VorbisMetadataSetter.set_genres(test_file, ["(17)(6)"])
+
+            # Validate raw metadata
+            raw_metadata = VorbisMetadataGetter.get_raw_metadata(test_file)
+            assert "(17)(6)" in raw_metadata
+
+            # Read via API
+            genres = get_unified_metadata_field(test_file, UnifiedMetadataKey.GENRES_NAMES)
+            assert genres == ["Rock", "Grunge"]
+
+    def test_code_text_then_text_part_even_if_different(self):
+        """Test code+text: '(17)Rock' -> 'Rock' (text part only)."""
+        with temp_file_with_metadata({"title": "Test Song"}, "id3v2.4") as test_file:
+            # Set genre with code+text
+            ID3v2MetadataSetter.set_genres(test_file, ["(17)Rock"], version="2.4")
+
+            # Read via API
+            genres = get_unified_metadata_field(test_file, UnifiedMetadataKey.GENRES_NAMES)
+
+            assert genres == ["Rock"]
+
+    def test_single_entry_code_text_without_separators(self):
+        """Test single genre entry with code+text without separators: '(17)Rock(6)Blues' -> ['Rock', 'Grunge']."""
+        with temp_file_with_metadata({"title": "Test Song"}, "id3v2.4") as test_file:
+            # Set genre with code+text without separators
+            ID3v2MetadataSetter.set_genres(test_file, ["(17)Rock(6)Blues"], version="2.4")
+
+            # Validate raw metadata
+            raw_metadata = ID3v2MetadataGetter.get_raw_metadata(test_file)
+            assert "(17)Rock(6)Blues" in raw_metadata["TCON"]
+
+            # assert no null separators in raw metadata genre
+            assert not any("\x00" in s for s in raw_metadata["TCON"])
+
+            # Read via API
+            genres = get_unified_metadata_field(test_file, UnifiedMetadataKey.GENRES_NAMES)
+
+            assert genres == ["Rock", "Blues"]
+
+    def test_one_code_and_one_code_text_in_single_entry(self):
+        """Test one code and one code+text: '(17)', '(6)Grunge' -> ['Rock', 'Grunge']."""
+        with temp_file_with_metadata({"title": "Test Song"}, "id3v2.4") as test_file:
+            # Set genre with one code and one code+text
+            ID3v2MetadataSetter.set_genres(test_file, ["(17)(6)Grunge"], version="2.4")
+
+            # Read via API
+            genres = get_unified_metadata_field(test_file, UnifiedMetadataKey.GENRES_NAMES)
+
+            assert genres == ["Rock", "Grunge"]
+
+    def test_one_code_and_one_code_text_in_multi_entries(self):
+        """Test one code and one code+text: '(17)', '(6)Grunge' -> ['Rock', 'Grunge']."""
+        with temp_file_with_metadata({"title": "Test Song"}, "id3v2.4") as test_file:
+            # Set genre with one code and one code+text
+            ID3v2MetadataSetter.set_genres(test_file, ["(17)", "(6)Grunge"], in_separate_frames=True, version="2.4")
+            raw_metadata = ID3v2MetadataGetter.get_raw_metadata(test_file)
+
+            assert "(17)" in raw_metadata["TCON"]
+            assert "(6)Grunge" in raw_metadata["TCON"]
+
+            # Read via API
+            genres = get_unified_metadata_field(test_file, UnifiedMetadataKey.GENRES_NAMES)
+
+            assert genres == ["Rock", "Grunge"]
+
+    def test_single_entry_text_with_slash_separators(self):
+        """Test single genre entry with text with slash separators: 'Rock/Blues' -> ['Rock', 'Blues']."""
+        with temp_file_with_metadata({"title": "Test Song"}, "id3v2.4") as test_file:
+            # Set genre with text with separators
+            ID3v2MetadataSetter.set_genres(test_file, ["Rock/Blues"], version="2.4")
+
+            # Validate raw metadata
+            raw_metadata = ID3v2MetadataGetter.get_raw_metadata(test_file)
+            assert "Rock/Blues" in raw_metadata["TCON"]
+
+            # Read via API
+            genres = get_unified_metadata_field(test_file, UnifiedMetadataKey.GENRES_NAMES)
+
+            assert genres == ["Rock", "Blues"]
+
+    def test_single_entry_text_with_semicolon_separators(self):
+        """Test single genre entry with text with semicolon separators:
+
+        'Rock; Alternative' -> ['Rock', 'Alternative']
+        """
+        with temp_file_with_metadata({"title": "Test Song"}, "id3v2.4") as test_file:
+            # Set genre with text with separators
+            ID3v2MetadataSetter.set_genres(test_file, ["Rock; Alternative"], version="2.4")
+
+            # Validate raw metadata
+            raw_metadata = ID3v2MetadataGetter.get_raw_metadata(test_file)
+            assert "Rock; Alternative" in raw_metadata["TCON"]
+
+            # Read via API
+            genres = get_unified_metadata_field(test_file, UnifiedMetadataKey.GENRES_NAMES)
+
+            assert genres == ["Rock", "Alternative"]
+
+    def test_multi_codes_with_text_with_separators(self):
+        """Test single genre entry with mixed separators: '(17)Rock/(6)Blues' -> ['Rock', 'Blues']."""
+        with temp_file_with_metadata({"title": "Test Song"}, "id3v2.4") as test_file:
+            # Set genre with mixed separators
+            ID3v2MetadataSetter.set_genres(test_file, ["(17)Rock/(6)Blues"], version="2.4")
+
+            # Validate raw metadata
+            raw_metadata = ID3v2MetadataGetter.get_raw_metadata(test_file)
+            assert "(17)Rock/(6)Blues" in raw_metadata["TCON"]
+
+            # Read via API
+            genres = get_unified_metadata_field(test_file, UnifiedMetadataKey.GENRES_NAMES)
+
+            assert genres == ["Rock", "Blues"]
+
+    def test_multiple_entries_return_as_is(self):
+        """Test multiple genre entries: separate TCON frames, return as-is without parsing."""
+        with temp_file_with_metadata({"title": "Test Song"}, "id3v2.4") as test_file:
+            # Set multiple genres in separate frames
+            ID3v2MetadataSetter.set_genres(test_file, ["Rock/Grunge", "Blues"], in_separate_frames=True, version="2.4")
+
+            # Read via API
+            genres = get_unified_metadata_field(test_file, UnifiedMetadataKey.GENRES_NAMES)
+
+            # Should return as-is without parsing
+            assert set(genres) == {"Rock/Grunge", "Blues"}
+
+    def test_code_to_name_conversion_with_unknown_code(self):
+        """Test code conversion: '(17)' -> 'Rock', (unknown code) -> unknown code in parentheses should be ignored."""
+        with temp_file_with_metadata({"title": "Test Song"}, "id3v2.4") as test_file:
+            # Set genre with known and unknown codes
+            ID3v2MetadataSetter.set_genres(test_file, ["(17)", "(999)"], version="2.4")
+
+            # Read via API
+            genres = get_unified_metadata_field(test_file, UnifiedMetadataKey.GENRES_NAMES)
+
+            assert genres == ["Rock"]
+
+    def test_code_text_uses_text_part(self):
+        """Test code+text: '(199)Rock' -> 'Rock' (text part only)."""
+        with temp_file_with_metadata({"title": "Test Song"}, "id3v2.4") as test_file:
+            # Set genre with code+text
+            ID3v2MetadataSetter.set_genres(test_file, ["(199)Rock"], version="2.4")
+
+            # Read via API
+            genres = get_unified_metadata_field(test_file, UnifiedMetadataKey.GENRES_NAMES)
+
+            assert genres == ["Rock"]

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

@@ -0,0 +1,62 @@
+import pytest
+
+from audiometa import get_unified_metadata_field, update_metadata
+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.temp_file_with_metadata import temp_file_with_metadata
+from audiometa.test.helpers.vorbis import VorbisMetadataSetter
+from audiometa.utils.metadata_format import MetadataFormat
+from audiometa.utils.unified_metadata_key import UnifiedMetadataKey
+
+
+@pytest.mark.integration
+class TestGenreDeleting:
+    def test_delete_genre_id3v2(self):
+        with temp_file_with_metadata({}, "mp3") as test_file:
+            ID3v2MetadataSetter.set_genre(test_file, "Rock")
+            assert get_unified_metadata_field(test_file, UnifiedMetadataKey.GENRES_NAMES) == ["Rock"]
+
+            update_metadata(test_file, {UnifiedMetadataKey.GENRES_NAMES: None}, metadata_format=MetadataFormat.ID3V2)
+            assert get_unified_metadata_field(test_file, UnifiedMetadataKey.GENRES_NAMES) is None
+
+    def test_delete_genre_id3v1(self):
+        with temp_file_with_metadata({}, "id3v1") as test_file:
+            ID3v1MetadataSetter.set_genre(test_file, "Rock")
+            assert get_unified_metadata_field(test_file, UnifiedMetadataKey.GENRES_NAMES) == ["Rock"]
+
+            update_metadata(test_file, {UnifiedMetadataKey.GENRES_NAMES: None}, metadata_format=MetadataFormat.ID3V1)
+            assert get_unified_metadata_field(test_file, UnifiedMetadataKey.GENRES_NAMES) is None
+
+    def test_delete_genre_riff(self):
+        with temp_file_with_metadata({}, "wav") as test_file:
+            RIFFMetadataSetter.set_genres(test_file, ["Rock"])
+            assert get_unified_metadata_field(test_file, UnifiedMetadataKey.GENRES_NAMES) == ["Rock"]
+
+            update_metadata(test_file, {UnifiedMetadataKey.GENRES_NAMES: None}, metadata_format=MetadataFormat.RIFF)
+            assert get_unified_metadata_field(test_file, UnifiedMetadataKey.GENRES_NAMES) is None
+
+    def test_delete_genre_vorbis(self):
+        with temp_file_with_metadata({}, "flac") as test_file:
+            VorbisMetadataSetter.set_genre(test_file, "Rock")
+            assert get_unified_metadata_field(test_file, UnifiedMetadataKey.GENRES_NAMES) == ["Rock"]
+
+            update_metadata(test_file, {UnifiedMetadataKey.GENRES_NAMES: None}, metadata_format=MetadataFormat.VORBIS)
+            assert get_unified_metadata_field(test_file, UnifiedMetadataKey.GENRES_NAMES) is None
+
+    def test_delete_genre_preserves_other_fields(self):
+        with temp_file_with_metadata({}, "mp3") as test_file:
+            ID3v2MetadataSetter.set_genre(test_file, "Rock")
+            ID3v2MetadataSetter.set_title(test_file, "Test Title")
+            ID3v2MetadataSetter.set_artists(test_file, "Test Artist")
+
+            update_metadata(test_file, {UnifiedMetadataKey.GENRES_NAMES: None}, metadata_format=MetadataFormat.ID3V2)
+
+            assert get_unified_metadata_field(test_file, UnifiedMetadataKey.GENRES_NAMES) 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_genre_already_none(self):
+        with temp_file_with_metadata({}, "mp3") as test_file:
+            update_metadata(test_file, {UnifiedMetadataKey.GENRES_NAMES: None}, metadata_format=MetadataFormat.ID3V2)
+            assert get_unified_metadata_field(test_file, UnifiedMetadataKey.GENRES_NAMES) is None

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

@@ -0,0 +1,64 @@
+import pytest
+
+from audiometa import get_unified_metadata, update_metadata
+from audiometa.test.helpers.id3v1.id3v1_metadata_getter import ID3v1MetadataGetter
+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 TestGenreWriting:
+    def test_id3v1(self):
+        with temp_file_with_metadata({}, "mp3") as test_file:
+            test_genre = "Rock"
+            test_metadata = {UnifiedMetadataKey.GENRES_NAMES: [test_genre]}
+            update_metadata(test_file, test_metadata, metadata_format=MetadataFormat.ID3V1)
+
+            raw_metadata = ID3v1MetadataGetter.get_raw_metadata(test_file)
+            assert raw_metadata["genre"] == 17
+
+    def test_id3v2_3(self):
+        with temp_file_with_metadata({}, "mp3") as test_file:
+            test_genre = "Test Genre ID3v2"
+            test_metadata = {UnifiedMetadataKey.GENRES_NAMES: [test_genre]}
+            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 raw_metadata["TCON"] == [test_genre]
+
+    def test_id3v2_4(self):
+        with temp_file_with_metadata({}, "mp3") as test_file:
+            test_genre = "Test Genre ID3v2"
+            test_metadata = {UnifiedMetadataKey.GENRES_NAMES: [test_genre]}
+            update_metadata(test_file, test_metadata, metadata_format=MetadataFormat.ID3V2, id3v2_version=(2, 4, 0))
+
+            raw_metadata = ID3v2MetadataGetter.get_raw_metadata(test_file, version="2.4")
+            assert raw_metadata["TCON"] == [test_genre]
+
+    def test_riff(self):
+        with temp_file_with_metadata({}, "wav") as test_file:
+            test_genre = "Rock"
+            test_metadata = {UnifiedMetadataKey.GENRES_NAMES: [test_genre]}
+            update_metadata(test_file, test_metadata, metadata_format=MetadataFormat.RIFF)
+
+            raw_metadata = RIFFMetadataGetter.get_raw_metadata(test_file)
+            assert "TAG:genre=Rock" in raw_metadata
+
+    def test_vorbis(self):
+        with temp_file_with_metadata({}, "flac") as test_file:
+            test_genre = "Test Genre Vorbis"
+            test_metadata = {UnifiedMetadataKey.GENRES_NAMES: [test_genre]}
+            update_metadata(test_file, test_metadata, metadata_format=MetadataFormat.VORBIS)
+            metadata = get_unified_metadata(test_file)
+            assert metadata.get(UnifiedMetadataKey.GENRES_NAMES) == [test_genre]
+
+    def test_invalid_type_raises(self):
+        from audiometa.exceptions import InvalidMetadataFieldTypeError
+
+        with temp_file_with_metadata({}, "mp3") as test_file:
+            bad_metadata = {UnifiedMetadataKey.GENRES_NAMES: 123}
+            with pytest.raises(InvalidMetadataFieldTypeError):
+                update_metadata(test_file, bad_metadata)

audiometa/test/tests/integration/metadata_field/isrc/__init__.py

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

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

@@ -0,0 +1,31 @@
+"""Tests for deleting ISRC metadata field."""
+
+import pytest
+
+from audiometa import delete_all_metadata, get_unified_metadata_field
+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 TestISRCDeleting:
+    def test_id3v2_isrc_deleted_with_all_metadata(self):
+        """Test that ISRC is deleted when deleting all metadata from MP3."""
+        with temp_file_with_metadata({"isrc": "USRC17607839"}, "mp3") as test_file:
+            delete_all_metadata(test_file)
+            isrc = get_unified_metadata_field(test_file, UnifiedMetadataKey.ISRC)
+            assert isrc is None
+
+    def test_vorbis_isrc_deleted_with_all_metadata(self):
+        """Test that ISRC is deleted when deleting all metadata from FLAC."""
+        with temp_file_with_metadata({"isrc": "GBUM71505078"}, "flac") as test_file:
+            delete_all_metadata(test_file)
+            isrc = get_unified_metadata_field(test_file, UnifiedMetadataKey.ISRC)
+            assert isrc is None
+
+    def test_riff_isrc_deleted_with_all_metadata(self):
+        """Test that ISRC is deleted when deleting all metadata from WAV."""
+        with temp_file_with_metadata({"isrc": "FRXM01500014"}, "wav") as test_file:
+            delete_all_metadata(test_file)
+            isrc = get_unified_metadata_field(test_file, UnifiedMetadataKey.ISRC)
+            assert isrc is None

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

@@ -0,0 +1,35 @@
+"""Tests for reading ISRC metadata field across different formats."""
+
+import pytest
+
+from audiometa import get_unified_metadata_field
+from audiometa.exceptions import MetadataFieldNotSupportedByMetadataFormatError
+from audiometa.test.helpers.riff import RIFFMetadataSetter
+from audiometa.test.helpers.temp_file_with_metadata import temp_file_with_metadata
+from audiometa.test.helpers.vorbis import VorbisMetadataSetter
+from audiometa.utils.metadata_format import MetadataFormat
+from audiometa.utils.unified_metadata_key import UnifiedMetadataKey
+
+
+@pytest.mark.integration
+class TestISRCReading:
+    def test_id3v1_isrc_not_supported(self, sample_mp3_file):
+        """Test that ISRC is not supported by ID3v1 format when explicitly requesting ID3v1."""
+        with pytest.raises(MetadataFieldNotSupportedByMetadataFormatError):
+            get_unified_metadata_field(sample_mp3_file, UnifiedMetadataKey.ISRC, metadata_format=MetadataFormat.ID3V1)
+
+    def test_vorbis_max_isrc(self):
+        with temp_file_with_metadata({}, "flac") as test_file:
+            VorbisMetadataSetter.set_max_metadata(test_file)
+            isrc = get_unified_metadata_field(test_file, UnifiedMetadataKey.ISRC)
+            # Max ISRC set by set_max_metadata is "USXXX9999999" (12 chars, standard format)
+            assert isrc == "USXXX9999999"
+            assert len(isrc) == 12
+
+    def test_riff_max_isrc(self):
+        with temp_file_with_metadata({}, "wav") as test_file:
+            RIFFMetadataSetter.set_max_metadata(test_file)
+            isrc = get_unified_metadata_field(test_file, UnifiedMetadataKey.ISRC)
+            # Max ISRC set by set_max_metadata is "USXXX9999999" (12 chars, standard format)
+            assert isrc == "USXXX9999999"
+            assert len(isrc) == 12

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

@@ -0,0 +1,165 @@
+"""Tests for writing ISRC metadata field across different formats."""
+
+import pytest
+
+from audiometa import get_unified_metadata, get_unified_metadata_field, update_metadata
+from audiometa.exceptions import MetadataFieldNotSupportedByMetadataFormatError
+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 TestISRCWritingByMetadataFormat:
+    """Test ISRC writing explicitly by metadata format (ID3v2, Vorbis, RIFF)."""
+
+    # Test 12-character format against each metadata format
+    @pytest.mark.parametrize(
+        "isrc",
+        [
+            "USRC17607839",  # Standard 12-char format
+            "GBUM71505078",  # UK code
+        ],
+    )
+    def test_id3v2_12_char_format(self, isrc):
+        """Test 12-character ISRC format with ID3v2."""
+        with temp_file_with_metadata({}, "mp3") as test_file:
+            update_metadata(
+                test_file,
+                {UnifiedMetadataKey.ISRC: isrc},
+                metadata_format=MetadataFormat.ID3V2,
+            )
+            result = get_unified_metadata_field(
+                test_file, UnifiedMetadataKey.ISRC, metadata_format=MetadataFormat.ID3V2
+            )
+            assert result == isrc
+
+    @pytest.mark.parametrize(
+        "isrc",
+        [
+            "USRC17607839",  # Standard 12-char format
+            "GBUM71505078",  # UK code
+        ],
+    )
+    def test_vorbis_12_char_format(self, isrc):
+        """Test 12-character ISRC format with Vorbis."""
+        with temp_file_with_metadata({}, "flac") as test_file:
+            update_metadata(
+                test_file,
+                {UnifiedMetadataKey.ISRC: isrc},
+                metadata_format=MetadataFormat.VORBIS,
+            )
+            result = get_unified_metadata_field(
+                test_file, UnifiedMetadataKey.ISRC, metadata_format=MetadataFormat.VORBIS
+            )
+            assert result == isrc
+
+    @pytest.mark.parametrize(
+        "isrc",
+        [
+            "USRC17607839",  # Standard 12-char format
+            "GBUM71505078",  # UK code
+        ],
+    )
+    def test_riff_12_char_format(self, isrc):
+        """Test 12-character ISRC format with RIFF."""
+        with temp_file_with_metadata({}, "wav") as test_file:
+            update_metadata(
+                test_file,
+                {UnifiedMetadataKey.ISRC: isrc},
+                metadata_format=MetadataFormat.RIFF,
+            )
+            result = get_unified_metadata_field(test_file, UnifiedMetadataKey.ISRC, metadata_format=MetadataFormat.RIFF)
+            assert result == isrc
+
+    # Test hyphenated format against each metadata format
+    @pytest.mark.parametrize(
+        "isrc",
+        [
+            "US-RC1-76-07839",  # Standard hyphenated format
+            "GB-UM7-15-05078",  # UK code with hyphens
+        ],
+    )
+    def test_id3v2_hyphenated_format(self, isrc):
+        """Test hyphenated ISRC format with ID3v2."""
+        with temp_file_with_metadata({}, "mp3") as test_file:
+            update_metadata(
+                test_file,
+                {UnifiedMetadataKey.ISRC: isrc},
+                metadata_format=MetadataFormat.ID3V2,
+            )
+            result = get_unified_metadata_field(
+                test_file, UnifiedMetadataKey.ISRC, metadata_format=MetadataFormat.ID3V2
+            )
+            assert result == isrc
+
+    @pytest.mark.parametrize(
+        "isrc",
+        [
+            "US-RC1-76-07839",  # Standard hyphenated format
+            "GB-UM7-15-05078",  # UK code with hyphens
+        ],
+    )
+    def test_vorbis_hyphenated_format(self, isrc):
+        """Test hyphenated ISRC format with Vorbis."""
+        with temp_file_with_metadata({}, "flac") as test_file:
+            update_metadata(
+                test_file,
+                {UnifiedMetadataKey.ISRC: isrc},
+                metadata_format=MetadataFormat.VORBIS,
+            )
+            result = get_unified_metadata_field(
+                test_file, UnifiedMetadataKey.ISRC, metadata_format=MetadataFormat.VORBIS
+            )
+            assert result == isrc
+
+    @pytest.mark.parametrize(
+        "isrc",
+        [
+            "US-RC1-76-07839",  # Standard hyphenated format
+            "GB-UM7-15-05078",  # UK code with hyphens
+        ],
+    )
+    def test_riff_hyphenated_format(self, isrc):
+        """Test hyphenated ISRC format with RIFF."""
+        with temp_file_with_metadata({}, "wav") as test_file:
+            update_metadata(
+                test_file,
+                {UnifiedMetadataKey.ISRC: isrc},
+                metadata_format=MetadataFormat.RIFF,
+            )
+            result = get_unified_metadata_field(test_file, UnifiedMetadataKey.ISRC, metadata_format=MetadataFormat.RIFF)
+            assert result == isrc
+
+    def test_id3v1_isrc_not_supported_on_write(self, sample_mp3_file):
+        """Test that ISRC is not supported by ID3v1 format when explicitly targeting ID3v1."""
+        test_metadata = {UnifiedMetadataKey.ISRC: "USRC17607839"}
+
+        with pytest.raises(MetadataFieldNotSupportedByMetadataFormatError):
+            update_metadata(
+                sample_mp3_file,
+                test_metadata,
+                metadata_format=MetadataFormat.ID3V1,
+                fail_on_unsupported_field=True,
+            )
+
+
+@pytest.mark.integration
+class TestISRCWritingRoundtrip:
+    """Test ISRC writing roundtrip by file format."""
+
+    def test_isrc_with_other_fields(self):
+        test_metadata = {
+            UnifiedMetadataKey.TITLE: "Test Song",
+            UnifiedMetadataKey.ARTISTS: ["Test Artist"],
+            UnifiedMetadataKey.ALBUM: "Test Album",
+            UnifiedMetadataKey.ISRC: "USRC17607839",
+        }
+
+        with temp_file_with_metadata({}, "mp3") as test_file:
+            update_metadata(test_file, test_metadata)
+            metadata = get_unified_metadata(test_file)
+            assert metadata.get(UnifiedMetadataKey.TITLE) == "Test Song"
+            assert metadata.get(UnifiedMetadataKey.ARTISTS) == ["Test Artist"]
+            assert metadata.get(UnifiedMetadataKey.ALBUM) == "Test Album"
+            assert metadata.get(UnifiedMetadataKey.ISRC) == "USRC17607839"

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

@@ -0,0 +1,75 @@
+import pytest
+
+from audiometa import get_unified_metadata_field, update_metadata
+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.metadata_format import MetadataFormat
+from audiometa.utils.unified_metadata_key import UnifiedMetadataKey
+
+
+@pytest.mark.integration
+class TestLanguageDeleting:
+    def test_delete_language_id3v2(self):
+        with temp_file_with_metadata({}, "mp3") as test_file:
+            ID3v2MetadataSetter.set_language(test_file, "en")
+            assert get_unified_metadata_field(test_file, UnifiedMetadataKey.LANGUAGE) == "en"
+
+            # Delete metadata using library API
+            update_metadata(test_file, {UnifiedMetadataKey.LANGUAGE: None}, metadata_format=MetadataFormat.ID3V2)
+            assert get_unified_metadata_field(test_file, UnifiedMetadataKey.LANGUAGE) is None
+
+    def test_delete_language_id3v1(self):
+        from audiometa.exceptions import MetadataFieldNotSupportedByMetadataFormatError
+
+        with (
+            temp_file_with_metadata({}, "id3v1") as test_file,
+            pytest.raises(MetadataFieldNotSupportedByMetadataFormatError),
+        ):
+            # Deleting should fail since the field isn't supported
+            update_metadata(test_file, {UnifiedMetadataKey.LANGUAGE: None}, metadata_format=MetadataFormat.ID3V1)
+
+    def test_delete_language_riff(self):
+        with temp_file_with_metadata({}, "wav") as test_file:
+            RIFFMetadataSetter.set_language(test_file, "en")
+            raw_metadata = RIFFMetadataGetter.get_raw_metadata(test_file)
+            assert "TAG:language=en" in raw_metadata
+
+            # Delete metadata using library API
+            update_metadata(test_file, {UnifiedMetadataKey.LANGUAGE: None}, metadata_format=MetadataFormat.RIFF)
+            assert get_unified_metadata_field(test_file, UnifiedMetadataKey.LANGUAGE) is None
+
+    def test_delete_language_vorbis(self):
+        with temp_file_with_metadata({}, "flac") as test_file:
+            VorbisMetadataSetter.set_language(test_file, "en")
+            assert get_unified_metadata_field(test_file, UnifiedMetadataKey.LANGUAGE) == "en"
+
+            # Delete metadata using library API
+            update_metadata(test_file, {UnifiedMetadataKey.LANGUAGE: None}, metadata_format=MetadataFormat.VORBIS)
+            assert get_unified_metadata_field(test_file, UnifiedMetadataKey.LANGUAGE) is None
+
+    def test_delete_language_preserves_other_fields(self):
+        with temp_file_with_metadata({}, "mp3") as test_file:
+            ID3v2MetadataSetter.set_language(test_file, "en")
+            ID3v2MetadataSetter.set_title(test_file, "Test Title")
+            ID3v2MetadataSetter.set_artists(test_file, "Test Artist")
+
+            # Delete only language using library API
+            update_metadata(test_file, {UnifiedMetadataKey.LANGUAGE: None}, metadata_format=MetadataFormat.ID3V2)
+
+            assert get_unified_metadata_field(test_file, UnifiedMetadataKey.LANGUAGE) 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_language_already_none(self):
+        with temp_file_with_metadata({}, "mp3") as test_file:
+            # Try to delete language that doesn't exist
+            update_metadata(test_file, {UnifiedMetadataKey.LANGUAGE: None}, metadata_format=MetadataFormat.ID3V2)
+            assert get_unified_metadata_field(test_file, UnifiedMetadataKey.LANGUAGE) is None
+
+    def test_delete_language_empty_string(self):
+        with temp_file_with_metadata({}, "mp3") as test_file:
+            update_metadata(test_file, {UnifiedMetadataKey.LANGUAGE: ""}, metadata_format=MetadataFormat.ID3V2)
+            assert get_unified_metadata_field(test_file, UnifiedMetadataKey.LANGUAGE) is None