@digitalpaws/starr 0.0.1

package/tests/config-route.test.ts

@@ -0,0 +1,345 @@
+// SPDX-License-Identifier: 0BSD
+// SPDX-FileCopyrightText: 2025 Digi <digitalpaws@proton.me>
+
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import Database from "better-sqlite3";
+import Fastify from "fastify";
+import { mkdtempSync, existsSync, unlinkSync, rmdirSync } from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import type { FastifyInstance } from "fastify";
+
+import { runMigrations, CORE_MIGRATIONS } from "../src/datastore/migrations.js";
+import { loadEncryptionKey, resetEncryptionKey } from "../src/datastore/encrypt.js";
+import { ConfigService, SECRET_UNCHANGED_SENTINEL } from "../src/config/config-service.js";
+import { initConfigRoutes, default as configRoutes } from "../src/web/routes/config.js";
+import { createLogger } from "../src/logging/logger.js";
+import type { ConfigSchema } from "../src/types/plugin.js";
+import type { PluginRuntime } from "../src/host.js";
+
+// ── Helpers ────────────────────────────────────────────────────────────
+
+const testLogger = createLogger("test", "silent");
+
+function createTestDb(): Database.Database {
+  const db = new Database(":memory:");
+  db.pragma("journal_mode = WAL");
+  db.pragma("foreign_keys = ON");
+  return db;
+}
+
+interface MockRuntimeOpts {
+  hasTestConnection?: boolean;
+}
+
+function createMockRuntime(
+  pluginId: string,
+  opts: MockRuntimeOpts = {},
+): PluginRuntime {
+  return {
+    meta: { id: pluginId, version: "1.0.0", starrApiVersion: "^1.0.0" },
+    lifecycle: {
+      testConnection: opts.hasTestConnection
+        ? async (values: Record<string, unknown>) => {
+            const endpoint = String(values.endpoint ?? "");
+            const apiKey = String(values.apiKey ?? "");
+            if (!endpoint || !apiKey) {
+              return { ok: false, message: "Missing fields" };
+            }
+            return { ok: true, message: "Test passed" };
+          }
+        : undefined,
+    },
+    startOrder: 0,
+  };
+}
+
+// ── Test helper: inject an admin user for routes that require auth ──
+
+function injectAdminUser(app: FastifyInstance): void {
+  app.addHook("onRequest", async (request) => {
+    (request as any).user = {
+      id: "admin",
+      username: "admin",
+      role: "admin",
+    };
+  });
+}
+
+// ── Tests ──────────────────────────────────────────────────────────────
+
+describe("Config Route — GET /api/config/:pluginId (supportsTest)", () => {
+  let db: Database.Database;
+  let dataDir: string;
+  let cs: ConfigService;
+  let app: FastifyInstance;
+
+  beforeEach(async () => {
+    db = createTestDb();
+    runMigrations(db, CORE_MIGRATIONS, testLogger);
+    dataDir = mkdtempSync(path.join(tmpdir(), "starr-config-route-"));
+    resetEncryptionKey();
+    loadEncryptionKey(dataDir, testLogger);
+
+    cs = new ConfigService(db, testLogger);
+
+    // Register a plugin schema
+    const schema: ConfigSchema<{ endpoint: string; apiKey: string }> = {
+      endpoint: { type: "url", label: "Endpoint", required: true },
+      apiKey: { type: "secret", label: "API Key", required: true },
+    };
+    cs.register("test-plugin", schema);
+
+    app = Fastify({ logger: false });
+    injectAdminUser(app);
+  });
+
+  afterEach(async () => {
+    await app.close();
+    db.close();
+    try {
+      const keyPath = path.join(dataDir, "starr.key");
+      if (existsSync(keyPath)) unlinkSync(keyPath);
+      rmdirSync(dataDir);
+    } catch {
+      // ignore
+    }
+    resetEncryptionKey();
+  });
+
+  it("returns supportsTest: true when runtime has testConnection", async () => {
+    const runtimes = [createMockRuntime("test-plugin", { hasTestConnection: true })];
+    initConfigRoutes(cs, () => runtimes);
+    await app.register(configRoutes);
+
+    const res = await app.inject({
+      method: "GET",
+      url: "/api/config/test-plugin",
+    });
+
+    expect(res.statusCode).toBe(200);
+    const body = JSON.parse(res.body);
+    expect(body.supportsTest).toBe(true);
+  });
+
+  it("returns supportsTest: false when runtime lacks testConnection", async () => {
+    const runtimes = [createMockRuntime("test-plugin", { hasTestConnection: false })];
+    initConfigRoutes(cs, () => runtimes);
+    await app.register(configRoutes);
+
+    const res = await app.inject({
+      method: "GET",
+      url: "/api/config/test-plugin",
+    });
+
+    expect(res.statusCode).toBe(200);
+    const body = JSON.parse(res.body);
+    expect(body.supportsTest).toBe(false);
+  });
+
+  it("returns supportsTest: false when no runtime found", async () => {
+    const runtimes: PluginRuntime[] = [];
+    initConfigRoutes(cs, () => runtimes);
+    await app.register(configRoutes);
+
+    const res = await app.inject({
+      method: "GET",
+      url: "/api/config/test-plugin",
+    });
+
+    expect(res.statusCode).toBe(200);
+    const body = JSON.parse(res.body);
+    expect(body.supportsTest).toBe(false);
+  });
+});
+
+describe("Config Route — POST /api/config/:pluginId/test", () => {
+  let db: Database.Database;
+  let dataDir: string;
+  let cs: ConfigService;
+  let app: FastifyInstance;
+  let runtimes: PluginRuntime[];
+
+  beforeEach(async () => {
+    db = createTestDb();
+    runMigrations(db, CORE_MIGRATIONS, testLogger);
+    dataDir = mkdtempSync(path.join(tmpdir(), "starr-config-route-"));
+    resetEncryptionKey();
+    loadEncryptionKey(dataDir, testLogger);
+
+    cs = new ConfigService(db, testLogger);
+
+    // Register a plugin schema
+    const schema: ConfigSchema<{ endpoint: string; apiKey: string; requestTimeoutMs: number }> = {
+      endpoint: { type: "url", label: "Endpoint", required: true },
+      apiKey: { type: "secret", label: "API Key", required: true },
+      requestTimeoutMs: { type: "number", label: "Timeout", default: 15000 },
+    };
+    cs.register("test-plugin", schema);
+
+    runtimes = [];
+
+    app = Fastify({ logger: false });
+    injectAdminUser(app);
+  });
+
+  afterEach(async () => {
+    await app.close();
+    db.close();
+    try {
+      const keyPath = path.join(dataDir, "starr.key");
+      if (existsSync(keyPath)) unlinkSync(keyPath);
+      rmdirSync(dataDir);
+    } catch {
+      // ignore
+    }
+    resetEncryptionKey();
+  });
+
+  it("returns 400 when plugin does not support testConnection", async () => {
+    runtimes.push(createMockRuntime("test-plugin", { hasTestConnection: false }));
+    initConfigRoutes(cs, () => runtimes);
+    await app.register(configRoutes);
+
+    const res = await app.inject({
+      method: "POST",
+      url: "/api/config/test-plugin/test",
+      body: { endpoint: "http://jackett:9117/api", apiKey: "test-key" },
+    });
+
+    expect(res.statusCode).toBe(400);
+    const body = JSON.parse(res.body);
+    expect(body.error).toContain("does not support");
+  });
+
+  it("returns 404 for unknown plugin", async () => {
+    initConfigRoutes(cs, () => runtimes);
+    await app.register(configRoutes);
+
+    const res = await app.inject({
+      method: "POST",
+      url: "/api/config/unknown-plugin/test",
+      body: {},
+    });
+
+    expect(res.statusCode).toBe(404);
+  });
+
+  it("calls testConnection with raw values and returns result", async () => {
+    let calledWith: Record<string, unknown> | undefined;
+    runtimes.push({
+      meta: { id: "test-plugin", version: "1.0.0", starrApiVersion: "^1.0.0" },
+      lifecycle: {
+        testConnection: async (values: Record<string, unknown>) => {
+          calledWith = values;
+          return { ok: true, message: "Test passed" };
+        },
+      },
+      startOrder: 0,
+    });
+    initConfigRoutes(cs, () => runtimes);
+    await app.register(configRoutes);
+
+    const res = await app.inject({
+      method: "POST",
+      url: "/api/config/test-plugin/test",
+      body: { endpoint: "http://jackett:9117/api", apiKey: "test-key" },
+    });
+
+    expect(res.statusCode).toBe(200);
+    const body = JSON.parse(res.body);
+    expect(body.ok).toBe(true);
+    expect(body.message).toBe("Test passed");
+    expect(calledWith).toBeDefined();
+    expect(calledWith!.endpoint).toBe("http://jackett:9117/api");
+    expect(calledWith!.apiKey).toBe("test-key");
+  });
+
+  it("resolves sentinel secret from stored decrypted value", async () => {
+    // First, save a config with a real secret
+    cs.update("test-plugin", {
+      endpoint: { type: "url", label: "Endpoint", required: true },
+      apiKey: { type: "secret", label: "API Key", required: true },
+      requestTimeoutMs: { type: "number", label: "Timeout", default: 15000 },
+    }, {
+      endpoint: "http://jackett:9117/api",
+      apiKey: "stored-secret-value",
+    });
+
+    let calledWith: Record<string, unknown> | undefined;
+    runtimes.push({
+      meta: { id: "test-plugin", version: "1.0.0", starrApiVersion: "^1.0.0" },
+      lifecycle: {
+        testConnection: async (values: Record<string, unknown>) => {
+          calledWith = values;
+          return { ok: true, message: "OK" };
+        },
+      },
+      startOrder: 0,
+    });
+    initConfigRoutes(cs, () => runtimes);
+    await app.register(configRoutes);
+
+    // Now test with the sentinel for apiKey
+    const res = await app.inject({
+      method: "POST",
+      url: "/api/config/test-plugin/test",
+      body: {
+        endpoint: "http://jackett:9117/api",
+        apiKey: SECRET_UNCHANGED_SENTINEL,
+      },
+    });
+
+    expect(res.statusCode).toBe(200);
+    expect(calledWith).toBeDefined();
+    // The sentinel should have been resolved to the stored decrypted value
+    expect(calledWith!.apiKey).toBe("stored-secret-value");
+  });
+
+  it("returns 400 when sentinel is used but no stored secret exists", async () => {
+    // Don't save any config - just register (which creates defaults with no apiKey set)
+    runtimes.push(createMockRuntime("test-plugin", { hasTestConnection: true }));
+    initConfigRoutes(cs, () => runtimes);
+    await app.register(configRoutes);
+
+    const res = await app.inject({
+      method: "POST",
+      url: "/api/config/test-plugin/test",
+      body: {
+        endpoint: "http://jackett:9117/api",
+        apiKey: SECRET_UNCHANGED_SENTINEL,
+      },
+    });
+
+    expect(res.statusCode).toBe(400);
+    const body = JSON.parse(res.body);
+    expect(body.error).toContain("apiKey");
+  });
+
+  it("catches unexpected errors and returns 500 with sanitized message", async () => {
+    runtimes.push({
+      meta: { id: "test-plugin", version: "1.0.0", starrApiVersion: "^1.0.0" },
+      lifecycle: {
+        testConnection: async () => {
+          throw new Error("Connection refused to test-key");
+        },
+      },
+      startOrder: 0,
+    });
+    initConfigRoutes(cs, () => runtimes);
+    await app.register(configRoutes);
+
+    const res = await app.inject({
+      method: "POST",
+      url: "/api/config/test-plugin/test",
+      body: { endpoint: "http://jackett:9117/api", apiKey: "test-key" },
+    });
+
+    expect(res.statusCode).toBe(500);
+    const body = JSON.parse(res.body);
+    expect(body.ok).toBe(false);
+    // The secret value "test-key" should be sanitized (redacted with ***)
+    expect(body.message).not.toContain("test-key");
+    expect(body.message).toContain("***");
+  });
+});