audiometa-python 0.2.2__py3-none-any.whl

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

@@ -0,0 +1,26 @@
+from pathlib import Path
+
+import pytest
+
+from audiometa._audio_file import _AudioFile
+
+
+@pytest.mark.unit
+class TestAudioFileBitrate:
+    def test_get_bitrate_mp3(self, sample_mp3_file: Path):
+        audio_file = _AudioFile(sample_mp3_file)
+        bitrate = audio_file.get_bitrate()
+        assert isinstance(bitrate, int)
+        assert bitrate > 0
+
+    def test_get_bitrate_flac(self, sample_flac_file: Path):
+        audio_file = _AudioFile(sample_flac_file)
+        bitrate = audio_file.get_bitrate()
+        assert isinstance(bitrate, int)
+        assert bitrate > 0
+
+    def test_get_bitrate_wav(self, sample_wav_file: Path):
+        audio_file = _AudioFile(sample_wav_file)
+        bitrate = audio_file.get_bitrate()
+        assert isinstance(bitrate, int)
+        assert bitrate > 0

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

@@ -0,0 +1,31 @@
+from pathlib import Path
+
+import pytest
+
+from audiometa._audio_file import _AudioFile
+
+
+@pytest.mark.unit
+class TestAudioFileChannels:
+    def test_get_channels_mp3(self, sample_mp3_file: Path):
+        audio_file = _AudioFile(sample_mp3_file)
+        channels = audio_file.get_channels()
+        assert isinstance(channels, int)
+        assert channels > 0
+
+    def test_get_channels_flac(self, sample_flac_file: Path):
+        audio_file = _AudioFile(sample_flac_file)
+        channels = audio_file.get_channels()
+        assert isinstance(channels, int)
+        assert channels > 0
+
+    def test_get_channels_wav(self, sample_wav_file: Path):
+        audio_file = _AudioFile(sample_wav_file)
+        channels = audio_file.get_channels()
+        assert isinstance(channels, int)
+        assert channels > 0
+
+    def test_get_channels_returns_int(self, sample_mp3_file: Path):
+        audio_file = _AudioFile(sample_mp3_file)
+        channels = audio_file.get_channels()
+        assert isinstance(channels, int)

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

@@ -0,0 +1,38 @@
+from pathlib import Path
+
+import pytest
+
+from audiometa._audio_file import _AudioFile
+
+
+@pytest.mark.unit
+class TestAudioFileDurationInSec:
+    def test_get_duration_in_sec_mp3(self, sample_mp3_file: Path):
+        audio_file = _AudioFile(sample_mp3_file)
+        duration = audio_file.get_duration_in_sec()
+        assert isinstance(duration, float)
+        assert duration > 0
+        assert duration < 1000  # Reasonable bounds check
+
+    def test_get_duration_in_sec_flac(self, sample_flac_file: Path):
+        audio_file = _AudioFile(sample_flac_file)
+        duration = audio_file.get_duration_in_sec()
+        assert isinstance(duration, float)
+        assert duration > 0
+
+    def test_get_duration_in_sec_wav(self, sample_wav_file: Path):
+        audio_file = _AudioFile(sample_wav_file)
+        duration = audio_file.get_duration_in_sec()
+        assert isinstance(duration, float)
+        assert duration > 0
+
+    def test_get_duration_in_sec_long_file(self, duration_182s_mp3: Path):
+        audio_file = _AudioFile(duration_182s_mp3)
+        duration = audio_file.get_duration_in_sec()
+        assert isinstance(duration, float)
+        assert duration > 100
+
+    def test_get_duration_in_sec_returns_float(self, sample_mp3_file: Path):
+        audio_file = _AudioFile(sample_mp3_file)
+        duration = audio_file.get_duration_in_sec()
+        assert isinstance(duration, float)

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

@@ -0,0 +1,130 @@
+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

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_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")