audiometa-python 0.2.2__py3-none-any.whl

audiometa/test/tests/unit/metadata_managers/metadata_field/rating/writing/test_validation.py

@@ -0,0 +1,151 @@
+from unittest.mock import MagicMock
+
+import pytest
+
+from audiometa.exceptions import InvalidRatingValueError
+from audiometa.manager._rating_supporting._RatingSupportingMetadataManager import _RatingSupportingMetadataManager
+from audiometa.manager._rating_supporting.id3v2._Id3v2Manager import _Id3v2Manager as Id3v2Manager
+from audiometa.utils.unified_metadata_key import UnifiedMetadataKey
+
+
+@pytest.mark.unit
+class TestRatingValidation:
+    def test_validate_rating_value_raw_mode_non_negative_allowed(self):
+        # These should not raise any exceptions
+        _RatingSupportingMetadataManager.validate_rating_value(0, None)
+        _RatingSupportingMetadataManager.validate_rating_value(1, None)
+        _RatingSupportingMetadataManager.validate_rating_value(128, None)
+        _RatingSupportingMetadataManager.validate_rating_value(255, None)
+        _RatingSupportingMetadataManager.validate_rating_value(1000, None)
+        _RatingSupportingMetadataManager.validate_rating_value(1.5, None)
+        _RatingSupportingMetadataManager.validate_rating_value(75.7, None)
+        _RatingSupportingMetadataManager.validate_rating_value(0.0, None)
+
+    def test_validate_rating_value_raw_mode_negative_rejected(self):
+        with pytest.raises(InvalidRatingValueError) as exc_info:
+            _RatingSupportingMetadataManager.validate_rating_value(-1, None)
+        assert "must be non-negative" in str(exc_info.value)
+
+        with pytest.raises(InvalidRatingValueError) as exc_info:
+            _RatingSupportingMetadataManager.validate_rating_value(-100, None)
+        assert "must be non-negative" in str(exc_info.value)
+
+        with pytest.raises(InvalidRatingValueError) as exc_info:
+            _RatingSupportingMetadataManager.validate_rating_value(-0.5, None)
+        assert "must be non-negative" in str(exc_info.value)
+
+    def test_validate_rating_value_normalized_mode_valid_values(self):
+        # Valid values: those that map to BASE_100_PROPORTIONAL profile
+        # (value/100 * 100) must be in [0, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100]
+        valid_values = [0, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100]
+        for value in valid_values:
+            _RatingSupportingMetadataManager.validate_rating_value(value, 100)
+
+    def test_validate_rating_value_normalized_mode_valid_float_values(self):
+        # Valid float values: 1.5/10 * 100 = 15 (in BASE_100_PROPORTIONAL)
+        _RatingSupportingMetadataManager.validate_rating_value(1.5, 10)
+        # 2.5/10 * 100 = 25 (in BASE_100_PROPORTIONAL)
+        _RatingSupportingMetadataManager.validate_rating_value(2.5, 10)
+        # 7.5/10 * 100 = 75 (in BASE_100_PROPORTIONAL)
+        _RatingSupportingMetadataManager.validate_rating_value(7.5, 10)
+        # 50.0/100 * 100 = 50 (in BASE_100_PROPORTIONAL)
+        _RatingSupportingMetadataManager.validate_rating_value(50.0, 100)
+
+    def test_validate_rating_value_normalized_mode_negative_rejected(self):
+        with pytest.raises(InvalidRatingValueError) as exc_info:
+            _RatingSupportingMetadataManager.validate_rating_value(-1, 100)
+        assert "must be non-negative" in str(exc_info.value)
+
+    @pytest.mark.parametrize(
+        "rating",
+        [101, 100.1, 101.5],
+    )
+    def test_validate_rating_value_normalized_mode_over_max_rejected(self, rating):
+        with pytest.raises(InvalidRatingValueError) as exc_info:
+            _RatingSupportingMetadataManager.validate_rating_value(rating, 100)
+        assert "out of range" in str(exc_info.value)
+        assert "must be between 0 and 100" in str(exc_info.value)
+
+    def test_validate_rating_value_normalized_mode_invalid_profile_value(self):
+        # 33/100 maps to star rating index 3 (1.5 stars), which is valid
+        # This test verifies that values mapping to valid star rating indices are accepted
+        # Note: The old validation checked if output values exist, but the conversion uses star rating indices
+        _RatingSupportingMetadataManager.validate_rating_value(33, 100)
+
+        # Test a value that would map to an invalid star rating index (> 10)
+        with pytest.raises(InvalidRatingValueError) as exc_info:
+            _RatingSupportingMetadataManager.validate_rating_value(110, 100)
+        assert "out of range" in str(exc_info.value)
+
+    def test_validate_rating_value_normalized_mode_different_max_values(self):
+        """Test profile-based validation with different max values."""
+        # Test with max_value = 10 (0-10 scale)
+        # All values 0-10 map to valid profile values
+        valid_values_10 = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+        for value in valid_values_10:
+            _RatingSupportingMetadataManager.validate_rating_value(value, 10)
+
+        # Test with max_value = 255
+        # Valid values: those that map to BASE_255_NON_PROPORTIONAL profile values
+        # Profile values: 0, 13, 1, 54, 64, 118, 128, 186, 196, 242, 255
+        # So valid normalized values are: 0, 13, 1, 54, 64, 118, 128, 186, 196, 242, 255
+        valid_values_255 = [0, 1, 13, 54, 64, 118, 128, 186, 196, 242, 255]
+        for value in valid_values_255:
+            _RatingSupportingMetadataManager.validate_rating_value(value, 255)
+
+        # Also valid: values that map to BASE_100_PROPORTIONAL when scaled
+        # For example: 50/255 * 100 = 20 (round), which is in BASE_100_PROPORTIONAL
+        valid_values_255_also_100 = [25, 50, 76, 102, 127, 153, 178, 204, 229]
+        for value in valid_values_255_also_100:
+            _RatingSupportingMetadataManager.validate_rating_value(value, 255)
+
+        # Values that map to valid star rating indices are accepted
+        # The conversion uses star rating indices (0-10), not direct output values
+        # 37/255 -> index 1 (0.5 stars) -> valid
+        # 99/255 -> index 4 (2 stars) -> valid
+        # 200/255 -> index 8 (4 stars) -> valid
+        # All these values map to valid star rating indices, so they are accepted
+
+        # Test a value that would map to an invalid star rating index (> 10)
+        with pytest.raises(InvalidRatingValueError) as exc_info:
+            _RatingSupportingMetadataManager.validate_rating_value(256, 255)
+        assert "out of range" in str(exc_info.value)
+
+    def test_validate_rating_in_unified_metadata_valid(self):
+        manager = Id3v2Manager(audio_file=MagicMock(), normalized_rating_max_value=100)
+
+        # Valid metadata should not raise
+        manager._validate_rating_in_unified_metadata({UnifiedMetadataKey.RATING: 50})
+
+    def test_validate_rating_in_unified_metadata_invalid_type(self):
+        manager = Id3v2Manager(audio_file=MagicMock(), normalized_rating_max_value=100)
+
+        # String should raise InvalidRatingValueError
+        with pytest.raises(InvalidRatingValueError) as exc_info:
+            manager._validate_rating_in_unified_metadata({UnifiedMetadataKey.RATING: "invalid"})
+        assert "Rating value must be numeric" in str(exc_info.value)
+
+        # Dict should raise InvalidRatingValueError
+        with pytest.raises(InvalidRatingValueError) as exc_info:
+            manager._validate_rating_in_unified_metadata({UnifiedMetadataKey.RATING: {"not": "valid"}})
+        assert "Rating value must be numeric" in str(exc_info.value)
+
+    def test_validate_rating_in_unified_metadata_float_accepted(self):
+        manager = Id3v2Manager(audio_file=MagicMock(), normalized_rating_max_value=100)
+
+        # Float should be accepted
+        manager._validate_rating_in_unified_metadata({UnifiedMetadataKey.RATING: 50.0})
+        manager._validate_rating_in_unified_metadata({UnifiedMetadataKey.RATING: 1.5})
+        manager._validate_rating_in_unified_metadata({UnifiedMetadataKey.RATING: 7.5})
+
+    def test_validate_rating_in_unified_metadata_none_ignored(self):
+        manager = Id3v2Manager(audio_file=MagicMock(), normalized_rating_max_value=100)
+
+        # None should be ignored (no exception)
+        manager._validate_rating_in_unified_metadata({UnifiedMetadataKey.RATING: None})
+
+    def test_validate_rating_in_unified_metadata_missing_key(self):
+        manager = Id3v2Manager(audio_file=MagicMock(), normalized_rating_max_value=100)
+
+        # Missing key should be ignored
+        manager._validate_rating_in_unified_metadata({})

audiometa/test/tests/unit/metadata_managers/metadata_field/rating/writing/test_writing_profiles.py

@@ -0,0 +1,61 @@
+from unittest.mock import MagicMock
+
+import pytest
+
+from audiometa.manager._rating_supporting.id3v2._Id3v2Manager import _Id3v2Manager as Id3v2Manager
+from audiometa.manager._rating_supporting.riff._RiffManager import _RiffManager as RiffManager
+from audiometa.manager._rating_supporting.vorbis._VorbisManager import _VorbisManager as VorbisManager
+
+
+@pytest.mark.unit
+class TestWritingProfiles:
+    @pytest.mark.parametrize(
+        ("normalized_rating", "expected_raw_rating"),
+        [
+            (0, 0),
+            (1, 13),
+            (2, 1),
+            (3, 54),
+            (4, 64),
+            (5, 118),
+            (6, 128),
+            (7, 186),
+            (8, 196),
+            (9, 242),
+            (10, 255),
+        ],
+    )
+    def test_base_255_non_proportional(self, normalized_rating, expected_raw_rating):
+        id3v2_audio_file = MagicMock()
+        id3v2_manager = Id3v2Manager(audio_file=id3v2_audio_file, normalized_rating_max_value=10)
+        raw_rating = id3v2_manager._convert_normalized_rating_to_file_rating(normalized_rating=normalized_rating)
+        assert raw_rating == expected_raw_rating
+
+        wave_audio_file = MagicMock()
+        wave_audio_file.file_extension = ".wav"
+        riff_manager = RiffManager(audio_file=wave_audio_file, normalized_rating_max_value=10)
+        raw_rating = riff_manager._convert_normalized_rating_to_file_rating(normalized_rating=normalized_rating)
+        assert raw_rating == expected_raw_rating
+
+    @pytest.mark.parametrize(
+        ("normalized_rating", "expected_raw_rating"),
+        [
+            (0, 0),
+            (1, 10),
+            (2, 20),
+            (3, 30),
+            (4, 40),
+            (5, 50),
+            (6, 60),
+            (7, 70),
+            (8, 80),
+            (9, 90),
+            (10, 100),
+        ],
+    )
+    def test_base_100_proportional(self, normalized_rating, expected_raw_rating):
+        flac_audio_file = MagicMock()
+        flac_audio_file.file_extension = ".flac"
+        vorbis_manager = VorbisManager(audio_file=flac_audio_file, normalized_rating_max_value=10)
+        raw_rating = vorbis_manager._convert_normalized_rating_to_file_rating(normalized_rating=normalized_rating)
+        assert raw_rating == expected_raw_rating

audiometa/test/tests/unit/metadata_managers/metadata_field/test_date_format_validation.py

@@ -0,0 +1,135 @@
+import pytest
+
+from audiometa import validate_metadata_for_update
+from audiometa.exceptions import InvalidMetadataFieldFormatError, InvalidMetadataFieldTypeError
+from audiometa.utils.unified_metadata_key import UnifiedMetadataKey
+
+
+@pytest.mark.unit
+class TestReleaseDateFormatValidation:
+    @pytest.mark.parametrize(
+        "year",
+        ["2024", "1900", "0000", "9999", "1970"],
+    )
+    def test_valid_yyyy_format(self, year):
+        validate_metadata_for_update({UnifiedMetadataKey.RELEASE_DATE: year})
+
+    @pytest.mark.parametrize(
+        "date",
+        [
+            "2024-01-01",
+            "2024-12-31",
+            "1900-01-01",
+            "0000-00-00",
+            "9999-12-31",
+            "1970-06-15",
+        ],
+    )
+    def test_valid_yyyy_mm_dd_format(self, date):
+        validate_metadata_for_update({UnifiedMetadataKey.RELEASE_DATE: date})
+
+    @pytest.mark.parametrize(
+        "date",
+        [
+            "2024/01/01",
+            "2024.01.01",
+            "2024_01_01",
+            "2024 01 01",
+        ],
+    )
+    def test_invalid_format_wrong_separator(self, date):
+        with pytest.raises(InvalidMetadataFieldFormatError) as exc_info:
+            validate_metadata_for_update({UnifiedMetadataKey.RELEASE_DATE: date})
+        error = exc_info.value
+        assert error.field == UnifiedMetadataKey.RELEASE_DATE.value
+        assert error.value == date
+        assert "YYYY" in error.expected_format
+
+    @pytest.mark.parametrize(
+        "date",
+        [
+            "2024-1-1",
+            "2024-1-01",
+            "2024-01-1",
+        ],
+    )
+    def test_invalid_format_single_digit_month_day(self, date):
+        with pytest.raises(InvalidMetadataFieldFormatError) as exc_info:
+            validate_metadata_for_update({UnifiedMetadataKey.RELEASE_DATE: date})
+        error = exc_info.value
+        assert error.field == UnifiedMetadataKey.RELEASE_DATE.value
+        assert error.value == date
+
+    @pytest.mark.parametrize(
+        "date",
+        [
+            "24",
+            "024",
+            "999",
+        ],
+    )
+    def test_invalid_format_short_year(self, date):
+        with pytest.raises(InvalidMetadataFieldFormatError) as exc_info:
+            validate_metadata_for_update({UnifiedMetadataKey.RELEASE_DATE: date})
+        error = exc_info.value
+        assert error.field == UnifiedMetadataKey.RELEASE_DATE.value
+        assert error.value == date
+
+    @pytest.mark.parametrize(
+        "date",
+        [
+            "20241",
+            "20241-01-01",
+        ],
+    )
+    def test_invalid_format_long_year(self, date):
+        with pytest.raises(InvalidMetadataFieldFormatError) as exc_info:
+            validate_metadata_for_update({UnifiedMetadataKey.RELEASE_DATE: date})
+        error = exc_info.value
+        assert error.field == UnifiedMetadataKey.RELEASE_DATE.value
+        assert error.value == date
+
+    @pytest.mark.parametrize(
+        "date",
+        [
+            "not-a-date",
+            "2024-abc-01",
+            "abcd-01-01",
+            "2024-01-abc",
+            "2024a",
+        ],
+    )
+    def test_invalid_format_non_numeric(self, date):
+        with pytest.raises(InvalidMetadataFieldFormatError) as exc_info:
+            validate_metadata_for_update({UnifiedMetadataKey.RELEASE_DATE: date})
+        error = exc_info.value
+        assert error.field == UnifiedMetadataKey.RELEASE_DATE.value
+        assert error.value == date
+
+    @pytest.mark.parametrize(
+        "date",
+        [
+            "2024-",
+            "2024-01",
+            "2024-01-",
+            "-01-01",
+        ],
+    )
+    def test_invalid_format_incomplete_date(self, date):
+        with pytest.raises(InvalidMetadataFieldFormatError) as exc_info:
+            validate_metadata_for_update({UnifiedMetadataKey.RELEASE_DATE: date})
+        error = exc_info.value
+        assert error.field == UnifiedMetadataKey.RELEASE_DATE.value
+        assert error.value == date
+
+    def test_none_value_allowed(self):
+        validate_metadata_for_update({UnifiedMetadataKey.RELEASE_DATE: None})
+
+    def test_empty_string_allowed(self):
+        validate_metadata_for_update({UnifiedMetadataKey.RELEASE_DATE: ""})
+
+    def test_format_validation_after_type_validation(self):
+        invalid_type = {UnifiedMetadataKey.RELEASE_DATE: 2024}
+        with pytest.raises(InvalidMetadataFieldTypeError) as exc_info:
+            validate_metadata_for_update(invalid_type)
+        assert not isinstance(exc_info.value, InvalidMetadataFieldFormatError)

audiometa/test/tests/unit/metadata_managers/metadata_field/test_track_number_validation.py

@@ -0,0 +1,46 @@
+import pytest
+
+from audiometa import validate_metadata_for_update
+from audiometa.exceptions import InvalidMetadataFieldFormatError, InvalidMetadataFieldTypeError
+from audiometa.utils.unified_metadata_key import UnifiedMetadataKey
+
+
+@pytest.mark.unit
+class TestTrackNumberValidation:
+    """Test track number field validation in validate_metadata_for_update."""
+
+    @pytest.mark.parametrize(
+        "track_number",
+        [1, 5, 99],
+    )
+    def test_valid_track_number_as_int(self, track_number):
+        validate_metadata_for_update({UnifiedMetadataKey.TRACK_NUMBER: track_number})
+
+    @pytest.mark.parametrize(
+        "track_number",
+        ["1", "5", "99"],
+    )
+    def test_valid_track_number_as_string(self, track_number):
+        validate_metadata_for_update({UnifiedMetadataKey.TRACK_NUMBER: track_number})
+
+    @pytest.mark.parametrize(
+        "track_number",
+        ["5/12", "1/10", "99/100"],
+    )
+    def test_valid_track_number_with_total(self, track_number):
+        validate_metadata_for_update({UnifiedMetadataKey.TRACK_NUMBER: track_number})
+
+    def test_invalid_track_number_format(self):
+        with pytest.raises(InvalidMetadataFieldFormatError):
+            validate_metadata_for_update({UnifiedMetadataKey.TRACK_NUMBER: "/12"})
+
+    def test_track_number_none_is_allowed(self):
+        validate_metadata_for_update({UnifiedMetadataKey.TRACK_NUMBER: None})
+
+    @pytest.mark.parametrize(
+        "invalid_value",
+        [3.14, []],
+    )
+    def test_invalid_track_number_type(self, invalid_value):
+        with pytest.raises(InvalidMetadataFieldTypeError):
+            validate_metadata_for_update({UnifiedMetadataKey.TRACK_NUMBER: invalid_value})

audiometa/test/tests/unit/metadata_managers/metadata_field/test_type_validation_exception.py

@@ -0,0 +1,22 @@
+import pytest
+
+from audiometa.exceptions import InvalidMetadataFieldTypeError
+
+
+@pytest.mark.unit
+class TestExceptionClasses:
+    def test_invalid_metadata_field_type_error_attributes(self):
+        error = InvalidMetadataFieldTypeError("title", "str", 123)
+        assert error.field == "title"
+        assert error.expected_type == "str"
+        assert error.actual_type == "int"
+        assert error.value == 123
+        assert isinstance(error, TypeError)
+
+    def test_invalid_metadata_field_type_error_message_format(self):
+        error = InvalidMetadataFieldTypeError("artists", "list[str]", {"key": "value"})
+        message = str(error)
+        assert "artists" in message
+        assert "list[str]" in message
+        assert "dict" in message or "actual_type" in message
+        assert "'artists'" in message or "artists" in message

audiometa/test/tests/unit/metadata_managers/metadata_field/test_validation.py

@@ -0,0 +1,83 @@
+import pytest
+
+from audiometa import validate_metadata_for_update
+from audiometa.utils.unified_metadata_key import UnifiedMetadataKey
+
+
+@pytest.mark.unit
+class TestValidateMetadata:
+    """Test the integrate validate_metadata_for_update function.
+
+    This class tests the high-level validation function that integrates multiple validation layers. Specific field
+    validation (type, format) is tested separately in metadata_field/ test files.
+    """
+
+    def test_empty_dict_raises_error(self):
+        with pytest.raises(ValueError, match="no metadata fields specified"):
+            validate_metadata_for_update({})
+
+    def test_none_values_allowed(self):
+        validate_metadata_for_update({UnifiedMetadataKey.TITLE: None})
+
+        validate_metadata_for_update(
+            {
+                UnifiedMetadataKey.TITLE: None,
+                UnifiedMetadataKey.ARTISTS: None,
+                UnifiedMetadataKey.ALBUM: None,
+            }
+        )
+
+    def test_empty_string_allowed(self):
+        validate_metadata_for_update({UnifiedMetadataKey.TITLE: ""})
+
+    def test_empty_list_allowed(self):
+        validate_metadata_for_update({UnifiedMetadataKey.ARTISTS: []})
+
+    def test_list_with_none_values_allowed(self):
+        validate_metadata_for_update({UnifiedMetadataKey.ARTISTS: [None, None]})
+        validate_metadata_for_update({UnifiedMetadataKey.ARTISTS: [None]})
+        validate_metadata_for_update({UnifiedMetadataKey.GENRES_NAMES: [None, None, None]})
+
+    def test_empty_string_and_empty_list_allowed(self):
+        validate_metadata_for_update({UnifiedMetadataKey.TITLE: "", UnifiedMetadataKey.ARTISTS: []})
+
+    def test_valid_metadata_passes(self):
+        validate_metadata_for_update({UnifiedMetadataKey.TITLE: "Song Title"})
+        validate_metadata_for_update({UnifiedMetadataKey.ARTISTS: ["Artist 1", "Artist 2"]})
+        validate_metadata_for_update({UnifiedMetadataKey.ALBUM: "Album Name"})
+
+    def test_multiple_valid_fields_passes(self):
+        validate_metadata_for_update(
+            {
+                UnifiedMetadataKey.TITLE: "Song Title",
+                UnifiedMetadataKey.ARTISTS: ["Artist"],
+                UnifiedMetadataKey.ALBUM: "Album",
+            }
+        )
+
+    def test_mixed_none_and_valid_fields_passes(self):
+        validate_metadata_for_update(
+            {
+                UnifiedMetadataKey.TITLE: None,
+                UnifiedMetadataKey.ARTISTS: ["Artist"],
+            }
+        )
+
+    def test_combined_validation_rating_and_release_date(self):
+        validate_metadata_for_update(
+            {
+                UnifiedMetadataKey.RATING: 50,
+                UnifiedMetadataKey.RELEASE_DATE: "2024-01-01",
+            },
+            normalized_rating_max_value=100,
+        )
+
+    def test_combined_validation_with_empty_fields(self):
+        validate_metadata_for_update(
+            {
+                UnifiedMetadataKey.TITLE: "",
+                UnifiedMetadataKey.ARTISTS: [],
+                UnifiedMetadataKey.RATING: 50,
+            },
+            normalized_rating_max_value=100,
+        )

audiometa/test/tests/unit/metadata_managers/test_metadata_format_managers_write_and_read.py

@@ -0,0 +1,74 @@
+import pytest
+
+from audiometa._audio_file import _AudioFile
+from audiometa.manager._rating_supporting.id3v2._Id3v2Manager import _Id3v2Manager as Id3v2Manager
+from audiometa.manager._rating_supporting.riff._RiffManager import _RiffManager as RiffManager
+from audiometa.manager._rating_supporting.vorbis._VorbisManager import _VorbisManager as VorbisManager
+from audiometa.manager.id3v1._Id3v1Manager import _Id3v1Manager as Id3v1Manager
+from audiometa.manager.id3v1.id3v1_raw_metadata_key import Id3v1RawMetadataKey
+from audiometa.test.helpers.temp_file_with_metadata import temp_file_with_metadata
+from audiometa.utils.unified_metadata_key import UnifiedMetadataKey
+
+
+@pytest.mark.unit
+class TestMetadataFormatManagersWriteAndRead:
+    def test_id3v1_manager_write_and_read(self):
+        with temp_file_with_metadata({}, "mp3") as test_file:
+            audio_file = _AudioFile(test_file)
+            manager = Id3v1Manager(audio_file)
+
+            manager.update_metadata(
+                {UnifiedMetadataKey.TITLE: "Test Title", UnifiedMetadataKey.ARTISTS: ["Test Artist"]}
+            )
+
+            raw_metadata = manager._extract_mutagen_metadata()
+
+            assert raw_metadata.tags.get(Id3v1RawMetadataKey.TITLE) == ["Test Title"]
+            assert raw_metadata.tags.get(Id3v1RawMetadataKey.ARTISTS_NAMES_STR) == ["Test Artist"]
+
+    def test_id3v2_manager_write_and_read(self):
+        with temp_file_with_metadata({}, "mp3") as test_file:
+            audio_file = _AudioFile(test_file)
+            manager = Id3v2Manager(audio_file)
+
+            manager.update_metadata(
+                {UnifiedMetadataKey.TITLE: "Test Title", UnifiedMetadataKey.ARTISTS: ["Test Artist"]}
+            )
+
+            raw_metadata = manager._extract_mutagen_metadata()
+
+            assert Id3v2Manager.Id3TextFrame.TITLE in raw_metadata
+            assert str(raw_metadata[Id3v2Manager.Id3TextFrame.TITLE][0]) == "Test Title"
+            assert Id3v2Manager.Id3TextFrame.ARTISTS in raw_metadata
+            artists_text = str(raw_metadata[Id3v2Manager.Id3TextFrame.ARTISTS][0])
+            assert "Test Artist" in artists_text
+
+    def test_riff_manager_write_and_read(self):
+        with temp_file_with_metadata({}, "wav") as test_file:
+            audio_file = _AudioFile(test_file)
+            manager = RiffManager(audio_file)
+
+            manager.update_metadata(
+                {UnifiedMetadataKey.TITLE: "Test Title", UnifiedMetadataKey.ARTISTS: ["Test Artist"]}
+            )
+
+            raw_metadata = manager._extract_mutagen_metadata()
+
+            assert hasattr(raw_metadata, "info")
+            info_tags = getattr(raw_metadata, "info", {})
+            assert info_tags.get(RiffManager.RiffTagKey.TITLE) == ["Test Title"]
+            assert info_tags.get(RiffManager.RiffTagKey.ARTIST) == ["Test Artist"]
+
+    def test_vorbis_manager_write_and_read(self):
+        with temp_file_with_metadata({}, "flac") as test_file:
+            audio_file = _AudioFile(test_file)
+            manager = VorbisManager(audio_file)
+
+            manager.update_metadata(
+                {UnifiedMetadataKey.TITLE: "Test Title", UnifiedMetadataKey.ARTISTS: ["Test Artist"]}
+            )
+
+            raw_metadata = manager._extract_mutagen_metadata()
+
+            assert raw_metadata.get(VorbisManager.VorbisKey.TITLE) == ["Test Title"]
+            assert raw_metadata.get(VorbisManager.VorbisKey.ARTIST) == ["Test Artist"]

audiometa/utils/__init__.py

@@ -0,0 +1 @@
+"""Utility classes and functions for audio metadata processing."""