@digitalpaws/starr 0.0.1

package/tests/e2e.test.ts

@@ -0,0 +1,430 @@
+// 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 { writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { randomBytes } from "node:crypto";
+
+import { runMigrations, CORE_MIGRATIONS } from "../src/datastore/migrations.js";
+import { openDatastore, type Datastore } from "../src/datastore/db.js";
+import { createLogger } from "../src/logging/logger.js";
+import { loadJwtSecret, resetJwtSecret } from "../src/auth/jwt-secret.js";
+import { AuthService } from "../src/auth/auth-service.js";
+import { Starr } from "../src/host.js";
+import { ConfigService } from "../src/config/config-service.js";
+import { StateStore } from "../src/state/state-store.js";
+import { loadPlugins, stopPlugins } from "../src/plugins/loader.js";
+
+import { createWebServer, initAuthService } from "../src/web/index.js";
+import { initAuthRoutes } from "../src/web/routes/auth.js";
+import { initConfigRoutes } from "../src/web/routes/config.js";
+import { initDiscoveryRoutes } from "../src/web/routes/discovery.js";
+import { initRequestRoutes } from "../src/web/routes/requests.js";
+import { initActivityRoutes } from "../src/web/routes/activity.js";
+import { initSseRoutes } from "../src/web/routes/sse.js";
+import { initContentTypeRoutes } from "../src/web/routes/content-types.js";
+import { initTraceStore } from "../src/state/trace-store.js";
+
+const logger = createLogger("test", "silent");
+
+/** Set up a temporary JWT secret for the test run. */
+function setupJwtSecret(tmpDir: string): void {
+  resetJwtSecret();
+  const keyPath = path.join(tmpDir, "starr.jwt");
+  const key = randomBytes(32).toString("base64") + "\n";
+  writeFileSync(keyPath, key, { mode: 0o600 });
+  loadJwtSecret(tmpDir, logger);
+}
+
+/** Write a fake plugin (JavaScript) into the temporary plugins directory. */
+async function writePlugin(
+  baseDir: string,
+  dirName: string,
+  code: string,
+): Promise<void> {
+  const dir = path.join(baseDir, dirName);
+  await mkdir(dir, { recursive: true });
+  await writeFile(
+    path.join(dir, "package.json"),
+    JSON.stringify({ type: "module", main: "./index.js" }),
+  );
+  await writeFile(path.join(dir, "index.js"), code);
+}
+
+/** Extract the starr_sid cookie value from a Set-Cookie header. */
+function extractCookie(setCookie: string | string[] | undefined): string | null {
+  if (!setCookie) return null;
+  const header = Array.isArray(setCookie) ? setCookie[0] : setCookie;
+  const match = header.match(/starr_sid=([^;]+)/);
+  return match ? match[1] : null;
+}
+
+// ── End-to-end acquisition flow ─────────────────────────────────────
+
+describe("end-to-end acquisition flow", () => {
+  let tmpDir: string;
+  let pluginsDir: string;
+  let datastore: Datastore;
+  let db: Database.Database;
+  let starr: Starr;
+  let webServer: Awaited<ReturnType<typeof createWebServer>>;
+  let cookie: string;
+
+  beforeAll(async () => {
+    tmpDir = await mkdtemp(path.join(tmpdir(), "starr-e2e-"));
+    pluginsDir = path.join(tmpDir, "plugins");
+    await mkdir(pluginsDir, { recursive: true });
+
+    // Fake metadata plugin: registers a movie type and responds to discovery.search
+    await writePlugin(
+      pluginsDir,
+      "fake-metadata",
+      `
+      export default function register(ctx) {
+        ctx.define({ id: "fake-metadata", version: "1.0.0", starrApiVersion: "^1.0.0" });
+        ctx.contentTypes.register({
+          id: "fake/movie@1",
+          name: "Fake Movie",
+          pluralName: "Fake Movies",
+          identity: ["tmdb"],
+          fields: [],
+          display: { primaryImageRole: "poster", subtitle: "releaseDate" },
+        });
+        ctx.events.on("discovery.search", async (event) => {
+          const { contentTypeIds } = event.payload;
+          if (!contentTypeIds || contentTypeIds.includes("fake/movie@1")) {
+            ctx.events.emit("discovery.results", {
+              contentTypeId: "fake/movie@1",
+              items: [{
+                contentTypeId: "fake/movie@1",
+                title: "End-to-End Movie",
+                externalIds: { tmdb: "99999" },
+                releaseDate: "2026-07-14",
+                search: { category: "movie", terms: ["End-to-End Movie"] },
+              }],
+            });
+          }
+        });
+      }
+      `,
+    );
+
+    // Fake duplicate-emitter plugin: registers a show type and emits discovery.results
+    // for the SAME contentTypeId TWICE (simulating the old OMDB bug pattern).
+    await writePlugin(
+      pluginsDir,
+      "fake-duplicate",
+      `
+      export default function register(ctx) {
+        ctx.define({ id: "fake-duplicate", version: "1.0.0", starrApiVersion: "^1.0.0" });
+        ctx.contentTypes.register({
+          id: "fake/show@1",
+          name: "Fake Show",
+          pluralName: "Fake Shows",
+          identity: ["tmdb"],
+          fields: [],
+          display: { primaryImageRole: "poster", subtitle: "releaseDate" },
+        });
+        ctx.events.on("discovery.search", async (event) => {
+          const { contentTypeIds } = event.payload;
+          if (!contentTypeIds || contentTypeIds.includes("fake/show@1")) {
+            // First emission — basic show
+            ctx.events.emit("discovery.results", {
+              contentTypeId: "fake/show@1",
+              items: [{
+                contentTypeId: "fake/show@1",
+                title: "Fake Show",
+                externalIds: { tmdb: "88888" },
+                releaseDate: "2026-01-01",
+                search: { category: "tv", terms: ["Fake Show"] },
+              }],
+            });
+            // Second emission — same contentTypeId, same externalIds (DUPLICATE!)
+            ctx.events.emit("discovery.results", {
+              contentTypeId: "fake/show@1",
+              items: [{
+                contentTypeId: "fake/show@1",
+                title: "Fake Show (enriched)",
+                externalIds: { tmdb: "88888" },
+                releaseDate: "2026-01-01",
+                search: { category: "tv", terms: ["Fake Show"] },
+              }],
+            });
+          }
+        });
+      }
+      `,
+    );
+
+    // Fake indexer plugin: emits a release.found for every content.requested
+    await writePlugin(
+      pluginsDir,
+      "fake-indexer",
+      `
+      export default function register(ctx) {
+        ctx.define({ id: "fake-indexer", version: "1.0.0", starrApiVersion: "^1.0.0" });
+        ctx.events.on("content.requested", async (event) => {
+          const { requestId, item } = event.payload;
+          ctx.events.emit("release.found", {
+            requestId,
+            contentTypeId: item.contentTypeId,
+            release: {
+              id: "release-1",
+              indexerId: "fake-indexer",
+              title: "End-to-End Release",
+              protocol: "torrent",
+              downloadUri: "magnet:?xt=urn:btih:e2e",
+              sizeBytes: 1073741824,
+              seeders: 42,
+            },
+          });
+        });
+      }
+      `,
+    );
+
+    // Fake selection plugin: immediately picks the first release
+    await writePlugin(
+      pluginsDir,
+      "fake-selection",
+      `
+      export default function register(ctx) {
+        ctx.define({ id: "fake-selection", version: "1.0.0", starrApiVersion: "^1.0.0" });
+        ctx.events.on("release.found", async (event) => {
+          const { requestId, release } = event.payload;
+          ctx.events.emit("release.chosen", { requestId, release });
+        });
+      }
+      `,
+    );
+
+    // Fake downloader plugin: immediately completes any chosen release
+    await writePlugin(
+      pluginsDir,
+      "fake-downloader",
+      `
+      export default function register(ctx) {
+        ctx.define({ id: "fake-downloader", version: "1.0.0", starrApiVersion: "^1.0.0" });
+        ctx.events.on("release.chosen", async (event) => {
+          const { requestId, release } = event.payload;
+          ctx.events.emit("download.started", { requestId, release });
+          ctx.events.emit("download.completed", {
+            requestId,
+            release,
+            location: "/downloads/e2e",
+          });
+        });
+      }
+      `,
+    );
+
+    datastore = openDatastore(path.join(tmpDir, "data"), logger);
+    db = datastore.db;
+    runMigrations(db, CORE_MIGRATIONS, logger);
+    setupJwtSecret(tmpDir);
+    process.env.STARR_DISCOVERY_WINDOW_MS = "200";
+
+    starr = new Starr({ pluginsDir, apiVersion: "1.0.0", logger });
+    starr.datastore = datastore;
+
+    const configService = new ConfigService(
+      db,
+      logger.child("config"),
+      async (pluginId: string) => {
+        const { reloadPlugin } = await import("../src/plugins/loader.js");
+        await reloadPlugin(starr, pluginId);
+      },
+    );
+    starr.configService = configService;
+
+    const stateStore = new StateStore(db, starr.coreBus, logger);
+    starr.stateStore = stateStore;
+
+    const authService = new AuthService(db, logger.child("auth"));
+
+    webServer = await createWebServer(logger.child("web"));
+    starr.webServer = webServer;
+
+    initAuthService(authService);
+    initAuthRoutes(authService);
+    initConfigRoutes(configService);
+    initTraceStore(stateStore);
+
+    await loadPlugins(starr);
+
+    initContentTypeRoutes(
+      () => starr.contentTypeRegistry.list(),
+      (id: string) => starr.contentTypeRegistry.get(id),
+    );
+    initDiscoveryRoutes(starr.coreBus);
+    initRequestRoutes(starr);
+    initActivityRoutes(starr);
+    initSseRoutes(starr.coreBus);
+
+    await webServer.listen({ port: 0, host: "127.0.0.1" });
+
+    // First-run setup
+    const setupRes = await webServer.inject({
+      method: "POST",
+      url: "/api/auth/setup",
+      payload: { username: "admin", password: "hunter2hunter2" },
+    });
+    expect(setupRes.statusCode).toBe(200);
+    cookie = extractCookie(setupRes.headers["set-cookie"]) ?? "";
+    expect(cookie).toBeTruthy();
+  }, 60_000);
+
+  afterAll(async () => {
+    if (starr) {
+      await stopPlugins(starr);
+    }
+    if (webServer) {
+      await webServer.close();
+    }
+    if (datastore) {
+      datastore.close();
+    }
+    if (tmpDir) {
+      await rm(tmpDir, { recursive: true, force: true });
+    }
+  }, 30_000);
+
+  it("discovers content via GET /api/discovery/search", async () => {
+    const res = await webServer.inject({
+      method: "GET",
+      url: "/api/discovery/search?q=e2e&type=fake/movie@1",
+      headers: { cookie: `starr_sid=${cookie}` },
+    });
+
+    expect(res.statusCode).toBe(200);
+    const body = JSON.parse(res.body);
+    expect(body.items).toHaveLength(1);
+    expect(body.items[0].contentTypeId).toBe("fake/movie@1");
+    expect(body.items[0].title).toBe("End-to-End Movie");
+  });
+
+  it("discovers content without a type filter (All tab)", async () => {
+    const res = await webServer.inject({
+      method: "GET",
+      url: "/api/discovery/search?q=e2e",  // no &type= parameter
+      headers: { cookie: `starr_sid=${cookie}` },
+    });
+
+    expect(res.statusCode).toBe(200);
+    const body = JSON.parse(res.body);
+    // Both fake-metadata and fake-duplicate plugins respond when
+    // contentTypeIds is undefined (no type filter = "All" tab).
+    // The ordering depends on handler registration; just verify the
+    // expected movie is present among the results.
+    expect(body.items.length).toBeGreaterThanOrEqual(1);
+    expect(body.items.some((i: any) => i.title === "End-to-End Movie")).toBe(true);
+  });
+
+  it("detects duplicate items in search results (duplicate-emitter plugin)", async () => {
+    const res = await webServer.inject({
+      method: "GET",
+      url: "/api/discovery/search?q=fake&type=fake/show@1",
+      headers: { cookie: `starr_sid=${cookie}` },
+    });
+
+    expect(res.statusCode).toBe(200);
+    const body = JSON.parse(res.body);
+
+    // The fake-duplicate plugin emits TWO items with the same contentTypeId
+    // and externalIds. The route collector does NOT deduplicate, so both
+    // items should appear in the response.
+    expect(body.items.length).toBe(2);
+
+    // Both items should have the same identity key (contentTypeId + first externalId)
+    const keys = body.items.map((item: any) => {
+      const ext = Object.values(item.externalIds ?? {})[0] ?? "";
+      return `${item.contentTypeId}::${ext}`;
+    });
+    expect(keys[0]).toBe(keys[1]);
+
+    // This is the exact condition the Browse.svelte dev warning would catch:
+    // duplicate itemKey() values indicate a rendering problem.
+    const uniqueKeys = new Set(keys);
+    expect(uniqueKeys.size).toBeLessThan(keys.length);
+    expect(uniqueKeys.size).toBe(1);
+
+    // The client-side allowedTypes filter in Browse.svelte would keep both
+    // (both have contentTypeId "fake/show@1", which is in allowedTypes),
+    // confirming the frontend would receive duplicate keys.
+    const allowedTypes = ["starr-video/movie@1", "starr-video/show@1", "fake/show@1"];
+    const filtered = body.items.filter((item: any) =>
+      allowedTypes.includes(item.contentTypeId)
+    );
+    expect(filtered.length).toBe(2);
+  });
+
+  it("requests content and reaches terminal downloaded status", async () => {
+    const item = {
+      contentTypeId: "fake/movie@1",
+      title: "End-to-End Movie",
+      externalIds: { tmdb: "99999" },
+      releaseDate: "2026-07-14",
+      search: { category: "movie", terms: ["End-to-End Movie"] },
+    };
+
+    const createRes = await webServer.inject({
+      method: "POST",
+      url: "/api/requests",
+      headers: { cookie: `starr_sid=${cookie}` },
+      payload: item,
+    });
+
+    expect(createRes.statusCode).toBe(201);
+    const { requestId } = JSON.parse(createRes.body);
+    expect(requestId).toBeTruthy();
+
+    // Poll the request endpoint until the status becomes terminal.
+    let status = "requested";
+    for (let i = 0; i < 50; i++) {
+      const res = await webServer.inject({
+        method: "GET",
+        url: `/api/requests/${requestId}`,
+        headers: { cookie: `starr_sid=${cookie}` },
+      });
+      expect(res.statusCode).toBe(200);
+      const req = JSON.parse(res.body);
+      status = req.status;
+      if (status === "downloaded" || status === "failed") break;
+      await new Promise((r) => setTimeout(r, 50));
+    }
+
+    expect(status).toBe("downloaded");
+
+    // Verify the trace log captured the full spine chain.
+    const activityRes = await webServer.inject({
+      method: "GET",
+      url: `/api/requests/${requestId}/activity`,
+      headers: { cookie: `starr_sid=${cookie}` },
+    });
+    expect(activityRes.statusCode).toBe(200);
+    const { events } = JSON.parse(activityRes.body);
+    const types = events.map((e: { eventType: string }) => e.eventType);
+    expect(types).toContain("release.found");
+    expect(types).toContain("download.started");
+    expect(types).toContain("download.completed");
+
+    // All captured events share the same traceId.
+    const traceIds = new Set(events.map((e: { traceId: string }) => e.traceId));
+    expect(traceIds.size).toBe(1);
+  });
+
+  it("lists tracked requests for the authenticated user", async () => {
+    const res = await webServer.inject({
+      method: "GET",
+      url: "/api/requests",
+      headers: { cookie: `starr_sid=${cookie}` },
+    });
+    expect(res.statusCode).toBe(200);
+    const body = JSON.parse(res.body);
+    expect(body.requests.length).toBeGreaterThan(0);
+    expect(body.requests[0].ownerUserId).toBe("admin");
+  });
+});