@digitalpaws/starr 0.0.1

package/tests/scan-controller.test.ts

@@ -0,0 +1,328 @@
+// SPDX-License-Identifier: 0BSD
+// SPDX-FileCopyrightText: 2025 Digi <digitalpaws@proton.me>
+
+import { describe, it, expect, vi, 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 { MetadataMatcher } from "../src/library/metadata-matcher.js";
+import { ScanController } from "../src/library/scan-controller.js";
+import { LibraryCache } from "../src/library/library-cache.js";
+import { EventBusImpl } from "../src/events/event-bus.js";
+import { ContentTypeRegistryImpl } from "../src/content-types/registry.js";
+import type { LibraryConfig } from "../src/library/library-config.js";
+import type { ContentItemBase } from "@digitalpaws/starr-types-core";
+
+let tmpDir: string;
+
+beforeAll(async () => {
+  tmpDir = await mkdtemp(path.join(tmpdir(), "starr-scan-ctrl-test-"));
+});
+
+afterAll(async () => {
+  await rm(tmpDir, { recursive: true, force: true });
+});
+
+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);
+
+  // Create library structure with unique subdir per test call
+  const moviesDir = path.join(tmpDir, `Movies-${Math.random().toString(36).slice(2, 8)}`);
+  const duneDir = path.join(moviesDir, "Dune (2021)");
+  mkdirSync(moviesDir, { recursive: true });
+  mkdirSync(duneDir, { recursive: true });
+  writeFileSync(path.join(duneDir, "Dune (2021) [2160p].mkv"), "content");
+
+  const getConfig = (): LibraryConfig => ({
+    defaultLibraryRoot: moviesDir,
+    roots: { "starr-video/movie@1": moviesDir },
+    linkType: "copy",
+    importSubtitles: false,
+    subtitleExtensions: [],
+  });
+
+  const impl = new EventBusImpl(logger);
+  const coreBus = impl.coreBus();
+  const registry = new ContentTypeRegistryImpl();
+  registry.register({
+    id: "starr-video/movie@1",
+    name: "Movie",
+    identity: ["tmdb", "imdb"],
+    fields: [],
+  });
+
+  const scanner = new LibraryScanner(db, logger, getConfig);
+  const matcher = new MetadataMatcher(coreBus, registry, logger, 100); // short timeout for tests
+  const cache = new LibraryCache(db, coreBus, logger);
+
+  const controller = new ScanController(
+    scanner,
+    matcher,
+    db,
+    coreBus,
+    logger,
+    cache,
+    registry,
+    getConfig,
+    1, // concurrency = 1 for deterministic tests
+  );
+
+  return { db, coreBus, controller, registry, moviesDir };
+}
+
+// Need sync versions for setup
+import { mkdirSync, writeFileSync } from "node:fs";
+
+describe("ScanController", () => {
+  it("starts a scan and returns scanId", async () => {
+    const { controller } = setup();
+    const scanId = controller.startScan();
+    expect(scanId).toBeDefined();
+    expect(typeof scanId).toBe("string");
+
+    // Give the scan time to discover groups (sync part happens first tick)
+    const state = controller.getScan(scanId);
+    expect(state).toBeDefined();
+    expect(state!.scanId).toBe(scanId);
+  });
+
+  it("returns scan progress with candidates", { timeout: 15_000 }, async () => {
+    const { controller } = setup();
+    const scanId = controller.startScan();
+
+    // Wait for scan to complete
+    await vi.waitFor(
+      () => {
+        const state = controller.getScan(scanId);
+        expect(state?.status).toBe("complete");
+      },
+      { timeout: 15_000, interval: 500 },
+    );
+
+    const state = controller.getScan(scanId)!;
+    expect(state.progress.total).toBeGreaterThanOrEqual(1);
+    expect(state.candidates.length).toBeGreaterThanOrEqual(1);
+    expect(state.candidates[0].directory).toContain("Dune (2021)");
+  });
+
+  it("imports accepted candidates into the library", { timeout: 15_000 }, async () => {
+    const { controller, db } = setup();
+    const scanId = controller.startScan();
+
+    // Wait for scan to complete
+    await vi.waitFor(
+      () => {
+        const state = controller.getScan(scanId);
+        expect(state?.status).toBe("complete");
+      },
+      { timeout: 15_000, interval: 500 },
+    );
+
+    const state = controller.getScan(scanId)!;
+    const candidateIds = state.candidates
+      .filter((c) => c.status === "matched" || c.status === "no-match")
+      .map((c) => c.id);
+
+    if (candidateIds.length > 0) {
+      const result = controller.importCandidates(scanId, candidateIds);
+      expect(result.imported).toBeGreaterThanOrEqual(1);
+
+      // Check that tracked_requests has the new entry
+      const row = db
+        .prepare("SELECT status, library_path FROM tracked_requests WHERE content_identity LIKE ?")
+        .get(`%Dune%`) as any;
+      expect(row).toBeDefined();
+      expect(row.status).toBe("downloaded");
+    }
+  });
+
+  it("returns empty result for unknown scanId", () => {
+    const { controller } = setup();
+    const result = controller.importCandidates("nonexistent", ["candidate-1"]);
+    expect(result.imported).toBe(0);
+    expect(result.failed).toBe(0);
+  });
+
+  it("cancelScan returns false for unknown scanId", () => {
+    const { controller } = setup();
+    const result = controller.cancelScan("nonexistent");
+    expect(result).toBe(false);
+  });
+
+  it("candidates have matches array after scan completes", { timeout: 15_000 }, async () => {
+    const { controller, coreBus } = setup();
+
+    // Register a mock metadata plugin so matches are found
+    coreBus.on("discovery.search", (event: any) => {
+      coreBus.emit("discovery.results", {
+        contentTypeId: "starr-video/movie@1",
+        items: [
+          {
+            contentTypeId: "starr-video/movie@1",
+            title: "Dune",
+            releaseDate: "2021-10-22",
+            externalIds: { tmdb: "438631" },
+            images: [],
+          },
+        ],
+      });
+    });
+
+    const scanId = controller.startScan();
+
+    await vi.waitFor(
+      () => {
+        const state = controller.getScan(scanId);
+        expect(state?.status).toBe("complete");
+      },
+      { timeout: 15_000, interval: 500 },
+    );
+
+    const state = controller.getScan(scanId)!;
+    const candidate = state.candidates[0];
+    expect(candidate).toBeDefined();
+    expect(Array.isArray(candidate.matches)).toBe(true);
+    expect(candidate.matches.length).toBeGreaterThanOrEqual(1);
+    expect(candidate.selectedMatchIndex).toBe(0);
+    expect(candidate.matches[0].item.title).toBe("Dune");
+  });
+
+  it("selectMatch changes the selected match index", { timeout: 15_000 }, async () => {
+    const { controller, coreBus } = setup();
+
+    // Register a mock metadata plugin returning multiple results
+    coreBus.on("discovery.search", (event: any) => {
+      coreBus.emit("discovery.results", {
+        contentTypeId: "starr-video/movie@1",
+        items: [
+          {
+            contentTypeId: "starr-video/movie@1",
+            title: "Dune",
+            releaseDate: "2021-10-22",
+            externalIds: { tmdb: "438631" },
+            images: [],
+          },
+          {
+            contentTypeId: "starr-video/movie@1",
+            title: "Dune: Part Two",
+            releaseDate: "2024-03-01",
+            externalIds: { tmdb: "693134" },
+            images: [],
+          },
+        ],
+      });
+    });
+
+    const scanId = controller.startScan();
+
+    await vi.waitFor(
+      () => {
+        const state = controller.getScan(scanId);
+        expect(state?.status).toBe("complete");
+      },
+      { timeout: 15_000, interval: 500 },
+    );
+
+    const state = controller.getScan(scanId)!;
+    const candidateId = state.candidates[0].id;
+
+    // Select the second match
+    const ok = controller.selectMatch(scanId, candidateId, 1);
+    expect(ok).toBe(true);
+
+    const updated = controller.getScan(scanId)!;
+    const candidate = updated.candidates[0];
+    expect(candidate.selectedMatchIndex).toBe(1);
+    expect(candidate.matches[1].item.title).toBe("Dune: Part Two");
+  });
+
+  it("selectMatch rejects out-of-range index", { timeout: 15_000 }, async () => {
+    const { controller, coreBus } = setup();
+
+    coreBus.on("discovery.search", (event: any) => {
+      coreBus.emit("discovery.results", {
+        contentTypeId: "starr-video/movie@1",
+        items: [
+          {
+            contentTypeId: "starr-video/movie@1",
+            title: "Dune",
+            releaseDate: "2021-10-22",
+            externalIds: { tmdb: "438631" },
+            images: [],
+          },
+        ],
+      });
+    });
+
+    const scanId = controller.startScan();
+
+    await vi.waitFor(
+      () => {
+        const state = controller.getScan(scanId);
+        expect(state?.status).toBe("complete");
+      },
+      { timeout: 15_000, interval: 500 },
+    );
+
+    const state = controller.getScan(scanId)!;
+    const candidateId = state.candidates[0].id;
+
+    // Out-of-range index should fail
+    const ok = controller.selectMatch(scanId, candidateId, 99);
+    expect(ok).toBe(false);
+  });
+
+  it("searchCandidate updates matches list", { timeout: 15_000 }, async () => {
+    const { controller, coreBus } = setup();
+
+    // No metadata plugin for initial scan — will get no matches
+    const scanId = controller.startScan();
+
+    await vi.waitFor(
+      () => {
+        const state = controller.getScan(scanId);
+        expect(state?.status).toBe("complete");
+      },
+      { timeout: 15_000, interval: 500 },
+    );
+
+    let state = controller.getScan(scanId)!;
+    const candidateId = state.candidates[0].id;
+
+    // Initial state: no matches
+    expect(state.candidates[0].matches.length).toBe(0);
+
+    // Now register a metadata plugin and run custom search
+    coreBus.on("discovery.search", (event: any) => {
+      coreBus.emit("discovery.results", {
+        contentTypeId: "starr-video/movie@1",
+        items: [
+          {
+            contentTypeId: "starr-video/movie@1",
+            title: "Dune",
+            releaseDate: "2021-10-22",
+            externalIds: { tmdb: "438631" },
+            images: [],
+          },
+        ],
+      });
+    });
+
+    const ok = await controller.searchCandidate(scanId, candidateId, "Dune 2021");
+    expect(ok).toBe(true);
+
+    state = controller.getScan(scanId)!;
+    const candidate = state.candidates[0];
+    expect(candidate.matches.length).toBeGreaterThanOrEqual(1);
+    expect(candidate.matches[0].item.title).toBe("Dune");
+    expect(candidate.status).toBe("matched");
+  });
+});

package/tests/source-resolver.test.ts

@@ -0,0 +1,100 @@
+// 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 { resolveSourcePath } from "../src/library/source-resolver.js";
+
+let tmpDir: string;
+
+beforeAll(async () => {
+  tmpDir = await mkdtemp(path.join(tmpdir(), "starr-source-resolver-"));
+});
+
+afterAll(async () => {
+  await rm(tmpDir, { recursive: true, force: true });
+});
+
+describe("resolveSourcePath", () => {
+  it("resolves a single file path", async () => {
+    const filePath = path.join(tmpDir, "test.mkv");
+    await writeFile(filePath, "content");
+
+    const result = await resolveSourcePath(`qbittorrent:${filePath}`);
+    expect(result.files).toHaveLength(1);
+    expect(result.files[0]).toBe(filePath);
+    expect(result.sourceDir).toBe(tmpDir);
+  });
+
+  it("resolves a directory by scanning for media files", async () => {
+    const mediaDir = path.join(tmpDir, "multi");
+    await mkdir(mediaDir, { recursive: true });
+    await writeFile(path.join(mediaDir, "movie.mkv"), "movie");
+    await writeFile(path.join(mediaDir, "sample.mp4"), "sample");
+    await writeFile(path.join(mediaDir, "info.nfo"), "info"); // non-media, skipped
+
+    const result = await resolveSourcePath(`qbittorrent:${mediaDir}`);
+    expect(result.files).toHaveLength(2);
+    expect(result.files).toContain(path.join(mediaDir, "movie.mkv"));
+    expect(result.files).toContain(path.join(mediaDir, "sample.mp4"));
+    expect(result.sourceDir).toBe(mediaDir);
+  });
+
+  it("throws when location is not provided", async () => {
+    await expect(resolveSourcePath(undefined)).rejects.toThrow(
+      "no location provided",
+    );
+  });
+
+  it("throws when path does not exist", async () => {
+    await expect(
+      resolveSourcePath(`protocol:/nonexistent/path/file.mkv`),
+    ).rejects.toThrow("Cannot access source path");
+  });
+
+  it("handles protocol-prefixed and non-prefixed paths", async () => {
+    const filePath = path.join(tmpDir, "noprefix.mkv");
+    await writeFile(filePath, "content");
+
+    // With protocol prefix
+    const result1 = await resolveSourcePath(`qbittorrent:${filePath}`);
+    expect(result1.files).toHaveLength(1);
+
+    // Without protocol prefix
+    const result2 = await resolveSourcePath(filePath);
+    expect(result2.files).toHaveLength(1);
+  });
+
+  it("skips hidden directories and Extras/Sample folders", async () => {
+    const mediaDir = path.join(tmpDir, "skips");
+    await mkdir(mediaDir, { recursive: true });
+    await writeFile(path.join(mediaDir, "main.mkv"), "main");
+
+    // Hidden dir
+    const hiddenDir = path.join(mediaDir, ".hidden");
+    await mkdir(hiddenDir, { recursive: true });
+    await writeFile(path.join(hiddenDir, "hidden.mkv"), "hidden");
+
+    // Extras dir
+    const extrasDir = path.join(mediaDir, "Extras");
+    await mkdir(extrasDir, { recursive: true });
+    await writeFile(path.join(extrasDir, "extra.mkv"), "extra");
+
+    const result = await resolveSourcePath(`qbittorrent:${mediaDir}`);
+    // Should only find main.mkv, not hidden/extra
+    expect(result.files).toHaveLength(1);
+    expect(result.files[0]).toBe(path.join(mediaDir, "main.mkv"));
+  });
+
+  it("throws when a directory has no media files", async () => {
+    const emptyDir = path.join(tmpDir, "empty");
+    await mkdir(emptyDir, { recursive: true });
+    await writeFile(path.join(emptyDir, "readme.txt"), "not media");
+
+    await expect(
+      resolveSourcePath(`qbittorrent:${emptyDir}`),
+    ).rejects.toThrow("No media files found in directory");
+  });
+});

package/tests/starr-video-integration.test.ts

@@ -0,0 +1,153 @@
+// SPDX-License-Identifier: 0BSD
+// SPDX-FileCopyrightText: 2025 Digi <digitalpaws@proton.me>
+
+import { describe, it, expect, beforeAll, afterAll } from "vitest";
+import Database from "better-sqlite3";
+import { runMigrations, CORE_MIGRATIONS } from "../src/datastore/migrations.js";
+import { createLogger } from "../src/logging/logger.js";
+import { createContext } from "../src/plugins/context.js";
+import { Starr } from "../src/host.js";
+import {
+  ContentTypeRegistryImpl,
+  computeContentIdentity,
+  areSameItem,
+} from "../src/content-types/registry.js";
+
+// Import the real descriptors to test them end-to-end
+// (types-only; the plugin module imports at compile time)
+import type { ContentTypeDescriptor } from "@digitalpaws/starr-types-core";
+import type { Movie, Show, Season, Episode } from "@digitalpaws/starr-types-video";
+
+describe("starr-video integration", () => {
+  let db: Database.Database;
+  let registry: ContentTypeRegistryImpl;
+
+  beforeAll(() => {
+    db = new Database(":memory:");
+    db.pragma("journal_mode = WAL");
+    db.pragma("foreign_keys = ON");
+    runMigrations(db, CORE_MIGRATIONS, createLogger("test", "silent"));
+    registry = new ContentTypeRegistryImpl();
+  });
+
+  afterAll(() => {
+    db.close();
+  });
+
+  // ── 3.2.1 ── All four descriptors register without errors
+
+  it("accepts all four starr-video descriptors", () => {
+    const descriptors: ContentTypeDescriptor[] = [
+      {
+        id: "starr-video/movie@1",
+        name: "Movie",
+        pluralName: "Movies",
+        icon: "film",
+        identity: ["tmdb", "imdb"],
+        fields: [
+          { key: "genres", label: "Genres", type: "list", itemType: "string", group: "Details", order: 10 },
+          { key: "studio", label: "Studio", type: "string", group: "Details", order: 20 },
+          { key: "releaseStatus", label: "Status", type: "string", group: "Details", order: 30 },
+        ],
+        display: { primaryImageRole: "poster", subtitle: "releaseDate" },
+      },
+      {
+        id: "starr-video/show@1",
+        name: "TV Show",
+        pluralName: "TV Shows",
+        icon: "tv",
+        identity: ["tmdb"],
+        fields: [
+          { key: "genres", label: "Genres", type: "list", itemType: "string", group: "Details", order: 10 },
+          { key: "firstAirDate", label: "First Aired", type: "date", group: "Details", order: 20 },
+          { key: "lastAirDate", label: "Last Aired", type: "date", group: "Details", order: 30 },
+          { key: "status", label: "Status", type: "string", group: "Details", order: 40 },
+        ],
+        display: { primaryImageRole: "poster", subtitle: "fields.firstAirDate" },
+      },
+      {
+        id: "starr-video/season@1",
+        name: "Season",
+        pluralName: "Seasons",
+        icon: "layers",
+        identity: ["tmdb"],
+        fields: [
+          { key: "seasonNumber", label: "Season No.", type: "number", group: "Details", order: 10 },
+          { key: "episodeCount", label: "Episodes", type: "number", group: "Details", order: 20 },
+          { key: "firstAirDate", label: "First Aired", type: "date", group: "Details", order: 30 },
+        ],
+        display: { primaryImageRole: "poster", subtitle: "fields.seasonNumber" },
+      },
+      {
+        id: "starr-video/episode@1",
+        name: "Episode",
+        pluralName: "Episodes",
+        icon: "play",
+        identity: ["tmdb"],
+        fields: [
+          { key: "seasonNumber", label: "Season No.", type: "number", group: "Details", order: 10 },
+          { key: "episodeNumber", label: "Episode No.", type: "number", group: "Details", order: 20 },
+          { key: "airDate", label: "Air Date", type: "date", group: "Details", order: 30 },
+        ],
+        display: { primaryImageRole: "thumbnail", subtitle: "fields.episodeNumber" },
+      },
+    ];
+
+    for (const desc of descriptors) {
+      expect(() => registry.register(desc, "starr-video")).not.toThrow();
+    }
+
+    expect(registry.list()).toHaveLength(4);
+  });
+
+  // ── 3.2.2 ── Content identity for TV hierarchy
+
+  it("identifies a season by its tmdb id", () => {
+    const seasonItem = {
+      contentTypeId: "starr-video/season@1",
+      externalIds: { tmdb: "3624" },
+    };
+    const identity = computeContentIdentity(seasonItem, registry);
+    expect(identity).toBe("starr-video/season@1::tmdb=3624");
+  });
+
+  it("identifies a movie with tmdb primary, imdb fallback", () => {
+    const movieWithImdb = {
+      contentTypeId: "starr-video/movie@1",
+      externalIds: { imdb: "tt1160419" },
+    };
+    const identity = computeContentIdentity(movieWithImdb, registry);
+    // tmdb key is first in identity array but absent → falls to imdb
+    expect(identity).toBe("starr-video/movie@1::imdb=tt1160419");
+  });
+
+  it("treats different contentTypeIds as not same (ID2)", () => {
+    const movie = {
+      contentTypeId: "starr-video/movie@1",
+      externalIds: { tmdb: "438631" },
+    };
+    const show = {
+      contentTypeId: "starr-video/show@1",
+      externalIds: { tmdb: "438631" },  // same tmdb, different type
+    };
+    expect(areSameItem(movie, show, registry)).toBe(false);
+  });
+
+  // ── 3.2.3 ── All descriptors pass host validation
+
+  it("all descriptors have non-empty identity", () => {
+    for (const desc of registry.list()) {
+      expect(desc.identity.length).toBeGreaterThan(0);
+    }
+  });
+
+  it("season and episode have a parent relationship (by convention)", () => {
+    // The descriptor doesn't enforce parent; producers must set it.
+    // This test documents the expectation.
+    const season = registry.get("starr-video/season@1")!;
+    const episode = registry.get("starr-video/episode@1")!;
+    expect(season.id).toBe("starr-video/season@1");
+    expect(episode.id).toBe("starr-video/episode@1");
+    // Both exist — their items should carry parent at runtime.
+  });
+});