audiometa-python 0.2.2__py3-none-any.whl

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."""

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

@@ -0,0 +1,80 @@
+import pytest
+
+from audiometa import get_unified_metadata
+from audiometa.test.helpers.id3v1 import ID3v1MetadataSetter
+from audiometa.test.helpers.id3v2 import ID3v2MetadataSetter
+from audiometa.test.helpers.id3v2.id3v2_metadata_getter import ID3v2MetadataGetter
+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 TestMultipleMetadata:
+    def test_id3v1(self):
+        with temp_file_with_metadata({}, "mp3") as test_file:
+            # First set ID3v1 metadata using external tools
+            ID3v1MetadataSetter.set_title(test_file, "ID3v1 Title")
+            ID3v1MetadataSetter.set_artist(test_file, "ID3v1 Artist")
+            ID3v1MetadataSetter.set_album(test_file, "ID3v1 Album")
+
+            merged_metadata = get_unified_metadata(test_file)
+            assert merged_metadata.get(UnifiedMetadataKey.TITLE) == "ID3v1 Title"
+            assert merged_metadata.get(UnifiedMetadataKey.ARTISTS) == ["ID3v1 Artist"]
+            assert merged_metadata.get(UnifiedMetadataKey.ALBUM) == "ID3v1 Album"
+
+    def test_id3v2_3(self):
+        with temp_file_with_metadata({}, "id3v2.3") as test_file:
+            # First set ID3v2.3 metadata using external tools
+            ID3v2MetadataSetter.set_title(test_file, "ID3v2.3 Title", version="2.3")
+            ID3v2MetadataSetter.set_artists(test_file, "ID3v2.3 Artist", version="2.3")
+            ID3v2MetadataSetter.set_album(test_file, "ID3v2.3 Album", version="2.3")
+
+            merged_metadata = get_unified_metadata(test_file)
+            assert merged_metadata.get(UnifiedMetadataKey.TITLE) == "ID3v2.3 Title"
+            assert merged_metadata.get(UnifiedMetadataKey.ARTISTS) == ["ID3v2.3 Artist"]
+            assert merged_metadata.get(UnifiedMetadataKey.ALBUM) == "ID3v2.3 Album"
+
+    def test_id3v2_4(self):
+        with temp_file_with_metadata({}, "id3v2.4") as test_file:
+            # First set ID3v2.4 metadata using external tools
+            ID3v2MetadataSetter.set_title(test_file, "ID3v2.4 Title", version="2.4")
+            ID3v2MetadataSetter.set_artists(test_file, "ID3v2.4 Artist", version="2.4")
+            ID3v2MetadataSetter.set_album(test_file, "ID3v2.4 Album", version="2.4")
+
+            raw_metadata = ID3v2MetadataGetter.get_raw_metadata(test_file, version="2.4")
+            assert raw_metadata["TIT2"] == ["ID3v2.4 Title"]
+            assert raw_metadata["TPE1"] == ["ID3v2.4 Artist"]
+            assert raw_metadata["TALB"] == ["ID3v2.4 Album"]
+
+            merged_metadata = get_unified_metadata(test_file)
+            assert merged_metadata.get(UnifiedMetadataKey.TITLE) == "ID3v2.4 Title"
+            assert merged_metadata.get(UnifiedMetadataKey.ARTISTS) == ["ID3v2.4 Artist"]
+            assert merged_metadata.get(UnifiedMetadataKey.ALBUM) == "ID3v2.4 Album"
+
+    def test_riff(self):
+        with temp_file_with_metadata({}, "wav") as test_file:
+            # First set RIFF metadata using external tools
+            from audiometa.test.helpers.riff import RIFFMetadataSetter
+
+            RIFFMetadataSetter.set_title(test_file, "RIFF Title")
+            RIFFMetadataSetter.set_artist(test_file, "RIFF Artist")
+            RIFFMetadataSetter.set_album(test_file, "RIFF Album")
+
+            merged_metadata = get_unified_metadata(test_file)
+            assert merged_metadata.get(UnifiedMetadataKey.TITLE) == "RIFF Title"
+            assert merged_metadata.get(UnifiedMetadataKey.ARTISTS) == ["RIFF Artist"]
+            assert merged_metadata.get(UnifiedMetadataKey.ALBUM) == "RIFF Album"
+
+    def test_vorbis(self):
+        with temp_file_with_metadata({}, "flac") as test_file:
+            # First set Vorbis metadata using external tools
+            from audiometa.test.helpers.vorbis import VorbisMetadataSetter
+
+            VorbisMetadataSetter.add_title(test_file, "Vorbis Title")
+            VorbisMetadataSetter.set_artist(test_file, "Vorbis Artist")
+            VorbisMetadataSetter.set_album(test_file, "Vorbis Album")
+
+            merged_metadata = get_unified_metadata(test_file)
+            assert merged_metadata.get(UnifiedMetadataKey.TITLE) == "Vorbis Title"
+            assert merged_metadata.get(UnifiedMetadataKey.ARTISTS) == ["Vorbis Artist"]
+            assert merged_metadata.get(UnifiedMetadataKey.ALBUM) == "Vorbis Album"

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

@@ -0,0 +1,36 @@
+from pathlib import Path
+
+import pytest
+
+from audiometa import get_unified_metadata, get_unified_metadata_field
+from audiometa.exceptions import FileTypeNotSupportedError
+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 TestReadingErrorHandling:
+    def test_unsupported_file_type_raises_error(self):
+        # Create a file with unsupported extension
+        with temp_file_with_metadata({}, "mp3") as temp_audio_file_path:
+            temp_audio_file_path.write_bytes(b"fake audio content")
+            txt_file_path = temp_audio_file_path.with_suffix(".txt")
+            txt_file_path.write_bytes(b"fake audio content")
+
+            with pytest.raises(FileTypeNotSupportedError):
+                get_unified_metadata(str(txt_file_path))
+
+    def test_nonexistent_file_raises_error(self):
+        nonexistent_file = "nonexistent_file.mp3"
+
+        with pytest.raises(FileNotFoundError):
+            get_unified_metadata(nonexistent_file)
+
+        with pytest.raises(FileNotFoundError):
+            get_unified_metadata_field(nonexistent_file, UnifiedMetadataKey.TITLE)
+
+    def test_metadata_key_not_found_returns_none(self, sample_mp3_file: Path):
+        # This should not raise an error, but return None when the field is not found
+        # Using a valid UnifiedMetadataKey that might not be present in the file
+        result = get_unified_metadata_field(sample_mp3_file, UnifiedMetadataKey.UNSYNCHRONIZED_LYRICS)
+        assert result is None

audiometa/test/tests/integration/real_audio_files/test_reading.py

@@ -0,0 +1,146 @@
+"""End-to-end tests using real audio files from data/audio_files."""
+
+from pathlib import Path
+
+import pytest
+
+from audiometa import get_unified_metadata
+from audiometa.utils.unified_metadata_key import UnifiedMetadataKey
+
+
+@pytest.mark.integration
+class TestRealAudioFilesReading:
+    """Test cases using real audio files for end-to-end validation."""
+
+    def test_recording_allumerlefeu_metadata(self, assets_dir: Path):
+        file_path = assets_dir / "recording=Allumerlefeu_2 matches one with more release groups.mp3"
+
+        metadata = get_unified_metadata(file_path)
+        assert isinstance(metadata, dict)
+        assert metadata[UnifiedMetadataKey.TITLE] == "Allumer le feu"
+        assert metadata[UnifiedMetadataKey.ARTISTS] == ["Johnny Hallyday"]
+        assert metadata[UnifiedMetadataKey.ALBUM] == "Les Années 80-90-2000, C'Etait Mieux Avant"
+        assert metadata[UnifiedMetadataKey.GENRES_NAMES] == ["Variétés Internationales"]
+        assert metadata[UnifiedMetadataKey.RELEASE_DATE] == "2018-09-28"
+        assert metadata[UnifiedMetadataKey.TRACK_NUMBER] == "39"
+        assert metadata[UnifiedMetadataKey.BPM] == 139
+        assert metadata[UnifiedMetadataKey.COMPOSERS] == ["Pascal Obispo", "Pierre Jaconelli"]
+        assert metadata[UnifiedMetadataKey.PUBLISHER] == ""
+        assert metadata[UnifiedMetadataKey.COPYRIGHT] == "© 2018 Mercury Music Group"
+
+    def test_recording_celinekin_park_metadata(self, assets_dir: Path):
+        file_path = assets_dir / "recording=Celinekin Park - no musicbrainz recording duration.mp3"
+
+        metadata = get_unified_metadata(file_path)
+        assert isinstance(metadata, dict)
+        assert metadata[UnifiedMetadataKey.TITLE] == "Celinekin Park (Linkin Park vs. Celine Dion)"
+        assert metadata[UnifiedMetadataKey.ARTISTS] == ["The Table"]
+        assert metadata[UnifiedMetadataKey.ALBUM] == "Bootie Top 10 – November/December 2018"  # noqa: RUF001
+        assert metadata[UnifiedMetadataKey.ALBUM_ARTISTS] == ["A Plus D"]
+        assert metadata[UnifiedMetadataKey.RELEASE_DATE] == "2018-11-30"
+        assert metadata[UnifiedMetadataKey.TRACK_NUMBER] == "9/10"
+        assert metadata[UnifiedMetadataKey.BPM] == 99
+        assert metadata[UnifiedMetadataKey.PUBLISHER] == "[no label]"
+        assert metadata[UnifiedMetadataKey.COMMENT] == "BootieMashup.com"
+
+    def test_recording_dans_la_legende_metadata(self, assets_dir: Path):
+        file_path = assets_dir / "recording=Dans la legende.flac"
+
+        metadata = get_unified_metadata(file_path)
+        assert isinstance(metadata, dict)
+        assert metadata[UnifiedMetadataKey.TITLE] == "DA"
+        assert metadata[UnifiedMetadataKey.ARTISTS] == ["PNL"]
+        assert metadata[UnifiedMetadataKey.ALBUM] == "Dans La Légende"
+        assert metadata[UnifiedMetadataKey.ALBUM_ARTISTS] == ["PNL"]
+        assert metadata[UnifiedMetadataKey.GENRES_NAMES] == ["French cloud rap"]
+        assert metadata[UnifiedMetadataKey.RATING] == 10
+        assert metadata[UnifiedMetadataKey.LANGUAGE] == "French"
+        assert metadata[UnifiedMetadataKey.RELEASE_DATE] == "2016"
+        assert metadata[UnifiedMetadataKey.TRACK_NUMBER] == "01"
+
+    def test_recording_kemar_france_metadata(self, assets_dir: Path):
+        file_path = assets_dir / "recording=Kemar - France.mp3"
+
+        metadata = get_unified_metadata(file_path)
+        assert isinstance(metadata, dict)
+        assert metadata[UnifiedMetadataKey.TITLE] == "Kemar - France"
+        assert metadata[UnifiedMetadataKey.BPM] == 140
+
+    def test_recording_tokyo_drift_metadata(self, assets_dir: Path):
+        file_path = assets_dir / "recording=Tokyo Drift_no mb recording.mp3"
+
+        metadata = get_unified_metadata(file_path)
+        assert isinstance(metadata, dict)
+        assert metadata[UnifiedMetadataKey.TITLE] == "Tokyo Drift x Temperature x You Little Beauty (BENNE BOOM Mashup)"
+        assert metadata[UnifiedMetadataKey.RELEASE_DATE] == "2021"
+        assert metadata[UnifiedMetadataKey.BPM] == 128
+
+    def test_recording_y_do_i_carmina_burana_mp3_metadata(self, assets_dir: Path):
+        file_path = assets_dir / "recording=Y do i - Carmina Burana Remix - 7m52.mp3"
+
+        metadata = get_unified_metadata(file_path)
+        assert isinstance(metadata, dict)
+        assert len(metadata) == 0  # No metadata
+
+    def test_recording_y_do_i_carmina_burana_wav_metadata(self, assets_dir: Path):
+        file_path = assets_dir / "recording=Y do i - Carmina Burana Remix - 7m52.wav"
+
+        metadata = get_unified_metadata(file_path)
+        assert isinstance(metadata, dict)
+        assert metadata.get(UnifiedMetadataKey.TITLE) == "Y do i - Carmina Burana Remix (Techno of the Opera)"
+        # Additional metadata fields that should be present if added:
+        if UnifiedMetadataKey.ARTISTS in metadata:
+            assert metadata.get(UnifiedMetadataKey.ARTISTS) == ["Y do I"]
+        if UnifiedMetadataKey.ALBUM_ARTISTS in metadata:
+            assert metadata.get(UnifiedMetadataKey.ALBUM_ARTISTS) == ["Y do I"]
+        if UnifiedMetadataKey.COMPOSERS in metadata:
+            assert metadata.get(UnifiedMetadataKey.COMPOSERS) == ["Carl Orff"]
+        if UnifiedMetadataKey.ALBUM in metadata:
+            assert metadata.get(UnifiedMetadataKey.ALBUM) == "Remixes"
+
+    def test_recording_california_gurls_metadata(self, assets_dir: Path):
+        file_path = assets_dir / "recording=california gurls_id3v2 tags.flac"
+
+        metadata = get_unified_metadata(file_path)
+        assert isinstance(metadata, dict)
+        assert metadata[UnifiedMetadataKey.TITLE] == "California Gurls"
+        assert metadata[UnifiedMetadataKey.ARTISTS] == ["Katy Perry feat. Snoop Dogg"]
+        assert metadata[UnifiedMetadataKey.ALBUM] == "Now That's What I Call Music! 76"
+        assert metadata[UnifiedMetadataKey.ALBUM_ARTISTS] == ["Various"]
+        assert metadata[UnifiedMetadataKey.GENRES_NAMES] == ["Pop Rock", "Euro House"]
+        assert metadata[UnifiedMetadataKey.RELEASE_DATE] == "2010"
+        assert metadata[UnifiedMetadataKey.TRACK_NUMBER] == "1"
+        assert metadata[UnifiedMetadataKey.BPM] == 125
+        assert (
+            metadata[UnifiedMetadataKey.COPYRIGHT]
+            == "© EMI Records Ltd. © Virgin Records Ltd. © Universal Music Operations Ltd."
+        )
+
+    def test_recording_juan_hansen_drown_flac_metadata(self, assets_dir: Path):
+        file_path = assets_dir / "recording=juan hansen oostil - drown (massano remix) - 7m20.flac"
+
+        metadata = get_unified_metadata(file_path)
+        assert isinstance(metadata, dict)
+        assert metadata[UnifiedMetadataKey.TITLE] == "Drown (Massano Remix)"
+        assert metadata[UnifiedMetadataKey.ARTISTS] == ["Øostil & Juan Hansen"]
+        assert metadata[UnifiedMetadataKey.ALBUM] == "In My System EP"
+        assert metadata[UnifiedMetadataKey.ALBUM_ARTISTS] == ["Massano"]
+        assert metadata[UnifiedMetadataKey.GENRES_NAMES] == ["Techno"]
+        assert metadata[UnifiedMetadataKey.RELEASE_DATE] == "2022"
+        assert metadata[UnifiedMetadataKey.TRACK_NUMBER] == "2"
+        assert metadata[UnifiedMetadataKey.BPM] == 122
+
+    def test_recording_juan_hansen_drown_mp3_metadata(self, assets_dir: Path):
+        file_path = assets_dir / "recording=juan hansen oostil - drown (massano remix) - 7m21.mp3"
+
+        metadata = get_unified_metadata(file_path)
+        assert isinstance(metadata, dict)
+        assert metadata[UnifiedMetadataKey.TITLE] == "Drown (Massano Remix)"
+        assert metadata[UnifiedMetadataKey.ARTISTS] == ["Øostil"]
+        assert metadata[UnifiedMetadataKey.ALBUM] == "In My System EP"
+        assert metadata[UnifiedMetadataKey.ALBUM_ARTISTS] == ["Massano"]
+        assert metadata[UnifiedMetadataKey.GENRES_NAMES] == ["Electro"]
+        assert metadata[UnifiedMetadataKey.RELEASE_DATE] == "2022-04-15"
+        assert metadata[UnifiedMetadataKey.TRACK_NUMBER] == "2"
+        assert metadata[UnifiedMetadataKey.BPM] == 122
+        assert metadata[UnifiedMetadataKey.PUBLISHER] == "Afterlife"