@digitalpaws/starr 0.0.1

package/tests/content-types.test.ts

@@ -0,0 +1,376 @@
+// SPDX-License-Identifier: 0BSD
+// SPDX-FileCopyrightText: 2025 Digi <digitalpaws@proton.me>
+
+import { describe, it, expect, beforeEach, beforeAll, afterAll } from "vitest";
+import Database from "better-sqlite3";
+import { runMigrations, CORE_MIGRATIONS } from "../src/datastore/migrations.js";
+import {
+  validateDescriptor,
+  ContentTypeRegistryImpl,
+  computeContentIdentity,
+  areSameItem,
+} from "../src/content-types/registry.js";
+import { createLogger } from "../src/logging/logger.js";
+import { createContext } from "../src/plugins/context.js";
+import { Starr } from "../src/host.js";
+import type { ContentTypeDescriptor, FieldDef } from "@digitalpaws/starr-types-core";
+
+// ── Helpers ──────────────────────────────────────────────────────────
+
+function makeDesc(overrides: Partial<ContentTypeDescriptor> = {}): ContentTypeDescriptor {
+  return {
+    id: "test/movie@1",
+    name: "Movie",
+    identity: ["tmdb"],
+    fields: [],
+    ...overrides,
+  };
+}
+
+// ── Step 7.1: Descriptor validation tests ─────────────────────────────
+
+describe("validateDescriptor", () => {
+  it("accepts a valid minimal descriptor", () => {
+    expect(validateDescriptor(makeDesc())).toBeNull();
+  });
+
+  it("rejects empty id", () => {
+    expect(validateDescriptor(makeDesc({ id: "" }))).toContain("id");
+  });
+
+  it("rejects missing id", () => {
+    const d = makeDesc();
+    (d as Record<string, unknown>).id = undefined;
+    expect(validateDescriptor(d as ContentTypeDescriptor)).toContain("id");
+  });
+
+  it("rejects empty name", () => {
+    expect(validateDescriptor(makeDesc({ name: "" }))).toContain("name");
+  });
+
+  it("rejects empty identity array", () => {
+    expect(validateDescriptor(makeDesc({ identity: [] }))).toContain("identity");
+  });
+
+  it("rejects undefined identity", () => {
+    const d = makeDesc();
+    (d as Record<string, unknown>).identity = undefined;
+    expect(validateDescriptor(d as ContentTypeDescriptor)).toContain("identity");
+  });
+
+  it("rejects list field without itemType", () => {
+    const d = makeDesc({
+      fields: [{ key: "tags", label: "Tags", type: "list" } as FieldDef],
+    });
+    expect(validateDescriptor(d)).toContain("itemType");
+  });
+
+  it("accepts list field with itemType", () => {
+    const d = makeDesc({
+      fields: [{ key: "tags", label: "Tags", type: "list", itemType: "string" }],
+    });
+    expect(validateDescriptor(d)).toBeNull();
+  });
+
+  it("rejects enum field without options", () => {
+    const d = makeDesc({
+      fields: [{ key: "status", label: "Status", type: "enum" } as FieldDef],
+    });
+    expect(validateDescriptor(d)).toContain("options");
+  });
+
+  it("rejects enum field with empty options", () => {
+    const d = makeDesc({
+      fields: [{ key: "status", label: "Status", type: "enum", options: [] }],
+    });
+    expect(validateDescriptor(d)).toContain("options");
+  });
+
+  it("accepts enum field with options", () => {
+    const d = makeDesc({
+      fields: [
+        { key: "status", label: "Status", type: "enum", options: ["a", "b"] },
+      ],
+    });
+    expect(validateDescriptor(d)).toBeNull();
+  });
+
+  it("rejects field missing key", () => {
+    const d = makeDesc({
+      fields: [{ label: "X", type: "string" } as FieldDef],
+    });
+    expect(validateDescriptor(d)).toContain("key");
+  });
+
+  it("rejects field missing label", () => {
+    const d = makeDesc({
+      fields: [{ key: "x", type: "string" } as FieldDef],
+    });
+    expect(validateDescriptor(d)).toContain("label");
+  });
+});
+
+// ── Step 7.2: Registry class tests ────────────────────────────────────
+
+describe("ContentTypeRegistryImpl", () => {
+  let registry: ContentTypeRegistryImpl;
+
+  const movieDesc: ContentTypeDescriptor = {
+    id: "starr-video/movie@1",
+    name: "Movie",
+    identity: ["tmdb", "imdb"],
+    fields: [],
+  };
+
+  const showDesc: ContentTypeDescriptor = {
+    id: "starr-video/show@1",
+    name: "TV Show",
+    identity: ["tmdb"],
+    fields: [],
+  };
+
+  beforeEach(() => {
+    registry = new ContentTypeRegistryImpl();
+  });
+
+  it("register and get round-trip", () => {
+    registry.register(movieDesc);
+    expect(registry.get("starr-video/movie@1")).toEqual(movieDesc);
+  });
+
+  it("get returns undefined for unknown id", () => {
+    expect(registry.get("nonexistent")).toBeUndefined();
+  });
+
+  it("list returns all registered descriptors", () => {
+    registry.register(movieDesc);
+    registry.register(showDesc);
+    expect(registry.list()).toHaveLength(2);
+  });
+
+  it("rejects duplicate id from different plugins", () => {
+    registry.register(movieDesc, "plugin-a");
+    expect(() => registry.register(movieDesc, "plugin-b")).toThrow("Duplicate");
+  });
+
+  it("allows same plugin to register multiple types", () => {
+    registry.register(movieDesc, "plugin-a");
+    registry.register(showDesc, "plugin-a");
+    expect(registry.list()).toHaveLength(2);
+  });
+
+  it("rejects malformed descriptor (empty identity)", () => {
+    expect(() =>
+      registry.register({ id: "x", name: "X", identity: [], fields: [] }),
+    ).toThrow("identity");
+  });
+
+  it("rollbackPlugin removes only that plugin's descriptors", () => {
+    registry.register(movieDesc, "plugin-a");
+    registry.register(showDesc, "plugin-b");
+    registry.rollbackPlugin("plugin-a");
+    expect(registry.get("starr-video/movie@1")).toBeUndefined();
+    expect(registry.get("starr-video/show@1")).toEqual(showDesc);
+  });
+
+  it("rollbackPlugin is safe for unknown plugin", () => {
+    expect(() => registry.rollbackPlugin("nonexistent")).not.toThrow();
+  });
+
+  it("register with pluginId tracks association", () => {
+    registry.register(movieDesc, "my-plugin");
+    registry.rollbackPlugin("my-plugin");
+    expect(registry.list()).toHaveLength(0);
+  });
+
+  it("register without pluginId works (no tracking)", () => {
+    registry.register(movieDesc);
+    // rollback should be a no-op since no plugin association
+    registry.rollbackPlugin("my-plugin");
+    expect(registry.list()).toHaveLength(1);
+  });
+});
+
+// ── Step 7.3: Content identity tests ─────────────────────────────────
+
+describe("content identity", () => {
+  let registry: ContentTypeRegistryImpl;
+
+  beforeEach(() => {
+    registry = new ContentTypeRegistryImpl();
+    registry.register({
+      id: "starr-video/movie@1",
+      name: "Movie",
+      identity: ["tmdb", "imdb"],
+      fields: [],
+    });
+  });
+
+  describe("computeContentIdentity", () => {
+    it("uses first identity key present in externalIds", () => {
+      const item = {
+        contentTypeId: "starr-video/movie@1",
+        externalIds: { tmdb: "123", imdb: "tt456" },
+      };
+      const id = computeContentIdentity(item, registry);
+      expect(id).toBe("starr-video/movie@1::tmdb=123");
+    });
+
+    it("falls back to second identity key if first is missing", () => {
+      const item = {
+        contentTypeId: "starr-video/movie@1",
+        externalIds: { imdb: "tt456" },
+      };
+      const id = computeContentIdentity(item, registry);
+      expect(id).toBe("starr-video/movie@1::imdb=tt456");
+    });
+
+    it("returns deterministic fallback when no identity key present", () => {
+      const item = {
+        contentTypeId: "starr-video/movie@1",
+        externalIds: { foo: "bar" },
+      };
+      const id = computeContentIdentity(item, registry);
+      expect(id).toContain("starr-video/movie@1::undecidable::");
+      // Same input → same output
+      expect(id).toBe(computeContentIdentity(item, registry));
+    });
+
+    it("works for unknown contentTypeId (fallback)", () => {
+      const item = {
+        contentTypeId: "unknown/type@1",
+        externalIds: { x: "1" },
+      };
+      const id = computeContentIdentity(item, registry);
+      expect(id).toContain("unknown/type@1");
+    });
+
+    it("skips empty externalId values", () => {
+      const item = {
+        contentTypeId: "starr-video/movie@1",
+        externalIds: { tmdb: "", imdb: "tt456" },
+      };
+      const id = computeContentIdentity(item, registry);
+      // tmdb is empty, so falls to imdb
+      expect(id).toBe("starr-video/movie@1::imdb=tt456");
+    });
+
+    it("produces different identities for different items", () => {
+      const a = computeContentIdentity(
+        { contentTypeId: "starr-video/movie@1", externalIds: { tmdb: "1" } },
+        registry,
+      );
+      const b = computeContentIdentity(
+        { contentTypeId: "starr-video/movie@1", externalIds: { tmdb: "2" } },
+        registry,
+      );
+      expect(a).not.toBe(b);
+    });
+  });
+
+  describe("areSameItem", () => {
+    it("returns true for items with same identity key", () => {
+      const a = { contentTypeId: "starr-video/movie@1", externalIds: { tmdb: "123" } };
+      const b = { contentTypeId: "starr-video/movie@1", externalIds: { tmdb: "123", imdb: "tt456" } };
+      expect(areSameItem(a, b, registry)).toBe(true);
+    });
+
+    it("returns false for items with different identity key value", () => {
+      const a = { contentTypeId: "starr-video/movie@1", externalIds: { tmdb: "123" } };
+      const b = { contentTypeId: "starr-video/movie@1", externalIds: { tmdb: "456" } };
+      expect(areSameItem(a, b, registry)).toBe(false);
+    });
+
+    it("returns false for different contentTypeId (ID2)", () => {
+      // Register a second type
+      registry.register({ id: "other/movie@1", name: "O", identity: ["tmdb"], fields: [] });
+      const a = { contentTypeId: "starr-video/movie@1", externalIds: { tmdb: "123" } };
+      const b = { contentTypeId: "other/movie@1", externalIds: { tmdb: "123" } };
+      expect(areSameItem(a, b, registry)).toBe(false);
+    });
+
+    it("returns false when no mutual identity key (undecidable)", () => {
+      const a = { contentTypeId: "starr-video/movie@1", externalIds: { tmdb: "123" } };
+      const b = { contentTypeId: "starr-video/movie@1", externalIds: { imdb: "tt456" } };
+      expect(areSameItem(a, b, registry)).toBe(false);
+    });
+
+    it("returns false for unknown contentTypeId", () => {
+      const a = { contentTypeId: "unknown/type@1", externalIds: { x: "1" } };
+      const b = { contentTypeId: "unknown/type@1", externalIds: { x: "1" } };
+      expect(areSameItem(a, b, registry)).toBe(false);
+    });
+
+    it("uses second identity key when first is not mutually present", () => {
+      // Item a has only imdb, item b has both — second key (imdb) is first mutual
+      const a = { contentTypeId: "starr-video/movie@1", externalIds: { imdb: "tt456" } };
+      const b = { contentTypeId: "starr-video/movie@1", externalIds: { tmdb: "123", imdb: "tt456" } };
+      // identity order is ["tmdb","imdb"] — tmdb is not in a, so check imdb
+      expect(areSameItem(a, b, registry)).toBe(true);
+    });
+
+    it("returns false when first identity key differs even if second matches", () => {
+      // Both items have tmdb (first key) but with different values →
+      // first mutual present key decides, and they differ → false.
+      const a = { contentTypeId: "starr-video/movie@1", externalIds: { tmdb: "1", imdb: "t" } };
+      const b = { contentTypeId: "starr-video/movie@1", externalIds: { tmdb: "2", imdb: "t" } };
+      expect(areSameItem(a, b, registry)).toBe(false);
+    });
+  });
+});
+
+// ── Step 7.4: Context integration tests ───────────────────────────────
+
+describe("context integration - content types", () => {
+  let db: Database.Database;
+
+  beforeAll(() => {
+    db = new Database(":memory:");
+    db.pragma("journal_mode = WAL");
+    db.pragma("foreign_keys = ON");
+    runMigrations(db, CORE_MIGRATIONS, createLogger("test", "silent"));
+  });
+
+  afterAll(() => {
+    db.close();
+  });
+
+  it("ctx.contentTypes.register stores descriptor in host registry", () => {
+    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" });
+    ctx.contentTypes.register({
+      id: "test/movie@1",
+      name: "Movie",
+      identity: ["tmdb"],
+      fields: [],
+    });
+
+    const desc = starr.contentTypeRegistry.get("test/movie@1");
+    expect(desc).toBeDefined();
+    expect(desc!.id).toBe("test/movie@1");
+  });
+
+  it("ctx.contentTypes.register throws on malformed descriptor", () => {
+    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.contentTypes.register({ id: "x", name: "", identity: [], fields: [] }),
+    ).toThrow();
+  });
+
+  it("ctx.contentTypes.register throws if called before ctx.define", () => {
+    const logger = createLogger("core", "silent");
+    const starr = new Starr({ pluginsDir: "/tmp", apiVersion: "1.0.0", logger });
+    const ctx = createContext(starr, "/tmp/test-plugin", db);
+
+    expect(() =>
+      ctx.contentTypes.register({ id: "x", name: "X", identity: ["t"], fields: [] }),
+    ).toThrow("ctx.define must be called");
+  });
+});