@nathapp/nax 0.23.0 → 0.24.0

package/test/unit/pipeline/subscribers/events-writer.test.ts

@@ -0,0 +1,227 @@
+import { readFile, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
+import { PipelineEventBus } from "../../../../src/pipeline/event-bus";
+import { wireEventsWriter } from "../../../../src/pipeline/subscribers/events-writer";
+
+// Minimal UserStory stub for event payloads
+const stubStory = { id: "US-001", title: "Test story" } as never;
+
+describe("wireEventsWriter", () => {
+  let workdir: string;
+  let eventsFile: string;
+
+  beforeEach(() => {
+    // Use a temp workdir with a known basename so we can locate the events file
+    workdir = join(tmpdir(), `nax-evtest-${Date.now()}`);
+    const project = workdir.split("/").pop()!;
+    eventsFile = join(process.env.HOME ?? tmpdir(), ".nax", "events", project, "events.jsonl");
+  });
+
+  afterEach(async () => {
+    // Clean up the events file written under ~/.nax/events/<project>/
+    const project = workdir.split("/").pop()!;
+    const dir = join(process.env.HOME ?? tmpdir(), ".nax", "events", project);
+    await rm(dir, { recursive: true, force: true });
+    mock.restore();
+  });
+
+  async function readLines(): Promise<object[]> {
+    // Small delay to let async fire-and-forget writes finish
+    await Bun.sleep(50);
+    const text = await readFile(eventsFile, "utf8");
+    return text
+      .trim()
+      .split("\n")
+      .filter(Boolean)
+      .map((l) => JSON.parse(l));
+  }
+
+  test("returns an UnsubscribeFn", () => {
+    const bus = new PipelineEventBus();
+    const unsub = wireEventsWriter(bus, "my-feature", "run-001", workdir);
+    expect(typeof unsub).toBe("function");
+    unsub();
+  });
+
+  test("creates events.jsonl and writes run:started line", async () => {
+    const bus = new PipelineEventBus();
+    wireEventsWriter(bus, "feat-a", "run-abc", workdir);
+
+    bus.emit({ type: "run:started", feature: "feat-a", totalStories: 3, workdir });
+
+    const lines = await readLines();
+    expect(lines.length).toBe(1);
+    const line = lines[0] as Record<string, unknown>;
+    expect(line.event).toBe("run:started");
+    expect(line.runId).toBe("run-abc");
+    expect(line.feature).toBe("feat-a");
+    expect(typeof line.project).toBe("string");
+    expect(typeof line.ts).toBe("string");
+    // ts must be valid ISO8601
+    expect(() => new Date(line.ts as string).toISOString()).not.toThrow();
+  });
+
+  test("each line has required fields: ts, event, runId, feature, project", async () => {
+    const bus = new PipelineEventBus();
+    wireEventsWriter(bus, "feat-b", "run-xyz", workdir);
+
+    bus.emit({ type: "run:started", feature: "feat-b", totalStories: 1, workdir });
+
+    const lines = await readLines();
+    const line = lines[0] as Record<string, unknown>;
+    for (const field of ["ts", "event", "runId", "feature", "project"]) {
+      expect(line[field]).toBeDefined();
+    }
+  });
+
+  test("run:completed writes event=on-complete", async () => {
+    const bus = new PipelineEventBus();
+    wireEventsWriter(bus, "feat-c", "run-001", workdir);
+
+    bus.emit({
+      type: "run:completed",
+      totalStories: 1,
+      passedStories: 1,
+      failedStories: 0,
+      durationMs: 100,
+      totalCost: 0.01,
+    });
+
+    const lines = await readLines();
+    const line = lines[0] as Record<string, unknown>;
+    expect(line.event).toBe("on-complete");
+  });
+
+  test("story:started includes storyId", async () => {
+    const bus = new PipelineEventBus();
+    wireEventsWriter(bus, "feat-d", "run-001", workdir);
+
+    bus.emit({
+      type: "story:started",
+      storyId: "US-042",
+      story: stubStory,
+      workdir,
+    });
+
+    const lines = await readLines();
+    const line = lines[0] as Record<string, unknown>;
+    expect(line.event).toBe("story:started");
+    expect(line.storyId).toBe("US-042");
+  });
+
+  test("story:completed includes storyId", async () => {
+    const bus = new PipelineEventBus();
+    wireEventsWriter(bus, "feat-d", "run-001", workdir);
+
+    bus.emit({
+      type: "story:completed",
+      storyId: "US-042",
+      story: stubStory,
+      passed: true,
+      durationMs: 500,
+    });
+
+    const lines = await readLines();
+    const line = lines[0] as Record<string, unknown>;
+    expect(line.event).toBe("story:completed");
+    expect(line.storyId).toBe("US-042");
+  });
+
+  test("story:failed includes storyId", async () => {
+    const bus = new PipelineEventBus();
+    wireEventsWriter(bus, "feat-d", "run-001", workdir);
+
+    bus.emit({
+      type: "story:failed",
+      storyId: "US-042",
+      story: stubStory,
+      reason: "tests failed",
+      countsTowardEscalation: true,
+    });
+
+    const lines = await readLines();
+    const line = lines[0] as Record<string, unknown>;
+    expect(line.event).toBe("story:failed");
+    expect(line.storyId).toBe("US-042");
+  });
+
+  test("run:paused is written", async () => {
+    const bus = new PipelineEventBus();
+    wireEventsWriter(bus, "feat-e", "run-001", workdir);
+
+    bus.emit({ type: "run:paused", reason: "cost limit", cost: 5.0 });
+
+    const lines = await readLines();
+    const line = lines[0] as Record<string, unknown>;
+    expect(line.event).toBe("run:paused");
+  });
+
+  test("multiple events produce multiple JSONL lines", async () => {
+    const bus = new PipelineEventBus();
+    wireEventsWriter(bus, "feat-f", "run-multi", workdir);
+
+    bus.emit({ type: "run:started", feature: "feat-f", totalStories: 2, workdir });
+    bus.emit({ type: "story:started", storyId: "US-001", story: stubStory, workdir });
+    bus.emit({ type: "story:completed", storyId: "US-001", story: stubStory, passed: true, durationMs: 100 });
+    bus.emit({
+      type: "run:completed",
+      totalStories: 1,
+      passedStories: 1,
+      failedStories: 0,
+      durationMs: 200,
+    });
+
+    const lines = await readLines();
+    expect(lines.length).toBe(4);
+  });
+
+  test("write failure does not throw or crash", async () => {
+    const bus = new PipelineEventBus();
+    // Use a workdir whose project name would conflict with a file (simulate write error)
+    // by pointing to an invalid path — we patch mkdir to throw
+    const originalMkdir = (await import("node:fs/promises")).mkdir;
+
+    let callCount = 0;
+    const _fsMod = await import("node:fs/promises");
+    // Inject a failing write by pointing to a path that won't be writable
+    // We rely on the subscriber catching the error gracefully
+    const badWorkdir = "/dev/null/nonexistent-project";
+    const badBus = new PipelineEventBus();
+    wireEventsWriter(badBus, "feat-err", "run-err", badWorkdir);
+
+    // Should not throw
+    expect(() => {
+      badBus.emit({ type: "run:started", feature: "feat-err", totalStories: 0, workdir: badWorkdir });
+    }).not.toThrow();
+
+    // Give async time to attempt write and swallow error
+    await Bun.sleep(50);
+    // No assertion on file existence — the point is no crash/throw
+  });
+
+  test("unsubscribe stops further writes", async () => {
+    const bus = new PipelineEventBus();
+    const unsub = wireEventsWriter(bus, "feat-g", "run-unsub", workdir);
+
+    bus.emit({ type: "run:started", feature: "feat-g", totalStories: 1, workdir });
+    await Bun.sleep(50);
+
+    unsub();
+
+    bus.emit({
+      type: "run:completed",
+      totalStories: 1,
+      passedStories: 1,
+      failedStories: 0,
+      durationMs: 100,
+    });
+
+    await Bun.sleep(50);
+    const lines = await readLines();
+    // Only the first event should be written
+    expect(lines.length).toBe(1);
+    expect((lines[0] as Record<string, unknown>).event).toBe("run:started");
+  });
+});

package/test/unit/pipeline/subscribers/registry.test.ts

@@ -0,0 +1,149 @@
+import { readFile, rm } from "node:fs/promises";
+import { homedir } from "node:os";
+import { basename, join } from "node:path";
+import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
+import { PipelineEventBus } from "../../../../src/pipeline/event-bus";
+import { type MetaJson, wireRegistry } from "../../../../src/pipeline/subscribers/registry";
+
+describe("wireRegistry", () => {
+  let workdir: string;
+  let feature: string;
+  let runId: string;
+  let runDir: string;
+  let metaFile: string;
+
+  beforeEach(() => {
+    workdir = join("/tmp", `nax-regtest-${Date.now()}`);
+    feature = "auth-system";
+    runId = `run-${Date.now()}`;
+    const project = basename(workdir);
+    runDir = join(homedir(), ".nax", "runs", `${project}-${feature}-${runId}`);
+    metaFile = join(runDir, "meta.json");
+  });
+
+  afterEach(async () => {
+    await rm(runDir, { recursive: true, force: true });
+    mock.restore();
+  });
+
+  test("returns an UnsubscribeFn", () => {
+    const bus = new PipelineEventBus();
+    const unsub = wireRegistry(bus, feature, runId, workdir);
+    expect(typeof unsub).toBe("function");
+    unsub();
+  });
+
+  test("creates meta.json on run:started", async () => {
+    const bus = new PipelineEventBus();
+    wireRegistry(bus, feature, runId, workdir);
+
+    bus.emit({ type: "run:started", feature, totalStories: 3, workdir });
+
+    await Bun.sleep(50);
+    const text = await readFile(metaFile, "utf8");
+    const meta = JSON.parse(text) as MetaJson;
+    expect(meta).toBeDefined();
+  });
+
+  test("meta.json contains all required fields", async () => {
+    const bus = new PipelineEventBus();
+    wireRegistry(bus, feature, runId, workdir);
+
+    bus.emit({ type: "run:started", feature, totalStories: 1, workdir });
+
+    await Bun.sleep(50);
+    const meta = JSON.parse(await readFile(metaFile, "utf8")) as MetaJson;
+
+    expect(meta.runId).toBe(runId);
+    expect(meta.project).toBe(basename(workdir));
+    expect(meta.feature).toBe(feature);
+    expect(meta.workdir).toBe(workdir);
+    expect(typeof meta.statusPath).toBe("string");
+    expect(typeof meta.eventsDir).toBe("string");
+    expect(typeof meta.registeredAt).toBe("string");
+  });
+
+  test("statusPath points to <workdir>/nax/features/<feature>/status.json", async () => {
+    const bus = new PipelineEventBus();
+    wireRegistry(bus, feature, runId, workdir);
+
+    bus.emit({ type: "run:started", feature, totalStories: 1, workdir });
+
+    await Bun.sleep(50);
+    const meta = JSON.parse(await readFile(metaFile, "utf8")) as MetaJson;
+
+    expect(meta.statusPath).toBe(join(workdir, "nax", "features", feature, "status.json"));
+  });
+
+  test("eventsDir points to <workdir>/nax/features/<feature>/runs", async () => {
+    const bus = new PipelineEventBus();
+    wireRegistry(bus, feature, runId, workdir);
+
+    bus.emit({ type: "run:started", feature, totalStories: 1, workdir });
+
+    await Bun.sleep(50);
+    const meta = JSON.parse(await readFile(metaFile, "utf8")) as MetaJson;
+
+    expect(meta.eventsDir).toBe(join(workdir, "nax", "features", feature, "runs"));
+  });
+
+  test("registeredAt is valid ISO8601", async () => {
+    const bus = new PipelineEventBus();
+    wireRegistry(bus, feature, runId, workdir);
+
+    bus.emit({ type: "run:started", feature, totalStories: 1, workdir });
+
+    await Bun.sleep(50);
+    const meta = JSON.parse(await readFile(metaFile, "utf8")) as MetaJson;
+
+    expect(() => new Date(meta.registeredAt).toISOString()).not.toThrow();
+  });
+
+  test("write failure does not throw or crash", async () => {
+    const bus = new PipelineEventBus();
+    // Point to an unwritable path to trigger write failure
+    const badWorkdir = "/dev/null/nonexistent-project";
+    wireRegistry(bus, "feat-err", "run-err", badWorkdir);
+
+    expect(() => {
+      bus.emit({ type: "run:started", feature: "feat-err", totalStories: 0, workdir: badWorkdir });
+    }).not.toThrow();
+
+    await Bun.sleep(50);
+    // No crash — test passes if we reach here
+  });
+
+  test("MetaJson interface is exported", () => {
+    // Verify that MetaJson can be used as a type annotation
+    const meta: MetaJson = {
+      runId: "r1",
+      project: "proj",
+      feature: "feat",
+      workdir: "/tmp/proj",
+      statusPath: "/tmp/proj/nax/features/feat/status.json",
+      eventsDir: "/tmp/proj/nax/features/feat/runs",
+      registeredAt: new Date().toISOString(),
+    };
+    expect(meta.runId).toBe("r1");
+  });
+
+  test("unsubscribe stops further writes", async () => {
+    const bus = new PipelineEventBus();
+    const unsub = wireRegistry(bus, feature, runId, workdir);
+
+    unsub();
+
+    bus.emit({ type: "run:started", feature, totalStories: 1, workdir });
+
+    await Bun.sleep(50);
+    // File should not exist since we unsubscribed before event
+    let exists = false;
+    try {
+      await readFile(metaFile, "utf8");
+      exists = true;
+    } catch {
+      exists = false;
+    }
+    expect(exists).toBe(false);
+  });
+});