@digitalpaws/starr 0.0.1

package/tests/library-scanner.test.ts

@@ -0,0 +1,177 @@
+// SPDX-License-Identifier: 0BSD
+// SPDX-FileCopyrightText: 2025 Digi <digitalpaws@proton.me>
+
+import { describe, it, expect, beforeAll, afterAll } from "vitest";
+import { mkdtemp, mkdir, writeFile, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import Database from "better-sqlite3";
+import { createLogger } from "../src/logging/logger.js";
+import { runMigrations, CORE_MIGRATIONS } from "../src/datastore/migrations.js";
+import { LibraryScanner } from "../src/library/library-scanner.js";
+import type { LibraryConfig } from "../src/library/library-config.js";
+
+let tmpDir: string;
+let db: Database.Database;
+let scanner: LibraryScanner;
+
+beforeAll(async () => {
+  tmpDir = await mkdtemp(path.join(tmpdir(), "starr-scanner-test-"));
+
+  db = new Database(":memory:");
+  db.pragma("journal_mode = WAL");
+  const logger = createLogger("test", "silent");
+  runMigrations(db, CORE_MIGRATIONS, logger);
+
+  // Create library structure
+  const moviesDir = path.join(tmpDir, "Movies");
+  const booksDir = path.join(tmpDir, "Books");
+  await mkdir(moviesDir, { recursive: true });
+  await mkdir(booksDir, { recursive: true });
+
+  // Movie 1: Dune (2021)
+  const duneDir = path.join(moviesDir, "Dune (2021)");
+  await mkdir(duneDir, { recursive: true });
+  await writeFile(path.join(duneDir, "Dune (2021) [2160p].mkv"), "movie1");
+  await writeFile(path.join(duneDir, "Dune (2021).en.srt"), "subs1");
+
+  // Movie 2: The Matrix (1999)
+  const matrixDir = path.join(moviesDir, "The Matrix (1999)");
+  await mkdir(matrixDir, { recursive: true });
+  await writeFile(path.join(matrixDir, "The Matrix (1999) [1080p].mp4"), "movie2");
+  await writeFile(path.join(matrixDir, "The Matrix (1999).en.srt"), "subs2");
+
+  // Movie 3: Hidden dir (should be skipped)
+  const hiddenDir = path.join(moviesDir, ".hidden_movie");
+  await mkdir(hiddenDir, { recursive: true });
+  await writeFile(path.join(hiddenDir, "hidden.mkv"), "hidden");
+
+  // Movie 4: Extras dir (should be skipped)
+  const extrasDir = path.join(moviesDir, "Extras");
+  await mkdir(extrasDir, { recursive: true });
+  await writeFile(path.join(extrasDir, "extra.mkv"), "extra");
+
+  // Movie 5: Empty dir (no media files)
+  const emptyDir = path.join(moviesDir, "Empty Folder");
+  await mkdir(emptyDir, { recursive: true });
+  await writeFile(path.join(emptyDir, "readme.txt"), "not media");
+
+  // Book 1: Some Book (use mkv so scanner recognizes it)
+  const bookDir = path.join(booksDir, "Some Author", "Some Title");
+  await mkdir(bookDir, { recursive: true });
+  await writeFile(path.join(bookDir, "Some Title.mkv"), "book1");
+
+  // Insert a library_paths record to test already-imported detection
+  db.prepare(`INSERT INTO tracked_requests (request_id, content_type_id, content_identity, item, owner_user_id, status, library_path)
+    VALUES (?,?,?,?,?,?,?)`).run(
+    "existing-movie",
+    "starr-video/movie@1",
+    "id::1",
+    JSON.stringify({ title: "Existing", contentTypeId: "starr-video/movie@1", externalIds: {} }),
+    "admin",
+    "imported",
+    path.join(duneDir, "Dune (2021) [2160p].mkv"),
+  );
+  db.prepare(`INSERT INTO library_paths (request_id, library_path, library_root, imported_at)
+    VALUES (?,?,?,?)`).run(
+    "existing-movie",
+    path.join(duneDir, "Dune (2021) [2160p].mkv"),
+    moviesDir,
+    "2026-01-01",
+  );
+
+  const getConfig = (): LibraryConfig => ({
+    defaultLibraryRoot: moviesDir,
+    roots: {
+      "starr-video/movie@1": moviesDir,
+      "starr-books/book@1": booksDir,
+    },
+    linkType: "copy",
+    importSubtitles: true,
+    subtitleExtensions: ["srt", "ass"],
+  });
+
+  scanner = new LibraryScanner(db, logger, getConfig);
+});
+
+afterAll(async () => {
+  await rm(tmpDir, { recursive: true, force: true });
+  db.close();
+});
+
+describe("LibraryScanner", () => {
+  it("discovers media groups from library roots", async () => {
+    const groups = await scanner.discoverGroups();
+    expect(groups.length).toBeGreaterThanOrEqual(2);
+
+    const dune = groups.find((g) => g.folderName === "Dune (2021)");
+    expect(dune).toBeDefined();
+    expect(dune!.files).toHaveLength(1);
+    expect(dune!.files[0]).toContain("Dune (2021) [2160p].mkv");
+    expect(dune!.subtitleFiles).toHaveLength(1);
+    expect(dune!.contentTypeId).toBe("starr-video/movie@1");
+
+    const matrix = groups.find((g) => g.folderName === "The Matrix (1999)");
+    expect(matrix).toBeDefined();
+    expect(matrix!.files).toHaveLength(1);
+    expect(matrix!.contentTypeId).toBe("starr-video/movie@1");
+  });
+
+  it("scans only specified content types when contentTypeIds provided", async () => {
+    const groups = await scanner.discoverGroups({ contentTypeIds: ["starr-books/book@1"] });
+    // The books root has a nested structure: Some Author/Some Title/
+    // The scanner recurses into subdirectories, so this should find the book
+    expect(groups.length).toBeGreaterThanOrEqual(1);
+    for (const g of groups) {
+      expect(g.contentTypeId).toBe("starr-books/book@1");
+    }
+  });
+
+  it("skips hidden directories", async () => {
+    const groups = await scanner.discoverGroups();
+    const hidden = groups.find((g) => g.folderName.startsWith("."));
+    expect(hidden).toBeUndefined();
+  });
+
+  it("skips Extras and Sample directories", async () => {
+    const groups = await scanner.discoverGroups();
+    const extras = groups.find((g) => g.folderName === "Extras");
+    expect(extras).toBeUndefined();
+  });
+
+  it("skips directories with no media files", async () => {
+    const groups = await scanner.discoverGroups();
+    const empty = groups.find((g) => g.folderName === "Empty Folder");
+    expect(empty).toBeUndefined();
+  });
+
+  it("detects already-imported directories", async () => {
+    const groups = await scanner.discoverGroups();
+    const dirs = groups.map((g) => g.directory);
+    const existing = scanner.findExisting(dirs);
+    const duneDir = groups.find((g) => g.folderName === "Dune (2021)")?.directory;
+    expect(duneDir).toBeDefined();
+    expect(existing.has(duneDir!)).toBe(true);
+  });
+
+  it("includes subtitle files in discovered groups", async () => {
+    const groups = await scanner.discoverGroups();
+    const dune = groups.find((g) => g.folderName === "Dune (2021)");
+    expect(dune).toBeDefined();
+    expect(dune!.subtitleFiles.length).toBeGreaterThan(0);
+    expect(dune!.subtitleFiles[0]).toContain(".srt");
+  });
+
+  it("groups nested content directories by item name, not category", async () => {
+    // Simulate root/Category/Title/file.mkv structure
+    const groups = await scanner.discoverGroups();
+    // The test data has: moviesDir/Dune (2021)/file.mkv
+    // where moviesDir IS the defaultLibraryRoot
+    const dune = groups.find((g) => g.folderName === "Dune (2021)");
+    expect(dune).toBeDefined();
+    expect(dune!.directory).toContain("Dune (2021)");
+    // Ensure no group is accidentally named after the parent category
+    const moviesGroup = groups.find((g) => g.folderName === "Movies");
+    expect(moviesGroup).toBeUndefined();
+  });
+});

package/tests/library.test.ts

@@ -0,0 +1,210 @@
+// SPDX-License-Identifier: 0BSD
+// SPDX-FileCopyrightText: 2025 Digi <digitalpaws@proton.me>
+
+import { describe, it, expect, beforeAll, afterAll } from "vitest";
+import { mkdtemp, mkdir, writeFile, rm, copyFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import Database from "better-sqlite3";
+import { resolveNaming } from "../src/library/naming.js";
+import { Importer } from "../src/library/importer.js";
+import { EventBusImpl } from "../src/events/event-bus.js";
+import { createLogger } from "../src/logging/logger.js";
+import { runMigrations, CORE_MIGRATIONS } from "../src/datastore/migrations.js";
+import type { NamingRule, ContentItemBase } from "@digitalpaws/starr-types-core";
+
+// ── Helpers ──────────────────────────────────────────────────────────
+
+function movieItem(overrides?: Partial<ContentItemBase>): any {
+  return {
+    contentTypeId: "starr-video/movie@1",
+    title: "Dune",
+    externalIds: { tmdb: "123", imdb: "tt123" },
+    ...overrides,
+  };
+}
+
+// ── Naming tests (Phase 1c) ─────────────────────────────────────────
+
+describe("resolveNaming", () => {
+  it("resolves default naming: {Title}/{Title}.{ext}", () => {
+    const rule: NamingRule = {
+      directory: [[{ type: "field", value: "Title" }]],
+      filename: [[{ type: "field", value: "Title" }]],
+    };
+    expect(resolveNaming(rule, movieItem(), "mkv")).toBe("Dune/Dune.mkv");
+  });
+
+  it("resolves multi-segment naming with year and quality", () => {
+    const rule: NamingRule = {
+      directory: [[{ type: "field", value: "Title" }, { type: "literal", value: " (" }, { type: "field", value: "Year" }, { type: "literal", value: ")" }]],
+      filename: [[{ type: "field", value: "Title" }, { type: "literal", value: " (" }, { type: "field", value: "Year" }, { type: "literal", value: ") [" }, { type: "field", value: "Quality" }, { type: "literal", value: "]" }]],
+    };
+    const item = movieItem({ fields: { Quality: "2160p" }, year: 2021 });
+    expect(resolveNaming(rule, item, "mkv")).toBe("Dune (2021)/Dune (2021) [2160p].mkv");
+  });
+
+  it("sanitises problematic characters", () => {
+    const item = movieItem({ title: 'Movie: The <Best> "Ever"' });
+    const rule: NamingRule = {
+      directory: [[{ type: "field", value: "Title" }]],
+      filename: [[{ type: "field", value: "Title" }]],
+    };
+    expect(resolveNaming(rule, item, "mp4")).toBe("Movie The Best Ever/Movie The Best Ever.mp4");
+  });
+
+  it("resolves external ids and ContentType", () => {
+    const rule: NamingRule = {
+      directory: [[{ type: "field", value: "ContentType" }]],
+      filename: [[{ type: "field", value: "tmdb" }]],
+    };
+    expect(resolveNaming(rule, movieItem(), "mkv")).toBe("starr-video/movie@1/123.mkv");
+  });
+});
+
+// ── Importer tests (real fs with temp dirs) ─────────────────────────
+
+let tmpDirBase: string;
+let counter = 0;
+
+beforeAll(async () => {
+  tmpDirBase = await mkdtemp(path.join(tmpdir(), "starr-library-test-"));
+});
+
+afterAll(async () => {
+  await rm(tmpDirBase, { recursive: true, force: true });
+});
+
+/**
+ * Set up a fresh test environment with:
+ * - In-memory SQLite database with migrations
+ * - Event bus
+ * - A temp download directory with a source file
+ * - A temp library root
+ * - A tracked request in "downloaded" state
+ */
+async function setup() {
+  const db = new Database(":memory:");
+  db.pragma("journal_mode = WAL");
+  db.pragma("foreign_keys = ON");
+  const logger = createLogger("test", "silent");
+  runMigrations(db, CORE_MIGRATIONS, logger);
+
+  const impl = new EventBusImpl(logger);
+  const coreBus = impl.coreBus();
+
+  // Temp directories unique per test
+  const n = ++counter;
+  const downloadDir = path.join(tmpDirBase, `download-${n}`);
+  const libraryRoot = path.join(tmpDirBase, `library-${n}`);
+  await mkdir(downloadDir, { recursive: true });
+  await mkdir(libraryRoot, { recursive: true });
+
+  // Create a source file
+  const sourceFile = path.join(downloadDir, "Dune.mkv");
+  await writeFile(sourceFile, "fake media content");
+
+  // Insert a tracked request
+  db.prepare(`INSERT INTO tracked_requests (request_id, content_type_id, content_identity, item, owner_user_id, status)
+    VALUES (?,?,?,?,?,?)`).run(
+    "req-001",
+    "starr-video/movie@1",
+    "starr-video/movie@1::tmdb=123",
+    JSON.stringify({ title: "Dune", contentTypeId: "starr-video/movie@1", externalIds: { tmdb: "123" } }),
+    "admin",
+    "downloaded",
+  );
+
+  const getConfig = () => ({
+    defaultLibraryRoot: libraryRoot,
+    roots: {} as Record<string, string>,
+    linkType: "copy" as const,
+    importSubtitles: false,
+    subtitleExtensions: ["srt"],
+  });
+  const getNamingRule = () => ({
+    directory: [[{ type: "field", value: "Title" }]],
+    filename: [[{ type: "field", value: "Title" }]],
+  } as NamingRule);
+
+  const importer = new Importer(db, coreBus, logger, getConfig, getNamingRule);
+
+  return { db, coreBus, importer, sourceFile, libraryRoot };
+}
+
+describe("Importer.import", () => {
+  it("successfully imports a file via copy", async () => {
+    const { importer, coreBus, sourceFile, libraryRoot } = await setup();
+    const events: string[] = [];
+    coreBus.on("import.started", () => events.push("import.started"));
+    coreBus.on("import.completed", () => events.push("import.completed"));
+
+    const result = await importer.import(
+      "req-001",
+      sourceFile,
+      { title: "Dune", contentTypeId: "starr-video/movie@1", externalIds: { tmdb: "123" } },
+      "starr-video/movie@1",
+      "mkv",
+      "starr-video/movie@1::tmdb=123",
+    );
+
+    expect(result.success).toBe(true);
+    expect(result.libraryPath).toBe(path.join(libraryRoot, "Dune", "Dune.mkv"));
+    expect(events).toContain("import.started");
+    expect(events).toContain("import.completed");
+  });
+
+  it("emits import.failed on error (non-existent source)", async () => {
+    const { importer, coreBus, libraryRoot } = await setup();
+    const events: string[] = [];
+    coreBus.on("import.failed", () => events.push("import.failed"));
+
+    const result = await importer.import(
+      "req-001",
+      "/nonexistent/path/file.mkv",
+      { title: "D", contentTypeId: "starr-video/movie@1", externalIds: { tmdb: "123" } },
+      "starr-video/movie@1",
+      "mkv",
+      "starr-video/movie@1::tmdb=123",
+    );
+
+    expect(result.success).toBe(false);
+    expect(result.error).toBeDefined();
+    expect(events).toContain("import.failed");
+  });
+
+  it("records library_path in the database", async () => {
+    const { importer, db, sourceFile, libraryRoot } = await setup();
+
+    await importer.import(
+      "req-001",
+      sourceFile,
+      { title: "Dune", contentTypeId: "starr-video/movie@1", externalIds: { tmdb: "123" } },
+      "starr-video/movie@1",
+      "mkv",
+      "starr-video/movie@1::tmdb=123",
+    );
+
+    const row = db.prepare("SELECT library_path FROM library_paths WHERE request_id = ?").get("req-001") as any;
+    expect(row).toBeDefined();
+    expect(row!.library_path).toBe(path.join(libraryRoot, "Dune", "Dune.mkv"));
+  });
+
+  it("creates the destination file on disk", async () => {
+    const { importer, sourceFile, libraryRoot } = await setup();
+
+    const result = await importer.import(
+      "req-001",
+      sourceFile,
+      { title: "Dune", contentTypeId: "starr-video/movie@1", externalIds: { tmdb: "123" } },
+      "starr-video/movie@1",
+      "mkv",
+      "starr-video/movie@1::tmdb=123",
+    );
+
+    expect(result.success).toBe(true);
+    // Verify the file actually exists
+    const { access } = await import("node:fs/promises");
+    await expect(access(result.libraryPath!)).resolves.toBeUndefined();
+  });
+});