audiometa-python 0.6.0__py3-none-any.whl

audiometa/test/helpers/vorbis/vorbis_metadata_getter.py

@@ -0,0 +1,67 @@
+"""Vorbis metadata inspection utilities for testing audio file metadata."""
+
+import subprocess
+from pathlib import Path
+
+from mutagen.flac import FLAC
+
+from audiometa.utils.tool_path_resolver import get_tool_path
+
+
+class VorbisMetadataGetter:
+    @staticmethod
+    def get_raw_metadata(file_path: Path) -> str:
+        result = subprocess.run(
+            [get_tool_path("metaflac"), "--list", str(file_path)], capture_output=True, text=True, check=True
+        )
+        return result.stdout
+
+    @staticmethod
+    def get_raw_metadata_without_truncating_null_bytes_but_lower_case_keys(file_path: Path) -> str:
+        audio = FLAC(str(file_path))
+        lines = []
+        lines.append("METADATA block #0")
+        lines.append("  type: 0 (STREAMINFO)")
+        lines.append("  is last: false")
+        lines.append("  length: 34")
+        lines.append("  minimum blocksize: 4096 samples")
+        lines.append("  maximum blocksize: 4096 samples")
+        lines.append("  minimum framesize: 0 bytes")
+        lines.append("  maximum framesize: 0 bytes")
+        lines.append("  sample_rate: 48000 Hz")
+        lines.append("  channels: 1")
+        lines.append("  bits-per-sample: 24")
+        lines.append("  total samples: 26177")
+        lines.append("  MD5 signature: 07598496b7623dfea10aafb241fae1a8")
+        lines.append("METADATA block #1")
+        lines.append("  type: 4 (VORBIS_COMMENT)")
+        lines.append("  is last: false")
+        lines.append("  length: 72")
+        lines.append("  vendor string: ")
+        comments = []
+        if audio.tags is not None and hasattr(audio.tags, "keys"):
+            for key in sorted(audio.tags.keys()):  # type: ignore[union-attr]
+                values = audio.tags[key]  # type: ignore[union-attr]
+                if isinstance(values, list):
+                    for value in values:
+                        comments.append(f"    comment[{len(comments)}]: {key}={value}")
+                else:
+                    comments.append(f"    comment[{len(comments)}]: {key}={values}")
+        lines.append(f"  comments: {len(comments)}")
+        lines.extend(comments)
+        lines.append("METADATA block #2")
+        lines.append("  type: 1 (PADDING)")
+        lines.append("  is last: true")
+        lines.append("  length: 1076")
+        return "\n".join(lines)
+
+    @staticmethod
+    def get_title(file_path: Path) -> str:
+        result = subprocess.run(
+            [get_tool_path("metaflac"), "--show-tag=TITLE", str(file_path)], capture_output=True, text=True, check=True
+        )
+        # Output is like "TITLE=Song Title\n"
+        lines = result.stdout.strip().split("\n")
+        if lines and "=" in lines[0]:
+            return lines[0].split("=", 1)[1]
+        return ""

audiometa/test/helpers/vorbis/vorbis_metadata_setter.py

@@ -0,0 +1,221 @@
+"""Vorbis metadata setting operations."""
+
+from pathlib import Path
+from typing import Any
+
+from mutagen.flac import FLAC
+
+from ..common.external_tool_runner import run_external_tool
+
+
+class VorbisMetadataSetter:
+    """Static utility class for Vorbis metadata setting using external tools."""
+
+    @staticmethod
+    def set_multiple_tags(
+        file_path: Path, tag_name: str, values: list[str], removing_existing=True, key_lower_case=False
+    ) -> None:
+        """Set multiple Vorbis comment tags with the same name."""
+
+        if key_lower_case:
+            tag_name = tag_name.lower()
+
+        if removing_existing:
+            try:
+                command = ["metaflac", "--remove-tag", tag_name, str(file_path)]
+                run_external_tool(command, "metaflac")
+            except Exception:
+                # Ignore if tags don't exist
+                pass
+
+        # Add each value as a separate tag
+        for value in values:
+            command = ["metaflac", "--set-tag", f"{tag_name}={value}", str(file_path)]
+            run_external_tool(command, "metaflac")
+
+    @staticmethod
+    def set_metadata(file_path: Path, metadata: dict[str, Any]) -> None:
+        """Set FLAC metadata using metaflac tool."""
+        cmd = ["metaflac"]
+
+        # Map common metadata keys to metaflac arguments
+        key_mapping = {
+            "title": "TITLE",
+            "artist": "ARTIST",
+            "album": "ALBUM",
+            "date": "DATE",
+            "genre": "GENRE",
+            "comment": "COMMENT",
+            "track_number": "TRACKNUMBER",
+            "bpm": "BPM",
+            "composer": "COMPOSER",
+            "copyright": "COPYRIGHT",
+            "lyrics": "LYRICS",
+            "language": "LANGUAGE",
+            "rating": "RATING",
+            "album_artist": "ALBUMARTIST",
+            "mood": "MOOD",
+            "key": "KEY",
+            "encoder": "ENCODER",
+            "url": "URL",
+            "isrc": "ISRC",
+            "publisher": "PUBLISHER",
+            "disc_number": "DISCNUMBER",
+            "disc_total": "DISCTOTAL",
+            "replaygain": "REPLAYGAIN",
+            "archival_location": "ARCHIVAL_LOCATION",
+        }
+
+        # Handle list values first (they need special handling)
+        for key, value in metadata.items():
+            if isinstance(value, list) and value:
+                if key.lower() == "artist":
+                    VorbisMetadataSetter.set_artists(file_path, value)
+                elif key.lower() == "genre":
+                    VorbisMetadataSetter.set_genres(file_path, value)
+                elif key.lower() == "composer":
+                    VorbisMetadataSetter.set_composers(file_path, value)
+                elif key.lower() == "album_artist":
+                    VorbisMetadataSetter.set_album_artists(file_path, value)
+
+        # Handle non-list values
+        metadata_added = False
+        for key, value in metadata.items():
+            if key.lower() in key_mapping and not isinstance(value, list):
+                cmd.extend([f"--set-tag={key_mapping[key.lower()]}={value}"])
+                metadata_added = True
+
+        # Only run metaflac if metadata was actually added
+        if metadata_added:
+            cmd.append(str(file_path))
+            run_external_tool(cmd, "metaflac")
+
+    @staticmethod
+    def set_genre(file_path: Path, genre_text: str) -> None:
+        command = ["metaflac", "--set-tag", f"GENRE={genre_text}", str(file_path)]
+        run_external_tool(command, "metaflac")
+
+    @staticmethod
+    def set_comment(file_path: Path, comment: str) -> None:
+        command = ["metaflac", "--set-tag", f"COMMENT={comment}", str(file_path)]
+        run_external_tool(command, "metaflac")
+
+    @staticmethod
+    def add_title(file_path: Path, title: str, key_lower_case=False) -> None:
+        if key_lower_case:
+            command = ["metaflac", "--set-tag", f"title={title}", str(file_path)]
+        else:
+            command = ["metaflac", "--set-tag", f"TITLE={title}", str(file_path)]
+        run_external_tool(command, "metaflac")
+
+    @staticmethod
+    def set_artist(file_path: Path, artist: str) -> None:
+        command = ["metaflac", "--set-tag", f"ARTIST={artist}", str(file_path)]
+        run_external_tool(command, "metaflac")
+
+    @staticmethod
+    def set_album(file_path: Path, album: str) -> None:
+        command = ["metaflac", "--set-tag", f"ALBUM={album}", str(file_path)]
+        run_external_tool(command, "metaflac")
+
+    @staticmethod
+    def set_lyrics(file_path: Path, lyrics: str) -> None:
+        command = ["metaflac", "--set-tag", f"LYRICS={lyrics}", str(file_path)]
+        run_external_tool(command, "metaflac")
+
+    @staticmethod
+    def set_language(file_path: Path, language: str) -> None:
+        command = ["metaflac", "--set-tag", f"LANGUAGE={language}", str(file_path)]
+        run_external_tool(command, "metaflac")
+
+    @staticmethod
+    def set_bpm(file_path: Path, bpm: int) -> None:
+        command = ["metaflac", "--set-tag", f"BPM={bpm}", str(file_path)]
+        run_external_tool(command, "metaflac")
+
+    @staticmethod
+    def set_release_date(file_path: Path, date_str: str) -> None:
+        """Set Vorbis release date using DATE tag."""
+        command = ["metaflac", "--set-tag", f"DATE={date_str}", str(file_path)]
+        run_external_tool(command, "metaflac")
+
+    @staticmethod
+    def set_max_metadata(file_path: Path) -> None:
+        from pathlib import Path
+
+        from ..common.external_tool_runner import run_script
+
+        scripts_dir = Path(__file__).parent.parent.parent.parent / "test" / "helpers" / "scripts"
+        run_script("set-vorbis-max-metadata.sh", file_path, scripts_dir)
+
+    @staticmethod
+    def set_artists(
+        file_path: Path, artists: list[str], removing_existing=True, key_lower_case=False, in_single_entry=False
+    ) -> None:
+        """Set multiple Vorbis artists using mutagen."""
+        audio = FLAC(str(file_path))
+        key = "artist" if key_lower_case else "ARTIST"
+        if removing_existing:
+            existing: list[str] = []
+        else:
+            existing_raw = audio.get(key, [])
+            if existing_raw is None:
+                existing = []
+            elif isinstance(existing_raw, str):
+                existing = [existing_raw]
+            else:
+                existing = list(existing_raw)
+        if in_single_entry:
+            value = "\x00".join(artists)
+            existing.append(value)
+        else:
+            existing.extend(artists)
+        audio[key] = existing
+        audio.save()
+
+    @staticmethod
+    def set_album_artists(file_path: Path, album_artists: list[str]):
+        """Set multiple Vorbis album artists using external metaflac tool."""
+        VorbisMetadataSetter.set_multiple_tags(file_path, "ALBUMARTIST", album_artists)
+
+    @staticmethod
+    def set_composers(file_path: Path, composers: list[str]):
+        """Set multiple Vorbis composers using external metaflac tool."""
+        VorbisMetadataSetter.set_multiple_tags(file_path, "COMPOSER", composers)
+
+    @staticmethod
+    def set_genres(file_path: Path, genres: list[str]):
+        """Set multiple Vorbis genres using external metaflac tool."""
+        VorbisMetadataSetter.set_multiple_tags(file_path, "GENRE", genres)
+
+    @staticmethod
+    def set_performers(file_path: Path, performers: list[str]):
+        """Set multiple Vorbis performers using external metaflac tool."""
+        VorbisMetadataSetter.set_multiple_tags(file_path, "PERFORMER", performers)
+
+    @staticmethod
+    def set_multiple_comments(file_path: Path, comments: list[str]):
+        """Set multiple Vorbis comments using external metaflac tool."""
+        VorbisMetadataSetter.set_multiple_tags(file_path, "COMMENT", comments)
+
+    @staticmethod
+    def set_null_bytes_test_metadata(file_path: Path) -> None:
+        """Set test metadata including null bytes for testing null byte handling."""
+        # First remove existing ARTIST tags
+        try:
+            command = ["metaflac", "--remove-tag=ARTIST", str(file_path)]
+            run_external_tool(command, "metaflac")
+        except Exception:
+            # Ignore if tags don't exist
+            pass
+
+        # Set ARTIST tags, one with null bytes
+        command = ["metaflac", "--set-tag=ARTIST=Artist\x00with\x00nulls", str(file_path)]
+        run_external_tool(command, "metaflac")
+
+        command = ["metaflac", "--set-tag=ARTIST=Normal Artist", str(file_path)]
+        run_external_tool(command, "metaflac")
+
+        # Set TITLE
+        command = ["metaflac", "--set-tag=TITLE=Normal Title", str(file_path)]
+        run_external_tool(command, "metaflac")

audiometa/test/tests/conftest.py

@@ -0,0 +1,276 @@
+"""Test configuration for audiometa-python tests."""
+
+import importlib.util
+import sys
+from pathlib import Path
+
+import pytest
+
+# Import the shared verification script
+project_root = Path(__file__).parent.parent.parent.parent
+verify_script_path = project_root / "scripts" / "verify-system-dependency-versions.py"
+
+# Load the module dynamically
+spec = importlib.util.spec_from_file_location("verify_system_dependency_versions", verify_script_path)
+verify_module = importlib.util.module_from_spec(spec)
+sys.modules["verify_system_dependency_versions"] = verify_module
+spec.loader.exec_module(verify_module)  # type: ignore[union-attr]
+
+verify_dependency_versions = verify_module.verify_dependency_versions
+
+
+def pytest_configure(config: pytest.Config) -> None:  # noqa: ARG001
+    """Verify system dependency versions match pinned versions before running tests."""
+    exit_code = verify_dependency_versions()
+    if exit_code != 0:
+        pytest.exit("Dependency version verification failed. See errors above.", returncode=exit_code)
+
+
+def pytest_collection_modifyitems(items):
+    """Reorder test items to ensure proper execution order: unit → integration → e2e."""
+    # Define the desired test execution order based on directory structure
+    test_order = {"unit": 1, "integration": 2, "e2e": 3}
+
+    def get_test_priority(item):
+        """Get the priority order for a test item based on its path."""
+        test_path = str(item.fspath)
+
+        # Check for unit tests
+        if "/unit/" in test_path:
+            return test_order["unit"]
+        # Check for integration tests
+        if "/integration/" in test_path:
+            return test_order["integration"]
+        # Check for e2e tests
+        if "/e2e/" in test_path:
+            return test_order["e2e"]
+        # Default priority for other tests (comprehensive, etc.)
+        return 0  # Run first (before unit tests)
+
+    # Sort items by priority
+    items.sort(key=get_test_priority)
+
+
+@pytest.fixture
+def assets_dir() -> Path:
+    return Path(__file__).parent.parent.parent / "test" / "assets"
+
+
+@pytest.fixture
+def sample_mp3_file(assets_dir: Path) -> Path:
+    return assets_dir / "sample.mp3"
+
+
+@pytest.fixture
+def sample_flac_file(assets_dir: Path) -> Path:
+    return assets_dir / "sample.flac"
+
+
+@pytest.fixture
+def sample_wav_file(assets_dir: Path) -> Path:
+    return assets_dir / "sample.wav"
+
+
+@pytest.fixture
+def sample_m4a_file(assets_dir: Path) -> Path:
+    return assets_dir / "sample.m4a"
+
+
+@pytest.fixture
+def metadata_id3v1_big_mp3(assets_dir: Path) -> Path:
+    return assets_dir / "metadata=long a_id3v1_big.mp3"
+
+
+@pytest.fixture
+def metadata_id3v1_small_flac(assets_dir: Path) -> Path:
+    return assets_dir / "metadata=long a_id3v1_small.flac"
+
+
+@pytest.fixture
+def metadata_id3v1_big_flac(assets_dir: Path) -> Path:
+    return assets_dir / "metadata=long a_id3v1_big.flac"
+
+
+@pytest.fixture
+def metadata_id3v1_small_wav(assets_dir: Path) -> Path:
+    return assets_dir / "metadata=long a_id3v1_small.wav"
+
+
+@pytest.fixture
+def metadata_id3v1_big_wav(assets_dir: Path) -> Path:
+    return assets_dir / "metadata=long a_id3v1_big.wav"
+
+
+@pytest.fixture
+def metadata_id3v2_small_mp3(assets_dir: Path) -> Path:
+    return assets_dir / "metadata=long a_id3v2_small.mp3"
+
+
+@pytest.fixture
+def metadata_id3v2_big_mp3(assets_dir: Path) -> Path:
+    return assets_dir / "metadata=long a_id3v2_big.mp3"
+
+
+@pytest.fixture
+def metadata_id3v2_small_flac(assets_dir: Path) -> Path:
+    return assets_dir / "metadata=long a_id3v2_small.flac"
+
+
+@pytest.fixture
+def metadata_id3v2_big_flac(assets_dir: Path) -> Path:
+    return assets_dir / "metadata=long a_id3v2_big.flac"
+
+
+@pytest.fixture
+def metadata_id3v2_small_wav(assets_dir: Path) -> Path:
+    return assets_dir / "metadata=long a_id3v2_small.wav"
+
+
+@pytest.fixture
+def metadata_id3v2_big_wav(assets_dir: Path) -> Path:
+    return assets_dir / "metadata=long a_id3v2_big.wav"
+
+
+@pytest.fixture
+def metadata_id3v2_and_riff_small_wav(assets_dir: Path) -> Path:
+    return assets_dir / "metadata=long a_id3v2_and_riff_small.wav"
+
+
+@pytest.fixture
+def metadata_riff_small_wav(assets_dir: Path) -> Path:
+    return assets_dir / "metadata=long a_riff_small.wav"
+
+
+@pytest.fixture
+def metadata_riff_big_wav(assets_dir: Path) -> Path:
+    return assets_dir / "metadata=long a_riff_big.wav"
+
+
+@pytest.fixture
+def metadata_vorbis_small_flac(assets_dir: Path) -> Path:
+    return assets_dir / "metadata=long a_vorbis_small.flac"
+
+
+@pytest.fixture
+def metadata_vorbis_big_flac(assets_dir: Path) -> Path:
+    return assets_dir / "metadata=long a_vorbis_big.flac"
+
+
+@pytest.fixture
+def artists_one_two_three_comma_id3v2(assets_dir: Path) -> Path:
+    return assets_dir / "artists=One Two Three_comma_id3v2.mp3"
+
+
+@pytest.fixture
+def artists_one_two_three_semicolon_id3v2(assets_dir: Path) -> Path:
+    return assets_dir / "artists=One Two Three_semicolon_id3v2.mp3"
+
+
+@pytest.fixture
+def artists_one_two_three_multi_tags_vorbis(assets_dir: Path) -> Path:
+    return assets_dir / "artists=One Two Three_muti tags_vorbis.flac"
+
+
+@pytest.fixture
+def album_koko_id3v2_mp3(assets_dir: Path) -> Path:
+    return assets_dir / "album=koko_id3v2.mp3"
+
+
+@pytest.fixture
+def album_koko_id3v2_wav(assets_dir: Path) -> Path:
+    return assets_dir / "album=koko_id3v2.wav"
+
+
+@pytest.fixture
+def album_koko_vorbis_flac(assets_dir: Path) -> Path:
+    return assets_dir / "album=koko_vorbis.flac"
+
+
+@pytest.fixture
+def genre_code_id3v1_abstract_mp3(assets_dir: Path) -> Path:
+    return assets_dir / "genre_code_id3v1=Abstract.mp3"
+
+
+@pytest.fixture
+def genre_code_id3v1_unknown_mp3(assets_dir: Path) -> Path:
+    return assets_dir / "genre_code_id3v1=Unknown.mp3"
+
+
+@pytest.fixture
+def duration_1s_mp3(assets_dir: Path) -> Path:
+    return assets_dir / "duration=1s.wav"
+
+
+@pytest.fixture
+def duration_182s_mp3(assets_dir: Path) -> Path:
+    return assets_dir / "duration=182.mp3"
+
+
+@pytest.fixture
+def duration_335s_flac(assets_dir: Path) -> Path:
+    return assets_dir / "duration=335s.flac"
+
+
+@pytest.fixture
+def duration_472s_wav(assets_dir: Path) -> Path:
+    return assets_dir / "duration=472s.wav"
+
+
+@pytest.fixture
+def bitrate_320_mp3(assets_dir: Path) -> Path:
+    return assets_dir / "bitrate in kbps_big=320.mp3"
+
+
+@pytest.fixture
+def bitrate_946_flac(assets_dir: Path) -> Path:
+    return assets_dir / "bitrate in kbps_big=946.flac"
+
+
+@pytest.fixture
+def bitrate_1411_wav(assets_dir: Path) -> Path:
+    return assets_dir / "bitrate in kbps_big=1411.wav"
+
+
+@pytest.fixture
+def bitrate_192_mp3(assets_dir: Path) -> Path:
+    return assets_dir / "bitrate in kbps_small=192.mp3"
+
+
+@pytest.fixture
+def bitrate_723_flac(assets_dir: Path) -> Path:
+    return assets_dir / "bitrate in kbps_small=723.flac"
+
+
+@pytest.fixture
+def bitrate_1152_wav(assets_dir: Path) -> Path:
+    return assets_dir / "bitrate in kbps_small=1152.wav"
+
+
+@pytest.fixture
+def size_small_mp3(assets_dir: Path) -> Path:
+    return assets_dir / "size_small=0.01mo.mp3"
+
+
+@pytest.fixture
+def size_big_mp3(assets_dir: Path) -> Path:
+    return assets_dir / "size_big=9.98mo.mp3"
+
+
+@pytest.fixture
+def size_small_flac(assets_dir: Path) -> Path:
+    return assets_dir / "size_small=0.05mo.flac"
+
+
+@pytest.fixture
+def size_big_flac(assets_dir: Path) -> Path:
+    return assets_dir / "size_big=26.6mo.flac"
+
+
+@pytest.fixture
+def size_small_wav(assets_dir: Path) -> Path:
+    return assets_dir / "size_small=0.08mo.wav"
+
+
+@pytest.fixture
+def size_big_wav(assets_dir: Path) -> Path:
+    return assets_dir / "size_big=79.55mo.wav"

audiometa/test/tests/e2e/cli/error_handling/__init__.py

@@ -0,0 +1 @@
+# Error handling tests for CLI

audiometa/test/tests/e2e/cli/error_handling/test_command_structure_errors.py

@@ -0,0 +1,77 @@
+import subprocess
+import sys
+
+import pytest
+
+from audiometa.test.helpers.temp_file_with_metadata import temp_file_with_metadata
+
+
+@pytest.mark.e2e
+class TestCLICommandStructureErrors:
+    def test_cli_unified_with_no_headers_technical_flags(self):
+        with temp_file_with_metadata({}, "mp3") as temp_file_path:
+            result = subprocess.run(
+                [sys.executable, "-m", "audiometa", "unified", str(temp_file_path), "--no-headers", "--no-technical"],
+                capture_output=True,
+                text=True,
+                check=False,
+            )
+
+            # Should fail - unified command doesn't accept these flags
+            assert result.returncode != 0
+            stderr_output = result.stderr.lower()
+            assert "unrecognized arguments" in stderr_output
+
+    def test_cli_read_help_flag(self):
+        result = subprocess.run(
+            [sys.executable, "-m", "audiometa", "read", "--help"], capture_output=True, text=True, check=False
+        )
+
+        # Should show read command help
+        assert result.returncode == 0
+        stdout_output = result.stdout.lower()
+        assert "read" in stdout_output
+        assert "files" in stdout_output
+
+    def test_cli_recursive_with_single_file(self):
+        """Test CLI recursive flag with single file (should work but be redundant)."""
+        with temp_file_with_metadata({}, "mp3") as temp_file_path:
+            result = subprocess.run(
+                [sys.executable, "-m", "audiometa", "read", str(temp_file_path), "--recursive"],
+                capture_output=True,
+                text=True,
+                check=False,
+            )
+
+            # Should succeed - recursive with single file is valid
+            assert result.returncode == 0
+            assert len(result.stdout.strip()) > 0
+
+    def test_cli_invalid_command(self):
+        result = subprocess.run(
+            [sys.executable, "-m", "audiometa", "invalidcommand"], capture_output=True, text=True, check=False
+        )
+
+        # Should fail due to invalid command
+        assert result.returncode != 0
+        stderr_output = result.stderr.lower()
+        assert "invalid choice" in stderr_output or "error" in stderr_output
+
+    def test_cli_no_command(self):
+        result = subprocess.run([sys.executable, "-m", "audiometa"], capture_output=True, text=True, check=False)
+
+        # Should show help and exit with code 1
+        assert result.returncode == 1
+        stdout_output = result.stdout.lower()
+        assert "usage" in stdout_output or "help" in stdout_output
+
+    def test_cli_help_flag(self):
+        result = subprocess.run(
+            [sys.executable, "-m", "audiometa", "--help"], capture_output=True, text=True, check=False
+        )
+
+        # Should show help and exit successfully
+        assert result.returncode == 0
+        stdout_output = result.stdout.lower()
+        assert "usage" in stdout_output
+        assert "help" in stdout_output