@gizmo-ai/client 0.2.2

package/src/__tests__/client.test.ts

@@ -0,0 +1,412 @@
+import { describe, expect, test, mock } from "bun:test";
+import { createClient } from "../client.ts";
+import { GizmoClientError } from "../errors.ts";
+import type { GizmoManifest, InvokeResponse, RunsResponse, RunDetails, RunSummary, HydrateResponse } from "../types.ts";
+
+// ── Mock fetch helper ──────────────────────────────────────────────
+
+interface TrackedFetch {
+  fetch: typeof globalThis.fetch;
+  calls: Array<{ url: string; init?: RequestInit }>;
+}
+
+function mockFetch(responses: Record<string, { status?: number; body: unknown }>): TrackedFetch {
+  const calls: TrackedFetch["calls"] = [];
+  const fn = async (input: RequestInfo | URL, init?: RequestInit) => {
+    const url = typeof input === "string" ? input : input.toString();
+    const method = init?.method ?? "GET";
+    const key = `${method} ${url}`;
+
+    calls.push({ url, init });
+
+    // Find matching response — try exact match first
+    const match = responses[key];
+
+    if (!match) {
+      return new Response(JSON.stringify({ error: "Not found" }), {
+        status: 404,
+        headers: { "Content-Type": "application/json" },
+      });
+    }
+
+    return new Response(JSON.stringify(match.body), {
+      status: match.status ?? 200,
+      headers: { "Content-Type": "application/json" },
+    });
+  };
+
+  return { fetch: fn as typeof globalThis.fetch, calls };
+}
+
+// ── Fixtures ───────────────────────────────────────────────────────
+
+const MANIFEST: GizmoManifest = {
+  manifestVersion: "1.0.0",
+  identity: { agentId: "test-agent", name: "Test Agent", version: "1.0.0" },
+  endpoints: {
+    invoke: "/invoke",
+    state: "/state",
+    runs: "/runs",
+    streams: { state: "/stream/state", actions: "/stream/actions", events: "/events" },
+  },
+  state: { slices: ["agent", "execution"], schemaVersion: "1.0.0" },
+  capabilities: {},
+};
+
+// ── Tests ──────────────────────────────────────────────────────────
+
+describe("createClient", () => {
+  describe("discover()", () => {
+    test("fetches manifest and caches it", async () => {
+      const { fetch, calls } = mockFetch({
+        "GET http://localhost:3001/.well-known/manifest.json": { body: MANIFEST },
+      });
+      const client = createClient("http://localhost:3001", { fetch });
+
+      const m1 = await client.discover();
+      const m2 = await client.discover();
+
+      expect(m1).toEqual(MANIFEST);
+      expect(m2).toEqual(MANIFEST);
+      // fetch should only be called once due to caching
+      expect(calls).toHaveLength(1);
+    });
+  });
+
+  describe("invoke()", () => {
+    test("sends correct body and returns response", async () => {
+      const response: InvokeResponse = { executionId: "exec-1", turnId: "turn-1" };
+      const { fetch, calls } = mockFetch({
+        "POST http://localhost:3001/invoke": { status: 200, body: response },
+      });
+      const client = createClient("http://localhost:3001", { fetch });
+
+      const result = await client.invoke("Hello agent");
+      expect(result).toEqual(response);
+
+      // Verify the body was sent correctly
+      expect(JSON.parse(calls[0].init!.body as string)).toEqual({ input: "Hello agent" });
+    });
+  });
+
+  describe("abort()", () => {
+    test("posts to /abort", async () => {
+      const { fetch } = mockFetch({
+        "POST http://localhost:3001/abort": { body: { status: "aborted", executionId: "exec-1" } },
+      });
+      const client = createClient("http://localhost:3001", { fetch });
+
+      const result = await client.abort();
+      expect(result.status).toBe("aborted");
+    });
+  });
+
+  describe("state()", () => {
+    test("fetches full state without slice arg", async () => {
+      const state = { agent: { conversation: [] }, execution: { id: null } };
+      const { fetch } = mockFetch({
+        "GET http://localhost:3001/state": { body: state },
+      });
+      const client = createClient("http://localhost:3001", { fetch });
+
+      const result = await client.state();
+      expect(result).toEqual(state);
+    });
+
+    test("fetches specific slice when provided", async () => {
+      const agentState = { conversation: [], loopCount: 0 };
+      const { fetch } = mockFetch({
+        "GET http://localhost:3001/state/agent": { body: agentState },
+      });
+      const client = createClient("http://localhost:3001", { fetch });
+
+      const result = await client.state("agent");
+      expect(result).toEqual(agentState);
+    });
+  });
+
+  describe("health()", () => {
+    test("fetches health endpoint", async () => {
+      const { fetch } = mockFetch({
+        "GET http://localhost:3001/health": { body: { status: "ok" } },
+      });
+      const client = createClient("http://localhost:3001", { fetch });
+
+      const result = await client.health();
+      expect(result).toEqual({ status: "ok" });
+    });
+  });
+
+  describe("dispatch()", () => {
+    test("posts action to /dispatch", async () => {
+      const { fetch, calls } = mockFetch({
+        "POST http://localhost:3001/dispatch": { body: { ok: true } },
+      });
+      const client = createClient("http://localhost:3001", { fetch });
+
+      await client.dispatch({ type: "CUSTOM_ACTION", payload: { value: 42 } });
+
+      expect(JSON.parse(calls[0].init!.body as string)).toEqual({
+        type: "CUSTOM_ACTION",
+        payload: { value: 42 },
+      });
+    });
+  });
+
+  describe("runs", () => {
+    test("list() builds query params correctly", async () => {
+      const { fetch } = mockFetch({
+        "GET http://localhost:3001/runs?status=completed&limit=5": {
+          body: { runs: [] } satisfies RunsResponse,
+        },
+      });
+      const client = createClient("http://localhost:3001", { fetch });
+
+      const result = await client.runs.list({ status: "completed", limit: 5 });
+      expect(result).toEqual([]);
+    });
+
+    test("list() without params calls /runs", async () => {
+      const runs: RunSummary[] = [
+        { executionId: "exec-1", startTime: 1000, status: "completed", actionCount: 5 },
+      ];
+      const { fetch } = mockFetch({
+        "GET http://localhost:3001/runs": { body: { runs } },
+      });
+      const client = createClient("http://localhost:3001", { fetch });
+
+      const result = await client.runs.list();
+      expect(result).toEqual(runs);
+    });
+
+    test("get() fetches run details", async () => {
+      const run: RunDetails = {
+        executionId: "exec-1",
+        startTime: 1000,
+        status: "completed",
+        actionCount: 2,
+        actions: [{ type: "A" }, { type: "B" }],
+      };
+      const { fetch } = mockFetch({
+        "GET http://localhost:3001/runs/exec-1": { body: run },
+      });
+      const client = createClient("http://localhost:3001", { fetch });
+
+      const result = await client.runs.get("exec-1");
+      expect(result).toEqual(run);
+    });
+
+    test("actions() returns just the actions array", async () => {
+      const actions = [{ type: "A" }, { type: "B" }];
+      const run: RunDetails = {
+        executionId: "exec-1",
+        startTime: 1000,
+        status: "completed",
+        actionCount: 2,
+        actions,
+      };
+      const { fetch } = mockFetch({
+        "GET http://localhost:3001/runs/exec-1": { body: run },
+      });
+      const client = createClient("http://localhost:3001", { fetch });
+
+      const result = await client.runs.actions("exec-1");
+      expect(result).toEqual(actions);
+    });
+
+    test("cancel() posts to /runs/:id/cancel", async () => {
+      const { fetch } = mockFetch({
+        "POST http://localhost:3001/runs/exec-1/cancel": {
+          body: { status: "cancelled", executionId: "exec-1" },
+        },
+      });
+      const client = createClient("http://localhost:3001", { fetch });
+
+      const result = await client.runs.cancel("exec-1");
+      expect(result.status).toBe("cancelled");
+      expect(result.executionId).toBe("exec-1");
+    });
+
+    test("hydrate() posts to /hydrate with executionId in body", async () => {
+      const hydrateRes: HydrateResponse = {
+        status: "hydrated",
+        actionCount: 10,
+        state: { conversationLength: 5, loopCount: 2 },
+      };
+      const { fetch, calls } = mockFetch({
+        "POST http://localhost:3001/hydrate": { body: hydrateRes },
+      });
+      const client = createClient("http://localhost:3001", { fetch });
+
+      const result = await client.runs.hydrate("exec-1", { upToTurn: 3 });
+      expect(result).toEqual(hydrateRes);
+
+      // Verify executionId is in the body
+      expect(JSON.parse(calls[0].init!.body as string)).toEqual({
+        executionId: "exec-1",
+        upToTurn: 3,
+      });
+    });
+  });
+
+  describe("approvals", () => {
+    const approval = {
+      id: "apr-1",
+      executionId: "exec-1",
+      toolCall: { name: "bash", args: { cmd: "ls" } },
+      status: "pending" as const,
+      requestedAt: 1000,
+    };
+
+    test("list() returns approvals array", async () => {
+      const { fetch } = mockFetch({
+        "GET http://localhost:3001/approvals": { body: { approvals: [approval] } },
+      });
+      const client = createClient("http://localhost:3001", { fetch });
+
+      const result = await client.approvals.list();
+      expect(result).toEqual([approval]);
+    });
+
+    test("history() returns history array", async () => {
+      const decided = { ...approval, status: "approved" as const, decidedAt: 2000 };
+      const { fetch } = mockFetch({
+        "GET http://localhost:3001/approvals/history": { body: { history: [decided] } },
+      });
+      const client = createClient("http://localhost:3001", { fetch });
+
+      const result = await client.approvals.history();
+      expect(result).toEqual([decided]);
+    });
+
+    test("get() returns single approval", async () => {
+      const { fetch } = mockFetch({
+        "GET http://localhost:3001/approvals/apr-1": { body: { approval } },
+      });
+      const client = createClient("http://localhost:3001", { fetch });
+
+      const result = await client.approvals.get("apr-1");
+      expect(result).toEqual(approval);
+    });
+
+    test("approve() sends correct decision", async () => {
+      const decided = { ...approval, status: "approved" as const, decidedAt: 2000 };
+      const { fetch, calls } = mockFetch({
+        "POST http://localhost:3001/approvals/apr-1": { body: { approval: decided } },
+      });
+      const client = createClient("http://localhost:3001", { fetch });
+
+      const result = await client.approvals.approve("apr-1", "Looks safe");
+      expect(result.status).toBe("approved");
+
+      expect(JSON.parse(calls[0].init!.body as string)).toEqual({
+        decision: "approve",
+        reason: "Looks safe",
+      });
+    });
+
+    test("reject() sends correct decision", async () => {
+      const decided = { ...approval, status: "rejected" as const, decidedAt: 2000 };
+      const { fetch, calls } = mockFetch({
+        "POST http://localhost:3001/approvals/apr-1": { body: { approval: decided } },
+      });
+      const client = createClient("http://localhost:3001", { fetch });
+
+      const result = await client.approvals.reject("apr-1", "Too dangerous");
+      expect(result.status).toBe("rejected");
+
+      expect(JSON.parse(calls[0].init!.body as string)).toEqual({
+        decision: "reject",
+        reason: "Too dangerous",
+      });
+    });
+  });
+
+  describe("error handling", () => {
+    test("HTTP errors throw GizmoClientError", async () => {
+      const { fetch } = mockFetch({
+        "GET http://localhost:3001/health": {
+          status: 500,
+          body: { error: "Internal server error" },
+        },
+      });
+      const client = createClient("http://localhost:3001", { fetch });
+
+      try {
+        await client.health();
+        expect.unreachable("Should have thrown");
+      } catch (err) {
+        expect(err).toBeInstanceOf(GizmoClientError);
+        const e = err as GizmoClientError;
+        expect(e.status).toBe(500);
+        expect(e.message).toBe("Internal server error");
+        expect(e.body).toEqual({ error: "Internal server error" });
+      }
+    });
+
+    test("404 errors include status", async () => {
+      const { fetch } = mockFetch({
+        "GET http://localhost:3001/runs/missing": {
+          status: 404,
+          body: { error: "Run \"missing\" not found" },
+        },
+      });
+      const client = createClient("http://localhost:3001", { fetch });
+
+      try {
+        await client.runs.get("missing");
+        expect.unreachable("Should have thrown");
+      } catch (err) {
+        const e = err as GizmoClientError;
+        expect(e.status).toBe(404);
+      }
+    });
+  });
+
+  describe("custom headers", () => {
+    test("headers are threaded through all requests", async () => {
+      const { fetch, calls } = mockFetch({
+        "GET http://localhost:3001/health": { body: { status: "ok" } },
+      });
+      const client = createClient("http://localhost:3001", {
+        fetch,
+        headers: { Authorization: "Bearer token-123" },
+      });
+
+      await client.health();
+
+      const reqHeaders = calls[0].init!.headers as Record<string, string>;
+      expect(reqHeaders.Authorization).toBe("Bearer token-123");
+    });
+
+    test("custom headers are present on POST requests", async () => {
+      const { fetch, calls } = mockFetch({
+        "POST http://localhost:3001/invoke": {
+          body: { executionId: "e", turnId: "t" },
+        },
+      });
+      const client = createClient("http://localhost:3001", {
+        fetch,
+        headers: { "X-Api-Key": "key-456" },
+      });
+
+      await client.invoke("test");
+
+      const reqHeaders = calls[0].init!.headers as Record<string, string>;
+      expect(reqHeaders["X-Api-Key"]).toBe("key-456");
+    });
+  });
+
+  describe("trailing slash handling", () => {
+    test("strips trailing slash from baseUrl", async () => {
+      const { fetch, calls } = mockFetch({
+        "GET http://localhost:3001/health": { body: { status: "ok" } },
+      });
+      const client = createClient("http://localhost:3001/", { fetch });
+
+      await client.health();
+
+      expect(calls[0].url).toBe("http://localhost:3001/health");
+    });
+  });
+});