audiometa-python 0.6.0__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_disc_number_validation.py

@@ -0,0 +1,75 @@
+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 TestDiscNumberValidation:
+    """Test disc number field validation in validate_metadata_for_update."""
+
+    @pytest.mark.parametrize(
+        "disc_number",
+        [1, 5, 99, 255],
+    )
+    def test_valid_disc_number_as_int(self, disc_number):
+        validate_metadata_for_update({UnifiedMetadataKey.DISC_NUMBER: disc_number})
+
+    @pytest.mark.parametrize(
+        "disc_number",
+        ["1", "5", "99"],
+    )
+    def test_invalid_disc_number_as_string(self, disc_number):
+        with pytest.raises(InvalidMetadataFieldTypeError):
+            validate_metadata_for_update({UnifiedMetadataKey.DISC_NUMBER: disc_number})
+
+    def test_disc_number_none_is_allowed(self):
+        validate_metadata_for_update({UnifiedMetadataKey.DISC_NUMBER: None})
+
+    @pytest.mark.parametrize(
+        "invalid_value",
+        [3.14, [], "1"],
+    )
+    def test_invalid_disc_number_type(self, invalid_value):
+        with pytest.raises(InvalidMetadataFieldTypeError):
+            validate_metadata_for_update({UnifiedMetadataKey.DISC_NUMBER: invalid_value})
+
+    @pytest.mark.parametrize(
+        "disc_number",
+        [-1, -5],
+    )
+    def test_invalid_disc_number_negative(self, disc_number):
+        with pytest.raises(InvalidMetadataFieldFormatError):
+            validate_metadata_for_update({UnifiedMetadataKey.DISC_NUMBER: disc_number})
+
+
+@pytest.mark.unit
+class TestDiscTotalValidation:
+    """Test disc total field validation in validate_metadata_for_update."""
+
+    @pytest.mark.parametrize(
+        "disc_total",
+        [1, 5, 99, 255],
+    )
+    def test_valid_disc_total_as_int(self, disc_total):
+        validate_metadata_for_update({UnifiedMetadataKey.DISC_TOTAL: disc_total})
+
+    def test_disc_total_none_is_allowed(self):
+        validate_metadata_for_update({UnifiedMetadataKey.DISC_TOTAL: None})
+
+    @pytest.mark.parametrize(
+        "invalid_value",
+        [3.14, [], "1"],
+    )
+    def test_invalid_disc_total_type(self, invalid_value):
+        with pytest.raises(InvalidMetadataFieldTypeError):
+            validate_metadata_for_update({UnifiedMetadataKey.DISC_TOTAL: invalid_value})
+
+    @pytest.mark.parametrize(
+        "disc_total",
+        [-1, -5],
+    )
+    def test_invalid_disc_total_negative(self, disc_total):
+        with pytest.raises(InvalidMetadataFieldFormatError):
+            validate_metadata_for_update({UnifiedMetadataKey.DISC_TOTAL: disc_total})

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

@@ -0,0 +1,121 @@
+"""Unit tests for ISRC metadata field format validation."""
+
+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 TestISRCFormatValidation:
+    @pytest.mark.parametrize(
+        "isrc",
+        [
+            "USRC17607839",  # Standard 12-char format
+            "GBAYE0000001",  # UK code
+            "JPAB01234567",  # Japan code
+            "DEAB01234567",  # Germany code
+            "usrc17607839",  # Lowercase allowed
+            "UsRc17607839",  # Mixed case allowed
+        ],
+    )
+    def test_valid_12_char_format(self, isrc):
+        validate_metadata_for_update({UnifiedMetadataKey.ISRC: isrc})
+
+    @pytest.mark.parametrize(
+        "isrc",
+        [
+            "US-RC1-76-07839",  # Standard hyphenated format
+            "GB-AYE-00-00001",  # UK code with hyphens
+            "JP-AB0-12-34567",  # Japan code with hyphens
+        ],
+    )
+    def test_valid_hyphenated_format(self, isrc):
+        validate_metadata_for_update({UnifiedMetadataKey.ISRC: isrc})
+
+    @pytest.mark.parametrize(
+        "isrc",
+        [
+            "USRC1760783",  # Too short (11 chars)
+            "USRC176078",  # Too short (10 chars)
+            "USRC17607",  # Too short (9 chars)
+            "ABC",  # Way too short
+            "U",  # Single char
+        ],
+    )
+    def test_invalid_format_too_short(self, isrc):
+        with pytest.raises(InvalidMetadataFieldFormatError) as exc_info:
+            validate_metadata_for_update({UnifiedMetadataKey.ISRC: isrc})
+        error = exc_info.value
+        assert error.field == UnifiedMetadataKey.ISRC.value
+        assert error.value == isrc
+        assert "12 alphanumeric characters" in error.expected_format
+
+    @pytest.mark.parametrize(
+        "isrc",
+        [
+            "USRC176078390",  # Too long (13 chars)
+            "USRC1760783901",  # Too long (14 chars)
+            "USRC17607839012",  # Too long (15 chars non-hyphenated)
+            "USRC176078390123",  # Too long (16 chars)
+        ],
+    )
+    def test_invalid_format_too_long(self, isrc):
+        with pytest.raises(InvalidMetadataFieldFormatError) as exc_info:
+            validate_metadata_for_update({UnifiedMetadataKey.ISRC: isrc})
+        error = exc_info.value
+        assert error.field == UnifiedMetadataKey.ISRC.value
+        assert error.value == isrc
+        assert "12 alphanumeric characters" in error.expected_format
+
+    @pytest.mark.parametrize(
+        "isrc",
+        [
+            "USRC-17607839",  # Wrong hyphen position
+            "US-RC17607839",  # Missing hyphens
+            "US-RC1-7607839",  # Wrong segment lengths
+            "US-RC1-76-0783",  # Last segment too short (4 chars)
+            "US-RC1-76-078390",  # Last segment too long (6 chars)
+            "US-R-76-07839",  # Second segment too short
+            "US-RC12-76-07839",  # Second segment too long
+            "U-RC1-76-07839",  # First segment too short
+            "USA-RC1-76-07839",  # First segment too long
+            "US-RC1-7-07839",  # Third segment too short
+            "US-RC1-761-07839",  # Third segment too long
+        ],
+    )
+    def test_invalid_hyphenated_format(self, isrc):
+        with pytest.raises(InvalidMetadataFieldFormatError) as exc_info:
+            validate_metadata_for_update({UnifiedMetadataKey.ISRC: isrc})
+        error = exc_info.value
+        assert error.field == UnifiedMetadataKey.ISRC.value
+        assert error.value == isrc
+
+    @pytest.mark.parametrize(
+        "isrc",
+        [
+            "USRC1760783!",  # Special character
+            "USRC@7607839",  # Special character
+            "USRC 7607839",  # Space
+            "USRC_7607839",  # Underscore
+        ],
+    )
+    def test_invalid_format_special_characters(self, isrc):
+        with pytest.raises(InvalidMetadataFieldFormatError) as exc_info:
+            validate_metadata_for_update({UnifiedMetadataKey.ISRC: isrc})
+        error = exc_info.value
+        assert error.field == UnifiedMetadataKey.ISRC.value
+        assert error.value == isrc
+
+    def test_none_value_allowed(self):
+        validate_metadata_for_update({UnifiedMetadataKey.ISRC: None})
+
+    def test_empty_string_allowed(self):
+        validate_metadata_for_update({UnifiedMetadataKey.ISRC: ""})
+
+    def test_format_validation_after_type_validation(self):
+        invalid_type = {UnifiedMetadataKey.ISRC: 12345}
+        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_isrc_type_validation.py

@@ -0,0 +1,30 @@
+"""Unit tests for ISRC metadata field type validation."""
+
+import pytest
+
+from audiometa import validate_metadata_for_update
+from audiometa.exceptions import InvalidMetadataFieldTypeError
+from audiometa.utils.unified_metadata_key import UnifiedMetadataKey
+
+
+@pytest.mark.unit
+class TestISRCTypeValidation:
+    def test_valid_isrc_string(self):
+        validate_metadata_for_update({UnifiedMetadataKey.ISRC: "USRC17607839"})
+
+    def test_valid_isrc_with_hyphens(self):
+        validate_metadata_for_update({UnifiedMetadataKey.ISRC: "US-RC1-76-07839"})
+
+    def test_invalid_isrc_type_integer_raises(self):
+        with pytest.raises(InvalidMetadataFieldTypeError):
+            validate_metadata_for_update({UnifiedMetadataKey.ISRC: 12345})
+
+    def test_invalid_isrc_type_list_raises(self):
+        with pytest.raises(InvalidMetadataFieldTypeError):
+            validate_metadata_for_update({UnifiedMetadataKey.ISRC: ["USRC17607839"]})
+
+    def test_isrc_none_is_allowed(self):
+        validate_metadata_for_update({UnifiedMetadataKey.ISRC: None})
+
+    def test_isrc_empty_string_is_allowed(self):
+        validate_metadata_for_update({UnifiedMetadataKey.ISRC: ""})

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