resourceCatalog.test.ts

import { afterEach, describe, expect, it, vi } from "vitest";
import {
  NO_FILE_CONTEXT,
  StandardResourceCatalog,
} from "../src/v3/resource-catalog/standardResourceCatalog.js";

// Regression tests for COULD_NOT_FIND_EXECUTOR on warm worker processes when
// a task's `task()` / `schemaTask()` call is evaluated during another task's
// execution (e.g. as a side effect of `await import(...)` of a module that
// contains a task definition).
//
// Production throw site:
//   - managed-run-worker.ts:566 (post-wrap)
//   - dev-run-worker.ts:578 (post-wrap)
// Pre-fix symptom: `resourceCatalog.getTask(execution.task.id)` returned
// undefined even after the worker re-imported the task entrypoint.
//
// Pre-fix mechanism: `registerTaskMetadata` silently returned when
// `_currentFileContext` was unset. Any `task()` call firing during a
// running task's run() / lifecycle hooks (directly, or transitively via a
// dynamic import) hit the silent guard. Node's ESM module cache then
// prevented recovery — the worker's setContext + re-import fallback didn't
// re-evaluate the module body, so the `task()` call never fired again.
//
// Post-fix: the runtime workers wrap their `executor.execute(...)` call with
// `setCurrentFileContext(NO_FILE_CONTEXT, NO_FILE_CONTEXT)` so any `task()`
// call firing during execution registers normally with sentinel file
// metadata. The catalog detects the sentinel and emits a one-time warning
// per task id to keep the bundle-shape pattern visible. The indexer never
// sets this sentinel context — its behavior is unchanged.

describe("StandardResourceCatalog — runtime registration via sentinel context", () => {
  afterEach(() => {
    delete (globalThis as { __catalogRegisterTaskMetadata?: unknown })
      .__catalogRegisterTaskMetadata;
    vi.restoreAllMocks();
  });

  it("silently drops registration when no context is set (indexer's invariant)", () => {
    const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
    const catalog = new StandardResourceCatalog();

    catalog.registerTaskMetadata({
      id: "no-context-task",
      fns: { run: async () => "ok" },
    });

    expect(catalog.getTask("no-context-task")).toBeUndefined();
    expect(warn).not.toHaveBeenCalled();
  });

  it(
    "registers normally and warns once when the sentinel context is set " +
      "(simulates the worker's executor wrap)",
    () => {
      const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
      const catalog = new StandardResourceCatalog();

      catalog.setCurrentFileContext(NO_FILE_CONTEXT, NO_FILE_CONTEXT);
      catalog.registerTaskMetadata({
        id: "lazy-task",
        fns: { run: async () => "ok" },
      });
      catalog.clearCurrentFileContext();

      const registered = catalog.getTask("lazy-task");
      expect(registered).toBeDefined();
      expect(registered?.id).toBe("lazy-task");
      expect(registered?.filePath).toBe(NO_FILE_CONTEXT);
      expect(registered?.entryPoint).toBe(NO_FILE_CONTEXT);
      expect(warn).toHaveBeenCalledTimes(1);
      expect(warn.mock.calls[0]?.[0]).toContain("lazy-task");
    }
  );

  it(
    "warm-start path: a task whose top-level definition fires during a " +
      "dynamic import inside the sentinel wrap remains findable; the " +
      "worker's setContext + re-import fallback (managed-run-worker.ts:482) " +
      "is not needed",
    async () => {
      vi.spyOn(console, "warn").mockImplementation(() => {});
      const catalog = new StandardResourceCatalog();

      (globalThis as { __catalogRegisterTaskMetadata?: unknown })
        .__catalogRegisterTaskMetadata = (
        task: Parameters<StandardResourceCatalog["registerTaskMetadata"]>[0]
      ) => {
        catalog.registerTaskMetadata(task);
      };

      // Simulate the worker wrap: setContext(NO_FILE_CONTEXT) → run user code
      // (which does a dynamic import) → clearContext.
      catalog.setCurrentFileContext(NO_FILE_CONTEXT, NO_FILE_CONTEXT);
      await import("./fixtures/dynamic-task-module.mjs");
      catalog.clearCurrentFileContext();

      const registered = catalog.getTask("lazy-task");
      expect(registered).toBeDefined();
      expect(registered?.filePath).toBe(NO_FILE_CONTEXT);
    }
  );

  it("warns at most once per task id under the sentinel context", () => {
    const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
    const catalog = new StandardResourceCatalog();

    catalog.setCurrentFileContext(NO_FILE_CONTEXT, NO_FILE_CONTEXT);

    const register = (id: string) =>
      catalog.registerTaskMetadata({
        id,
        fns: { run: async () => "ok" },
      });

    register("task-a");
    register("task-a");
    register("task-a");
    expect(warn).toHaveBeenCalledTimes(1);

    register("task-b");
    expect(warn).toHaveBeenCalledTimes(2);

    catalog.clearCurrentFileContext();
  });

  it(
    "control: real file context registers without firing the sentinel warning",
    async () => {
      const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
      const catalog = new StandardResourceCatalog();

      (globalThis as { __catalogRegisterTaskMetadata?: unknown })
        .__catalogRegisterTaskMetadata = (
        task: Parameters<StandardResourceCatalog["registerTaskMetadata"]>[0]
      ) => {
        catalog.registerTaskMetadata(task);
      };

      catalog.setCurrentFileContext(
        "/app/dist/lazy-task.entry.mjs",
        "src/tasks/lazy-task.ts"
      );
      await import("./fixtures/dynamic-task-module.mjs?control");
      catalog.clearCurrentFileContext();

      const task = catalog.getTask("lazy-task");
      expect(task).toBeDefined();
      expect(task?.filePath).toBe("/app/dist/lazy-task.entry.mjs");
      expect(task?.entryPoint).toBe("src/tasks/lazy-task.ts");
      expect(warn).not.toHaveBeenCalled();
    }
  );
});