Initial implementation of Music Metadata Enricher

AI-powered per-album pipeline: scan → local hints → MusicBrainz/Discogs/Claude
resolve → cover art → interactive or auto review → tag write + rename + report.
All external dependencies optional; 17/17 unit tests passing.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

test_suite_enricher.py

@@ -0,0 +1,272 @@
+#!/usr/bin/env python3
+"""test_suite_enricher.py — Unit- und Integrationstests für music_enricher."""
+from __future__ import annotations
+
+import sys
+import tempfile
+import traceback
+from pathlib import Path
+from typing import Callable
+
+sys.path.insert(0, str(Path(__file__).parent))
+
+from models import AlbumScan, TrackHints, AlbumHints
+
+RESULTS: list[dict] = []
+
+
+def record(test_id: str, passed: bool, detail: str = "") -> None:
+    RESULTS.append({"id": test_id, "status": "PASS" if passed else "FAIL", "detail": detail})
+
+
+def run_case(test_id: str, fn: Callable[[], str]) -> None:
+    try:
+        detail = fn()
+        record(test_id, True, detail)
+    except Exception:
+        record(test_id, False, traceback.format_exc()[:300])
+
+
+# ---------------------------------------------------------------------------
+# hint_extractor Tests
+# ---------------------------------------------------------------------------
+
+def test_parse_dirname_artist_album() -> str:
+    from hint_extractor import _parse_dirname
+    artist, album, year = _parse_dirname("Pink_Floyd_-_The_Wall")
+    assert artist and "Pink" in artist, f"artist: {artist}"
+    assert album and "Wall" in album, f"album: {album}"
+    return f"artist={artist!r}, album={album!r}"
+
+
+def test_parse_dirname_with_year() -> str:
+    from hint_extractor import _parse_dirname
+    artist, album, year = _parse_dirname("Abba_-_Greatest_Hits_1992")
+    assert year == "1992", f"year: {year}"
+    return f"year={year}"
+
+
+def test_parse_dirname_album_only() -> str:
+    from hint_extractor import _parse_dirname
+    artist, album, year = _parse_dirname("Beethoven_Complete_Edition")
+    assert album is not None, "album should not be None"
+    return f"album={album!r}"
+
+
+def test_parse_filename_track_artist_title() -> str:
+    from hint_extractor import _parse_filename
+    r = _parse_filename("07 - ABBA - Dancing Queen")
+    assert r.get("track") == "07", f"track: {r}"
+    assert "ABBA" in r.get("artist", ""), f"artist: {r}"
+    assert "Dancing" in r.get("title", ""), f"title: {r}"
+    return str(r)
+
+
+def test_parse_filename_disc_track_title() -> str:
+    from hint_extractor import _parse_filename
+    r = _parse_filename("2-07 - Bach - Toccata")
+    assert r.get("disc") == "2", f"disc: {r}"
+    assert r.get("track") == "07", f"track: {r}"
+    return str(r)
+
+
+def test_parse_filename_track_title() -> str:
+    from hint_extractor import _parse_filename
+    r = _parse_filename("01 - Dancing Queen")
+    assert r.get("track") == "01", f"track: {r}"
+    assert "Dancing" in r.get("title", ""), f"title: {r}"
+    return str(r)
+
+
+def test_parse_filename_artist_title() -> str:
+    from hint_extractor import _parse_filename
+    r = _parse_filename("Miles Davis - So What")
+    assert "Miles" in r.get("artist", ""), f"artist: {r}"
+    assert "What" in r.get("title", ""), f"title: {r}"
+    return str(r)
+
+
+def test_parse_tracklist_numbered() -> str:
+    from hint_extractor import _parse_tracklist
+    text = "1. Dancing Queen\n2. Waterloo\n3. Fernando"
+    tracks = _parse_tracklist(text)
+    assert len(tracks) == 3, f"count: {len(tracks)}"
+    assert tracks[0]["title"] == "Dancing Queen", f"title: {tracks[0]}"
+    return f"{len(tracks)} tracks parsed"
+
+
+def test_parse_tracklist_with_duration() -> str:
+    from hint_extractor import _parse_tracklist
+    text = "1-1  Toccata And Fugue   9:17\n1-2  Heartbeat   2:19\n2-1  Finale   5:00"
+    tracks = _parse_tracklist(text)
+    assert len(tracks) >= 2, f"count: {len(tracks)}"
+    assert tracks[0]["disc"] == "1", f"disc: {tracks[0]}"
+    return f"{len(tracks)} tracks parsed"
+
+
+def test_parse_tracklist_with_disc_sections() -> str:
+    from hint_extractor import _parse_tracklist
+    text = "CD 1\n1. Track A\n2. Track B\nCD 2\n1. Track C"
+    tracks = _parse_tracklist(text)
+    disc2 = [t for t in tracks if t.get("disc") == "2"]
+    assert len(disc2) >= 1, f"disc2: {disc2}"
+    return f"{len(tracks)} total, {len(disc2)} on disc 2"
+
+
+# ---------------------------------------------------------------------------
+# Scanner Tests
+# ---------------------------------------------------------------------------
+
+def test_scanner_classifies_files() -> str:
+    from scanner import scan_album
+    with tempfile.TemporaryDirectory() as tmpdir:
+        root = Path(tmpdir) / "TestAlbum"
+        root.mkdir()
+        (root / "01 - Song.mp3").write_bytes(b"\x00" * 100)
+        (root / "02 - Song.flac").write_bytes(b"\x00" * 100)
+        (root / "front.jpg").write_bytes(b"\xff\xd8" + b"\x00" * 100)
+        (root / "tracklist.txt").write_text("1. Track One\n2. Track Two")
+        (root / "notes.pdf").write_bytes(b"\x00" * 50)
+
+        scan = scan_album(root)
+        assert len(scan.audio_files) == 2, f"audio: {scan.audio_files}"
+        assert len(scan.image_files) == 1, f"images: {scan.image_files}"
+        assert len(scan.tracklist_files) == 1, f"tracklists: {scan.tracklist_files}"
+    return "scan OK: 2 audio, 1 image, 1 tracklist"
+
+
+def test_scanner_ignores_hidden() -> str:
+    from scanner import scan_album
+    with tempfile.TemporaryDirectory() as tmpdir:
+        root = Path(tmpdir) / "Album"
+        root.mkdir()
+        (root / "song.mp3").write_bytes(b"\x00" * 100)
+        (root / ".hidden.mp3").write_bytes(b"\x00" * 100)
+        (root / "_trash.mp3").write_bytes(b"\x00" * 100)
+        scan = scan_album(root)
+        assert len(scan.audio_files) == 1, f"should ignore hidden: {scan.audio_files}"
+    return "hidden files correctly ignored"
+
+
+# ---------------------------------------------------------------------------
+# extract_hints integration
+# ---------------------------------------------------------------------------
+
+def test_extract_hints_from_scan() -> str:
+    from scanner import scan_album
+    from hint_extractor import extract_hints
+    with tempfile.TemporaryDirectory() as tmpdir:
+        root = Path(tmpdir) / "ABBA_-_Greatest_Hits"
+        root.mkdir()
+        (root / "01 - ABBA - Dancing Queen.mp3").write_bytes(b"\x00" * 1024)
+        (root / "02 - ABBA - Waterloo.mp3").write_bytes(b"\x00" * 1024)
+        (root / "tracklist.txt").write_text("1. Dancing Queen\n2. Waterloo\n")
+
+        scan = scan_album(root)
+        hints = extract_hints(scan)
+        assert hints.dir_album is not None, "album hint missing"
+        assert len(hints.tracks) == 2, f"tracks: {len(hints.tracks)}"
+        assert hints.tracklist_text is not None, "tracklist not read"
+    return f"hints OK: album={hints.dir_album!r}, {len(hints.tracks)} tracks"
+
+
+def test_extract_hints_multi_disc() -> str:
+    from scanner import scan_album
+    from hint_extractor import extract_hints
+    with tempfile.TemporaryDirectory() as tmpdir:
+        root = Path(tmpdir) / "Bach_Complete"
+        (root / "CD1").mkdir(parents=True)
+        (root / "CD2").mkdir()
+        (root / "CD1" / "01 - Toccata.mp3").write_bytes(b"\x00" * 1024)
+        (root / "CD2" / "01 - Fugue.mp3").write_bytes(b"\x00" * 1024)
+
+        scan = scan_album(root)
+        hints = extract_hints(scan)
+        disc_nums = {t.disc_number for t in hints.tracks if t.disc_number}
+        assert 1 in disc_nums, f"disc 1 missing: {disc_nums}"
+        assert 2 in disc_nums, f"disc 2 missing: {disc_nums}"
+    return f"disc numbers detected: {disc_nums}"
+
+
+# ---------------------------------------------------------------------------
+# executor Tests
+# ---------------------------------------------------------------------------
+
+def test_proposed_filename_single_disc() -> str:
+    from executor import _proposed_filename
+    from models import TrackProposal
+    from pathlib import Path
+    tp = TrackProposal(path=Path("dummy.mp3"), title="Dancing Queen",
+                       artist="ABBA", track_number=1, disc_number=None)
+    name = _proposed_filename(tp, ".mp3")
+    assert name == "01 - ABBA - Dancing Queen.mp3", f"got: {name!r}"
+    return name
+
+
+def test_proposed_filename_multi_disc() -> str:
+    from executor import _proposed_filename
+    from models import TrackProposal
+    from pathlib import Path
+    tp = TrackProposal(path=Path("dummy.flac"), title="Toccata",
+                       artist="Bach", track_number=7, disc_number=2)
+    name = _proposed_filename(tp, ".flac")
+    assert name == "2-07 - Bach - Toccata.flac", f"got: {name!r}"
+    return name
+
+
+def test_proposed_filename_sanitizes_chars() -> str:
+    from executor import _proposed_filename
+    from models import TrackProposal
+    from pathlib import Path
+    tp = TrackProposal(path=Path("x.mp3"), title='Track: "Live" / Today',
+                       artist="Artist?", track_number=3, disc_number=None)
+    name = _proposed_filename(tp, ".mp3")
+    assert "/" not in name and ":" not in name, f"unsafe chars in: {name!r}"
+    return name
+
+
+# ---------------------------------------------------------------------------
+# Runner
+# ---------------------------------------------------------------------------
+
+def main() -> None:
+    print("🧪 Starte Music Metadata Enricher Tests...")
+
+    cases = [
+        ("UNIT_01_parse_dirname_artist_album",       test_parse_dirname_artist_album),
+        ("UNIT_02_parse_dirname_with_year",           test_parse_dirname_with_year),
+        ("UNIT_03_parse_dirname_album_only",          test_parse_dirname_album_only),
+        ("UNIT_04_parse_filename_track_artist_title", test_parse_filename_track_artist_title),
+        ("UNIT_05_parse_filename_disc_track_title",   test_parse_filename_disc_track_title),
+        ("UNIT_06_parse_filename_track_title",        test_parse_filename_track_title),
+        ("UNIT_07_parse_filename_artist_title",       test_parse_filename_artist_title),
+        ("UNIT_08_parse_tracklist_numbered",          test_parse_tracklist_numbered),
+        ("UNIT_09_parse_tracklist_with_duration",     test_parse_tracklist_with_duration),
+        ("UNIT_10_parse_tracklist_disc_sections",     test_parse_tracklist_with_disc_sections),
+        ("UNIT_11_scanner_classifies_files",          test_scanner_classifies_files),
+        ("UNIT_12_scanner_ignores_hidden",            test_scanner_ignores_hidden),
+        ("UNIT_13_extract_hints_from_scan",           test_extract_hints_from_scan),
+        ("UNIT_14_extract_hints_multi_disc",          test_extract_hints_multi_disc),
+        ("UNIT_15_proposed_filename_single_disc",     test_proposed_filename_single_disc),
+        ("UNIT_16_proposed_filename_multi_disc",      test_proposed_filename_multi_disc),
+        ("UNIT_17_proposed_filename_sanitizes_chars", test_proposed_filename_sanitizes_chars),
+    ]
+
+    for test_id, fn in cases:
+        run_case(test_id, fn)
+
+    print("=" * 70)
+    for r in RESULTS:
+        icon = "✅" if r["status"] == "PASS" else "❌"
+        detail = r["detail"][:100] + "..." if len(r["detail"]) > 100 else r["detail"]
+        print(f"{icon} [{r['status']}] {r['id']}  {detail}")
+    print("=" * 70)
+
+    passed = sum(1 for r in RESULTS if r["status"] == "PASS")
+    total = len(RESULTS)
+    print(f"📊 {passed}/{total} Tests erfolgreich")
+    sys.exit(0 if passed == total else 1)
+
+
+if __name__ == "__main__":
+    main()