@digitalpaws/starr 0.0.1

package/tests/loader-context.test.ts

@@ -0,0 +1,644 @@
+// 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 { createContext } from "../src/plugins/context.js";
+import { loadPlugins, stopPlugins, reloadPlugin } from "../src/plugins/loader.js";
+import { runMigrations, CORE_MIGRATIONS } from "../src/datastore/migrations.js";
+import { Starr } from "../src/host.js";
+
+// ── Helpers ──────────────────────────────────────────────────────────
+
+function createTestDb(): Database.Database {
+  const db = new Database(":memory:");
+  db.pragma("journal_mode = WAL");
+  db.pragma("foreign_keys = ON");
+  runMigrations(db, CORE_MIGRATIONS, createLogger("test", "silent"));
+  return db;
+}
+
+async function writePlugin(
+  baseDir: string,
+  dirName: string,
+  code: string,
+): Promise<string> {
+  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);
+  return dir;
+}
+
+// ── Phase 1: PluginStorage.deleteAll ─────────────────────────────────
+
+describe("PluginStorage.deleteAll", () => {
+  let db: Database.Database;
+
+  beforeAll(() => {
+    db = createTestDb();
+  });
+
+  afterAll(() => {
+    db.close();
+  });
+
+  it("removes all keys for a plugin", async () => {
+    const logger = createLogger("core", "silent");
+    const starr = new Starr({
+      pluginsDir: "/tmp",
+      apiVersion: "1.0.0",
+      logger,
+    });
+    const ctx = createContext(starr, "/tmp/test-plugin", db);
+    ctx.define({
+      id: "test-plugin",
+      version: "1.0.0",
+      starrApiVersion: "^1.0.0",
+    });
+
+    await ctx.storage.set("key1", "val1");
+    await ctx.storage.set("key2", "val2");
+
+    const before = await ctx.storage.list();
+    expect(before).toHaveLength(2);
+
+    await ctx.storage.deleteAll();
+
+    const after = await ctx.storage.list();
+    expect(after).toHaveLength(0);
+  });
+
+  it("does not affect another plugin's keys", async () => {
+    const logger = createLogger("core", "silent");
+    const starr = new Starr({
+      pluginsDir: "/tmp",
+      apiVersion: "1.0.0",
+      logger,
+    });
+
+    const ctxA = createContext(starr, "/tmp/a", db);
+    ctxA.define({ id: "a", version: "1.0.0", starrApiVersion: "^1.0.0" });
+    await ctxA.storage.set("key", "a-value");
+
+    const ctxB = createContext(starr, "/tmp/b", db);
+    ctxB.define({ id: "b", version: "1.0.0", starrApiVersion: "^1.0.0" });
+    await ctxB.storage.set("key", "b-value");
+
+    await ctxA.storage.deleteAll();
+
+    const aAfter = await ctxA.storage.list();
+    const bAfter = await ctxB.storage.list();
+
+    expect(aAfter).toHaveLength(0);
+    expect(bAfter).toHaveLength(1);
+    expect(bAfter[0].value).toBe("b-value");
+  });
+});
+
+// ── Phase 2: context unsubscribeAll ──────────────────────────────────
+
+describe("context unsubscribeAll", () => {
+  let db: Database.Database;
+
+  beforeAll(() => {
+    db = createTestDb();
+  });
+
+  afterAll(() => {
+    db.close();
+  });
+
+  it("removes all event subscriptions", () => {
+    const logger = createLogger("core", "silent");
+    const starr = new Starr({
+      pluginsDir: "/tmp",
+      apiVersion: "1.0.0",
+      logger,
+    });
+    const ctx = createContext(starr, "/tmp/test-plugin", db);
+    ctx.define({
+      id: "test-plugin",
+      version: "1.0.0",
+      starrApiVersion: "^1.0.0",
+    });
+
+    const calls: string[] = [];
+    ctx.events.on("test.event", () => calls.push("a"));
+    ctx.events.on("test.event", () => calls.push("b"));
+
+    ctx.unsubscribeAll();
+
+    ctx.events.emit("test.event", {});
+    expect(calls).toHaveLength(0);
+  });
+
+  it("is safe to call when no subscriptions exist", () => {
+    const logger = createLogger("core", "silent");
+    const starr = new Starr({
+      pluginsDir: "/tmp",
+      apiVersion: "1.0.0",
+      logger,
+    });
+    const ctx = createContext(starr, "/tmp/test-plugin", db);
+    ctx.define({
+      id: "test-plugin",
+      version: "1.0.0",
+      starrApiVersion: "^1.0.0",
+    });
+
+    expect(() => ctx.unsubscribeAll()).not.toThrow();
+  });
+});
+
+// ── Phase 4: Rollback tests ──────────────────────────────────────────
+
+describe("plugin register failure rollback", () => {
+  let tmpDir: string;
+
+  beforeAll(async () => {
+    tmpDir = await mkdtemp(path.join(tmpdir(), "starr-rollback-"));
+  });
+
+  afterAll(async () => {
+    await rm(tmpDir, { recursive: true, force: true });
+  });
+
+  it("rolls back event subscriptions when a plugin fails", async () => {
+    const subDir = await mkdtemp(path.join(tmpdir(), "starr-sub-rollback-"));
+    try {
+      // Plugin A subscribes to an event, then throws
+      await writePlugin(
+        subDir,
+        "failing-plugin",
+        `
+        export default function register(ctx) {
+          ctx.define({ id: "failing", version: "1.0.0", starrApiVersion: "^1.0.0" });
+          ctx.events.on("test.event", () => {});
+          throw new Error("boom after subscribe");
+        }
+      `,
+      );
+
+      await writePlugin(
+        subDir,
+        "observer-plugin",
+        `
+        export default function register(ctx) {
+          ctx.define({ id: "observer", version: "1.0.0", starrApiVersion: "^1.0.0" });
+          let count = 0;
+          ctx.events.on("test.event", () => { count++; });
+          return {
+            start() {
+              ctx.events.emit("test.event", {});
+              globalThis.__starr_observer_count = count;
+            }
+          };
+        }
+      `,
+      );
+
+      const db = createTestDb();
+      const logger = createLogger("core", "error");
+      const starr = new Starr({
+        pluginsDir: subDir,
+        apiVersion: "1.0.0",
+        logger,
+      });
+      starr.datastore = { db, dbPath: ":memory:", close: () => {} };
+
+      await loadPlugins(starr);
+
+      // The failing plugin's subscription should have been rolled back.
+      // observer emits test.event in start — count should be 1 (only observer's
+      // own handler), not 2 (the failing plugin's handler should be gone).
+      expect((globalThis as any).__starr_observer_count).toBe(1);
+
+      delete (globalThis as any).__starr_observer_count;
+      db.close();
+    } finally {
+      await rm(subDir, { recursive: true, force: true });
+    }
+  });
+
+  it("rolls back content-type descriptors when a plugin fails", async () => {
+    const subDir = await mkdtemp(
+      path.join(tmpdir(), "starr-ct-rollback-"),
+    );
+    try {
+      await writePlugin(
+        subDir,
+        "ct-failing",
+        `
+        export default function register(ctx) {
+          ctx.define({ id: "ct-fail", version: "1.0.0", starrApiVersion: "^1.0.0" });
+          ctx.contentTypes.register({
+            id: "test/movie@1",
+            name: "Movie",
+            identity: ["tmdb"],
+            fields: [],
+          });
+          throw new Error("boom after content type");
+        }
+      `,
+      );
+
+      const db = createTestDb();
+      const logger = createLogger("core", "error");
+      const starr = new Starr({
+        pluginsDir: subDir,
+        apiVersion: "1.0.0",
+        logger,
+      });
+      starr.datastore = { db, dbPath: ":memory:", close: () => {} };
+
+      await loadPlugins(starr);
+
+      // The content-type descriptor should have been rolled back
+      expect(
+        starr.contentTypeRegistry.get("test/movie@1"),
+      ).toBeUndefined();
+      db.close();
+    } finally {
+      await rm(subDir, { recursive: true, force: true });
+    }
+  });
+
+  it("rolls back plugin storage when a plugin fails", async () => {
+    const subDir = await mkdtemp(
+      path.join(tmpdir(), "starr-storage-rollback-"),
+    );
+    try {
+      await writePlugin(
+        subDir,
+        "storage-failing",
+        `
+        export default async function register(ctx) {
+          ctx.define({ id: "storage-fail", version: "1.0.0", starrApiVersion: "^1.0.0" });
+          await ctx.storage.set("key", "should-be-rolled-back");
+          throw new Error("boom after storage write");
+        }
+      `,
+      );
+
+      const db = createTestDb();
+      const logger = createLogger("core", "error");
+      const starr = new Starr({
+        pluginsDir: subDir,
+        apiVersion: "1.0.0",
+        logger,
+      });
+      starr.datastore = { db, dbPath: ":memory:", close: () => {} };
+
+      await loadPlugins(starr);
+
+      // Storage should be cleaned up — create a new context to check
+      const checkCtx = createContext(
+        starr,
+        "/tmp/storage-fail",
+        db,
+      );
+      checkCtx.define({
+        id: "storage-fail",
+        version: "1.0.0",
+        starrApiVersion: "^1.0.0",
+      });
+      const val = await checkCtx.storage.get("key");
+      expect(val).toBeUndefined();
+      db.close();
+    } finally {
+      await rm(subDir, { recursive: true, force: true });
+    }
+  });
+});
+
+// ── Phase 3: Start/stop timeout tests ────────────────────────────────
+
+describe("start/stop timeouts", () => {
+  it("start timeout does not block other plugins from starting", async () => {
+    const tmpDir = await mkdtemp(path.join(tmpdir(), "starr-timeouts-start-"));
+    await writePlugin(
+      tmpDir,
+      "slow-starter",
+      `
+      export default function register(ctx) {
+        ctx.define({ id: "slow", version: "1.0.0", starrApiVersion: "^1.0.0" });
+        return {
+          start() {
+            return new Promise(() => {}); // never resolves
+          }
+        };
+      }
+    `,
+    );
+
+    await writePlugin(
+      tmpDir,
+      "fast-starter",
+      `
+      export default function register(ctx) {
+        ctx.define({ id: "fast", version: "1.0.0", starrApiVersion: "^1.0.0" });
+        return {
+          start() {
+            globalThis.__starr_fast_started = true;
+          }
+        };
+      }
+    `,
+    );
+
+    const db = createTestDb();
+    const logger = createLogger("core", "error");
+    const starr = new Starr({
+      pluginsDir: tmpDir,
+      apiVersion: "1.0.0",
+      logger,
+    });
+    starr.datastore = { db, dbPath: ":memory:", close: () => {} };
+
+    // This should complete (not hang) — fast starter should start,
+    // slow starter should time out after 30s.
+    await loadPlugins(starr);
+
+    expect((globalThis as any).__starr_fast_started).toBe(true);
+
+    // slow plugin should NOT be in runtimes (timed out → startOrder = -1)
+    const runtimes = starr.getRuntimes();
+    const slowRuntime = runtimes.find((r) => r.meta.id === "slow");
+    expect(slowRuntime?.startOrder).toBe(-1);
+
+    await rm(tmpDir, { recursive: true, force: true });
+    delete (globalThis as any).__starr_fast_started;
+    db.close();
+  }, 40_000); // Extended timeout — the test waits for the 30s start timeout
+
+  it("stop timeout does not block shutdown", async () => {
+    const tmpDir = await mkdtemp(path.join(tmpdir(), "starr-timeouts-stop-"));
+    await writePlugin(
+      tmpDir,
+      "slow-stopper",
+      `
+      export default function register(ctx) {
+        ctx.define({ id: "slow-stop", version: "1.0.0", starrApiVersion: "^1.0.0" });
+        return {
+          stop() {
+            return new Promise(() => {}); // never resolves
+          }
+        };
+      }
+    `,
+    );
+
+    await writePlugin(
+      tmpDir,
+      "fast-stopper",
+      `
+      export default function register(ctx) {
+        ctx.define({ id: "fast-stop", version: "1.0.0", starrApiVersion: "^1.0.0" });
+        return {
+          stop() {
+            globalThis.__starr_fast_stopped = true;
+          }
+        };
+      }
+    `,
+    );
+
+    const db = createTestDb();
+    const logger = createLogger("core", "error");
+    const starr = new Starr({
+      pluginsDir: tmpDir,
+      apiVersion: "1.0.0",
+      logger,
+    });
+    starr.datastore = { db, dbPath: ":memory:", close: () => {} };
+
+    await loadPlugins(starr);
+    await stopPlugins(starr);
+
+    // Fast stopper should have run
+    expect((globalThis as any).__starr_fast_stopped).toBe(true);
+
+
+    await rm(tmpDir, { recursive: true, force: true });
+    delete (globalThis as any).__starr_fast_stopped;
+    db.close();
+  }, 20_000); // Extended timeout — the test waits for the 10s stop timeout
+});
+
+// ── Phase 5: reloadPlugin tests ──────────────────────────────────────
+
+describe("reloadPlugin", () => {
+  it("stops, re-imports, and restarts a plugin", async () => {
+    const tmpDir = await mkdtemp(path.join(tmpdir(), "starr-reload-seq-"));
+    const events: string[] = [];
+    const key = "__starr_reload_seq";
+    (globalThis as any)[key] = events;
+
+    await writePlugin(
+      tmpDir,
+      "reloadable",
+      `
+      const k = "${key}";
+      export default function register(ctx) {
+        globalThis[k].push("register");
+        ctx.define({ id: "reloadable", version: "1.0.0", starrApiVersion: "^1.0.0" });
+        return {
+          start() { globalThis[k].push("start"); },
+          stop() { globalThis[k].push("stop"); },
+        };
+      }
+    `,
+    );
+
+    const db = createTestDb();
+    const logger = createLogger("core", "error");
+    const starr = new Starr({
+      pluginsDir: tmpDir,
+      apiVersion: "1.0.0",
+      logger,
+    });
+    starr.datastore = { db, dbPath: ":memory:", close: () => {} };
+
+    await loadPlugins(starr);
+
+    // Initial: register → start
+    expect(events).toEqual(["register", "start"]);
+
+    // Clear events for reload
+    events.length = 0;
+
+    await reloadPlugin(starr, "reloadable");
+
+    // Reload: stop → register → start
+    expect(events).toEqual(["stop", "register", "start"]);
+
+    await rm(tmpDir, { recursive: true, force: true });
+    delete (globalThis as any)[key];
+    db.close();
+  });
+
+  it("reload picks up code changes (cache bust)", async () => {
+    const tmpDir = await mkdtemp(path.join(tmpdir(), "starr-reload-cache-"));
+    let value = 1;
+    const key = "__starr_reload_value";
+
+    const dir = path.join(tmpDir, "versioned-plugin");
+    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"),
+      `
+      export default function register(ctx) {
+        ctx.define({ id: "versioned", version: "1.0.0", starrApiVersion: "^1.0.0" });
+        return {
+          start() {
+            globalThis["${key}"] = ${value};
+          }
+        };
+      }
+    `,
+    );
+
+    const db = createTestDb();
+    const logger = createLogger("core", "error");
+    const starr = new Starr({
+      pluginsDir: tmpDir,
+      apiVersion: "1.0.0",
+      logger,
+    });
+    starr.datastore = { db, dbPath: ":memory:", close: () => {} };
+
+    await loadPlugins(starr);
+    expect((globalThis as any)[key]).toBe(1);
+
+    // Update the source file
+    value = 2;
+    await writeFile(
+      path.join(dir, "index.js"),
+      `
+      export default function register(ctx) {
+        ctx.define({ id: "versioned", version: "1.0.0", starrApiVersion: "^1.0.0" });
+        return {
+          start() {
+            globalThis["${key}"] = ${value};
+          }
+        };
+      }
+    `,
+    );
+
+    await reloadPlugin(starr, "versioned");
+    expect((globalThis as any)[key]).toBe(2);
+
+    await rm(tmpDir, { recursive: true, force: true });
+    delete (globalThis as any)[key];
+    db.close();
+  });
+
+  it("reload of unknown plugin does not throw", async () => {
+    const tmpDir = await mkdtemp(path.join(tmpdir(), "starr-reload-unknown-"));
+    const db = createTestDb();
+    const logger = createLogger("core", "error");
+    const starr = new Starr({
+      pluginsDir: tmpDir,
+      apiVersion: "1.0.0",
+      logger,
+    });
+    starr.datastore = { db, dbPath: ":memory:", close: () => {} };
+
+    await expect(
+      reloadPlugin(starr, "nonexistent"),
+    ).resolves.toBeUndefined();
+    await rm(tmpDir, { recursive: true, force: true });
+    db.close();
+  });
+});
+
+// ── Phase 4: Comprehensive rollback ──────────────────────────────────
+
+describe("comprehensive rollback (L5)", () => {
+  let tmpDir: string;
+
+  beforeAll(async () => {
+    tmpDir = await mkdtemp(
+      path.join(tmpdir(), "starr-comprehensive-"),
+    );
+  });
+
+  afterAll(async () => {
+    await rm(tmpDir, { recursive: true, force: true });
+  });
+
+  it("rolls back subscriptions, descriptors, and storage on failure", async () => {
+    await writePlugin(
+      tmpDir,
+      "multi-fail",
+      `
+      export default async function register(ctx) {
+        ctx.define({ id: "multi-fail", version: "1.0.0", starrApiVersion: "^1.0.0" });
+        ctx.events.on("test.event", () => {});
+        ctx.contentTypes.register({
+          id: "fail/type@1",
+          name: "FailType",
+          identity: ["x"],
+          fields: [],
+        });
+        await ctx.storage.set("key", "value");
+        throw new Error("late failure");
+      }
+    `,
+    );
+
+    await writePlugin(
+      tmpDir,
+      "clean-plugin",
+      `
+      export default function register(ctx) {
+        ctx.define({ id: "clean", version: "1.0.0", starrApiVersion: "^1.0.0" });
+      }
+    `,
+    );
+
+    const db = createTestDb();
+    const logger = createLogger("core", "error");
+    const starr = new Starr({
+      pluginsDir: tmpDir,
+      apiVersion: "1.0.0",
+      logger,
+    });
+    starr.datastore = { db, dbPath: ":memory:", close: () => {} };
+
+    await loadPlugins(starr);
+
+    // multi-fail should be rejected
+    const runtimes = starr.getRuntimes();
+    expect(runtimes.map((r) => r.meta.id)).toEqual(["clean"]);
+
+    // Content-type descriptor should be rolled back
+    expect(
+      starr.contentTypeRegistry.get("fail/type@1"),
+    ).toBeUndefined();
+
+    // Storage should be cleaned up
+    const checkCtx = createContext(starr, "/tmp/multi-fail", db);
+    checkCtx.define({
+      id: "multi-fail",
+      version: "1.0.0",
+      starrApiVersion: "^1.0.0",
+    });
+    const val = await checkCtx.storage.get("key");
+    expect(val).toBeUndefined();
+    db.close();
+  });
+});