audiometa-python 0.6.0__py3-none-any.whl

audiometa/test/tests/unit/audio_file/technical_info/test_error_handling.py

@@ -0,0 +1,190 @@
+from pathlib import Path
+
+import pytest
+
+from audiometa._audio_file import _AudioFile
+from audiometa.exceptions import (
+    AudioFileMetadataParseError,
+    DurationNotFoundError,
+    FileByteMismatchError,
+    FileCorruptedError,
+    FlacMd5CheckFailedError,
+    InvalidChunkDecodeError,
+)
+
+
+@pytest.mark.unit
+class TestAudioFileTechnicalInfoErrorHandling:
+    def test_file_byte_mismatch_error_corrupted_flac(self, tmp_path):
+        corrupted_flac = tmp_path / "corrupted.flac"
+        corrupted_flac.write_bytes(b"fake file")
+
+        try:
+            audio_file = _AudioFile(corrupted_flac)
+            audio_file.get_duration_in_sec()
+            pytest.fail("Should have raised FileByteMismatchError or FileCorruptedError")
+        except (FileByteMismatchError, FileCorruptedError):
+            pass
+
+    def test_flac_md5_check_failed_error_corrupted_flac(self, monkeypatch, sample_flac_file: Path):
+        def mock_subprocess_run(args, *_, **_kwargs):
+            class MockResult:
+                pass
+
+            result = MockResult()
+
+            # Handle brew --prefix call from get_tool_path
+            if isinstance(args, list) and len(args) > 0 and args[0] == "brew":
+                result.stdout = ""
+                result.stderr = ""
+                result.returncode = 0
+                return result
+
+            # Handle flac -t call - return code 0 but no "ok" message to trigger FlacMd5CheckFailedError
+            result.stdout = b""
+            result.stderr = b"Some unexpected FLAC output"
+            result.returncode = 0
+            return result
+
+        monkeypatch.setattr("subprocess.run", mock_subprocess_run)
+
+        audio_file = _AudioFile(sample_flac_file)
+        try:
+            audio_file.is_flac_file_md5_valid()
+            pytest.fail("Should have raised FlacMd5CheckFailedError")
+        except FlacMd5CheckFailedError:
+            pass
+
+    def test_invalid_chunk_decode_error_corrupted_flac_chunks(self, monkeypatch):
+        def mock_get_duration_in_sec(_self):
+            try:
+                msg = "FLAC chunk decoding failed"
+                raise RuntimeError(msg)
+            except Exception as exc:
+                error_str = str(exc)
+                if "file said" in error_str and "bytes, read" in error_str:
+                    raise FileByteMismatchError(error_str.capitalize()) from exc
+                if "FLAC" in error_str or "chunk" in error_str.lower():
+                    msg = f"Failed to decode FLAC chunks: {error_str}"
+                    raise InvalidChunkDecodeError(msg) from exc
+                raise
+
+        monkeypatch.setattr("audiometa._audio_file._AudioFile.get_duration_in_sec", mock_get_duration_in_sec)
+
+        flac_file = "audiometa/test/assets/sample.flac"
+
+        try:
+            audio_file = _AudioFile(flac_file)
+            audio_file.get_duration_in_sec()
+            pytest.fail("Should have raised InvalidChunkDecodeError")
+        except InvalidChunkDecodeError:
+            pass
+
+    def test_duration_not_found_error_invalid_wav_duration(self, monkeypatch):
+        def mock_subprocess_run(*_args, **_kwargs):
+            class MockResult:
+                returncode = 0
+                stdout = '{"format": {"duration": "0.0"}, "streams": [{"duration": "0"}]}'
+
+            return MockResult()
+
+        monkeypatch.setattr("subprocess.run", mock_subprocess_run)
+
+        wav_file = "audiometa/test/assets/sample.wav"
+
+        try:
+            audio_file = _AudioFile(wav_file)
+            audio_file.get_duration_in_sec()
+            pytest.fail("Should have raised DurationNotFoundError")
+        except DurationNotFoundError:
+            pass
+
+    def test_audio_file_metadata_parse_error_invalid_json(self, monkeypatch):
+        def mock_subprocess_run(*_args, **_kwargs):
+            class MockResult:
+                returncode = 0
+                stdout = "invalid json response"
+
+            return MockResult()
+
+        monkeypatch.setattr("subprocess.run", mock_subprocess_run)
+
+        wav_file = "audiometa/test/assets/sample.wav"
+
+        try:
+            audio_file = _AudioFile(wav_file)
+            audio_file.get_duration_in_sec()
+            pytest.fail("Should have raised AudioFileMetadataParseError")
+        except AudioFileMetadataParseError:
+            pass
+
+    def test_file_corrupted_error_invalid_wav(self, tmp_path):
+        invalid_wav = tmp_path / "invalid.wav"
+        invalid_wav.write_bytes(b"not a valid wav file")
+
+        try:
+            audio_file = _AudioFile(invalid_wav)
+            audio_file.get_duration_in_sec()
+            pytest.fail("Should have raised FileCorruptedError")
+        except (FileCorruptedError, RuntimeError):
+            pass
+
+    def test_flac_duration_handles_generic_mutagen_exception(self, monkeypatch):
+        error_msg = "Some unexpected mutagen error"
+
+        class MockInfo:
+            @property
+            def length(self):
+                raise ValueError(error_msg)
+
+        class MockFLAC:
+            def __init__(self, *_args, **_kwargs):
+                self._info = MockInfo()
+
+            @property
+            def info(self):
+                return self._info
+
+        # Mock FLAC in get_duration_in_sec, not in __init__
+        original_get_duration = _AudioFile.get_duration_in_sec
+
+        def mock_get_duration(self):
+            if self.file_extension == ".flac":
+                try:
+                    return float(MockFLAC(self.file_path).info.length)
+                except Exception as exc:
+                    error_str = str(exc)
+                    if "file said" in error_str and "bytes, read" in error_str:
+                        raise FileByteMismatchError(error_str.capitalize()) from exc
+                    if "FLAC" in error_str or "chunk" in error_str.lower():
+                        msg = f"Failed to decode FLAC chunks: {error_str}"
+                        raise InvalidChunkDecodeError(msg) from exc
+                    from audiometa.utils.mutagen_exception_handler import handle_mutagen_exception
+
+                    handle_mutagen_exception("read duration from FLAC file", self.file_path, exc)
+            return original_get_duration(self)
+
+        monkeypatch.setattr(_AudioFile, "get_duration_in_sec", mock_get_duration)
+
+        flac_file = "audiometa/test/assets/sample.flac"
+        audio_file = _AudioFile(flac_file)
+
+        with pytest.raises(FileCorruptedError) as exc_info:
+            audio_file.get_duration_in_sec()
+        assert "Failed to read duration from FLAC file" in str(exc_info.value)
+        assert error_msg in str(exc_info.value)
+
+    def test_flac_md5_fixing_handles_generic_exception(self, monkeypatch, sample_flac_file: Path):
+        error_msg = "Some unexpected error during MD5 fixing"
+
+        def mock_subprocess_run(*_args, **_kwargs):
+            raise ValueError(error_msg)
+
+        monkeypatch.setattr("subprocess.run", mock_subprocess_run)
+
+        audio_file = _AudioFile(sample_flac_file)
+
+        with pytest.raises(FileCorruptedError) as exc_info:
+            audio_file.get_file_with_corrected_md5()
+        assert "Failed to fix FLAC MD5 checksum" in str(exc_info.value)
+        assert error_msg in str(exc_info.value)

audiometa/test/tests/unit/audio_file/technical_info/test_file_size.py

@@ -0,0 +1,51 @@
+from pathlib import Path
+
+import pytest
+
+from audiometa import get_file_size
+from audiometa.test.helpers.technical_info_inspector import TechnicalInfoInspector
+
+
+@pytest.mark.unit
+class TestFileSizeFunctions:
+    def test_file_size_mp3(self, sample_mp3_file: Path):
+        external_tool_size = TechnicalInfoInspector.get_file_size(sample_mp3_file)
+        assert external_tool_size == 17307
+
+        file_size = get_file_size(sample_mp3_file)
+        assert file_size == 17307
+
+    def test_file_size_mp3_big(self, size_big_mp3: Path):
+        external_tool_size = TechnicalInfoInspector.get_file_size(size_big_mp3)
+        assert external_tool_size == 10468959
+
+        file_size = get_file_size(size_big_mp3)
+        assert file_size == 10468959
+
+    def test_file_size_flac(self, sample_flac_file: Path):
+        external_tool_size = TechnicalInfoInspector.get_file_size(sample_flac_file)
+        assert external_tool_size == 18439
+
+        file_size = get_file_size(sample_flac_file)
+        assert file_size == 18439
+
+    def test_file_size_flac_big(self, size_big_flac: Path):
+        external_tool_size = TechnicalInfoInspector.get_file_size(size_big_flac)
+        assert external_tool_size == 27888561
+
+        file_size = get_file_size(size_big_flac)
+        assert file_size == 27888561
+
+    def test_file_size_wav(self, sample_wav_file: Path):
+        external_tool_size = TechnicalInfoInspector.get_file_size(sample_wav_file)
+        assert external_tool_size == 16822
+
+        file_size = get_file_size(sample_wav_file)
+        assert file_size == 16822
+
+    def test_file_size_wav_big(self, size_big_wav: Path):
+        external_tool_size = TechnicalInfoInspector.get_file_size(size_big_wav)
+        assert external_tool_size == 83414326
+
+        file_size = get_file_size(size_big_wav)
+        assert file_size == 83414326

audiometa/test/tests/unit/audio_file/technical_info/test_format_name.py

@@ -0,0 +1,28 @@
+"""Unit tests for _AudioFile get_audio_format_name method."""
+
+from pathlib import Path
+
+import pytest
+
+from audiometa._audio_file import _AudioFile
+
+
+@pytest.mark.unit
+class TestAudioFileFormatName:
+    def test_get_format_name_mp3(self, sample_mp3_file: Path):
+        audio_file = _AudioFile(sample_mp3_file)
+        audio_format_name = audio_file.get_audio_format_name()
+
+        assert audio_format_name == "MP3"
+
+    def test_get_format_name_wav(self, sample_wav_file: Path):
+        audio_file = _AudioFile(sample_wav_file)
+        audio_format_name = audio_file.get_audio_format_name()
+
+        assert audio_format_name == "WAV"
+
+    def test_get_format_name_flac(self, sample_flac_file: Path):
+        audio_file = _AudioFile(sample_flac_file)
+        audio_format_name = audio_file.get_audio_format_name()
+
+        assert audio_format_name == "FLAC"

audiometa/test/tests/unit/audio_file/technical_info/test_sample_rate.py

@@ -0,0 +1,31 @@
+from pathlib import Path
+
+import pytest
+
+from audiometa._audio_file import _AudioFile
+
+
+@pytest.mark.unit
+class TestAudioFileSampleRate:
+    def test_get_sample_rate_mp3(self, sample_mp3_file: Path):
+        audio_file = _AudioFile(sample_mp3_file)
+        sample_rate = audio_file.get_sample_rate()
+        assert isinstance(sample_rate, int)
+        assert sample_rate > 0
+
+    def test_get_sample_rate_wav(self, sample_wav_file: Path):
+        audio_file = _AudioFile(sample_wav_file)
+        sample_rate = audio_file.get_sample_rate()
+        assert isinstance(sample_rate, int)
+        assert sample_rate > 0
+
+    def test_get_sample_rate_flac(self, sample_flac_file: Path):
+        audio_file = _AudioFile(sample_flac_file)
+        sample_rate = audio_file.get_sample_rate()
+        assert isinstance(sample_rate, int)
+        assert sample_rate > 0
+
+    def test_get_sample_rate_returns_int(self, sample_mp3_file: Path):
+        audio_file = _AudioFile(sample_mp3_file)
+        sample_rate = audio_file.get_sample_rate()
+        assert isinstance(sample_rate, int)

audiometa/test/tests/unit/audio_file/test_context_manager.py

@@ -0,0 +1,30 @@
+from pathlib import Path
+
+import pytest
+
+from audiometa._audio_file import _AudioFile
+from audiometa.test.helpers.temp_file_with_metadata import temp_file_with_metadata
+
+
+@pytest.mark.unit
+class TestContextManager:
+    def test_context_manager(self, sample_mp3_file: Path):
+        with _AudioFile(sample_mp3_file) as audio_file:
+            assert isinstance(audio_file, _AudioFile)
+            assert audio_file.file_path == str(sample_mp3_file)
+
+            duration = audio_file.get_duration_in_sec()
+            assert duration > 0
+
+    def test_file_operations(self):
+        with temp_file_with_metadata({}, "mp3") as test_file:
+            audio_file = _AudioFile(test_file)
+
+            # Test write
+            test_data = b"test audio data"
+            bytes_written = audio_file.write(test_data)
+            assert bytes_written == len(test_data)
+
+            # Test read
+            read_data = audio_file.read()
+            assert read_data == test_data

audiometa/test/tests/unit/audio_file/test_file_validation.py

@@ -0,0 +1,40 @@
+from pathlib import Path
+
+import pytest
+
+from audiometa._audio_file import _AudioFile
+from audiometa.exceptions import FileCorruptedError, FileTypeNotSupportedError
+from audiometa.test.helpers.temp_file_with_metadata import temp_file_with_metadata
+
+
+@pytest.mark.unit
+class TestAudioFileFileTypeValidation:
+    def test_extension_mp3_then_ok(self, sample_mp3_file: Path):
+        audio_file = _AudioFile(sample_mp3_file)
+        assert audio_file.file_extension == ".mp3"
+
+    def test_extension_flac_then_ok(self, sample_flac_file: Path):
+        audio_file = _AudioFile(sample_flac_file)
+        assert audio_file.file_extension == ".flac"
+
+    def test_extension_wav_then_ok(self, sample_wav_file: Path):
+        audio_file = _AudioFile(sample_wav_file)
+        assert audio_file.file_extension == ".wav"
+
+    def test_extension_m4a_then_not_ok(self, sample_m4a_file: Path):
+        with pytest.raises(FileTypeNotSupportedError):
+            _AudioFile(sample_m4a_file)
+
+    def test_bad_content_then_not_ok(self):
+        # Create a file with valid extension but bad content
+        with temp_file_with_metadata({}, "mp3") as temp_audio_file_path:
+            temp_audio_file_path.write_bytes(b"not a real audio file")
+            mp3_file_path = temp_audio_file_path.with_suffix(".mp3")
+            mp3_file_path.write_bytes(b"not a real audio file")
+
+            with pytest.raises(FileCorruptedError):
+                _AudioFile(str(mp3_file_path))
+
+    def test_nonexistent_file_raises_error(self):
+        with pytest.raises(FileNotFoundError):
+            _AudioFile("nonexistent.mp3")

audiometa/test/tests/unit/audio_file/test_is_audio_file.py

@@ -0,0 +1,49 @@
+from pathlib import Path
+
+import pytest
+
+from audiometa import is_audio_file
+
+
+@pytest.mark.unit
+class TestIsAudioFile:
+    def test_valid_mp3_file_returns_true(self, sample_mp3_file: Path):
+        assert is_audio_file(sample_mp3_file) is True
+        assert is_audio_file(str(sample_mp3_file)) is True
+
+    def test_valid_flac_file_returns_true(self, sample_flac_file: Path):
+        assert is_audio_file(sample_flac_file) is True
+        assert is_audio_file(str(sample_flac_file)) is True
+
+    def test_valid_wav_file_returns_true(self, sample_wav_file: Path):
+        assert is_audio_file(sample_wav_file) is True
+        assert is_audio_file(str(sample_wav_file)) is True
+
+    def test_nonexistent_file_returns_false(self):
+        assert is_audio_file("nonexistent.mp3") is False
+        assert is_audio_file(Path("nonexistent.flac")) is False
+
+    def test_unsupported_extension_returns_false(self, sample_m4a_file: Path):
+        assert is_audio_file(sample_m4a_file) is False
+        assert is_audio_file(str(sample_m4a_file)) is False
+
+    def test_invalid_mp3_content_returns_false(self, tmp_path: Path):
+        invalid_mp3 = tmp_path / "invalid.mp3"
+        invalid_mp3.write_bytes(b"not a real audio file")
+
+        assert is_audio_file(invalid_mp3) is False
+        assert is_audio_file(str(invalid_mp3)) is False
+
+    def test_invalid_flac_content_returns_false(self, tmp_path: Path):
+        invalid_flac = tmp_path / "invalid.flac"
+        invalid_flac.write_bytes(b"not a real audio file")
+
+        assert is_audio_file(invalid_flac) is False
+        assert is_audio_file(str(invalid_flac)) is False
+
+    def test_invalid_wav_content_returns_false(self, tmp_path: Path):
+        invalid_wav = tmp_path / "invalid.wav"
+        invalid_wav.write_bytes(b"not a real audio file")
+
+        assert is_audio_file(invalid_wav) is False
+        assert is_audio_file(str(invalid_wav)) is False

audiometa/test/tests/unit/audio_file/test_operations.py

@@ -0,0 +1,20 @@
+import pytest
+
+from audiometa._audio_file import _AudioFile
+from audiometa.test.helpers.temp_file_with_metadata import temp_file_with_metadata
+
+
+@pytest.mark.unit
+class TestAudioFileOperations:
+    def test_file_operations(self):
+        with temp_file_with_metadata({}, "mp3") as test_file:
+            audio_file = _AudioFile(test_file)
+
+            # Test write
+            test_data = b"test audio data"
+            bytes_written = audio_file.write(test_data)
+            assert bytes_written == len(test_data)
+
+            # Test read
+            read_data = audio_file.read()
+            assert read_data == test_data

audiometa/test/tests/unit/audio_file/test_path_handling.py

@@ -0,0 +1,23 @@
+from pathlib import Path
+
+import pytest
+
+from audiometa._audio_file import _AudioFile
+
+
+@pytest.mark.unit
+class TestAudioFilePathHandling:
+    def test_audio_file_with_string_path(self, sample_mp3_file: Path):
+        sample_mp3_file_str = str(sample_mp3_file)
+        audio_file = _AudioFile(sample_mp3_file_str)
+        assert audio_file.file_path == sample_mp3_file_str
+        assert audio_file.file_extension == ".mp3"
+
+    def test_audio_file_with_path_object(self, sample_mp3_file: Path):
+        audio_file = _AudioFile(sample_mp3_file)
+        assert audio_file.file_path == str(sample_mp3_file)
+        assert audio_file.file_extension == ".mp3"
+
+    def test_audio_file_nonexistent_file(self):
+        with pytest.raises(FileNotFoundError):
+            _AudioFile("nonexistent_file.mp3")