@kirrosh/apitool 0.4.3

package/tests/runner/assertions.test.ts

@@ -0,0 +1,262 @@
+import { describe, test, expect } from "bun:test";
+import { checkAssertions, extractCaptures } from "../../src/core/runner/assertions.ts";
+import type { HttpResponse } from "../../src/core/runner/types.ts";
+
+function makeResponse(overrides: Partial<HttpResponse> = {}): HttpResponse {
+  return {
+    status: 200,
+    headers: { "content-type": "application/json" },
+    body: "{}",
+    body_parsed: {},
+    duration_ms: 100,
+    ...overrides,
+  };
+}
+
+describe("checkAssertions", () => {
+  describe("status", () => {
+    test("passes when status matches", () => {
+      const results = checkAssertions({ status: 200 }, makeResponse({ status: 200 }));
+      expect(results).toHaveLength(1);
+      expect(results[0]!.passed).toBe(true);
+      expect(results[0]!.field).toBe("status");
+    });
+
+    test("fails when status does not match", () => {
+      const results = checkAssertions({ status: 201 }, makeResponse({ status: 200 }));
+      expect(results[0]!.passed).toBe(false);
+      expect(results[0]!.actual).toBe(200);
+      expect(results[0]!.expected).toBe(201);
+    });
+  });
+
+  describe("duration", () => {
+    test("passes when duration is within limit", () => {
+      const results = checkAssertions({ duration: 200 }, makeResponse({ duration_ms: 100 }));
+      expect(results[0]!.passed).toBe(true);
+    });
+
+    test("fails when duration exceeds limit", () => {
+      const results = checkAssertions({ duration: 50 }, makeResponse({ duration_ms: 100 }));
+      expect(results[0]!.passed).toBe(false);
+    });
+  });
+
+  describe("headers", () => {
+    test("passes when header matches", () => {
+      const results = checkAssertions(
+        { headers: { "content-type": "application/json" } },
+        makeResponse({ headers: { "content-type": "application/json" } }),
+      );
+      expect(results[0]!.passed).toBe(true);
+    });
+
+    test("fails when header does not match", () => {
+      const results = checkAssertions(
+        { headers: { "content-type": "text/plain" } },
+        makeResponse({ headers: { "content-type": "application/json" } }),
+      );
+      expect(results[0]!.passed).toBe(false);
+    });
+  });
+
+  describe("body type assertions", () => {
+    test("string type", () => {
+      const res = makeResponse({ body_parsed: { name: "John" } });
+      const results = checkAssertions({ body: { name: { type: "string" } } }, res);
+      expect(results[0]!.passed).toBe(true);
+    });
+
+    test("integer type", () => {
+      const res = makeResponse({ body_parsed: { id: 42 } });
+      const results = checkAssertions({ body: { id: { type: "integer" } } }, res);
+      expect(results[0]!.passed).toBe(true);
+    });
+
+    test("integer type fails for float", () => {
+      const res = makeResponse({ body_parsed: { val: 3.14 } });
+      const results = checkAssertions({ body: { val: { type: "integer" } } }, res);
+      expect(results[0]!.passed).toBe(false);
+    });
+
+    test("number type", () => {
+      const res = makeResponse({ body_parsed: { val: 3.14 } });
+      const results = checkAssertions({ body: { val: { type: "number" } } }, res);
+      expect(results[0]!.passed).toBe(true);
+    });
+
+    test("boolean type", () => {
+      const res = makeResponse({ body_parsed: { active: true } });
+      const results = checkAssertions({ body: { active: { type: "boolean" } } }, res);
+      expect(results[0]!.passed).toBe(true);
+    });
+
+    test("array type", () => {
+      const res = makeResponse({ body_parsed: { items: [1, 2, 3] } });
+      const results = checkAssertions({ body: { items: { type: "array" } } }, res);
+      expect(results[0]!.passed).toBe(true);
+    });
+
+    test("object type", () => {
+      const res = makeResponse({ body_parsed: { data: { nested: true } } });
+      const results = checkAssertions({ body: { data: { type: "object" } } }, res);
+      expect(results[0]!.passed).toBe(true);
+    });
+
+    test("object type fails for array", () => {
+      const res = makeResponse({ body_parsed: { data: [1] } });
+      const results = checkAssertions({ body: { data: { type: "object" } } }, res);
+      expect(results[0]!.passed).toBe(false);
+    });
+  });
+
+  describe("body equals", () => {
+    test("exact primitive match", () => {
+      const res = makeResponse({ body_parsed: { id: 1 } });
+      const results = checkAssertions({ body: { id: { equals: 1 } } }, res);
+      expect(results[0]!.passed).toBe(true);
+    });
+
+    test("string match", () => {
+      const res = makeResponse({ body_parsed: { name: "John" } });
+      const results = checkAssertions({ body: { name: { equals: "John" } } }, res);
+      expect(results[0]!.passed).toBe(true);
+    });
+
+    test("loose numeric comparison", () => {
+      const res = makeResponse({ body_parsed: { id: 123 } });
+      const results = checkAssertions({ body: { id: { equals: "123" } } }, res);
+      expect(results[0]!.passed).toBe(true);
+    });
+
+    test("fails on mismatch", () => {
+      const res = makeResponse({ body_parsed: { id: 1 } });
+      const results = checkAssertions({ body: { id: { equals: 2 } } }, res);
+      expect(results[0]!.passed).toBe(false);
+    });
+  });
+
+  describe("body contains", () => {
+    test("passes when string contains substring", () => {
+      const res = makeResponse({ body_parsed: { msg: "hello world" } });
+      const results = checkAssertions({ body: { msg: { contains: "world" } } }, res);
+      expect(results[0]!.passed).toBe(true);
+    });
+
+    test("fails when not a string", () => {
+      const res = makeResponse({ body_parsed: { val: 42 } });
+      const results = checkAssertions({ body: { val: { contains: "42" } } }, res);
+      expect(results[0]!.passed).toBe(false);
+    });
+  });
+
+  describe("body matches", () => {
+    test("passes when regex matches", () => {
+      const res = makeResponse({ body_parsed: { email: "test@example.com" } });
+      const results = checkAssertions({ body: { email: { matches: ".+@.+" } } }, res);
+      expect(results[0]!.passed).toBe(true);
+    });
+
+    test("fails when regex does not match", () => {
+      const res = makeResponse({ body_parsed: { email: "invalid" } });
+      const results = checkAssertions({ body: { email: { matches: ".+@.+" } } }, res);
+      expect(results[0]!.passed).toBe(false);
+    });
+  });
+
+  describe("body gt/lt", () => {
+    test("gt passes when value is greater", () => {
+      const res = makeResponse({ body_parsed: { count: 10 } });
+      const results = checkAssertions({ body: { count: { gt: 5 } } }, res);
+      expect(results[0]!.passed).toBe(true);
+    });
+
+    test("gt fails when value is not greater", () => {
+      const res = makeResponse({ body_parsed: { count: 3 } });
+      const results = checkAssertions({ body: { count: { gt: 5 } } }, res);
+      expect(results[0]!.passed).toBe(false);
+    });
+
+    test("lt passes when value is less", () => {
+      const res = makeResponse({ body_parsed: { count: 3 } });
+      const results = checkAssertions({ body: { count: { lt: 5 } } }, res);
+      expect(results[0]!.passed).toBe(true);
+    });
+  });
+
+  describe("body exists", () => {
+    test("exists: true passes when field exists", () => {
+      const res = makeResponse({ body_parsed: { name: "John" } });
+      const results = checkAssertions({ body: { name: { exists: true } } }, res);
+      expect(results[0]!.passed).toBe(true);
+    });
+
+    test("exists: true fails when field is missing", () => {
+      const res = makeResponse({ body_parsed: {} });
+      const results = checkAssertions({ body: { name: { exists: true } } }, res);
+      expect(results[0]!.passed).toBe(false);
+    });
+
+    test("exists: false passes when field is missing", () => {
+      const res = makeResponse({ body_parsed: {} });
+      const results = checkAssertions({ body: { name: { exists: false } } }, res);
+      expect(results[0]!.passed).toBe(true);
+    });
+  });
+
+  describe("nested paths", () => {
+    test("accesses deeply nested field", () => {
+      const res = makeResponse({ body_parsed: { data: { user: { name: "John" } } } });
+      const results = checkAssertions({ body: { "data.user.name": { equals: "John" } } }, res);
+      expect(results[0]!.passed).toBe(true);
+    });
+  });
+
+  describe("multiple assertions on same field", () => {
+    test("checks both type and capture", () => {
+      const res = makeResponse({ body_parsed: { id: 42 } });
+      const results = checkAssertions({ body: { id: { type: "integer", gt: 0 } } }, res);
+      expect(results).toHaveLength(2);
+      expect(results.every((r) => r.passed)).toBe(true);
+    });
+  });
+
+  test("returns empty array when no assertions", () => {
+    const results = checkAssertions({}, makeResponse());
+    expect(results).toEqual([]);
+  });
+});
+
+describe("extractCaptures", () => {
+  test("extracts captures from response body", () => {
+    const captures = extractCaptures(
+      { id: { capture: "user_id" }, name: { type: "string" } },
+      { id: 42, name: "John" },
+    );
+    expect(captures).toEqual({ user_id: 42 });
+  });
+
+  test("extracts nested captures", () => {
+    const captures = extractCaptures(
+      { "data.id": { capture: "item_id" } },
+      { data: { id: 99 } },
+    );
+    expect(captures).toEqual({ item_id: 99 });
+  });
+
+  test("skips capture when field is undefined", () => {
+    const captures = extractCaptures(
+      { missing: { capture: "val" } },
+      { other: 1 },
+    );
+    expect(captures).toEqual({});
+  });
+
+  test("returns empty when no body rules", () => {
+    expect(extractCaptures(undefined, { id: 1 })).toEqual({});
+  });
+
+  test("returns empty when body is undefined", () => {
+    expect(extractCaptures({ id: { capture: "x" } }, undefined)).toEqual({});
+  });
+});

package/tests/runner/executor.test.ts

@@ -0,0 +1,310 @@
+import { describe, test, expect, mock, afterEach } from "bun:test";
+import { runSuite, runSuites } from "../../src/core/runner/executor.ts";
+import type { TestSuite } from "../../src/core/parser/types.ts";
+import { DEFAULT_CONFIG } from "../../src/core/parser/schema.ts";
+
+const originalFetch = globalThis.fetch;
+
+afterEach(() => {
+  globalThis.fetch = originalFetch;
+});
+
+function mockFetchResponses(responses: Array<{ status: number; body: unknown; headers?: Record<string, string> }>) {
+  let callIndex = 0;
+  globalThis.fetch = mock(async () => {
+    const resp = responses[callIndex++] ?? { status: 500, body: { error: "unexpected call" } };
+    return new Response(JSON.stringify(resp.body), {
+      status: resp.status,
+      headers: { "Content-Type": "application/json", ...resp.headers },
+    });
+  }) as unknown as typeof fetch;
+}
+
+describe("runSuite", () => {
+  test("runs single passing step", async () => {
+    mockFetchResponses([{ status: 200, body: { ok: true } }]);
+
+    const suite: TestSuite = {
+      name: "Simple",
+      config: DEFAULT_CONFIG,
+      tests: [{
+        name: "Health",
+        method: "GET",
+        path: "http://example.com/health",
+        expect: { status: 200 },
+      }],
+    };
+
+    const result = await runSuite(suite);
+    expect(result.suite_name).toBe("Simple");
+    expect(result.total).toBe(1);
+    expect(result.passed).toBe(1);
+    expect(result.failed).toBe(0);
+    expect(result.steps[0]!.status).toBe("pass");
+  });
+
+  test("runs single failing step", async () => {
+    mockFetchResponses([{ status: 500, body: { error: "internal" } }]);
+
+    const suite: TestSuite = {
+      name: "Fail",
+      config: DEFAULT_CONFIG,
+      tests: [{
+        name: "Bad",
+        method: "GET",
+        path: "http://example.com/fail",
+        expect: { status: 200 },
+      }],
+    };
+
+    const result = await runSuite(suite);
+    expect(result.total).toBe(1);
+    expect(result.failed).toBe(1);
+    expect(result.steps[0]!.status).toBe("fail");
+  });
+
+  test("captures values and passes to subsequent steps", async () => {
+    mockFetchResponses([
+      { status: 201, body: { id: 42, name: "John" } },
+      { status: 200, body: { id: 42, name: "John" } },
+    ]);
+
+    const suite: TestSuite = {
+      name: "Capture chain",
+      base_url: "http://example.com",
+      config: DEFAULT_CONFIG,
+      tests: [
+        {
+          name: "Create",
+          method: "POST",
+          path: "/users",
+          json: { name: "John" },
+          expect: {
+            status: 201,
+            body: { id: { capture: "user_id", type: "integer" } },
+          },
+        },
+        {
+          name: "Get",
+          method: "GET",
+          path: "/users/{{user_id}}",
+          expect: {
+            status: 200,
+            body: { id: { equals: "{{user_id}}" } },
+          },
+        },
+      ],
+    };
+
+    const result = await runSuite(suite);
+    expect(result.passed).toBe(2);
+    expect(result.steps[0]!.captures).toEqual({ user_id: 42 });
+
+    // Verify the second request used the captured value
+    expect(result.steps[1]!.request.url).toBe("http://example.com/users/42");
+  });
+
+  test("skips steps that depend on failed captures", async () => {
+    mockFetchResponses([
+      { status: 500, body: {} }, // Create fails, capture not obtained
+    ]);
+
+    const suite: TestSuite = {
+      name: "Skip test",
+      base_url: "http://example.com",
+      config: DEFAULT_CONFIG,
+      tests: [
+        {
+          name: "Create",
+          method: "POST",
+          path: "/users",
+          expect: {
+            status: 201,
+            body: { id: { capture: "user_id", type: "integer" } },
+          },
+        },
+        {
+          name: "Get (depends on user_id)",
+          method: "GET",
+          path: "/users/{{user_id}}",
+          expect: { status: 200 },
+        },
+        {
+          name: "List (no dependency)",
+          method: "GET",
+          path: "/users",
+          expect: { status: 200 },
+        },
+      ],
+    };
+
+    // Need a third response for the "List" step
+    let callCount = 0;
+    globalThis.fetch = mock(async () => {
+      callCount++;
+      if (callCount === 1) return new Response(JSON.stringify({}), { status: 500, headers: { "Content-Type": "application/json" } });
+      return new Response(JSON.stringify([]), { status: 200, headers: { "Content-Type": "application/json" } });
+    }) as unknown as typeof fetch;
+
+    const result = await runSuite(suite);
+    expect(result.total).toBe(3);
+    expect(result.failed).toBe(1);  // Create fails
+    expect(result.skipped).toBe(1); // Get skipped
+    expect(result.passed).toBe(1);  // List passes
+    expect(result.steps[1]!.status).toBe("skip");
+    expect(result.steps[1]!.error).toContain("user_id");
+  });
+
+  test("merges suite-level headers with step headers", async () => {
+    let capturedHeaders: Record<string, string> = {};
+    globalThis.fetch = mock(async (_url: string | URL | Request, init?: RequestInit) => {
+      capturedHeaders = Object.fromEntries(new Headers(init?.headers as Record<string, string>).entries());
+      return new Response("{}", { status: 200, headers: { "Content-Type": "application/json" } });
+    }) as unknown as typeof fetch;
+
+    const suite: TestSuite = {
+      name: "Headers",
+      headers: { Authorization: "Bearer suite-token", "X-Suite": "yes" },
+      config: DEFAULT_CONFIG,
+      tests: [{
+        name: "Step",
+        method: "GET",
+        path: "http://example.com/test",
+        headers: { "X-Step": "yes", Authorization: "Bearer step-token" },
+        expect: {},
+      }],
+    };
+
+    await runSuite(suite);
+    expect(capturedHeaders["authorization"]).toBe("Bearer step-token"); // step overrides suite
+    expect(capturedHeaders["x-suite"]).toBe("yes"); // suite header preserved
+    expect(capturedHeaders["x-step"]).toBe("yes"); // step header added
+  });
+
+  test("substitutes environment variables", async () => {
+    let capturedUrl = "";
+    globalThis.fetch = mock(async (url: string | URL | Request) => {
+      capturedUrl = typeof url === "string" ? url : (url as Request).url;
+      return new Response("{}", { status: 200, headers: { "Content-Type": "application/json" } });
+    }) as unknown as typeof fetch;
+
+    const suite: TestSuite = {
+      name: "Env test",
+      base_url: "{{base}}",
+      config: DEFAULT_CONFIG,
+      tests: [{
+        name: "Health",
+        method: "GET",
+        path: "/health",
+        expect: { status: 200 },
+      }],
+    };
+
+    await runSuite(suite, { base: "http://api.example.com" });
+    expect(capturedUrl).toBe("http://api.example.com/health");
+  });
+
+  test("auto-sets Content-Type for JSON body", async () => {
+    let capturedHeaders: Record<string, string> = {};
+    globalThis.fetch = mock(async (_url: string | URL | Request, init?: RequestInit) => {
+      capturedHeaders = Object.fromEntries(new Headers(init?.headers as Record<string, string>).entries());
+      return new Response("{}", { status: 201, headers: { "Content-Type": "application/json" } });
+    }) as unknown as typeof fetch;
+
+    const suite: TestSuite = {
+      name: "JSON",
+      config: DEFAULT_CONFIG,
+      tests: [{
+        name: "Create",
+        method: "POST",
+        path: "http://example.com/users",
+        json: { name: "John" },
+        expect: { status: 201 },
+      }],
+    };
+
+    await runSuite(suite);
+    expect(capturedHeaders["content-type"]).toBe("application/json");
+  });
+
+  test("handles fetch error with error status", async () => {
+    globalThis.fetch = mock(async () => {
+      throw new Error("Connection refused");
+    }) as unknown as typeof fetch;
+
+    const suite: TestSuite = {
+      name: "Error",
+      config: { ...DEFAULT_CONFIG, retries: 0 },
+      tests: [{
+        name: "Fail",
+        method: "GET",
+        path: "http://example.com/fail",
+        expect: { status: 200 },
+      }],
+    };
+
+    const result = await runSuite(suite);
+    expect(result.steps[0]!.status).toBe("error");
+    expect(result.steps[0]!.error).toContain("Connection refused");
+  });
+
+  test("builds URL with query params", async () => {
+    let capturedUrl = "";
+    globalThis.fetch = mock(async (url: string | URL | Request) => {
+      capturedUrl = typeof url === "string" ? url : (url as Request).url;
+      return new Response("{}", { status: 200, headers: { "Content-Type": "application/json" } });
+    }) as unknown as typeof fetch;
+
+    const suite: TestSuite = {
+      name: "Query",
+      base_url: "http://example.com",
+      config: DEFAULT_CONFIG,
+      tests: [{
+        name: "List",
+        method: "GET",
+        path: "/users",
+        query: { page: "1", limit: "10" },
+        expect: {},
+      }],
+    };
+
+    await runSuite(suite);
+    expect(capturedUrl).toContain("page=1");
+    expect(capturedUrl).toContain("limit=10");
+  });
+
+  test("provides timestamps in result", async () => {
+    mockFetchResponses([{ status: 200, body: {} }]);
+
+    const suite: TestSuite = {
+      name: "Timestamps",
+      config: DEFAULT_CONFIG,
+      tests: [{ name: "T", method: "GET", path: "http://x.com/t", expect: {} }],
+    };
+
+    const result = await runSuite(suite);
+    expect(result.started_at).toMatch(/^\d{4}-\d{2}-\d{2}T/);
+    expect(result.finished_at).toMatch(/^\d{4}-\d{2}-\d{2}T/);
+  });
+});
+
+describe("runSuites", () => {
+  test("runs multiple suites in parallel", async () => {
+    let callCount = 0;
+    globalThis.fetch = mock(async () => {
+      callCount++;
+      return new Response(JSON.stringify({ n: callCount }), { status: 200, headers: { "Content-Type": "application/json" } });
+    }) as unknown as typeof fetch;
+
+    const suites: TestSuite[] = [
+      { name: "A", config: DEFAULT_CONFIG, tests: [{ name: "A1", method: "GET", path: "http://x.com/a", expect: { status: 200 } }] },
+      { name: "B", config: DEFAULT_CONFIG, tests: [{ name: "B1", method: "GET", path: "http://x.com/b", expect: { status: 200 } }] },
+    ];
+
+    const results = await runSuites(suites);
+    expect(results).toHaveLength(2);
+    expect(results[0]!.suite_name).toBe("A");
+    expect(results[1]!.suite_name).toBe("B");
+    expect(callCount).toBe(2);
+  });
+});