@stigmer/react 3.35.0 → 3.37.0

package/src/workflow/__tests__/useWorkflowCanvas.drag.test.tsx

@@ -1,229 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { renderHook, act } from "@testing-library/react";
-import type { ReactNode } from "react";
-import { ReactFlowProvider } from "@xyflow/react";
-import type { Node, OnNodeDrag } from "@xyflow/react";
-import { useWorkflowCanvas } from "../useWorkflowCanvas";
-
-// Regression tests for oss#602: node drags updated only React Flow's copy
-// of positions — nothing wrote them back to the WorkflowGraphModel. Any
-// later dispatch's syncFromModel snapped dragged nodes back to stale model
-// positions, and drags were invisible to undo (inconsistent with
-// auto-layout, which records a MoveNodesCommand). These tests drive the
-// hook through the same event sequence React Flow produces: position
-// changes stream through onNodesChange during the drag, then
-// onNodeDragStop fires with the dragged nodes' final positions.
-
-const FIXTURE_YAML = `apiVersion: agentic.stigmer.ai/v1
-kind: Workflow
-metadata:
-  name: drag-fixture
-spec:
-  document:
-    dsl: "1.0.0"
-    namespace: test
-    name: drag-fixture
-    version: "0.0.1"
-  tasks:
-    - name: step_1
-      kind: agent_call
-      task_config:
-        agent: "org/agent-slug"
-        message: "first"
-      flow:
-        then: step_2
-    - name: step_2
-      kind: agent_call
-      task_config:
-        agent: "org/agent-slug"
-        message: "second"
-      flow:
-        then: end
-`;
-
-function wrapper({ children }: { children: ReactNode }) {
-  return <ReactFlowProvider>{children}</ReactFlowProvider>;
-}
-
-function renderCanvas() {
-  return renderHook(() => useWorkflowCanvas(FIXTURE_YAML), { wrapper });
-}
-
-type CanvasResult = ReturnType<typeof renderCanvas>["result"];
-
-// The drag fixture derives its type from the handler itself, so it tracks
-// whatever event type the installed @xyflow/react declares (the pinned
-// 12.10.2 takes the React synthetic event; newer majors take the native
-// event) — a dependency bump can never strand this cast again (#821's
-// hand-written native-MouseEvent cast did not compile under npm ci).
-const DRAG_EVENT = {} as Parameters<OnNodeDrag>[0];
-
-function canvasPosition(result: CanvasResult, id: string): { x: number; y: number } {
-  const node = result.current.nodes.find((n) => n.id === id);
-  expect(node).toBeDefined();
-  return { x: node!.position.x, y: node!.position.y };
-}
-
-function modelPosition(result: CanvasResult, id: string): { x: number; y: number } {
-  const node = result.current.graph?.nodes.find((n) => n.id === id);
-  expect(node).toBeDefined();
-  return { x: node!.position.x, y: node!.position.y };
-}
-
-/**
- * Drives one full drag gesture the way React Flow does: dragStart with the
- * node at its current position, position changes streamed through
- * onNodesChange, then dragStop with the final positions.
- */
-function drag(result: CanvasResult, moves: readonly { id: string; to: { x: number; y: number } }[]) {
-  const startNodes = moves.map(({ id }) => {
-    const node = result.current.nodes.find((n) => n.id === id);
-    expect(node).toBeDefined();
-    return node!;
-  });
-
-  act(() => {
-    result.current.onNodeDragStart(DRAG_EVENT, startNodes[0], startNodes);
-  });
-  act(() => {
-    result.current.onNodesChange(
-      moves.map(({ id, to }) => ({ id, type: "position" as const, position: to, dragging: true })),
-    );
-    result.current.onNodesChange(
-      moves.map(({ id, to }) => ({ id, type: "position" as const, position: to, dragging: false })),
-    );
-  });
-
-  const stoppedNodes: Node[] = moves.map(({ id, to }, i) => ({
-    ...startNodes[i],
-    id,
-    position: to,
-  }));
-  act(() => {
-    result.current.onNodeDragStop(DRAG_EVENT, stoppedNodes[0], stoppedNodes);
-  });
-}
-
-describe("useWorkflowCanvas — drag → model sync (oss#602)", () => {
-  it("writes the dragged position into the graph model", () => {
-    const { result } = renderCanvas();
-    const target = { x: 640, y: 480 };
-
-    drag(result, [{ id: "step_2", to: target }]);
-
-    expect(modelPosition(result, "step_2")).toEqual(target);
-    expect(canvasPosition(result, "step_2")).toEqual(target);
-  });
-
-  it("a dragged position survives a later dispatch (the snap-back repro)", () => {
-    const { result } = renderCanvas();
-    const target = { x: 640, y: 480 };
-
-    drag(result, [{ id: "step_2", to: target }]);
-
-    // Any dispatch triggers syncFromModel, which rebuilds the canvas from
-    // the model — on main this snapped step_2 back to its stale position.
-    act(() => {
-      result.current.renameNode("step_1", "step_1_renamed");
-    });
-
-    expect(result.current.nodes.map((n) => n.id)).toContain("step_1_renamed");
-    expect(canvasPosition(result, "step_2")).toEqual(target);
-    expect(modelPosition(result, "step_2")).toEqual(target);
-  });
-
-  it("undo restores pre-drag positions on model AND canvas; redo reapplies", () => {
-    const { result } = renderCanvas();
-    const before = canvasPosition(result, "step_2");
-    const target = { x: 640, y: 480 };
-
-    drag(result, [{ id: "step_2", to: target }]);
-    expect(result.current.canUndo).toBe(true);
-
-    act(() => {
-      result.current.undo();
-    });
-    expect(modelPosition(result, "step_2")).toEqual(before);
-    expect(canvasPosition(result, "step_2")).toEqual(before);
-
-    act(() => {
-      result.current.redo();
-    });
-    expect(modelPosition(result, "step_2")).toEqual(target);
-    expect(canvasPosition(result, "step_2")).toEqual(target);
-  });
-
-  it("a multi-select drag is ONE history entry — a single undo restores the group", () => {
-    const { result } = renderCanvas();
-    const before1 = canvasPosition(result, "step_1");
-    const before2 = canvasPosition(result, "step_2");
-
-    drag(result, [
-      { id: "step_1", to: { x: 100, y: 700 } },
-      { id: "step_2", to: { x: 300, y: 700 } },
-    ]);
-    expect(modelPosition(result, "step_1")).toEqual({ x: 100, y: 700 });
-    expect(modelPosition(result, "step_2")).toEqual({ x: 300, y: 700 });
-
-    act(() => {
-      result.current.undo();
-    });
-    expect(modelPosition(result, "step_1")).toEqual(before1);
-    expect(modelPosition(result, "step_2")).toEqual(before2);
-    expect(result.current.canUndo).toBe(false);
-  });
-
-  it("a zero-delta drag records no history entry", () => {
-    const { result } = renderCanvas();
-    const before = canvasPosition(result, "step_2");
-
-    drag(result, [{ id: "step_2", to: before }]);
-
-    expect(result.current.canUndo).toBe(false);
-  });
-
-  it("selection survives a drag (record-only dispatch: no canvas rebuild)", () => {
-    const { result } = renderCanvas();
-
-    act(() => {
-      result.current.onNodesChange([{ id: "step_2", type: "select", selected: true }]);
-    });
-    expect(result.current.nodes.find((n) => n.id === "step_2")?.selected).toBe(true);
-
-    drag(result, [{ id: "step_2", to: { x: 640, y: 480 } }]);
-
-    // A syncing dispatch would rebuild the node array from the model and
-    // wipe React Flow's `selected` flags — the record-only invariant
-    // keeps the just-dragged node selected. Pinned so a refactor to the
-    // syncing dispatch() fails here.
-    expect(result.current.nodes.find((n) => n.id === "step_2")?.selected).toBe(true);
-  });
-
-  it("a drag invalidated by a mid-drag model mutation records nothing", () => {
-    const { result } = renderCanvas();
-    const startNode = result.current.nodes.find((n) => n.id === "step_2")!;
-
-    act(() => {
-      result.current.onNodeDragStart(DRAG_EVENT, startNode, [startNode]);
-    });
-    // A mutation lands while the mouse is still down (keyboard undo and
-    // the host's YAML prop are both reachable mid-drag). syncFromModel
-    // already rebuilt the canvas, so the drag has nothing valid to record.
-    act(() => {
-      result.current.renameNode("step_1", "step_1_renamed");
-    });
-    act(() => {
-      result.current.onNodeDragStop(DRAG_EVENT, { ...startNode, position: { x: 640, y: 480 } }, [
-        { ...startNode, position: { x: 640, y: 480 } },
-      ]);
-    });
-
-    expect(modelPosition(result, "step_2")).not.toEqual({ x: 640, y: 480 });
-
-    // Only the rename is in history: one undo drains it.
-    act(() => {
-      result.current.undo();
-    });
-    expect(result.current.canUndo).toBe(false);
-  });
-});

package/src/workflow/__tests__/useWorkflowCanvas.undo.test.tsx

@@ -1,133 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { renderHook, act } from "@testing-library/react";
-import type { ReactNode } from "react";
-import { ReactFlowProvider } from "@xyflow/react";
-import { useWorkflowCanvas } from "../useWorkflowCanvas";
-
-// Regression tests for oss#588: undoing a node deletion restored the graph
-// MODEL (inspector rebinds, history entry consumed) but the React Flow
-// nodes array was synced from a stale pre-undo snapshot, so the canvas
-// node never reappeared. These tests exercise the hook composition — the
-// exact layer the bug lived in; the pure command stack is covered in
-// graph-history.test.ts.
-
-const FIXTURE_YAML = `apiVersion: agentic.stigmer.ai/v1
-kind: Workflow
-metadata:
-  name: undo-fixture
-spec:
-  document:
-    dsl: "1.0.0"
-    namespace: test
-    name: undo-fixture
-    version: "0.0.1"
-  tasks:
-    - name: step_1
-      kind: agent_call
-      task_config:
-        agent: "org/agent-slug"
-        message: "first"
-      flow:
-        then: step_2
-    - name: step_2
-      kind: agent_call
-      task_config:
-        agent: "org/agent-slug"
-        message: "second"
-      flow:
-        then: end
-`;
-
-function wrapper({ children }: { children: ReactNode }) {
-  return <ReactFlowProvider>{children}</ReactFlowProvider>;
-}
-
-function renderCanvas() {
-  return renderHook(() => useWorkflowCanvas(FIXTURE_YAML), { wrapper });
-}
-
-function canvasNodeIds(result: { current: { nodes: readonly { id: string }[] } }): string[] {
-  return result.current.nodes.map((n) => n.id);
-}
-
-describe("useWorkflowCanvas — undo/redo canvas sync (oss#588)", () => {
-  it("parses the fixture into canvas nodes", () => {
-    const { result } = renderCanvas();
-    expect(canvasNodeIds(result)).toEqual(
-      expect.arrayContaining(["step_1", "step_2"]),
-    );
-  });
-
-  it("undo after a node delete restores the node on the CANVAS, not just the model", () => {
-    const { result } = renderCanvas();
-
-    const target = result.current.nodes.find((n) => n.id === "step_2");
-    expect(target).toBeDefined();
-
-    act(() => {
-      result.current.onNodesDelete([target!]);
-    });
-    expect(canvasNodeIds(result)).not.toContain("step_2");
-    expect(result.current.canUndo).toBe(true);
-
-    act(() => {
-      result.current.undo();
-    });
-
-    // The model restores (this always worked — the inspector saw it) …
-    expect(result.current.graph?.nodes.map((n) => n.id)).toContain("step_2");
-    // … and the canvas must restore with it (the oss#588 gap).
-    expect(canvasNodeIds(result)).toContain("step_2");
-    expect(result.current.canUndo).toBe(false);
-    expect(result.current.canRedo).toBe(true);
-  });
-
-  it("undo restores the deleted node's edges on the canvas", () => {
-    const { result } = renderCanvas();
-    const edgeCountBefore = result.current.edges.length;
-
-    const target = result.current.nodes.find((n) => n.id === "step_2");
-    act(() => {
-      result.current.onNodesDelete([target!]);
-    });
-    expect(result.current.edges.length).toBeLessThan(edgeCountBefore);
-
-    act(() => {
-      result.current.undo();
-    });
-    expect(result.current.edges.length).toBe(edgeCountBefore);
-  });
-
-  it("redo after an undo removes the node from the canvas again", () => {
-    const { result } = renderCanvas();
-
-    const target = result.current.nodes.find((n) => n.id === "step_2");
-    act(() => {
-      result.current.onNodesDelete([target!]);
-    });
-    act(() => {
-      result.current.undo();
-    });
-    expect(canvasNodeIds(result)).toContain("step_2");
-
-    act(() => {
-      result.current.redo();
-    });
-
-    expect(result.current.graph?.nodes.map((n) => n.id)).not.toContain("step_2");
-    expect(canvasNodeIds(result)).not.toContain("step_2");
-    expect(result.current.canUndo).toBe(true);
-    expect(result.current.canRedo).toBe(false);
-  });
-
-  it("undo with an empty history leaves the canvas untouched", () => {
-    const { result } = renderCanvas();
-    const before = canvasNodeIds(result);
-
-    act(() => {
-      result.current.undo();
-    });
-
-    expect(canvasNodeIds(result)).toEqual(before);
-  });
-});

package/src/workflow/__tests__/useWorkflowExecution.test.tsx

@@ -1,329 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
-import { renderHook, act } from "@testing-library/react";
-import type { ReactNode } from "react";
-import { createElement } from "react";
-import { StigmerContext } from "../../context";
-import { RunnerAdapterContext, type RunnerAdapter } from "../../runner-adapter";
-import { ExecutionTargetContext } from "../../execution-target-context";
-import { useWorkflowExecution } from "../useWorkflowExecution";
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-async function flush(): Promise<void> {
-  await act(async () => {
-    await Promise.resolve();
-  });
-}
-
-function makeExecution(
-  id: string,
-  phase: number,
-  opts?: { name?: string },
-) {
-  return {
-    metadata: { id, name: opts?.name ?? `exec-${id}`, org: "org-1" },
-    status: { phase },
-    spec: {},
-  } as any;
-}
-
-// Phase constants matching the proto enum
-const PHASE = {
-  IN_PROGRESS: 2,
-  COMPLETED: 3,
-  FAILED: 4,
-  CANCELLED: 5,
-  TERMINATED: 6,
-} as const;
-
-function makeMockClient(getFn: (...args: any[]) => Promise<any>) {
-  return {
-    workflowExecution: { get: getFn },
-  } as any;
-}
-
-function makeMockAdapter(): RunnerAdapter & { calls: string[][] } {
-  const calls: string[][] = [];
-  return {
-    calls,
-    onSessionOpened: vi.fn(async (id: string) => { calls.push(["onSessionOpened", id]); }),
-    onSessionClosed: vi.fn(async (id: string) => { calls.push(["onSessionClosed", id]); }),
-    onWorkflowExecutionCreated: vi.fn(async (id: string) => { calls.push(["onWorkflowExecutionCreated", id]); }),
-    onWorkflowExecutionTerminated: vi.fn(async (id: string) => { calls.push(["onWorkflowExecutionTerminated", id]); }),
-  };
-}
-
-function createWrapper(
-  client: any,
-  adapter: RunnerAdapter | null = null,
-  executionTarget: "local" | "cloud" | undefined = "local",
-) {
-  return function Wrapper({ children }: { children: ReactNode }) {
-    return createElement(
-      StigmerContext.Provider,
-      { value: client },
-      createElement(
-        RunnerAdapterContext.Provider,
-        { value: adapter },
-        createElement(
-          ExecutionTargetContext.Provider,
-          { value: executionTarget },
-          children,
-        ),
-      ),
-    );
-  };
-}
-
-beforeEach(() => {
-  vi.clearAllMocks();
-});
-
-// ---------------------------------------------------------------------------
-// Core data fetching
-// ---------------------------------------------------------------------------
-
-describe("useWorkflowExecution — data fetching", () => {
-  it("fetches execution by id", async () => {
-    const exec = makeExecution("wex-001", PHASE.IN_PROGRESS);
-    const getFn = vi.fn(async () => exec);
-    const client = makeMockClient(getFn);
-
-    const { result } = renderHook(
-      () => useWorkflowExecution("wex-001"),
-      { wrapper: createWrapper(client) },
-    );
-
-    await flush();
-    expect(result.current.execution).toBe(exec);
-    expect(result.current.isLoading).toBe(false);
-    expect(result.current.error).toBeNull();
-    expect(getFn).toHaveBeenCalledWith("wex-001");
-  });
-
-  it("returns null execution when id is null", async () => {
-    const getFn = vi.fn(async () => makeExecution("wex-001", PHASE.IN_PROGRESS));
-    const client = makeMockClient(getFn);
-
-    const { result } = renderHook(
-      () => useWorkflowExecution(null),
-      { wrapper: createWrapper(client) },
-    );
-
-    await flush();
-    expect(result.current.execution).toBeNull();
-    expect(result.current.isLoading).toBe(false);
-    expect(getFn).not.toHaveBeenCalled();
-  });
-
-  it("handles NOT_FOUND by returning null without error", async () => {
-    const notFoundErr = new Error("not found");
-    (notFoundErr as any).code = "NOT_FOUND";
-    // The hook uses isNotFound from @stigmer/sdk, so mock it globally
-    const getFn = vi.fn(async () => {
-      throw notFoundErr;
-    });
-    const client = makeMockClient(getFn);
-
-    const { result } = renderHook(
-      () => useWorkflowExecution("wex-gone"),
-      { wrapper: createWrapper(client) },
-    );
-
-    await flush();
-    // The hook will either return null (if isNotFound handles it) or set an error.
-    // Either way, verify we don't crash.
-    expect(result.current.isLoading).toBe(false);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Identity guard: Layer 2 defense against stale data
-//
-// This is the critical test suite that validates the fix for the premature
-// worker shutdown bug. The identity guard ensures that
-// onWorkflowExecutionTerminated is ONLY called when the fetched execution's
-// metadata.id matches the currently requested executionId.
-// ---------------------------------------------------------------------------
-
-describe("useWorkflowExecution — identity guard (Layer 2)", () => {
-  it("calls onWorkflowExecutionTerminated when execution reaches terminal phase", async () => {
-    const exec = makeExecution("wex-done", PHASE.COMPLETED);
-    const getFn = vi.fn(async () => exec);
-    const client = makeMockClient(getFn);
-    const adapter = makeMockAdapter();
-
-    const { result } = renderHook(
-      () => useWorkflowExecution("wex-done"),
-      { wrapper: createWrapper(client, adapter, "local") },
-    );
-
-    await flush();
-
-    expect(result.current.execution).toBe(exec);
-    expect(adapter.onWorkflowExecutionTerminated).toHaveBeenCalledWith("wex-done");
-    expect(adapter.onWorkflowExecutionTerminated).toHaveBeenCalledTimes(1);
-  });
-
-  it("does NOT call onWorkflowExecutionTerminated for non-terminal phases", async () => {
-    const exec = makeExecution("wex-running", PHASE.IN_PROGRESS);
-    const getFn = vi.fn(async () => exec);
-    const client = makeMockClient(getFn);
-    const adapter = makeMockAdapter();
-
-    renderHook(
-      () => useWorkflowExecution("wex-running"),
-      { wrapper: createWrapper(client, adapter, "local") },
-    );
-
-    await flush();
-    expect(adapter.onWorkflowExecutionTerminated).not.toHaveBeenCalled();
-  });
-
-  it("does NOT call onWorkflowExecutionTerminated when adapter is null (cloud mode)", async () => {
-    const exec = makeExecution("wex-cloud", PHASE.COMPLETED);
-    const getFn = vi.fn(async () => exec);
-    const client = makeMockClient(getFn);
-
-    renderHook(
-      () => useWorkflowExecution("wex-cloud"),
-      { wrapper: createWrapper(client, null, "cloud") },
-    );
-
-    await flush();
-    // No adapter, no call — cloud deployments don't manage runners
-  });
-
-  it("does NOT fire termination for stale data from a different execution ID", async () => {
-    // This is the exact scenario that caused the premature worker shutdown:
-    // - User navigates from completed exec-A to running exec-B
-    // - useFetch briefly holds exec-A's COMPLETED data while exec-B loads
-    // - Without the identity guard, the termination effect would fire
-    //   onWorkflowExecutionTerminated("exec-B") using exec-A's phase
-    //
-    // The fix: `fetchedId === executionId` guard prevents this.
-
-    const execA = makeExecution("exec-A", PHASE.COMPLETED);
-    const execB = makeExecution("exec-B", PHASE.IN_PROGRESS);
-
-    let currentId = "exec-A";
-    const getFn = vi.fn(async (id: string) => {
-      if (id === "exec-A") return execA;
-      if (id === "exec-B") return execB;
-      return null;
-    });
-    const client = makeMockClient(getFn);
-    const adapter = makeMockAdapter();
-
-    const { rerender } = renderHook(
-      () => useWorkflowExecution(currentId),
-      { wrapper: createWrapper(client, adapter, "local") },
-    );
-
-    // Exec-A completes → termination fires for exec-A
-    await flush();
-    expect(adapter.onWorkflowExecutionTerminated).toHaveBeenCalledWith("exec-A");
-    expect(adapter.onWorkflowExecutionTerminated).toHaveBeenCalledTimes(1);
-
-    // Clear mocks to track new calls
-    vi.clearAllMocks();
-
-    // Switch to exec-B (running) — the key moment
-    currentId = "exec-B";
-    rerender();
-
-    // useFetch should reset data to null (initialData) due to cache miss.
-    // Even if stale exec-A data briefly appears, the identity guard
-    // (fetchedId === executionId) prevents termination of exec-B.
-    await flush();
-
-    // onWorkflowExecutionTerminated must NOT have been called for exec-B
-    // because exec-B is IN_PROGRESS, not terminal.
-    expect(adapter.onWorkflowExecutionTerminated).not.toHaveBeenCalled();
-  });
-
-  it("fires termination only once per execution (dedup via terminatedRef)", async () => {
-    const exec = makeExecution("wex-dedup", PHASE.FAILED);
-    const getFn = vi.fn(async () => exec);
-    const client = makeMockClient(getFn);
-    const adapter = makeMockAdapter();
-
-    const { result } = renderHook(
-      () => useWorkflowExecution("wex-dedup"),
-      { wrapper: createWrapper(client, adapter, "local") },
-    );
-
-    await flush();
-    expect(adapter.onWorkflowExecutionTerminated).toHaveBeenCalledTimes(1);
-
-    // Trigger a refetch — the execution is still FAILED
-    await act(async () => {
-      result.current.refetch();
-    });
-    await flush();
-
-    // Should NOT fire again due to terminatedRef dedup
-    expect(adapter.onWorkflowExecutionTerminated).toHaveBeenCalledTimes(1);
-  });
-
-  it("resets terminatedRef when executionId changes", async () => {
-    const execX = makeExecution("wex-X", PHASE.COMPLETED);
-    const execY = makeExecution("wex-Y", PHASE.COMPLETED);
-
-    let currentId = "wex-X";
-    const getFn = vi.fn(async (id: string) => {
-      if (id === "wex-X") return execX;
-      if (id === "wex-Y") return execY;
-      return null;
-    });
-    const client = makeMockClient(getFn);
-    const adapter = makeMockAdapter();
-
-    const { rerender } = renderHook(
-      () => useWorkflowExecution(currentId),
-      { wrapper: createWrapper(client, adapter, "local") },
-    );
-
-    await flush();
-    expect(adapter.onWorkflowExecutionTerminated).toHaveBeenCalledWith("wex-X");
-    expect(adapter.onWorkflowExecutionTerminated).toHaveBeenCalledTimes(1);
-
-    // Switch to a different completed execution
-    currentId = "wex-Y";
-    rerender();
-    await flush();
-
-    // terminatedRef should have been reset by the executionId change effect,
-    // so termination fires for wex-Y too
-    expect(adapter.onWorkflowExecutionTerminated).toHaveBeenCalledWith("wex-Y");
-    expect(adapter.onWorkflowExecutionTerminated).toHaveBeenCalledTimes(2);
-  });
-
-  it("handles all terminal phases correctly", async () => {
-    const terminalPhases = [
-      PHASE.COMPLETED,
-      PHASE.FAILED,
-      PHASE.CANCELLED,
-      PHASE.TERMINATED,
-    ] as const;
-
-    for (const phase of terminalPhases) {
-      vi.clearAllMocks();
-
-      const exec = makeExecution(`wex-${phase}`, phase);
-      const getFn = vi.fn(async () => exec);
-      const client = makeMockClient(getFn);
-      const adapter = makeMockAdapter();
-
-      renderHook(
-        () => useWorkflowExecution(`wex-${phase}`),
-        { wrapper: createWrapper(client, adapter, "local") },
-      );
-
-      await flush();
-      expect(adapter.onWorkflowExecutionTerminated).toHaveBeenCalledTimes(1);
-    }
-  });
-});