@ryanfw/prompt-orchestration-pipeline 1.3.3 → 1.3.4

package/src/ui/client/__tests__/useJobDetailWithUpdates.test.ts

@@ -1,14 +1,56 @@
-import { describe, expect, it } from "vitest";
+import "../../components/__tests__/test-dom";
 
+import { afterEach, beforeEach, describe, expect, it, spyOn } from "bun:test";
+import { act, renderHook, waitFor } from "@testing-library/react";
+
+import type { JobWire } from "../../../config/sse-events.ts";
 import {
   applyDetailEvent,
-  extractJobDetail,
+  fetchJobDetail,
+  handleDetailSseMessage,
   matchesJobTasksStatusPath,
   REFRESH_DEBOUNCE_MS,
   shouldRefetchDetailForTaskSet,
+  useJobDetailWithUpdates,
 } from "../hooks/useJobDetailWithUpdates";
 import type { NormalizedJobDetail } from "../types";
 
+type Listener = (event: MessageEvent<string>) => void;
+
+class MockEventSource {
+  public readonly url: string;
+  public closed = false;
+  public listeners = new Map<string, Listener>();
+
+  constructor(url: string) {
+    this.url = url;
+    MockEventSource.instances.push(this);
+  }
+
+  addEventListener(type: string, listener: Listener): void {
+    this.listeners.set(type, listener);
+  }
+
+  close(): void {
+    this.closed = true;
+  }
+
+  emit(type: string, data: unknown): void {
+    const listener = this.listeners.get(type);
+    if (!listener) return;
+    listener(new MessageEvent(type, { data: JSON.stringify(data) }));
+  }
+
+  static instances: MockEventSource[] = [];
+  static reset(): void {
+    MockEventSource.instances = [];
+  }
+}
+
+function jsonResponse(body: unknown, status = 200): Response {
+  return new Response(JSON.stringify(body), { status });
+}
+
 function makeDetail(jobId: string): NormalizedJobDetail {
   return {
     id: jobId,
@@ -39,79 +81,44 @@ function makeDetail(jobId: string): NormalizedJobDetail {
   };
 }
 
+function makeJobWire(fields: Partial<JobWire> & { jobId: string }): JobWire {
+  return {
+    jobId: fields.jobId,
+    title: fields.title ?? `Title for ${fields.jobId}`,
+    status: fields.status ?? "pending",
+    progress: fields.progress ?? 0,
+    createdAt: fields.createdAt ?? null,
+    updatedAt: fields.updatedAt ?? null,
+    location: fields.location ?? null,
+    tasks: fields.tasks ?? {},
+    costsSummary: fields.costsSummary ?? {
+      totalTokens: 0,
+      totalInputTokens: 0,
+      totalOutputTokens: 0,
+      totalCost: 0,
+      totalInputCost: 0,
+      totalOutputCost: 0,
+      estimatedCost: 0,
+      hasEstimated: false,
+      unavailableCost: 0,
+    },
+  };
+}
+
 describe("useJobDetailWithUpdates helpers", () => {
   it("filters events by jobId", () => {
     const detail = makeDetail("job-1");
     expect(applyDetailEvent(detail, {
       type: "job:updated",
-      data: { jobId: "job-2", name: "other" },
+      data: makeJobWire({ jobId: "job-2", title: "other" }),
     })).toBe(detail);
   });
 
-  it("merges task updates and recomputes progress", () => {
-    const detail = makeDetail("job-1");
-    const next = applyDetailEvent(detail, {
-      type: "task:updated",
-      data: { jobId: "job-1", taskName: "build", task: { state: "done" } },
-    });
-
-    expect(next.tasks["build"]?.state).toBe("done");
-    expect(next.doneCount).toBe(1);
-    expect(next.progress).toBe(50);
-  });
-
   it("matches state-change paths for the active job", () => {
     expect(matchesJobTasksStatusPath("pipeline-data/current/job-1/tasks-status.json", "job-1")).toBe(true);
     expect(matchesJobTasksStatusPath("pipeline-data/current/job-2/tasks-status.json", "job-1")).toBe(false);
   });
 
-  it("extracts wrapped job detail payloads", () => {
-    expect(extractJobDetail({ ok: true, data: { jobId: "job-1" } })).toEqual({ jobId: "job-1" });
-  });
-
-  it("uses pipelineConfig.tasks.length as authoritative denominator", () => {
-    const detail: NormalizedJobDetail = {
-      ...makeDetail("job-1"),
-      pipelineConfig: {
-        tasks: ["a", "b", "c", "d", "e", "f"],
-      },
-      taskCount: 6,
-      tasks: {
-        a: { name: "a", state: "done", startedAt: null, endedAt: null, files: { artifacts: [], logs: [], tmp: [] } },
-        b: { name: "b", state: "done", startedAt: null, endedAt: null, files: { artifacts: [], logs: [], tmp: [] } },
-        c: { name: "c", state: "done", startedAt: null, endedAt: null, files: { artifacts: [], logs: [], tmp: [] } },
-        d: { name: "d", state: "running", startedAt: null, endedAt: null, files: { artifacts: [], logs: [], tmp: [] } },
-      },
-    };
-
-    const next = applyDetailEvent(detail, {
-      type: "task:updated",
-      data: { jobId: "job-1", taskName: "d", task: { state: "running" } },
-    });
-
-    expect(next.taskCount).toBe(6);
-    expect(next.doneCount).toBe(3);
-    expect(next.progress).toBe(50);
-  });
-
-  it("falls back to local task list length without pipelineConfig", () => {
-    const detail: NormalizedJobDetail = {
-      ...makeDetail("job-1"),
-      pipelineConfig: undefined,
-    };
-
-    const next = applyDetailEvent(detail, {
-      type: "task:updated",
-      data: { jobId: "job-1", taskName: "build", task: { state: "done" } },
-    });
-
-    expect(next.taskCount).toBe(2);
-    expect(next.doneCount).toBe(1);
-    expect(next.progress).toBe(50);
-    expect(next.progress).toBeGreaterThanOrEqual(0);
-    expect(next.progress).toBeLessThanOrEqual(100);
-  });
-
   it("refetches full detail when a job update has a different task set than pipelineConfig", () => {
     const detail: NormalizedJobDetail = {
       ...makeDetail("job-1"),
@@ -122,36 +129,342 @@ describe("useJobDetailWithUpdates helpers", () => {
 
     expect(shouldRefetchDetailForTaskSet(detail, {
       type: "job:updated",
-      data: {
+      data: makeJobWire({
         jobId: "job-1",
         tasks: {
           build: { state: "done" },
           inserted: { state: "pending" },
           test: { state: "pending" },
         },
-      },
+      }),
     })).toBe(true);
   });
 
-  it("refetches full detail when a task update targets an unknown inserted task", () => {
+  it("exports the detail debounce constant", () => {
+    expect(REFRESH_DEBOUNCE_MS).toBe(200);
+  });
+});
+
+describe("applyDetailEvent re-export wiring (AC-11)", () => {
+  it("updates the displayed task state for a matching job:updated with a changed task state", () => {
+    // Arrange
     const detail = makeDetail("job-1");
 
-    expect(shouldRefetchDetailForTaskSet(detail, {
-      type: "task:updated",
-      data: { jobId: "job-1", taskName: "inserted", task: { state: "pending" } },
-    })).toBe(true);
+    // Act
+    const next = applyDetailEvent(detail, {
+      type: "job:updated",
+      data: makeJobWire({
+        jobId: "job-1",
+        tasks: {
+          build: { state: "done" },
+          test: { state: "running" },
+        },
+      }),
+    });
+
+    // Assert
+    expect(next.tasks["build"]?.state).toBe("done");
+    expect(next.tasks["test"]?.state).toBe("running");
   });
+});
 
-  it("does not refetch full detail for known task updates", () => {
-    const detail = makeDetail("job-1");
+describe("handleDetailSseMessage (AC-12)", () => {
+  let warnSpy: ReturnType<typeof spyOn>;
 
-    expect(shouldRefetchDetailForTaskSet(detail, {
-      type: "task:updated",
-      data: { jobId: "job-1", taskName: "build", task: { state: "running" } },
-    })).toBe(false);
+  beforeEach(() => {
+    warnSpy = spyOn(console, "warn").mockImplementation(() => {});
   });
 
-  it("exports the detail debounce constant", () => {
-    expect(REFRESH_DEBOUNCE_MS).toBe(200);
+  afterEach(() => {
+    warnSpy.mockRestore();
+  });
+
+  it("schedules refetch and warns on malformed JSON without exposing an event", () => {
+    // Act
+    const result = handleDetailSseMessage("job:updated", "{not json", "job-1");
+
+    // Assert
+    expect(result).toEqual({ kind: "refetch" });
+    expect(warnSpy).toHaveBeenCalledTimes(1);
+    const [message] = warnSpy.mock.calls[0] as [string, ...unknown[]];
+    expect(message).toContain("failed to parse SSE payload");
+  });
+
+  it("schedules refetch and warns on a schema-invalid payload", () => {
+    // Act
+    const result = handleDetailSseMessage(
+      "job:updated",
+      JSON.stringify({ jobId: "job-1" }),
+      "job-1",
+    );
+
+    // Assert
+    expect(result).toEqual({ kind: "refetch" });
+    expect(warnSpy).toHaveBeenCalledTimes(1);
+    const [message] = warnSpy.mock.calls[0] as [string, ...unknown[]];
+    expect(message).toContain("dropping invalid SSE event");
+    expect(message).toContain("job:updated");
+  });
+
+  it("schedules refetch and warns on an unknown event type (task:updated is not in the contract)", () => {
+    // Act
+    const result = handleDetailSseMessage(
+      "task:updated",
+      JSON.stringify({ taskName: "build" }),
+      "job-1",
+    );
+
+    // Assert
+    expect(result).toEqual({ kind: "refetch" });
+    expect(warnSpy).toHaveBeenCalledTimes(1);
+    const [message] = warnSpy.mock.calls[0] as [string, ...unknown[]];
+    expect(message).toContain("dropping invalid SSE event");
+    expect(message).toContain("task:updated");
+  });
+
+  it("schedules refetch for a state:change targeting the active job", () => {
+    // Act
+    const result = handleDetailSseMessage(
+      "state:change",
+      JSON.stringify({
+        jobId: "job-1",
+        path: "pipeline-data/current/job-1/tasks-status.json",
+      }),
+      "job-1",
+    );
+
+    // Assert
+    expect(result).toEqual({ kind: "refetch" });
+    expect(warnSpy).not.toHaveBeenCalled();
+  });
+
+  it("skips a state:change that targets a different job", () => {
+    // Act
+    const result = handleDetailSseMessage(
+      "state:change",
+      JSON.stringify({
+        jobId: "job-2",
+        path: "pipeline-data/current/job-2/tasks-status.json",
+      }),
+      "job-1",
+    );
+
+    // Assert
+    expect(result).toEqual({ kind: "skip" });
+    expect(warnSpy).not.toHaveBeenCalled();
+  });
+
+  it("returns an apply action for a valid job:updated event without warning", () => {
+    // Arrange
+    const wire = makeJobWire({ jobId: "job-1", title: "My Job" });
+
+    // Act
+    const result = handleDetailSseMessage(
+      "job:updated",
+      JSON.stringify(wire),
+      "job-1",
+    );
+
+    // Assert
+    expect(result.kind).toBe("apply");
+    if (result.kind !== "apply") throw new Error("expected apply");
+    expect(result.event.type).toBe("job:updated");
+    expect(result.event.data).toEqual(wire);
+    expect(warnSpy).not.toHaveBeenCalled();
+  });
+});
+
+describe("fetchJobDetail", () => {
+  let fetchSpy: ReturnType<typeof spyOn>;
+
+  beforeEach(() => {
+    fetchSpy = spyOn(globalThis, "fetch");
+  });
+
+  afterEach(() => {
+    fetchSpy.mockRestore();
+  });
+
+  it("returns adapted detail on a 2xx {ok:true} envelope", async () => {
+    fetchSpy.mockResolvedValue(jsonResponse({
+      ok: true,
+      data: { jobId: "job-1", tasks: {} },
+    }));
+
+    const detail = await fetchJobDetail("job-1", new AbortController().signal);
+
+    expect(detail.jobId).toBe("job-1");
+    expect(detail.tasks).toEqual({});
+  });
+
+  it("rejects with malformed_response on a 2xx {ok:false} envelope", async () => {
+    fetchSpy.mockResolvedValue(jsonResponse({ ok: false }));
+
+    await expect(fetchJobDetail("job-1", new AbortController().signal)).rejects.toMatchObject({
+      code: "malformed_response",
+      message: "Malformed job detail response",
+      status: 200,
+    });
+  });
+
+  it("rejects with typed ApiError on a non-2xx response", async () => {
+    fetchSpy.mockResolvedValue(new Response("", { status: 404 }));
+
+    await expect(fetchJobDetail("job-1", new AbortController().signal)).rejects.toMatchObject({
+      code: "job_not_found",
+      status: 404,
+    });
+  });
+
+  it("propagates AbortError when fetch rejects with one", async () => {
+    fetchSpy.mockRejectedValue(new DOMException("Aborted", "AbortError"));
+
+    const promise = fetchJobDetail("job-1", new AbortController().signal);
+    await expect(promise).rejects.toBeInstanceOf(DOMException);
+    await expect(promise).rejects.toMatchObject({ name: "AbortError" });
   });
 });
+
+describe("useJobDetailWithUpdates hook (AC-10)", () => {
+  const originalEventSource = globalThis.EventSource;
+  let fetchSpy: ReturnType<typeof spyOn>;
+
+  beforeEach(() => {
+    fetchSpy = spyOn(globalThis, "fetch");
+    MockEventSource.reset();
+    globalThis.EventSource = MockEventSource as unknown as typeof EventSource;
+  });
+
+  afterEach(() => {
+    fetchSpy.mockRestore();
+    globalThis.EventSource = originalEventSource;
+    MockEventSource.reset();
+  });
+
+  it("sets typed error and leaves data null on an initial 404", async () => {
+    fetchSpy.mockResolvedValue(new Response("", { status: 404 }));
+
+    const { result } = renderHook(() => useJobDetailWithUpdates("job-1"));
+
+    await waitFor(() => expect(result.current.loading).toBe(false));
+    expect(result.current.error).toMatchObject({
+      code: "job_not_found",
+      status: 404,
+    });
+    expect(result.current.data).toBeNull();
+    expect(result.current.isHydrated).toBe(false);
+  });
+
+  it("sets typed error and leaves data null on an initial {ok:false} envelope", async () => {
+    fetchSpy.mockResolvedValue(jsonResponse({ ok: false }));
+
+    const { result } = renderHook(() => useJobDetailWithUpdates("job-1"));
+
+    await waitFor(() => expect(result.current.loading).toBe(false));
+    expect(result.current.error?.code).toBe("malformed_response");
+    expect(result.current.data).toBeNull();
+  });
+
+  it("populates data and clears any prior error on a valid response", async () => {
+    fetchSpy.mockResolvedValue(jsonResponse({
+      ok: true,
+      data: { jobId: "job-1", tasks: {} },
+    }));
+
+    const { result } = renderHook(() => useJobDetailWithUpdates("job-1"));
+
+    await waitFor(() => expect(result.current.data).not.toBeNull());
+    expect(result.current.data?.jobId).toBe("job-1");
+    expect(result.current.error).toBeNull();
+    expect(result.current.isHydrated).toBe(true);
+  });
+
+  it("keeps prior data and sets typed error on a failed refetch", async () => {
+    fetchSpy
+      .mockResolvedValueOnce(jsonResponse({ ok: true, data: { jobId: "job-1", tasks: {} } }))
+      .mockResolvedValueOnce(new Response("", { status: 500 }));
+
+    const { result } = renderHook(() => useJobDetailWithUpdates("job-1"));
+
+    await waitFor(() => expect(result.current.data?.jobId).toBe("job-1"));
+
+    act(() => {
+      result.current.refetch();
+    });
+
+    await waitFor(() => expect(result.current.error?.code).toBe("unknown_error"));
+    expect(result.current.data?.jobId).toBe("job-1");
+    expect(result.current.loading).toBe(false);
+    expect(result.current.isRefreshing).toBe(false);
+  });
+
+  it("ignores AbortError on initial load (no error, no data)", async () => {
+    fetchSpy.mockRejectedValue(new DOMException("Aborted", "AbortError"));
+
+    const { result } = renderHook(() => useJobDetailWithUpdates("job-1"));
+
+    await waitFor(() => expect(result.current.loading).toBe(false));
+    expect(result.current.error).toBeNull();
+    expect(result.current.data).toBeNull();
+  });
+
+  it("refetch() triggers another load and clears the error on success", async () => {
+    fetchSpy
+      .mockResolvedValueOnce(new Response("", { status: 500 }))
+      .mockResolvedValueOnce(jsonResponse({ ok: true, data: { jobId: "job-1", tasks: {} } }));
+
+    const { result } = renderHook(() => useJobDetailWithUpdates("job-1"));
+
+    await waitFor(() => expect(result.current.error?.code).toBe("unknown_error"));
+
+    act(() => {
+      result.current.refetch();
+    });
+
+    await waitFor(() => expect(result.current.data?.jobId).toBe("job-1"));
+    expect(result.current.error).toBeNull();
+    expect(result.current.isHydrated).toBe(true);
+  });
+
+  it("keeps the EventSource subscription active and applies job:updated after a fetch error (AC-10)", async () => {
+    fetchSpy
+      .mockResolvedValueOnce(jsonResponse({
+        ok: true,
+        data: {
+          jobId: "job-1",
+          tasks: {
+            build: { state: "pending" },
+            test: { state: "pending" },
+          },
+        },
+      }))
+      .mockResolvedValueOnce(new Response("", { status: 500 }));
+
+    const { result } = renderHook(() => useJobDetailWithUpdates("job-1"));
+
+    await waitFor(() => expect(result.current.data?.jobId).toBe("job-1"));
+    expect(MockEventSource.instances[0]?.closed).toBe(false);
+
+    act(() => {
+      result.current.refetch();
+    });
+
+    await waitFor(() => expect(result.current.error?.code).toBe("unknown_error"));
+    expect(result.current.data?.tasks["build"]?.state).toBe("pending");
+    expect(MockEventSource.instances[0]?.closed).toBe(false);
+
+    act(() => {
+      MockEventSource.instances[0]?.emit("job:updated", makeJobWire({
+        jobId: "job-1",
+        tasks: {
+          build: { state: "running" },
+          test: { state: "pending" },
+        },
+      }));
+    });
+
+    await waitFor(() => expect(result.current.data?.tasks["build"]?.state).toBe("running"));
+    expect(result.current.error?.code).toBe("unknown_error");
+    expect(MockEventSource.instances[0]?.closed).toBe(false);
+  });
+});