Add synthetic sample library

.gitignore

@@ -2,7 +2,9 @@ __pycache__/
 *.pyc
 .env
 .venv/
+*.egg-info/
 reports/
+samples/small-library/generated/
 *.sqlite
 *.db
 *.csv

CONTRIBUTING.md

@@ -11,3 +11,9 @@
 Never commit personal music library files, Serato databases, or crates.
 
 Never write repair code without dry-run mode, backup plan, and rollback log.
+
+## Testing
+
+Install development dependencies with `python3 -m pip install -e '.[dev]'`.
+
+Run `pytest` before committing. Tests and fixtures must use synthetic library data.

ROADMAP.md

@@ -8,8 +8,8 @@
 - [x] Missing reference CSV report
 - [x] Grouped missing reference report
 - [ ] HTML health dashboard
-- [ ] Test suite
+- [x] Test suite
-- [ ] Sample library fixtures
+- [x] Sample library fixtures
 - [ ] Database V2 read-only parser
 
 ## v0.2 — Diagnostics

docs/design/sample-library.md

@@ -0,0 +1,26 @@
+# Synthetic Sample Library
+
+## Problem
+
+Real Serato libraries contain private paths, listening history, and copyrighted
+music. Contributors still need a repeatable library for tests and demonstrations.
+
+## Architecture
+
+`samples/small-library/manifest.json` describes a compact migration scenario.
+`generate.py` turns that manifest into fake audio files and UTF-16-LE crate files
+inside an ignored `generated` directory. The generated files are disposable and
+contain no real audio or user library data.
+
+## Edge Cases
+
+- Five manually maintained crates and two smart/dynamic crates.
+- Mixed supported audio extensions.
+- One reference whose file is absent.
+- One stale reference whose file has been renamed.
+- References shared by static and smart crates.
+
+## Verification
+
+`pytest` generates the sample in a temporary directory and verifies its crate,
+track, and missing-reference counts through the production parser and scanner.

docs/design/test-foundation.md

@@ -0,0 +1,24 @@
+# Test Foundation
+
+## Problem
+
+The crate parser handles unusual binary text and known extension artifacts. Without
+automated tests, a small refactor could silently change library counts or reports.
+
+## Architecture
+
+Tests cover the read-only pipeline from crate and filesystem inputs through the
+core library model to CSV, text, and CLI output. All test data is synthetic and is
+created in temporary directories.
+
+## Edge Cases
+
+- Known MP3, M4A, WAV, and AIF decode artifacts.
+- Crate records without a recognized stop marker.
+- Supported extensions with mixed case and unsupported files.
+- References that exist by filename and references that remain missing.
+
+## Verification
+
+Run `pytest`. No test reads a real Serato library or writes outside pytest's
+temporary directory.

pyproject.toml

@@ -1,3 +1,7 @@
+[build-system]
+requires = ["setuptools>=61"]
+build-backend = "setuptools.build_meta"
+
 [project]
 name = "serato-doctor"
 version = "0.1.0"
@@ -5,5 +9,14 @@ description = "Inspect, diagnose, repair, and migrate DJ libraries."
 requires-python = ">=3.9"
 dependencies = []
 
+[project.optional-dependencies]
+dev = ["pytest>=8,<9"]
+
 [project.scripts]
 serato-doctor = "serato_doctor.cli:main"
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+
+[tool.setuptools.packages.find]
+include = ["serato_doctor*"]

samples/small-library/README.md

@@ -0,0 +1,25 @@
+# Small Synthetic Library
+
+This fixture models a small Serato migration without containing music or personal
+library data. It has 10 fake audio files, five static crates, two smart crates,
+one absent song, and one renamed song.
+
+Generate it with:
+
+```shell
+python3 samples/small-library/generate.py
+```
+
+Analyze it with:
+
+```shell
+python3 -m serato_doctor.cli \
+  --serato samples/small-library/generated/Serato/_Serato_ \
+  --music samples/small-library/generated/Music \
+  --out samples/small-library/generated/scan.csv \
+  --report samples/small-library/generated/report.txt
+```
+
+Expected CLI counts are 13 crate references, 10 disk tracks, and 2 references
+missing by filename. Everything under `generated/` is disposable and ignored by
+Git.

samples/small-library/generate.py

@@ -0,0 +1,50 @@
+"""Generate a disposable, synthetic Serato library from the sample manifest."""
+
+import argparse
+import json
+from pathlib import Path
+from typing import Optional
+
+
+SAMPLE_ROOT = Path(__file__).parent
+SERATO_PATH_PREFIX = "Users/djsplice/OneDrive/Jukebox/"
+
+
+def load_manifest() -> dict:
+    return json.loads((SAMPLE_ROOT / "manifest.json").read_text(encoding="utf-8"))
+
+
+def build_sample(output: Optional[Path] = None) -> Path:
+    root = output or SAMPLE_ROOT / "generated"
+    manifest = load_manifest()
+    music_root = root / "Music"
+    crate_root = root / "Serato" / "_Serato_" / "Subcrates"
+    crate_root.mkdir(parents=True, exist_ok=True)
+
+    for relative_path in manifest["tracks"]:
+        track_path = music_root / relative_path
+        track_path.parent.mkdir(parents=True, exist_ok=True)
+        track_path.write_bytes(
+            f"Synthetic Serato Doctor fixture: {relative_path}\n".encode("utf-8")
+        )
+
+    for crate in manifest["crates"]:
+        records = "".join(
+            f"{SERATO_PATH_PREFIX}{relative_path}otrk"
+            for relative_path in crate["references"]
+        )
+        (crate_root / crate["name"]).write_bytes(records.encode("utf-16-le"))
+
+    return root
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--output", type=Path)
+    args = parser.parse_args()
+    root = build_sample(args.output)
+    print(f"Generated synthetic library: {root}")
+
+
+if __name__ == "__main__":
+    main()

samples/small-library/manifest.json

@@ -0,0 +1,56 @@
+{
+  "tracks": [
+    "House/First.mp3",
+    "House/Second.m4a",
+    "Open Format/Third.wav",
+    "Open Format/Fourth.aif",
+    "Classics/Fifth.mp3",
+    "Classics/Sixth.flac",
+    "Warmup/Seventh.mp3",
+    "Warmup/Eighth.mp3",
+    "Renamed/New Name.mp3",
+    "Bonus/Ninth.MP3"
+  ],
+  "crates": [
+    {
+      "name": "House.crate",
+      "type": "static",
+      "references": ["House/First.mp3", "House/Second.m4a", "House/Missing.mp3"]
+    },
+    {
+      "name": "Open Format.crate",
+      "type": "static",
+      "references": ["Open Format/Third.wav", "Open Format/Fourth.aif"]
+    },
+    {
+      "name": "Classics.crate",
+      "type": "static",
+      "references": ["Classics/Fifth.mp3", "Classics/Sixth.flac"]
+    },
+    {
+      "name": "Renamed Tracks.crate",
+      "type": "static",
+      "references": ["Renamed/Old Name.mp3"]
+    },
+    {
+      "name": "Bonus.crate",
+      "type": "static",
+      "references": ["Bonus/Ninth.MP3"]
+    },
+    {
+      "name": "Compatible by key.crate",
+      "type": "smart",
+      "references": ["House/First.mp3", "House/Second.m4a"]
+    },
+    {
+      "name": "Smart Warmup.crate",
+      "type": "smart",
+      "references": ["Warmup/Seventh.mp3", "Warmup/Eighth.mp3"]
+    }
+  ],
+  "expected": {
+    "disk_tracks": 10,
+    "crate_references": 13,
+    "missing_by_filename": ["Missing.mp3", "Old Name.mp3"]
+  }
+}

serato_doctor/cli.py

@@ -2,6 +2,7 @@ from pathlib import Path
 import argparse
 
 from serato_doctor.crate_parser import parse_crates
+from serato_doctor.models.library import Library
 from serato_doctor.scanner import scan_audio
 from serato_doctor.report import write_csv, write_missing_report
 
@@ -19,27 +20,18 @@ def main():
     out = Path(args.out)
     report = Path(args.report)
 
-    refs = parse_crates(serato / "Subcrates")
+    library = Library.build(
-    disk = scan_audio(music)
+        references=parse_crates(serato / "Subcrates"),
+        tracks=scan_audio(music),
+    )
+    results = library.reconcile_by_filename()
+    missing_count = sum(1 for result in results if not result.exists_by_filename)
 
-    disk_names = {t.filename for t in disk}
+    write_csv(results, out)
+    write_missing_report(results, report)
 
-    rows = []
+    print(f"Crate references: {len(library.references)}")
-    for ref in refs:
+    print(f"Disk tracks: {len(library.tracks)}")
-        rows.append({
-            "crate": str(ref.source),
-            "serato_path": str(ref.path),
-            "filename": ref.filename,
-            "exists_by_filename": ref.filename in disk_names,
-        })
-
-    missing_count = sum(1 for r in rows if not r["exists_by_filename"])
-
-    write_csv(rows, out)
-    write_missing_report(rows, report)
-
-    print(f"Crate references: {len(refs)}")
-    print(f"Disk tracks: {len(disk)}")
     print(f"Missing by filename: {missing_count}")
     print(f"CSV: {out}")
     print(f"Report: {report}")

serato_doctor/crate_parser.py

@@ -1,6 +1,7 @@
 from pathlib import Path
 
-from serato_doctor.models import TrackReference
+from serato_doctor.models.crate import Crate
+from serato_doctor.models.reference import TrackReference
 
 
 def read_crate_text(crate_path: Path) -> str:
@@ -20,7 +21,7 @@ def clean_path(raw: str) -> str:
     return raw.strip()
 
 
-def parse_crate(crate_path: Path) -> list[TrackReference]:
+def load_crate(crate_path: Path) -> Crate:
     text = read_crate_text(crate_path)
     refs = []
 
@@ -48,7 +49,13 @@ def parse_crate(crate_path: Path) -> list[TrackReference]:
             )
         )
 
-    return refs
+    return Crate(path=crate_path, references=tuple(refs))
+
+
+def parse_crate(crate_path: Path) -> list[TrackReference]:
+    """Parse references from one crate, preserving the prototype API."""
+
+    return list(load_crate(crate_path).references)
 
 
 def parse_crates(root: Path) -> list[TrackReference]:

serato_doctor/models/__init__.py

@@ -0,0 +1,6 @@
+from serato_doctor.models.crate import Crate
+from serato_doctor.models.library import Library
+from serato_doctor.models.reference import ReferenceResult, TrackReference
+from serato_doctor.models.track import DiskTrack
+
+__all__ = ["Crate", "DiskTrack", "Library", "ReferenceResult", "TrackReference"]

serato_doctor/models/crate.py

@@ -0,0 +1,13 @@
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Tuple
+
+from serato_doctor.models.reference import TrackReference
+
+
+@dataclass(frozen=True)
+class Crate:
+    """A Serato crate and the track references parsed from it."""
+
+    path: Path
+    references: Tuple[TrackReference, ...]

serato_doctor/models/library.py

@@ -0,0 +1,31 @@
+from dataclasses import dataclass
+from typing import Iterable, Tuple
+
+from serato_doctor.models.reference import ReferenceResult, TrackReference
+from serato_doctor.models.track import DiskTrack
+
+
+@dataclass(frozen=True)
+class Library:
+    """The read-only view of crate references and audio found on disk."""
+
+    references: Tuple[TrackReference, ...]
+    tracks: Tuple[DiskTrack, ...]
+
+    @classmethod
+    def build(
+        cls,
+        references: Iterable[TrackReference],
+        tracks: Iterable[DiskTrack],
+    ) -> "Library":
+        return cls(tuple(references), tuple(tracks))
+
+    def reconcile_by_filename(self) -> Tuple[ReferenceResult, ...]:
+        disk_names = {track.filename for track in self.tracks}
+        return tuple(
+            ReferenceResult(
+                reference=reference,
+                exists_by_filename=reference.filename in disk_names,
+            )
+            for reference in self.references
+        )

serato_doctor/models/reference.py

@@ -0,0 +1,27 @@
+from dataclasses import dataclass
+from pathlib import Path
+
+
+@dataclass(frozen=True)
+class TrackReference:
+    """A track path referenced by a Serato crate."""
+
+    source: Path
+    path: Path
+    filename: str
+
+
+@dataclass(frozen=True)
+class ReferenceResult:
+    """The filename-level reconciliation result for a crate reference."""
+
+    reference: TrackReference
+    exists_by_filename: bool
+
+    def as_row(self) -> dict:
+        return {
+            "crate": str(self.reference.source),
+            "serato_path": str(self.reference.path),
+            "filename": self.reference.filename,
+            "exists_by_filename": self.exists_by_filename,
+        }

serato_doctor/models/track.py

@@ -2,15 +2,10 @@ from dataclasses import dataclass
 from pathlib import Path
 
 
-@dataclass(frozen=True)
-class TrackReference:
-    source: Path
-    path: Path
-    filename: str
-
-
 @dataclass(frozen=True)
 class DiskTrack:
+    """An audio file discovered on disk."""
+
     path: Path
     filename: str
     size: int

serato_doctor/report.py

@@ -1,9 +1,13 @@
 from collections import Counter, defaultdict
 from pathlib import Path
+from typing import Iterable
 import csv
 
+from serato_doctor.models.reference import ReferenceResult
 
-def write_missing_report(rows: list[dict], out: Path) -> None:
+
+def write_missing_report(results: Iterable[ReferenceResult], out: Path) -> None:
+    rows = [result.as_row() for result in results]
     missing = [r for r in rows if not r["exists_by_filename"]]
 
     crate_counts = Counter(r["crate"] for r in missing)
@@ -32,7 +36,8 @@ def write_missing_report(rows: list[dict], out: Path) -> None:
                 f.write(f"- {name}\n")
 
 
-def write_csv(rows: list[dict], out: Path) -> None:
+def write_csv(results: Iterable[ReferenceResult], out: Path) -> None:
+    rows = [result.as_row() for result in results]
     with out.open("w", newline="", encoding="utf-8") as f:
         writer = csv.DictWriter(
             f,

serato_doctor/scanner.py

@@ -1,6 +1,6 @@
 from pathlib import Path
 
-from serato_doctor.models import DiskTrack
+from serato_doctor.models.track import DiskTrack
 
 AUDIO_SUFFIXES = {".mp3", ".m4a", ".wav", ".aif", ".aiff", ".flac"}
 

tests/test_cli.py

@@ -0,0 +1,49 @@
+import csv
+import sys
+
+from serato_doctor.cli import main
+
+
+def test_cli_writes_reports_and_prints_counts(tmp_path, monkeypatch, capsys):
+    serato = tmp_path / "serato"
+    subcrates = serato / "Subcrates"
+    music = tmp_path / "music"
+    subcrates.mkdir(parents=True)
+    music.mkdir()
+
+    crate_text = (
+        "Users/djsplice/OneDrive/Jukebox/Found.mp漳牴k"
+        "Users/djsplice/OneDrive/Jukebox/Missing.mp漳牴k"
+    )
+    (subcrates / "Test.crate").write_bytes(crate_text.encode("utf-16-le"))
+    (music / "Found.mp3").write_bytes(b"synthetic audio")
+    csv_path = tmp_path / "scan.csv"
+    report_path = tmp_path / "report.txt"
+    monkeypatch.setattr(
+        sys,
+        "argv",
+        [
+            "serato-doctor",
+            "--serato",
+            str(serato),
+            "--music",
+            str(music),
+            "--out",
+            str(csv_path),
+            "--report",
+            str(report_path),
+        ],
+    )
+
+    main()
+
+    output = capsys.readouterr().out
+    assert "Crate references: 2" in output
+    assert "Disk tracks: 1" in output
+    assert "Missing by filename: 1" in output
+    assert f"CSV: {csv_path}" in output
+    assert f"Report: {report_path}" in output
+    with csv_path.open(newline="", encoding="utf-8") as csv_file:
+        rows = list(csv.DictReader(csv_file))
+    assert [row["exists_by_filename"] for row in rows] == ["True", "False"]
+    assert "Total missing references: 1" in report_path.read_text(encoding="utf-8")

tests/test_crates.py

@@ -0,0 +1,47 @@
+from pathlib import Path
+
+import pytest
+
+from serato_doctor.crate_parser import clean_path, load_crate, parse_crate
+
+
+@pytest.mark.parametrize(
+    ("artifact", "expected"),
+    [
+        ("song.mp漳", "song.mp3"),
+        ("song.m4愠", "song.m4a"),
+        ("song.wa瘠", "song.wav"),
+        ("song.ai映", "song.aif"),
+    ],
+)
+def test_clean_path_repairs_known_extension_artifacts(artifact, expected):
+    assert clean_path(artifact) == expected
+
+
+def test_parse_crate_extracts_references(tmp_path):
+    crate_path = tmp_path / "House.crate"
+    crate_text = (
+        "header"
+        "Users/djsplice/OneDrive/Jukebox/House/First.mp漳牴k"
+        "metadata"
+        "Users/djsplice/OneDrive/Jukebox/House/Second.m4愠otrk"
+    )
+    crate_path.write_bytes(crate_text.encode("utf-16-le"))
+
+    crate = load_crate(crate_path)
+
+    assert crate.path == crate_path
+    assert [reference.filename for reference in crate.references] == [
+        "First.mp3",
+        "Second.m4a",
+    ]
+    assert parse_crate(crate_path) == list(crate.references)
+
+
+def test_parse_crate_ignores_record_without_stop_marker(tmp_path):
+    crate_path = Path(tmp_path) / "Incomplete.crate"
+    crate_path.write_bytes(
+        "Users/djsplice/OneDrive/Jukebox/House/Incomplete.mp3".encode("utf-16-le")
+    )
+
+    assert parse_crate(crate_path) == []

tests/test_library.py

@@ -0,0 +1,24 @@
+from pathlib import Path
+
+from serato_doctor.models.library import Library
+from serato_doctor.models.reference import TrackReference
+from serato_doctor.models.track import DiskTrack
+
+
+def test_library_reconciles_references_by_filename():
+    crate = Path("House.crate")
+    references = [
+        TrackReference(crate, Path("/old/Found.mp3"), "Found.mp3"),
+        TrackReference(crate, Path("/old/Missing.mp3"), "Missing.mp3"),
+    ]
+    tracks = [DiskTrack(Path("/new/Found.mp3"), "Found.mp3", 10, ".mp3")]
+
+    results = Library.build(references, tracks).reconcile_by_filename()
+
+    assert [result.exists_by_filename for result in results] == [True, False]
+    assert results[1].as_row() == {
+        "crate": "House.crate",
+        "serato_path": "/old/Missing.mp3",
+        "filename": "Missing.mp3",
+        "exists_by_filename": False,
+    }

tests/test_sample_library.py

@@ -0,0 +1,28 @@
+import runpy
+from pathlib import Path
+
+from serato_doctor.crate_parser import parse_crates
+from serato_doctor.models.library import Library
+from serato_doctor.scanner import scan_audio
+
+
+def test_generated_sample_library_has_expected_scenario(tmp_path):
+    generator_path = (
+        Path(__file__).parents[1] / "samples" / "small-library" / "generate.py"
+    )
+    build_sample = runpy.run_path(str(generator_path))["build_sample"]
+    sample_root = build_sample(tmp_path / "sample")
+
+    references = parse_crates(sample_root / "Serato" / "_Serato_" / "Subcrates")
+    tracks = scan_audio(sample_root / "Music")
+    results = Library.build(references, tracks).reconcile_by_filename()
+    missing = {
+        result.reference.filename
+        for result in results
+        if not result.exists_by_filename
+    }
+
+    assert len(list((sample_root / "Serato").rglob("*.crate"))) == 7
+    assert len(references) == 13
+    assert len(tracks) == 10
+    assert missing == {"Missing.mp3", "Old Name.mp3"}

tests/test_scanner.py

@@ -0,0 +1,17 @@
+from serato_doctor.scanner import scan_audio
+
+
+def test_scan_audio_finds_supported_files(tmp_path):
+    music = tmp_path / "music"
+    nested = music / "House"
+    nested.mkdir(parents=True)
+    (nested / "First.MP3").write_bytes(b"synthetic audio")
+    (nested / "Second.flac").write_bytes(b"fixture")
+    (nested / "notes.txt").write_text("not audio", encoding="utf-8")
+
+    tracks = scan_audio(music)
+
+    assert {track.filename for track in tracks} == {"First.MP3", "Second.flac"}
+    first = next(track for track in tracks if track.filename == "First.MP3")
+    assert first.suffix == ".mp3"
+    assert first.size == len(b"synthetic audio")