@kirrosh/apitool 0.4.3

package/tests/cli/runs.test.ts

@@ -0,0 +1,94 @@
+import { describe, test, expect, beforeEach, afterEach } from "bun:test";
+import { tmpdir } from "os";
+import { join } from "path";
+import { unlinkSync } from "fs";
+import { getDb, closeDb } from "../../src/db/schema.ts";
+import { createRun, finalizeRun, saveResults } from "../../src/db/queries.ts";
+import { runsCommand } from "../../src/cli/commands/runs.ts";
+import type { TestRunResult } from "../../src/core/runner/types.ts";
+
+function tmpDb(): string {
+  return join(tmpdir(), `apitool-runs-test-${Date.now()}-${Math.random().toString(36).slice(2)}.db`);
+}
+
+function tryUnlink(path: string): void {
+  for (const suffix of ["", "-wal", "-shm"]) {
+    try { unlinkSync(path + suffix); } catch { /* ignore */ }
+  }
+}
+
+function makeSuiteResult(overrides?: Partial<TestRunResult>): TestRunResult {
+  return {
+    suite_name: "Users API",
+    started_at: "2024-01-01T00:00:00.000Z",
+    finished_at: "2024-01-01T00:00:01.000Z",
+    total: 2,
+    passed: 1,
+    failed: 1,
+    skipped: 0,
+    steps: [
+      {
+        name: "Get user",
+        status: "pass",
+        duration_ms: 100,
+        request: { method: "GET", url: "http://localhost/users/1", headers: {} },
+        response: { status: 200, headers: {}, body: '{"id":1}', duration_ms: 100 },
+        assertions: [{ field: "status", rule: "equals", passed: true, actual: 200, expected: 200 }],
+        captures: {},
+      },
+      {
+        name: "Create user",
+        status: "fail",
+        duration_ms: 200,
+        request: { method: "POST", url: "http://localhost/users", headers: {} },
+        response: { status: 500, headers: {}, body: "error", duration_ms: 200 },
+        assertions: [{ field: "status", rule: "equals", passed: false, actual: 500, expected: 201 }],
+        captures: {},
+        error: "Expected 201 but got 500",
+      },
+    ],
+    ...overrides,
+  };
+}
+
+describe("runsCommand", () => {
+  let dbPath: string;
+
+  beforeEach(() => {
+    dbPath = tmpDb();
+    getDb(dbPath);
+  });
+
+  afterEach(() => {
+    closeDb();
+    tryUnlink(dbPath);
+  });
+
+  test("list shows empty message when no runs", () => {
+    const code = runsCommand({ dbPath });
+    expect(code).toBe(0);
+  });
+
+  test("list shows runs table", () => {
+    const runId = createRun({ started_at: new Date().toISOString(), environment: "dev" });
+    const result = makeSuiteResult();
+    saveResults(runId, [result]);
+    finalizeRun(runId, [result]);
+    const code = runsCommand({ dbPath });
+    expect(code).toBe(0);
+  });
+
+  test("detail shows run info", () => {
+    const runId = createRun({ started_at: new Date().toISOString() });
+    const result = makeSuiteResult();
+    saveResults(runId, [result]);
+    finalizeRun(runId, [result]);
+    const code = runsCommand({ runId, dbPath });
+    expect(code).toBe(0);
+  });
+
+  test("detail returns 1 for missing run", () => {
+    const code = runsCommand({ runId: 9999, dbPath });
+    expect(code).toBe(1);
+  });
+});

package/tests/cli/safe-run.test.ts

@@ -0,0 +1,103 @@
+import { describe, test, expect, mock, afterEach, beforeEach } from "bun:test";
+import { tmpdir } from "os";
+import { join } from "path";
+import { unlinkSync } from "fs";
+import { runCommand } from "../../src/cli/commands/run.ts";
+import { closeDb } from "../../src/db/schema.ts";
+
+const FIXTURES = `${import.meta.dir}/../fixtures`;
+const originalFetch = globalThis.fetch;
+
+function tryUnlink(path: string): void {
+  for (const suffix of ["", "-wal", "-shm"]) {
+    try { unlinkSync(path + suffix); } catch { /* ignore */ }
+  }
+}
+
+function mockFetchResponses(responses: Array<{ status: number; body: unknown }>) {
+  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" },
+    });
+  }) as unknown as typeof fetch;
+}
+
+function suppressOutput() {
+  const origOut = process.stdout.write;
+  const origErr = process.stderr.write;
+  process.stdout.write = mock(() => true) as typeof process.stdout.write;
+  process.stderr.write = mock(() => true) as typeof process.stderr.write;
+  return () => {
+    process.stdout.write = origOut;
+    process.stderr.write = origErr;
+  };
+}
+
+describe("--safe mode", () => {
+  let restore: () => void;
+
+  beforeEach(() => {
+    restore = suppressOutput();
+  });
+
+  afterEach(() => {
+    restore();
+    globalThis.fetch = originalFetch;
+    closeDb();
+  });
+
+  test("safe mode runs only GET tests from crud suite", async () => {
+    // crud.yaml has POST, GET, DELETE — safe mode should only run GET
+    mockFetchResponses([
+      { status: 200, body: { id: 1, name: "John", email: "john@test.com" } },
+    ]);
+
+    const code = await runCommand({
+      path: `${FIXTURES}/crud.yaml`,
+      env: undefined,
+      report: "json",
+      bail: false,
+      noDb: true,
+      safe: true,
+    });
+
+    const fetchMock = globalThis.fetch as unknown as ReturnType<typeof mock>;
+    // Only the GET test should have run (1 call)
+    expect(fetchMock.mock.calls.length).toBe(1);
+  });
+
+  test("safe mode with GET-only suite runs normally", async () => {
+    // simple.yaml has only GET /health
+    mockFetchResponses([
+      { status: 200, body: { status: "ok" } },
+    ]);
+
+    const code = await runCommand({
+      path: `${FIXTURES}/simple.yaml`,
+      report: "json",
+      bail: false,
+      noDb: true,
+      safe: true,
+    });
+
+    expect(code).toBe(0);
+    const fetchMock = globalThis.fetch as unknown as ReturnType<typeof mock>;
+    expect(fetchMock.mock.calls.length).toBe(1);
+  });
+
+  test("safe mode returns 0 when no GET tests found", async () => {
+    const code = await runCommand({
+      path: `${FIXTURES}/post-only.yaml`,
+      report: "console",
+      bail: false,
+      noDb: true,
+      safe: true,
+    });
+
+    // Should return 0 (warning printed but no error)
+    expect(code).toBe(0);
+  });
+});

package/tests/cli/update.test.ts

@@ -0,0 +1,32 @@
+import { describe, expect, test } from "bun:test";
+import { detectTarget, parseVersion, compareVersions } from "../../src/cli/commands/update.ts";
+
+describe("update command", () => {
+  test("detectTarget returns valid target for current platform", () => {
+    const { target, archive } = detectTarget();
+    expect(target).toMatch(/^(linux|darwin|win)-(x64|arm64)$/);
+    expect(["tar.gz", "zip"]).toContain(archive);
+
+    if (process.platform === "win32") {
+      expect(archive).toBe("zip");
+      expect(target).toStartWith("win-");
+    } else {
+      expect(archive).toBe("tar.gz");
+    }
+  });
+
+  test("parseVersion strips v prefix", () => {
+    expect(parseVersion("v0.3.0")).toBe("0.3.0");
+    expect(parseVersion("0.3.0")).toBe("0.3.0");
+    expect(parseVersion("v1.2.3")).toBe("1.2.3");
+  });
+
+  test("compareVersions compares correctly", () => {
+    expect(compareVersions("0.2.0", "0.3.0")).toBeLessThan(0);
+    expect(compareVersions("0.3.0", "0.2.0")).toBeGreaterThan(0);
+    expect(compareVersions("0.2.0", "0.2.0")).toBe(0);
+    expect(compareVersions("1.0.0", "0.9.9")).toBeGreaterThan(0);
+    expect(compareVersions("0.2.0", "0.2.1")).toBeLessThan(0);
+    expect(compareVersions("0.10.0", "0.9.0")).toBeGreaterThan(0);
+  });
+});

package/tests/core/generator/schema-utils.test.ts

@@ -0,0 +1,108 @@
+import { describe, test, expect } from "bun:test";
+import { compressSchema, formatParam } from "../../../src/core/generator/schema-utils.ts";
+import type { OpenAPIV3 } from "openapi-types";
+
+describe("compressSchema", () => {
+  test("compresses simple object with required fields", () => {
+    const schema: OpenAPIV3.SchemaObject = {
+      type: "object",
+      required: ["name", "email"],
+      properties: {
+        name: { type: "string" },
+        email: { type: "string", format: "email" },
+        age: { type: "integer" },
+      },
+    };
+    const result = compressSchema(schema);
+    expect(result).toBe("{ name: string (req), email: string (req, email), age: integer }");
+  });
+
+  test("compresses array of objects", () => {
+    const schema: OpenAPIV3.SchemaObject = {
+      type: "array",
+      items: {
+        type: "object",
+        properties: {
+          id: { type: "integer" },
+          name: { type: "string" },
+        },
+      },
+    };
+    const result = compressSchema(schema);
+    expect(result).toBe("[{ id: integer, name: string }]");
+  });
+
+  test("compresses enum fields", () => {
+    const schema: OpenAPIV3.SchemaObject = {
+      type: "object",
+      properties: {
+        status: { type: "string", enum: ["active", "inactive", "pending"] },
+      },
+    };
+    const result = compressSchema(schema);
+    expect(result).toBe("{ status: string (enum: active|inactive|pending) }");
+  });
+
+  test("returns {…} at max depth", () => {
+    // compressSchema at depth 0 renders the outer object
+    // depth 1 renders inner properties, depth 2 renders deeper, depth > 2 returns {...}
+    const schema: OpenAPIV3.SchemaObject = {
+      type: "array",
+      items: {
+        type: "array",
+        items: {
+          type: "array",
+          items: {
+            type: "object",
+            properties: { id: { type: "integer" } },
+          },
+        },
+      },
+    };
+    // depth 0: [...], depth 1: [...], depth 2: [...], depth 3: {...}
+    const result = compressSchema(schema);
+    expect(result).toContain("{...}");
+  });
+
+  test("handles simple type without properties", () => {
+    expect(compressSchema({ type: "string" })).toBe("string");
+    expect(compressSchema({ type: "integer" })).toBe("integer");
+  });
+
+  test("handles array without items", () => {
+    expect(compressSchema({ type: "array" })).toBe("[]");
+  });
+
+  test("handles schema without type", () => {
+    expect(compressSchema({})).toBe("any");
+  });
+});
+
+describe("formatParam", () => {
+  test("formats required parameter", () => {
+    const param: OpenAPIV3.ParameterObject = {
+      name: "id",
+      in: "path",
+      required: true,
+      schema: { type: "integer" },
+    };
+    expect(formatParam(param)).toBe("id: integer (req)");
+  });
+
+  test("formats optional parameter", () => {
+    const param: OpenAPIV3.ParameterObject = {
+      name: "limit",
+      in: "query",
+      schema: { type: "integer" },
+    };
+    expect(formatParam(param)).toBe("limit: integer");
+  });
+
+  test("defaults to string type when no schema", () => {
+    const param: OpenAPIV3.ParameterObject = {
+      name: "q",
+      in: "query",
+    };
+    expect(formatParam(param)).toBe("q: string");
+  });
+});

package/tests/core/parser/nested-assertions.test.ts

@@ -0,0 +1,80 @@
+import { describe, test, expect } from "bun:test";
+import { flattenBodyAssertions } from "../../../src/core/parser/schema.ts";
+import { validateSuite } from "../../../src/core/parser/schema.ts";
+
+describe("flattenBodyAssertions", () => {
+  test("direct dot-notation passes through unchanged", () => {
+    const input = { "a.b": { equals: 1 } };
+    expect(flattenBodyAssertions(input)).toEqual({ "a.b": { equals: 1 } });
+  });
+
+  test("nested YAML flattens to dot-notation", () => {
+    const input = { a: { b: { equals: 1 } } };
+    expect(flattenBodyAssertions(input)).toEqual({ "a.b": { equals: 1 } });
+  });
+
+  test("deep nesting flattens correctly", () => {
+    const input = { a: { b: { c: { type: "string" } } } };
+    expect(flattenBodyAssertions(input)).toEqual({ "a.b.c": { type: "string" } });
+  });
+
+  test("mixed: assertion-level stays, nested flattens", () => {
+    const input = {
+      id: { capture: "x" },
+      meta: { status: { equals: "ok" } },
+    };
+    expect(flattenBodyAssertions(input)).toEqual({
+      id: { capture: "x" },
+      "meta.status": { equals: "ok" },
+    });
+  });
+
+  test("array index via dot-notation passes through", () => {
+    const input = { "items.0.name": { equals: "x" } };
+    expect(flattenBodyAssertions(input)).toEqual({ "items.0.name": { equals: "x" } });
+  });
+
+  test("_body key is not flattened", () => {
+    const input = { _body: { type: "array" } };
+    expect(flattenBodyAssertions(input)).toEqual({ _body: { type: "array" } });
+  });
+
+  test("_body.length key is not flattened", () => {
+    const input = { "_body.length": { gt: 0 } };
+    expect(flattenBodyAssertions(input)).toEqual({ "_body.length": { gt: 0 } });
+  });
+
+  test("multiple nested paths at same level", () => {
+    const input = {
+      category: { name: { equals: "Dogs" }, id: { type: "integer" } },
+    };
+    expect(flattenBodyAssertions(input)).toEqual({
+      "category.name": { equals: "Dogs" },
+      "category.id": { type: "integer" },
+    });
+  });
+});
+
+describe("nested assertions through full parser", () => {
+  test("validates suite with nested body assertions", () => {
+    const raw = {
+      name: "Nested test",
+      tests: [{
+        name: "Check nested",
+        GET: "/pets/1",
+        expect: {
+          status: 200,
+          body: {
+            category: { name: { equals: "Dogs" } },
+            id: { type: "integer" },
+          },
+        },
+      }],
+    };
+    const suite = validateSuite(raw);
+    expect(suite.tests[0]!.expect.body).toEqual({
+      "category.name": { equals: "Dogs" },
+      id: { type: "integer" },
+    });
+  });
+});

package/tests/core/runner/root-body-assertions.test.ts

@@ -0,0 +1,70 @@
+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(body: unknown, status = 200): HttpResponse {
+  return {
+    status,
+    headers: { "content-type": "application/json" },
+    body_raw: JSON.stringify(body),
+    body_parsed: body,
+    duration_ms: 50,
+  };
+}
+
+describe("_body root body assertions", () => {
+  test("_body type: array for array response → pass", () => {
+    const results = checkAssertions(
+      { status: 200, body: { _body: { type: "array" } } },
+      makeResponse([1, 2, 3]),
+    );
+    const bodyResult = results.find(r => r.field === "body._body");
+    expect(bodyResult).toBeDefined();
+    expect(bodyResult!.passed).toBe(true);
+  });
+
+  test("_body type: object for object response → pass", () => {
+    const results = checkAssertions(
+      { status: 200, body: { _body: { type: "object" } } },
+      makeResponse({ id: 1 }),
+    );
+    const bodyResult = results.find(r => r.field === "body._body");
+    expect(bodyResult!.passed).toBe(true);
+  });
+
+  test("_body type: array for object response → fail", () => {
+    const results = checkAssertions(
+      { status: 200, body: { _body: { type: "array" } } },
+      makeResponse({ id: 1 }),
+    );
+    const bodyResult = results.find(r => r.field === "body._body");
+    expect(bodyResult!.passed).toBe(false);
+  });
+
+  test("_body exists: true for non-empty body → pass", () => {
+    const results = checkAssertions(
+      { status: 200, body: { _body: { exists: true } } },
+      makeResponse([]),
+    );
+    const bodyResult = results.find(r => r.field === "body._body");
+    expect(bodyResult!.passed).toBe(true);
+  });
+
+  test("_body.length for array → checks length property", () => {
+    const results = checkAssertions(
+      { status: 200, body: { "_body.length": { gt: 0 } } },
+      makeResponse([1, 2, 3]),
+    );
+    const bodyResult = results.find(r => r.field === "body._body.length");
+    expect(bodyResult).toBeDefined();
+    expect(bodyResult!.passed).toBe(true);
+  });
+
+  test("_body capture captures entire body", () => {
+    const captures = extractCaptures(
+      { _body: { capture: "all" } },
+      [1, 2, 3],
+    );
+    expect(captures.all).toEqual([1, 2, 3]);
+  });
+});

package/tests/db/chat-queries.test.ts

@@ -0,0 +1,88 @@
+import { describe, test, expect, beforeEach } from "bun:test";
+import { getDb } from "../../src/db/schema.ts";
+import {
+  createChatSession,
+  saveChatMessage,
+  getChatMessages,
+  listChatSessions,
+  loadSessionHistory,
+} from "../../src/db/queries.ts";
+
+describe("chat queries", () => {
+  beforeEach(() => {
+    // Use default DB (same as query functions) and clean chat tables
+    const db = getDb();
+    db.exec("DELETE FROM chat_messages");
+    db.exec("DELETE FROM chat_sessions");
+  });
+
+  test("createChatSession returns id", () => {
+    const id = createChatSession("ollama", "llama3.2:3b", "Test Session");
+    expect(typeof id).toBe("number");
+    expect(id).toBeGreaterThan(0);
+  });
+
+  test("saveChatMessage + getChatMessages roundtrip", () => {
+    const sessionId = createChatSession("ollama", "llama3.2:3b");
+
+    saveChatMessage({ session_id: sessionId, role: "user", content: "Hello" });
+    saveChatMessage({ session_id: sessionId, role: "assistant", content: "Hi there!", input_tokens: 10, output_tokens: 20 });
+
+    const messages = getChatMessages(sessionId);
+    expect(messages).toHaveLength(2);
+    expect(messages[0]!.role).toBe("user");
+    expect(messages[0]!.content).toBe("Hello");
+    expect(messages[1]!.role).toBe("assistant");
+    expect(messages[1]!.content).toBe("Hi there!");
+    expect(messages[1]!.input_tokens).toBe(10);
+    expect(messages[1]!.output_tokens).toBe(20);
+  });
+
+  test("listChatSessions ordered by last_active DESC", () => {
+    const id1 = createChatSession("ollama", "llama3.2:3b", "Session 1");
+    const id2 = createChatSession("openai", "gpt-4o", "Session 2");
+
+    // Manually set last_active to force ordering
+    const db = getDb();
+    db.prepare("UPDATE chat_sessions SET last_active = '2025-01-01T00:00:00' WHERE id = ?").run(id1);
+    db.prepare("UPDATE chat_sessions SET last_active = '2025-01-02T00:00:00' WHERE id = ?").run(id2);
+
+    const sessions = listChatSessions();
+    expect(sessions.length).toBe(2);
+    // Session 2 has more recent last_active so should be first
+    expect(sessions[0]!.id).toBe(id2);
+    expect(sessions[1]!.id).toBe(id1);
+  });
+
+  test("loadSessionHistory returns CoreMessage[] format", () => {
+    const sessionId = createChatSession("ollama", "llama3.2:3b");
+
+    saveChatMessage({ session_id: sessionId, role: "user", content: "Run my tests" });
+    saveChatMessage({ session_id: sessionId, role: "assistant", content: "I'll run them now" });
+    saveChatMessage({ session_id: sessionId, role: "user", content: "Thanks" });
+
+    const history = loadSessionHistory(sessionId);
+    expect(history).toHaveLength(3);
+    expect(history[0]).toEqual({ role: "user", content: "Run my tests" });
+    expect(history[1]).toEqual({ role: "assistant", content: "I'll run them now" });
+    expect(history[2]).toEqual({ role: "user", content: "Thanks" });
+  });
+
+  test("saveChatMessage with tool data", () => {
+    const sessionId = createChatSession("ollama", "llama3.2:3b");
+
+    saveChatMessage({
+      session_id: sessionId,
+      role: "assistant",
+      content: "Running tests...",
+      tool_name: "run_tests",
+      tool_args: JSON.stringify({ testPath: "tests/" }),
+      tool_result: JSON.stringify({ runId: 1, status: "all_passed" }),
+    });
+
+    const messages = getChatMessages(sessionId);
+    expect(messages).toHaveLength(1);
+    expect(messages[0]!.tool_name).toBe("run_tests");
+    expect(messages[0]!.tool_args).toBe(JSON.stringify({ testPath: "tests/" }));
+  });
+});

package/tests/db/chat-schema.test.ts

@@ -0,0 +1,37 @@
+import { describe, test, expect } from "bun:test";
+import { getDb } from "../../src/db/schema.ts";
+
+describe("DB schema v3 — chat tables", () => {
+  test("migration sets user_version to 3", () => {
+    const db = getDb();
+    const row = db.query("PRAGMA user_version").get() as { user_version: number };
+    expect(row.user_version).toBe(5);
+  });
+
+  test("chat_sessions table exists", () => {
+    const db = getDb();
+    const tables = db.query(
+      "SELECT name FROM sqlite_master WHERE type='table' AND name='chat_sessions'"
+    ).all() as { name: string }[];
+    expect(tables).toHaveLength(1);
+    expect(tables[0]!.name).toBe("chat_sessions");
+  });
+
+  test("chat_messages table exists", () => {
+    const db = getDb();
+    const tables = db.query(
+      "SELECT name FROM sqlite_master WHERE type='table' AND name='chat_messages'"
+    ).all() as { name: string }[];
+    expect(tables).toHaveLength(1);
+    expect(tables[0]!.name).toBe("chat_messages");
+  });
+
+  test("FK constraint: message with invalid session_id fails", () => {
+    const db = getDb();
+    expect(() => {
+      db.prepare(
+        "INSERT INTO chat_messages (session_id, role, content) VALUES (99999, 'user', 'hello')"
+      ).run();
+    }).toThrow();
+  });
+});