audiometa-python 0.6.0__py3-none-any.whl

audiometa/test/tests/unit/cli/test_expand_file_patterns.py

@@ -0,0 +1,234 @@
+from pathlib import Path
+
+import pytest
+
+from audiometa.cli import expand_file_patterns
+
+
+@pytest.mark.unit
+class TestExpandFilePatterns:
+    def test_single_file_exists(self, tmp_path):
+        test_file = tmp_path / "test.mp3"
+        test_file.write_text("fake mp3 content")
+
+        result = expand_file_patterns([str(test_file)])
+        assert len(result) == 1
+        assert result[0] == test_file
+
+    def test_single_file_nonexistent(self, tmp_path):
+        nonexistent_file = tmp_path / "nonexistent.mp3"
+
+        result = expand_file_patterns([str(nonexistent_file)], continue_on_error=True)
+        assert result == []
+
+    def test_glob_pattern_matching_files(self, tmp_path):
+        # Create test files
+        (tmp_path / "song1.mp3").write_text("content1")
+        (tmp_path / "song2.mp3").write_text("content2")
+        (tmp_path / "other.txt").write_text("content3")
+
+        pattern = str(tmp_path / "*.mp3")
+        result = expand_file_patterns([pattern])
+
+        assert len(result) == 2
+        assert all(path.suffix == ".mp3" for path in result)
+        assert all(path.parent == tmp_path for path in result)
+
+    def test_glob_pattern_no_matches(self, tmp_path):
+        pattern = str(tmp_path / "*.wav")
+        result = expand_file_patterns([pattern], continue_on_error=True)
+        assert result == []
+
+    def test_directory_non_recursive(self, tmp_path):
+        subdir = tmp_path / "subdir"
+        subdir.mkdir()
+        (subdir / "song.mp3").write_text("content")
+
+        result = expand_file_patterns([str(subdir)], continue_on_error=True)
+        assert result == []
+
+    def test_directory_recursive(self, tmp_path):
+        subdir = tmp_path / "music"
+        subdir.mkdir()
+        nested_dir = subdir / "album1"
+        nested_dir.mkdir()
+
+        # Create various audio files
+        (subdir / "song1.mp3").write_text("content1")
+        (nested_dir / "song2.flac").write_text("content2")
+        (nested_dir / "song3.wav").write_text("content3")
+        (nested_dir / "notes.txt").write_text("content4")  # Non-audio file
+
+        result = expand_file_patterns([str(subdir)], recursive=True)
+
+        assert len(result) == 3
+        assert all(path.suffix in [".mp3", ".flac", ".wav"] for path in result)
+        assert all(subdir in path.parents for path in result)
+
+    def test_directory_recursive_nested_directories(self, tmp_path):
+        # Create nested structure: music/artist/album/songs
+        music_dir = tmp_path / "music"
+        artist_dir = music_dir / "artist"
+        album_dir = artist_dir / "album"
+        album_dir.mkdir(parents=True)
+
+        # Create files at different levels
+        (music_dir / "root.mp3").write_text("root")
+        (artist_dir / "artist.mp3").write_text("artist")
+        (album_dir / "song1.mp3").write_text("song1")
+        (album_dir / "song2.flac").write_text("song2")
+
+        result = expand_file_patterns([str(music_dir)], recursive=True)
+
+        assert len(result) == 4
+        assert all(path.suffix in [".mp3", ".flac"] for path in result)
+
+    def test_mixed_patterns(self, tmp_path):
+        # Create files and directories
+        single_file = tmp_path / "single.mp3"
+        single_file.write_text("single")
+
+        music_dir = tmp_path / "music"
+        music_dir.mkdir()
+        (music_dir / "album.mp3").write_text("album")
+
+        # Create glob-matching files
+        (tmp_path / "glob1.mp3").write_text("glob1")
+        (tmp_path / "glob2.mp3").write_text("glob2")
+
+        patterns = [
+            str(single_file),  # Single file
+            str(music_dir),  # Directory (recursive)
+            str(tmp_path / "glob*.mp3"),  # Glob pattern
+        ]
+
+        result = expand_file_patterns(patterns, recursive=True)
+
+        assert len(result) == 4  # single + album + glob1 + glob2
+        assert single_file in result
+        assert music_dir / "album.mp3" in result
+
+    def test_unsupported_audio_extensions_ignored(self, tmp_path):
+        music_dir = tmp_path / "music"
+        music_dir.mkdir()
+
+        # Create files with supported and unsupported extensions
+        (music_dir / "song.mp3").write_text("mp3")
+        (music_dir / "song.flac").write_text("flac")
+        (music_dir / "song.wav").write_text("wav")
+        (music_dir / "song.ogg").write_text("ogg")  # Not supported
+        (music_dir / "song.m4a").write_text("m4a")  # Not supported
+
+        result = expand_file_patterns([str(music_dir)], recursive=True)
+
+        assert len(result) == 3
+        assert all(path.suffix in [".mp3", ".flac", ".wav"] for path in result)
+
+    def test_no_files_found_continue_on_error_true(self, tmp_path, capsys):
+        nonexistent_pattern = str(tmp_path / "nonexistent.mp3")
+
+        result = expand_file_patterns([nonexistent_pattern], continue_on_error=True)
+
+        assert result == []
+        captured = capsys.readouterr()
+        assert "Warning: No valid audio files found" in captured.err
+
+    def test_no_files_found_continue_on_error_false(self, tmp_path, capsys):
+        nonexistent_pattern = str(tmp_path / "nonexistent.mp3")
+
+        with pytest.raises(SystemExit) as exc_info:
+            expand_file_patterns([nonexistent_pattern], continue_on_error=False)
+
+        assert exc_info.value.code == 1
+        captured = capsys.readouterr()
+        assert "Error: No valid audio files found" in captured.err
+
+    def test_complex_glob_patterns(self, tmp_path):
+        # Create test files with different patterns
+        (tmp_path / "track01.mp3").write_text("track01")
+        (tmp_path / "track02.mp3").write_text("track02")
+        (tmp_path / "song_a.mp3").write_text("song_a")
+        (tmp_path / "song_b.mp3").write_text("song_b")
+        (tmp_path / "other.wav").write_text("other")
+
+        # Test character class glob
+        pattern1 = str(tmp_path / "track[0-9][0-9].mp3")
+        result1 = expand_file_patterns([pattern1])
+        assert len(result1) == 2
+
+        # Test wildcard glob
+        pattern2 = str(tmp_path / "song_?.mp3")
+        result2 = expand_file_patterns([pattern2])
+        assert len(result2) == 2
+
+    def test_relative_paths(self, tmp_path, monkeypatch):
+        # Change to tmp_path directory
+        monkeypatch.chdir(tmp_path)
+
+        # Create relative file
+        rel_file = Path("relative.mp3")
+        rel_file.write_text("relative")
+
+        result = expand_file_patterns(["relative.mp3"])
+        assert len(result) == 1
+        assert result[0].name == "relative.mp3"
+
+    def test_hidden_files_ignored(self, tmp_path):
+        (tmp_path / "visible.mp3").write_text("visible")
+        (tmp_path / ".hidden.mp3").write_text("hidden")
+
+        pattern = str(tmp_path / "*.mp3")
+        result = expand_file_patterns([pattern])
+
+        assert len(result) == 1
+        assert result[0].name == "visible.mp3"
+
+    def test_case_sensitive_extensions(self, tmp_path):
+        # On case-insensitive filesystems, we can't create both .mp3 and .MP3 files
+        # So we'll test with different extensions instead
+        (tmp_path / "song.mp3").write_text("lowercase")
+        (tmp_path / "song.wav").write_text("wav")
+
+        pattern_mp3 = str(tmp_path / "*.mp3")
+        pattern_wav = str(tmp_path / "*.wav")
+
+        result_mp3 = expand_file_patterns([pattern_mp3], continue_on_error=True)
+        result_wav = expand_file_patterns([pattern_wav], continue_on_error=True)
+
+        # Each pattern should match exactly one file
+        assert len(result_mp3) == 1
+        assert result_mp3[0].name == "song.mp3"
+        assert len(result_wav) == 1
+        assert result_wav[0].name == "song.wav"
+
+    def test_empty_pattern_list(self):
+        result = expand_file_patterns([], continue_on_error=True)
+        assert result == []
+
+    def test_directory_with_no_audio_files_recursive(self, tmp_path):
+        empty_dir = tmp_path / "empty"
+        empty_dir.mkdir()
+        (empty_dir / "text.txt").write_text("text")
+
+        result = expand_file_patterns([str(empty_dir)], recursive=True, continue_on_error=True)
+        assert result == []
+
+    def test_file_vs_directory_same_name(self, tmp_path):
+        # Create a file named "music"
+        music_file = tmp_path / "music"
+        music_file.write_text("not audio")
+
+        # Create a directory named "music_dir" with audio files
+        music_dir = tmp_path / "music_dir"
+        music_dir.mkdir()
+        (music_dir / "song.mp3").write_text("audio")
+
+        # Test file takes precedence when it exists
+        result1 = expand_file_patterns([str(music_file)])
+        assert len(result1) == 1
+        assert result1[0] == music_file
+
+        # Test directory expansion
+        result2 = expand_file_patterns([str(music_dir)], recursive=True)
+        assert len(result2) == 1
+        assert result2[0] == music_dir / "song.mp3"

audiometa/test/tests/unit/metadata_managers/conftest.py

@@ -0,0 +1,142 @@
+from unittest.mock import MagicMock
+
+import pytest
+
+from audiometa._audio_file import _AudioFile
+
+
+@pytest.fixture
+def mock_audio_file_mp3():
+    mock_audio_file = MagicMock(spec=_AudioFile)
+    mock_audio_file.file_path = "/path/to/test.mp3"
+    mock_audio_file.file_extension = ".mp3"
+    return mock_audio_file
+
+
+@pytest.fixture
+def mock_audio_file_wav():
+    mock_audio_file = MagicMock(spec=_AudioFile)
+    mock_audio_file.file_path = "/path/to/test.wav"
+    mock_audio_file.file_extension = ".wav"
+    return mock_audio_file
+
+
+@pytest.fixture
+def mock_audio_file_flac():
+    mock_audio_file = MagicMock(spec=_AudioFile)
+    mock_audio_file.file_path = "/path/to/test.flac"
+    mock_audio_file.file_extension = ".flac"
+    return mock_audio_file
+
+
+@pytest.fixture
+def mock_id3_empty():
+    mock_id3 = MagicMock()
+    mock_id3.version = (2, 3, 0)
+    mock_id3.size = 0
+    mock_id3.flags = 0
+    mock_id3.__contains__ = lambda _self, _key: False
+    mock_id3.items.return_value = []
+    mock_id3.extended_header = None
+    return mock_id3
+
+
+@pytest.fixture
+def mock_id3_with_metadata():
+    mock_id3 = MagicMock()
+    mock_id3.version = (2, 3, 0)
+    mock_id3.size = 2048
+    mock_id3.flags = 0x40
+    mock_id3.extended_header = None
+
+    mock_title = MagicMock()
+    mock_title.text = ["Test Title"]
+    mock_artists = MagicMock()
+    mock_artists.text = ["Test Artist"]
+    mock_album = MagicMock()
+    mock_album.text = ["Test Album"]
+
+    frame_dict = {
+        "TIT2": mock_title,
+        "TPE1": mock_artists,
+        "TALB": mock_album,
+    }
+
+    mock_id3.__contains__ = lambda _self, key: key in frame_dict
+    mock_id3.__getitem__ = lambda _self, key: frame_dict.get(key)
+    mock_id3.items.return_value = []
+
+    return mock_id3
+
+
+@pytest.fixture
+def mock_id3_updatable():
+    """Mock ID3 object that supports add/delall operations for update_metadata testing."""
+    mock_id3 = MagicMock()
+    mock_id3.version = (2, 3, 0)
+    mock_id3.size = 0
+    mock_id3.flags = 0
+    mock_id3.extended_header = None
+
+    # Storage for frames
+    frames = {}
+
+    def mock_delall(key):
+        """Remove all frames with the given key."""
+        keys_to_remove = [k for k in frames if k.startswith(key)]
+        for k in keys_to_remove:
+            del frames[k]
+
+    def mock_add(frame):
+        """Add a frame to the mock."""
+        frame_id = frame.FrameID
+        if hasattr(frame, "email"):  # POPM frame
+            frame_id = f"{frame_id}:{frame.email}"
+
+        frames[frame_id] = frame
+
+    def mock_items():
+        """Return list of (key, frame) tuples."""
+        return list(frames.items())
+
+    mock_id3.delall = mock_delall
+    mock_id3.add = mock_add
+    mock_id3.items = mock_items
+    mock_id3.__contains__ = lambda _self, key: key in frames
+    mock_id3.__getitem__ = lambda _self, key: frames[key]
+
+    return mock_id3
+
+
+@pytest.fixture
+def mock_wave_empty():
+    mock_wave = MagicMock()
+    mock_wave.info = {}
+    return mock_wave
+
+
+@pytest.fixture
+def mock_wave_with_metadata():
+    mock_wave = MagicMock()
+    mock_wave.info = {
+        "INAM": ["Test Title"],
+        "IART": ["Test Artist"],
+        "IPRD": ["Test Album"],
+    }
+    return mock_wave
+
+
+@pytest.fixture
+def mock_vorbis_metadata_empty():
+    """Mock Vorbis metadata dict with no metadata."""
+    return {}
+
+
+@pytest.fixture
+def mock_vorbis_metadata_with_data():
+    """Mock Vorbis metadata dict with sample metadata."""
+    return {
+        "TITLE": ["Test Title"],
+        "ARTIST": ["Test Artist"],
+        "ALBUM": ["Test Album"],
+    }

audiometa/test/tests/unit/metadata_managers/header_info/test_id3v1.py

@@ -0,0 +1,49 @@
+from pathlib import Path
+
+import pytest
+
+from audiometa._audio_file import _AudioFile
+from audiometa.manager.id3v1._Id3v1Manager import _Id3v1Manager as Id3v1Manager
+
+
+@pytest.mark.unit
+class TestId3v1HeaderMethods:
+    def test_id3v1_manager_header_info(self, sample_mp3_file: Path):
+        audio_file = _AudioFile(sample_mp3_file)
+        manager = Id3v1Manager(audio_file)
+
+        header_info = manager.get_header_info()
+
+        # Should have ID3v1 specific structure
+        assert "present" in header_info
+        assert "position" in header_info
+        assert "size_bytes" in header_info
+        assert "version" in header_info
+        assert "has_track_number" in header_info
+
+        # Should be valid structure
+        assert isinstance(header_info["present"], bool)
+        assert header_info["position"] is None or isinstance(header_info["position"], str)
+        assert isinstance(header_info["size_bytes"], int)
+        assert header_info["version"] is None or isinstance(header_info["version"], str)
+        assert isinstance(header_info["has_track_number"], bool)
+
+    def test_id3v1_manager_raw_metadata_info(self, sample_mp3_file: Path):
+        audio_file = _AudioFile(sample_mp3_file)
+        manager = Id3v1Manager(audio_file)
+
+        raw_info = manager.get_raw_metadata_info()
+
+        # Should have ID3v1 specific structure
+        assert "raw_data" in raw_info
+        assert "parsed_fields" in raw_info
+        assert "frames" in raw_info
+        assert "comments" in raw_info
+        assert "chunk_structure" in raw_info
+
+        # Should be valid structure
+        assert raw_info["raw_data"] is None or isinstance(raw_info["raw_data"], bytes)
+        assert isinstance(raw_info["parsed_fields"], dict)
+        assert isinstance(raw_info["frames"], dict)
+        assert isinstance(raw_info["comments"], dict)
+        assert isinstance(raw_info["chunk_structure"], dict)

audiometa/test/tests/unit/metadata_managers/header_info/test_id3v2.py

@@ -0,0 +1,66 @@
+from unittest.mock import patch
+
+import pytest
+
+from audiometa.manager._rating_supporting.id3v2._Id3v2Manager import _Id3v2Manager as Id3v2Manager
+
+
+@pytest.mark.unit
+class TestId3v2HeaderMethods:
+    @patch("audiometa.manager._rating_supporting.id3v2._Id3v2Manager.ID3")
+    def test_id3v2_manager_header_info(self, mock_id3_class, mock_audio_file_mp3, mock_id3_with_metadata):
+        mock_id3_class.return_value = mock_id3_with_metadata
+
+        manager = Id3v2Manager(mock_audio_file_mp3)
+        header_info = manager.get_header_info()
+
+        assert "present" in header_info
+        assert "version" in header_info
+        assert "header_size_bytes" in header_info
+        assert "flags" in header_info
+        assert "extended_header" in header_info
+
+        assert isinstance(header_info["present"], bool)
+        assert isinstance(header_info["version"], str)
+        assert header_info["version"] == "2.3.0"
+        assert isinstance(header_info["header_size_bytes"], int)
+        assert isinstance(header_info["flags"], dict)
+        assert isinstance(header_info["extended_header"], dict)
+
+    @patch("audiometa.manager._rating_supporting.id3v2._Id3v2Manager.ID3")
+    def test_id3v2_manager_header_info_empty(self, mock_id3_class, mock_audio_file_mp3, mock_id3_empty):
+        mock_id3_class.return_value = mock_id3_empty
+
+        manager = Id3v2Manager(mock_audio_file_mp3)
+        header_info = manager.get_header_info()
+
+        assert "present" in header_info
+        assert "version" in header_info
+        assert "header_size_bytes" in header_info
+        assert "flags" in header_info
+        assert "extended_header" in header_info
+
+        assert isinstance(header_info["present"], bool)
+        assert isinstance(header_info["version"], str)
+        assert isinstance(header_info["header_size_bytes"], int)
+        assert isinstance(header_info["flags"], dict)
+        assert isinstance(header_info["extended_header"], dict)
+
+    @patch("audiometa.manager._rating_supporting.id3v2._Id3v2Manager.ID3")
+    def test_id3v2_manager_raw_metadata_info(self, mock_id3_class, mock_audio_file_mp3, mock_id3_empty):
+        mock_id3_class.return_value = mock_id3_empty
+
+        manager = Id3v2Manager(mock_audio_file_mp3)
+        raw_info = manager.get_raw_metadata_info()
+
+        assert "raw_data" in raw_info
+        assert "parsed_fields" in raw_info
+        assert "frames" in raw_info
+        assert "comments" in raw_info
+        assert "chunk_structure" in raw_info
+
+        assert raw_info["raw_data"] is None or isinstance(raw_info["raw_data"], bytes)
+        assert isinstance(raw_info["parsed_fields"], dict)
+        assert isinstance(raw_info["frames"], dict)
+        assert isinstance(raw_info["comments"], dict)
+        assert isinstance(raw_info["chunk_structure"], dict)