audiometa-python 0.6.0__py3-none-any.whl

audiometa/test/tests/integration/technical_info/flac_md5/test_invalid_md5/test_partial_md5.py

@@ -0,0 +1,29 @@
+from pathlib import Path
+
+import pytest
+
+from audiometa import fix_md5_checking, is_flac_md5_valid
+from audiometa.test.helpers.temp_file_with_metadata import temp_file_with_metadata
+from audiometa.test.tests.integration.technical_info.flac_md5.conftest import corrupt_md5, ensure_flac_has_md5
+
+
+@pytest.mark.integration
+class TestPartialMd5:
+    def test_is_flac_md5_valid_detects_partial_md5_corruption(self):
+        with temp_file_with_metadata({}, "flac") as test_file:
+            ensure_flac_has_md5(test_file)
+            corrupt_md5(test_file, "partial")
+
+            assert not is_flac_md5_valid(test_file), "Partially corrupted MD5 should be detected as invalid"
+
+    def test_fix_md5_checking_with_partial_corruption(self):
+        with temp_file_with_metadata({}, "flac") as test_file:
+            ensure_flac_has_md5(test_file)
+            corrupt_md5(test_file, "partial")
+
+            assert not is_flac_md5_valid(test_file), "Partially corrupted MD5 should be invalid"
+
+            fixed_file_path = fix_md5_checking(test_file)
+            assert is_flac_md5_valid(fixed_file_path), "Fixed file should have valid MD5"
+
+            Path(fixed_file_path).unlink()

audiometa/test/tests/integration/technical_info/flac_md5/test_invalid_md5/test_random_md5.py

@@ -0,0 +1,29 @@
+from pathlib import Path
+
+import pytest
+
+from audiometa import fix_md5_checking, is_flac_md5_valid
+from audiometa.test.helpers.temp_file_with_metadata import temp_file_with_metadata
+from audiometa.test.tests.integration.technical_info.flac_md5.conftest import corrupt_md5, ensure_flac_has_md5
+
+
+@pytest.mark.integration
+class TestRandomMd5:
+    def test_is_flac_md5_valid_detects_random_md5_corruption(self):
+        with temp_file_with_metadata({}, "flac") as test_file:
+            ensure_flac_has_md5(test_file)
+            corrupt_md5(test_file, "random")
+
+            assert not is_flac_md5_valid(test_file), "Random MD5 corruption should be detected as invalid"
+
+    def test_fix_md5_checking_with_random_corruption(self):
+        with temp_file_with_metadata({}, "flac") as test_file:
+            ensure_flac_has_md5(test_file)
+            corrupt_md5(test_file, "random")
+
+            assert not is_flac_md5_valid(test_file), "Random MD5 corruption should be invalid"
+
+            fixed_file_path = fix_md5_checking(test_file)
+            assert is_flac_md5_valid(fixed_file_path), "Fixed file should have valid MD5"
+
+            Path(fixed_file_path).unlink()

audiometa/test/tests/integration/technical_info/flac_md5/test_invalid_md5/test_unset_md5.py

@@ -0,0 +1,56 @@
+from pathlib import Path
+
+import pytest
+
+from audiometa import fix_md5_checking, is_flac_md5_valid
+from audiometa.test.helpers.temp_file_with_metadata import temp_file_with_metadata
+from audiometa.test.tests.integration.technical_info.flac_md5.conftest import (
+    corrupt_md5,
+    create_flac_without_md5,
+    ensure_flac_has_md5,
+)
+
+
+@pytest.mark.integration
+class TestUnsetMd5:
+    def test_is_flac_md5_valid_with_naturally_unset_md5(self):
+        with temp_file_with_metadata({}, "flac") as test_file:
+            # Create FLAC file without MD5 (naturally unset, not corrupted)
+            create_flac_without_md5(test_file)
+
+            # Unset MD5 (all zeros) should be consistently detected as invalid
+            result = is_flac_md5_valid(test_file)
+            assert result is False, "Unset MD5 should be detected as invalid"
+
+    def test_is_flac_md5_valid_with_corrupted_to_unset_md5(self):
+        with temp_file_with_metadata({}, "flac") as test_file:
+            ensure_flac_has_md5(test_file)
+            corrupt_md5(test_file, "zeros")
+
+            # Unset MD5 (all zeros) should be consistently detected as invalid
+            result = is_flac_md5_valid(test_file)
+            assert result is False, "Unset MD5 should be detected as invalid"
+
+    def test_fix_md5_checking_with_naturally_unset_md5(self):
+        with temp_file_with_metadata({}, "flac") as test_file:
+            # Create FLAC file without MD5 (naturally unset, not corrupted)
+            create_flac_without_md5(test_file)
+
+            assert not is_flac_md5_valid(test_file), "Unset MD5 should be detected as invalid"
+
+            fixed_file_path = fix_md5_checking(test_file)
+            assert is_flac_md5_valid(fixed_file_path), "Fixed file should have valid MD5"
+
+            Path(fixed_file_path).unlink()
+
+    def test_fix_md5_checking_with_corrupted_to_unset_md5(self):
+        with temp_file_with_metadata({}, "flac") as test_file:
+            ensure_flac_has_md5(test_file)
+            corrupt_md5(test_file, "zeros")
+
+            assert not is_flac_md5_valid(test_file), "Unset MD5 should be detected as invalid"
+
+            fixed_file_path = fix_md5_checking(test_file)
+            assert is_flac_md5_valid(fixed_file_path), "Fixed file should have valid MD5"
+
+            Path(fixed_file_path).unlink()

audiometa/test/tests/integration/technical_info/flac_md5/test_valid_md5.py

@@ -0,0 +1,21 @@
+from pathlib import Path
+
+import pytest
+
+from audiometa import is_flac_md5_valid
+from audiometa.exceptions import FileTypeNotSupportedError
+
+
+@pytest.mark.integration
+class TestValidFlacMd5:
+    def test_is_flac_md5_valid_works_with_path_string(self, sample_flac_file: Path):
+        is_valid = is_flac_md5_valid(str(sample_flac_file))
+        assert isinstance(is_valid, bool)
+
+    def test_is_flac_md5_valid_works_with_pathlib_path(self, sample_flac_file: Path):
+        is_valid = is_flac_md5_valid(sample_flac_file)
+        assert isinstance(is_valid, bool)
+
+    def test_is_flac_md5_valid_non_flac(self, sample_mp3_file: Path):
+        with pytest.raises(FileTypeNotSupportedError):
+            is_flac_md5_valid(sample_mp3_file)

audiometa/test/tests/integration/technical_info/test_bitrate.py

@@ -0,0 +1,79 @@
+from pathlib import Path
+
+import pytest
+
+from audiometa import get_bitrate
+from audiometa.test.helpers.technical_info_inspector import TechnicalInfoInspector
+
+
+@pytest.mark.integration
+class TestGetBitrate:
+    def test_get_bitrate_works_with_path_string(self, sample_mp3_file: Path):
+        bitrate = get_bitrate(str(sample_mp3_file))
+        assert isinstance(bitrate, int)
+        assert bitrate > 0
+
+    def test_get_bitrate_works_with_pathlib_path(self, sample_mp3_file: Path):
+        bitrate = get_bitrate(sample_mp3_file)
+        assert isinstance(bitrate, int)
+        assert bitrate > 0
+
+    def test_get_bitrate_matches_external_tool(self, sample_mp3_file: Path):
+        external_tool_bitrate = TechnicalInfoInspector.get_bitrate(sample_mp3_file)
+        assert external_tool_bitrate == 128
+
+        bitrate = get_bitrate(sample_mp3_file)
+        assert bitrate == 127997
+
+    def test_get_bitrate_supports_all_formats(
+        self, sample_mp3_file: Path, sample_flac_file: Path, sample_wav_file: Path
+    ):
+        mp3_bitrate = get_bitrate(sample_mp3_file)
+        flac_bitrate = get_bitrate(sample_flac_file)
+        wav_bitrate = get_bitrate(sample_wav_file)
+
+        assert isinstance(mp3_bitrate, int)
+        assert isinstance(flac_bitrate, int)
+        assert isinstance(wav_bitrate, int)
+        assert all(b > 0 for b in [mp3_bitrate, flac_bitrate, wav_bitrate])
+
+    def test_get_bitrate_for_320_kbps_mp3(self, bitrate_320_mp3: Path):
+        """Test bitrate for 320 kbps MP3 file."""
+        bitrate = get_bitrate(bitrate_320_mp3)
+        assert isinstance(bitrate, int)
+        # Expected: 320000 bps (320 kbps)
+        assert bitrate == 320000, f"Expected 320000 bps, got {bitrate} bps"
+
+    def test_get_bitrate_for_946_kbps_flac(self, bitrate_946_flac: Path):
+        """Test bitrate for 946 kbps FLAC file."""
+        bitrate = get_bitrate(bitrate_946_flac)
+        assert isinstance(bitrate, int)
+        # Expected: 946677 bps (≈946 kbps variable bitrate)
+        assert bitrate == 946677, f"Expected 946677 bps, got {bitrate} bps"
+
+    def test_get_bitrate_for_1411_kbps_wav(self, bitrate_1411_wav: Path):
+        """Test bitrate for 1411 kbps WAV file."""
+        bitrate = get_bitrate(bitrate_1411_wav)
+        assert isinstance(bitrate, int)
+        # Expected: 1411200 bps (≈1411 kbps)
+        assert bitrate == 1411200, f"Expected 1411200 bps, got {bitrate} bps"
+
+    def test_get_bitrate_validates_across_all_test_assets(self, assets_dir: Path):
+        """Test bitrate for all dedicated bitrate test assets."""
+        bitrate_test_files = [
+            ("bitrate in kbps_big=320.mp3", 320000),
+            ("bitrate in kbps_big=946.flac", 946677),  # Variable bitrate, actual measured value
+            ("bitrate in kbps_big=1411.wav", 1411200),
+            ("bitrate in kbps_small=192.mp3", 192000),
+            ("bitrate in kbps_small=723.flac", 777623),  # Variable bitrate, actual measured value
+            ("bitrate in kbps_small=1152.wav", 1152000),
+        ]
+
+        for filename, expected_bitrate_bps in bitrate_test_files:
+            file_path = assets_dir / filename
+            if file_path.exists():
+                bitrate = get_bitrate(file_path)
+                assert isinstance(bitrate, int), f"Bitrate for {filename} should be int"
+                assert (
+                    bitrate == expected_bitrate_bps
+                ), f"Expected {expected_bitrate_bps} bps for {filename}, got {bitrate} bps"

audiometa/test/tests/integration/technical_info/test_channels.py

@@ -0,0 +1,38 @@
+from pathlib import Path
+
+import pytest
+
+from audiometa import get_channels
+from audiometa.test.helpers.technical_info_inspector import TechnicalInfoInspector
+
+
+@pytest.mark.integration
+class TestGetChannels:
+    def test_get_channels_works_with_path_string(self, sample_mp3_file: Path):
+        channels = get_channels(str(sample_mp3_file))
+        assert isinstance(channels, int)
+        assert channels > 0
+
+    def test_get_channels_works_with_pathlib_path(self, sample_mp3_file: Path):
+        channels = get_channels(sample_mp3_file)
+        assert isinstance(channels, int)
+        assert channels > 0
+
+    def test_get_channels_matches_external_tool(self, sample_mp3_file: Path):
+        external_tool_channels = TechnicalInfoInspector.get_channels(sample_mp3_file)
+        assert external_tool_channels == 2
+
+        channels = get_channels(sample_mp3_file)
+        assert channels == 2
+
+    def test_get_channels_supports_all_formats(
+        self, sample_mp3_file: Path, sample_flac_file: Path, sample_wav_file: Path
+    ):
+        mp3_channels = get_channels(sample_mp3_file)
+        flac_channels = get_channels(sample_flac_file)
+        wav_channels = get_channels(sample_wav_file)
+
+        assert isinstance(mp3_channels, int)
+        assert isinstance(flac_channels, int)
+        assert isinstance(wav_channels, int)
+        assert all(c > 0 for c in [mp3_channels, flac_channels, wav_channels])

audiometa/test/tests/integration/technical_info/test_duration_in_sec.py

@@ -0,0 +1,38 @@
+from pathlib import Path
+
+import pytest
+
+from audiometa import get_duration_in_sec
+from audiometa.test.helpers.technical_info_inspector import TechnicalInfoInspector
+
+
+@pytest.mark.integration
+class TestGetDurationInSec:
+    def test_get_duration_in_sec_works_with_path_string(self, sample_mp3_file: Path):
+        duration = get_duration_in_sec(str(sample_mp3_file))
+        assert isinstance(duration, float)
+        assert duration > 0
+
+    def test_get_duration_in_sec_works_with_pathlib_path(self, sample_mp3_file: Path):
+        duration = get_duration_in_sec(sample_mp3_file)
+        assert isinstance(duration, float)
+        assert duration > 0
+
+    def test_get_duration_in_sec_matches_external_tool(self, sample_mp3_file: Path):
+        external_tool_duration = TechnicalInfoInspector.get_duration(sample_mp3_file)
+        assert external_tool_duration == 1.045
+
+        duration = get_duration_in_sec(sample_mp3_file)
+        assert duration == pytest.approx(1.0448979591836736, rel=1e-6)
+
+    def test_get_duration_in_sec_supports_all_formats(
+        self, sample_mp3_file: Path, sample_flac_file: Path, sample_wav_file: Path
+    ):
+        mp3_duration = get_duration_in_sec(sample_mp3_file)
+        flac_duration = get_duration_in_sec(sample_flac_file)
+        wav_duration = get_duration_in_sec(sample_wav_file)
+
+        assert isinstance(mp3_duration, float)
+        assert isinstance(flac_duration, float)
+        assert isinstance(wav_duration, float)
+        assert all(d > 0 for d in [mp3_duration, flac_duration, wav_duration])

audiometa/test/tests/integration/technical_info/test_sample_rate.py

@@ -0,0 +1,40 @@
+from pathlib import Path
+
+import pytest
+
+from audiometa import get_sample_rate
+from audiometa.test.helpers.technical_info_inspector import TechnicalInfoInspector
+
+
+@pytest.mark.integration
+class TestGetSampleRate:
+    def test_get_sample_rate_works_with_path_string(self, sample_mp3_file: Path):
+        sample_rate = get_sample_rate(str(sample_mp3_file))
+        assert isinstance(sample_rate, int)
+        assert sample_rate > 0
+
+    def test_get_sample_rate_works_with_pathlib_path(self, sample_mp3_file: Path):
+        sample_rate = get_sample_rate(sample_mp3_file)
+        assert isinstance(sample_rate, int)
+        assert sample_rate > 0
+
+    def test_get_sample_rate_matches_external_tool(self, sample_mp3_file: Path):
+        external_sample_rate = TechnicalInfoInspector.get_sample_rate(sample_mp3_file)
+        assert external_sample_rate is not None
+        assert isinstance(external_sample_rate, int)
+        assert external_sample_rate == 44100
+
+        sample_rate = get_sample_rate(sample_mp3_file)
+        assert sample_rate == external_sample_rate
+
+    def test_get_sample_rate_supports_all_formats(
+        self, sample_mp3_file: Path, sample_flac_file: Path, sample_wav_file: Path
+    ):
+        mp3_sample_rate = get_sample_rate(sample_mp3_file)
+        flac_sample_rate = get_sample_rate(sample_flac_file)
+        wav_sample_rate = get_sample_rate(sample_wav_file)
+
+        assert isinstance(mp3_sample_rate, int)
+        assert isinstance(flac_sample_rate, int)
+        assert isinstance(wav_sample_rate, int)
+        assert all(r > 0 for r in [mp3_sample_rate, flac_sample_rate, wav_sample_rate])

audiometa/test/tests/integration/test_audio_file.py

@@ -0,0 +1,35 @@
+from pathlib import Path
+
+import pytest
+
+from audiometa import get_unified_metadata, get_unified_metadata_field, is_audio_file
+from audiometa.utils.metadata_format import MetadataFormat
+from audiometa.utils.unified_metadata_key import UnifiedMetadataKey
+
+
+@pytest.mark.integration
+class TestAudioFileIntegration:
+    def test_functional_api_with_file_path(self, sample_mp3_file: Path):
+        # Test that functional APIs work with file paths (string)
+        metadata = get_unified_metadata(str(sample_mp3_file))
+        assert isinstance(metadata, dict)
+
+        # Test single format with file path
+        id3v2_metadata = get_unified_metadata(str(sample_mp3_file), metadata_format=MetadataFormat.ID3V2)
+        assert isinstance(id3v2_metadata, dict)
+
+        # Test specific metadata with file path
+        title = get_unified_metadata_field(str(sample_mp3_file), UnifiedMetadataKey.TITLE)
+        assert title is None or isinstance(title, str)
+
+    def test_is_audio_file_with_valid_files(self, sample_mp3_file: Path, sample_flac_file: Path, sample_wav_file: Path):
+        assert is_audio_file(sample_mp3_file) is True
+        assert is_audio_file(sample_flac_file) is True
+        assert is_audio_file(sample_wav_file) is True
+
+    def test_is_audio_file_before_processing(self, sample_mp3_file: Path):
+        if is_audio_file(sample_mp3_file):
+            metadata = get_unified_metadata(sample_mp3_file)
+            assert isinstance(metadata, dict)
+        else:
+            pytest.fail("Valid audio file should return True")

audiometa/test/tests/integration/test_audio_format_readable_after_update_all_metadata_formats.py

@@ -0,0 +1,95 @@
+import pytest
+
+from audiometa import 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 TestAudioFormatReadableAfterUpdate:
+    def test_mp3_playable_after_id3v1_and_id3v2_updates(self):
+        """Test that MP3 file remains playable after updating with ID3v1 and ID3v2 tags."""
+        sf = pytest.importorskip("soundfile")
+
+        with temp_file_with_metadata({}, "mp3") as test_file:
+            # Update with ID3v2 metadata first
+            id3v2_metadata = {
+                UnifiedMetadataKey.TITLE: "ID3v2 Test Title",
+                UnifiedMetadataKey.ARTISTS: ["ID3v2 Test Artist"],
+                UnifiedMetadataKey.ALBUM: "ID3v2 Test Album",
+                UnifiedMetadataKey.RATING: 80,
+            }
+            update_metadata(
+                test_file, id3v2_metadata, metadata_format=MetadataFormat.ID3V2, normalized_rating_max_value=100
+            )
+
+            # Update with ID3v1 metadata
+            id3v1_metadata = {
+                UnifiedMetadataKey.TITLE: "ID3v1 Test Title",
+                UnifiedMetadataKey.ARTISTS: ["ID3v1 Test Artist"],
+                UnifiedMetadataKey.ALBUM: "ID3v1 Test Album",
+            }
+            update_metadata(test_file, id3v1_metadata, metadata_format=MetadataFormat.ID3V1)
+
+            # Verify the track is still playable by trying to read audio frames
+            try:
+                with sf.SoundFile(str(test_file)) as f:
+                    # Just try reading a few frames
+                    frames = f.read(frames=1024)
+                    assert f.samplerate > 0
+                    assert f.channels > 0
+                    assert len(frames) > 0
+            except RuntimeError as e:
+                pytest.fail(f"Audio file {test_file} could not be opened or decoded: {e}")
+
+    def test_flac_playable_after_vorbis_updates(self):
+        """Test that FLAC file remains playable after updating with Vorbis tags."""
+        sf = pytest.importorskip("soundfile")
+
+        with temp_file_with_metadata({}, "flac") as test_file:
+            # Update with Vorbis metadata
+            vorbis_metadata = {
+                UnifiedMetadataKey.TITLE: "Vorbis Test Title",
+                UnifiedMetadataKey.ARTISTS: ["Vorbis Test Artist"],
+                UnifiedMetadataKey.ALBUM: "Vorbis Test Album",
+                UnifiedMetadataKey.RATING: 80,
+            }
+            update_metadata(
+                test_file, vorbis_metadata, metadata_format=MetadataFormat.VORBIS, normalized_rating_max_value=100
+            )
+
+            # Verify the track is still playable by trying to read audio frames
+            try:
+                with sf.SoundFile(str(test_file)) as f:
+                    # Just try reading a few frames
+                    frames = f.read(frames=1024)
+                    assert f.samplerate > 0
+                    assert f.channels > 0
+                    assert len(frames) > 0
+            except RuntimeError as e:
+                pytest.fail(f"Audio file {test_file} could not be opened or decoded: {e}")
+
+    def test_wav_playable_after_riff_updates(self):
+        """Test that WAV file remains playable after updating with RIFF tags."""
+        sf = pytest.importorskip("soundfile")
+
+        with temp_file_with_metadata({}, "wav") as test_file:
+            # Update with RIFF metadata
+            riff_metadata = {
+                UnifiedMetadataKey.TITLE: "RIFF Test Title",
+                UnifiedMetadataKey.ARTISTS: ["RIFF Test Artist"],
+                UnifiedMetadataKey.ALBUM: "RIFF Test Album",
+            }
+            update_metadata(test_file, riff_metadata, metadata_format=MetadataFormat.RIFF)
+
+            # Verify the track is still playable by trying to read audio frames
+            try:
+                with sf.SoundFile(str(test_file)) as f:
+                    # Just try reading a few frames
+                    frames = f.read(frames=1024)
+                    assert f.samplerate > 0
+                    assert f.channels > 0
+                    assert len(frames) > 0
+            except RuntimeError as e:
+                pytest.fail(f"Audio file {test_file} could not be opened or decoded: {e}")

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

@@ -0,0 +1,44 @@
+import pytest
+
+from audiometa import delete_all_metadata, update_metadata
+from audiometa.exceptions import FileTypeNotSupportedError, MetadataWritingConflictParametersError
+from audiometa.test.helpers.temp_file_with_metadata import temp_file_with_metadata
+from audiometa.utils.metadata_format import MetadataFormat
+from audiometa.utils.metadata_writing_strategy import MetadataWritingStrategy
+from audiometa.utils.unified_metadata_key import UnifiedMetadataKey
+
+
+@pytest.mark.integration
+class TestWritingErrorHandling:
+    def test_unsupported_file_type_raises_error(self):
+        # Create a file with unsupported extension using temp_file_with_metadata
+        with temp_file_with_metadata({}, "mp3") as temp_file_path:
+            temp_file_path.write_bytes(b"fake audio content")
+            temp_txt = temp_file_path.with_suffix(".txt")
+            temp_txt.write_bytes(b"fake audio content")
+
+            with pytest.raises(FileTypeNotSupportedError):
+                update_metadata(str(temp_txt), {UnifiedMetadataKey.TITLE: "Test"})
+
+            with pytest.raises(FileTypeNotSupportedError):
+                delete_all_metadata(str(temp_txt))
+
+    def test_nonexistent_file_raises_error(self):
+        nonexistent_file = "nonexistent_file.mp3"
+
+        with pytest.raises(FileNotFoundError):
+            update_metadata(nonexistent_file, {UnifiedMetadataKey.TITLE: "Test"})
+
+        # Note: delete_all_metadata error handling tests have been moved to test_delete_all_metadata.py
+
+    def test_metadata_writing_conflict_parameters_error_both_strategy_and_format(self):
+        with temp_file_with_metadata({}, "mp3") as test_file:
+            with pytest.raises(MetadataWritingConflictParametersError) as exc_info:
+                update_metadata(
+                    test_file,
+                    {UnifiedMetadataKey.TITLE: "Test"},
+                    metadata_strategy=MetadataWritingStrategy.SYNC,
+                    metadata_format=MetadataFormat.ID3V2,
+                )
+            assert "metadata_strategy" in str(exc_info.value).lower()
+            assert "metadata_format" in str(exc_info.value).lower()