@kirrosh/apitool 0.4.3

package/tests/ai/output-parser.test.ts

@@ -0,0 +1,132 @@
+import { describe, test, expect } from "bun:test";
+import { parseAIResponse } from "../../src/core/generator/ai/output-parser.ts";
+
+describe("output-parser", () => {
+  test("parses clean JSON with suites array", () => {
+    const raw = JSON.stringify({
+      suites: [
+        {
+          name: "Pet CRUD",
+          tests: [
+            {
+              name: "Create pet",
+              POST: "/pets",
+              json: { name: "Buddy", species: "dog" },
+              expect: { status: 201, body: { id: { type: "number", capture: "pet_id" } } },
+            },
+            {
+              name: "Get pet",
+              GET: "/pets/{{pet_id}}",
+              expect: { status: 200, body: { name: { type: "string" } } },
+            },
+          ],
+        },
+      ],
+    });
+
+    const result = parseAIResponse(raw);
+    expect(result.suites.length).toBe(1);
+    expect(result.suites[0]!.name).toBe("Pet CRUD");
+    expect(result.suites[0]!.tests.length).toBe(2);
+    expect(result.yaml).toContain("name: Pet CRUD");
+    expect(result.yaml).toContain("POST: /pets");
+    expect(result.yaml).toContain("GET: /pets/{{pet_id}}");
+  });
+
+  test("parses JSON wrapped in ```json fences", () => {
+    const raw = '```json\n{"suites":[{"name":"Test","tests":[{"name":"Get","GET":"/api","expect":{"status":200}}]}]}\n```';
+    const result = parseAIResponse(raw);
+    expect(result.suites.length).toBe(1);
+    expect(result.yaml).toContain("GET: /api");
+  });
+
+  test("parses JSON wrapped in ``` fences (no json tag)", () => {
+    const raw = '```\n{"suites":[{"name":"Test","tests":[{"name":"Get","GET":"/api","expect":{"status":200}}]}]}\n```';
+    const result = parseAIResponse(raw);
+    expect(result.suites.length).toBe(1);
+  });
+
+  test("parses JSON with leading text", () => {
+    const raw = 'Here is the generated test suite:\n\n{"suites":[{"name":"Test","tests":[{"name":"Get","GET":"/api","expect":{"status":200}}]}]}';
+    const result = parseAIResponse(raw);
+    expect(result.suites.length).toBe(1);
+  });
+
+  test("parses single suite object (not wrapped in suites array)", () => {
+    const raw = JSON.stringify({
+      name: "Single Suite",
+      tests: [
+        { name: "Get", GET: "/api", expect: { status: 200 } },
+      ],
+    });
+    const result = parseAIResponse(raw);
+    expect(result.suites.length).toBe(1);
+    expect(result.suites[0]!.name).toBe("Single Suite");
+  });
+
+  test("returns error for invalid JSON", () => {
+    const raw = "This is not JSON at all, just plain text response.";
+    const result = parseAIResponse(raw);
+    expect(result.suites.length).toBe(0);
+    expect(result.errors.length).toBeGreaterThan(0);
+  });
+
+  test("skips suites without tests but includes valid ones", () => {
+    const raw = JSON.stringify({
+      suites: [
+        { name: "Empty", base_url: "http://localhost" },
+        {
+          name: "Valid",
+          tests: [{ name: "Get", GET: "/api", expect: { status: 200 } }],
+        },
+      ],
+    });
+    const result = parseAIResponse(raw);
+    // The empty suite is skipped, only the valid one is included
+    expect(result.suites.length).toBe(1);
+    expect(result.suites[0]!.name).toBe("Valid");
+    expect(result.errors.length).toBeGreaterThan(0); // skip message for empty suite
+  });
+
+  test("generates valid YAML with captures", () => {
+    const raw = JSON.stringify({
+      suites: [
+        {
+          name: "Chain Test",
+          base_url: "{{base_url}}",
+          tests: [
+            {
+              name: "Create",
+              POST: "/items",
+              json: { name: "test" },
+              expect: {
+                status: 201,
+                body: { id: { type: "number", capture: "item_id" } },
+              },
+            },
+            {
+              name: "Verify",
+              GET: "/items/{{item_id}}",
+              expect: { status: 200 },
+            },
+          ],
+        },
+      ],
+    });
+    const result = parseAIResponse(raw);
+    expect(result.yaml).toContain("capture:");
+    expect(result.yaml).toContain("{{item_id}}");
+  });
+
+  test("handles array of suites at top level", () => {
+    const raw = JSON.stringify([
+      {
+        name: "Suite A",
+        tests: [{ name: "Get", GET: "/a", expect: { status: 200 } }],
+      },
+    ]);
+    const result = parseAIResponse(raw);
+    expect(result.suites.length).toBe(1);
+    expect(result.suites[0]!.name).toBe("Suite A");
+  });
+});

package/tests/ai/prompt-builder.test.ts

@@ -0,0 +1,67 @@
+import { describe, test, expect } from "bun:test";
+import { buildMessages } from "../../src/core/generator/ai/prompt-builder.ts";
+import { readOpenApiSpec, extractEndpoints, extractSecuritySchemes } from "../../src/core/generator/openapi-reader.ts";
+
+describe("prompt-builder", () => {
+  test("compresses petstore-simple spec to concise text", async () => {
+    const doc = await readOpenApiSpec("tests/fixtures/petstore-simple.json");
+    const endpoints = extractEndpoints(doc);
+    const securitySchemes = extractSecuritySchemes(doc);
+
+    const messages = buildMessages(endpoints, securitySchemes, "Create a pet and verify", "http://localhost:3000");
+
+    expect(messages.length).toBe(2);
+    expect(messages[0]!.role).toBe("system");
+    expect(messages[1]!.role).toBe("user");
+
+    const userMsg = messages[1]!.content;
+
+    // Should contain endpoint signatures
+    expect(userMsg).toContain("GET /pets");
+    expect(userMsg).toContain("POST /pets");
+    expect(userMsg).toContain("GET /pets/{petId}");
+    expect(userMsg).toContain("DELETE /pets/{petId}");
+
+    // Should contain response codes
+    expect(userMsg).toContain("201:");
+    expect(userMsg).toContain("409:");
+    expect(userMsg).toContain("200:");
+
+    // Should contain request body info
+    expect(userMsg).toContain("name: string");
+    expect(userMsg).toContain("species: string");
+
+    // Should contain the user prompt
+    expect(userMsg).toContain("Create a pet and verify");
+
+    // Should contain base URL
+    expect(userMsg).toContain("http://localhost:3000");
+
+    // Should be concise — well under 500 lines
+    const lines = userMsg.split("\n").length;
+    expect(lines).toBeLessThan(100);
+  });
+
+  test("includes security info for auth spec", async () => {
+    const doc = await readOpenApiSpec("tests/fixtures/petstore-auth.json");
+    const endpoints = extractEndpoints(doc);
+    const securitySchemes = extractSecuritySchemes(doc);
+
+    const messages = buildMessages(endpoints, securitySchemes, "Test CRUD with auth");
+    const userMsg = messages[1]!.content;
+
+    expect(userMsg).toContain("SECURITY:");
+    expect(userMsg).toContain("bearerAuth");
+    expect(userMsg).toContain("bearer");
+  });
+
+  test("system prompt defines JSON output format", async () => {
+    const messages = buildMessages([], [], "test");
+    const systemMsg = messages[0]!.content;
+
+    expect(systemMsg).toContain("suites");
+    expect(systemMsg).toContain("capture");
+    expect(systemMsg).toContain("expect");
+    expect(systemMsg).toContain("JSON");
+  });
+});

package/tests/ai/types.test.ts

@@ -0,0 +1,55 @@
+import { describe, test, expect } from "bun:test";
+import { resolveProviderConfig, PROVIDER_DEFAULTS } from "../../src/core/generator/ai/types.ts";
+
+describe("AI types", () => {
+  test("resolveProviderConfig fills ollama defaults", () => {
+    const config = resolveProviderConfig({ provider: "ollama" });
+    expect(config.baseUrl).toBe("http://localhost:11434/v1");
+    expect(config.model).toBe("qwen3:4b");
+    expect(config.temperature).toBe(0.2);
+    expect(config.maxTokens).toBe(4096);
+    expect(config.apiKey).toBeUndefined();
+  });
+
+  test("resolveProviderConfig fills openai defaults", () => {
+    const config = resolveProviderConfig({ provider: "openai", apiKey: "sk-test" });
+    expect(config.baseUrl).toBe("https://api.openai.com/v1");
+    expect(config.model).toBe("gpt-4o");
+    expect(config.apiKey).toBe("sk-test");
+  });
+
+  test("resolveProviderConfig fills anthropic defaults", () => {
+    const config = resolveProviderConfig({ provider: "anthropic" });
+    expect(config.baseUrl).toBe("https://api.anthropic.com");
+    expect(config.model).toBe("claude-sonnet-4-20250514");
+  });
+
+  test("resolveProviderConfig allows overrides", () => {
+    const config = resolveProviderConfig({
+      provider: "ollama",
+      baseUrl: "http://custom:1234/v1",
+      model: "custom-model",
+      temperature: 0.8,
+      maxTokens: 2048,
+    });
+    expect(config.baseUrl).toBe("http://custom:1234/v1");
+    expect(config.model).toBe("custom-model");
+    expect(config.temperature).toBe(0.8);
+    expect(config.maxTokens).toBe(2048);
+  });
+
+  test("custom provider uses empty defaults", () => {
+    const config = resolveProviderConfig({
+      provider: "custom",
+      baseUrl: "http://my-llm/v1",
+      model: "my-model",
+    });
+    expect(config.provider).toBe("custom");
+    expect(config.baseUrl).toBe("http://my-llm/v1");
+    expect(config.model).toBe("my-model");
+  });
+
+  test("PROVIDER_DEFAULTS has expected keys", () => {
+    expect(Object.keys(PROVIDER_DEFAULTS)).toEqual(["ollama", "openai", "anthropic"]);
+  });
+});

package/tests/cli/args.test.ts

@@ -0,0 +1,63 @@
+import { describe, test, expect } from "bun:test";
+import { parseArgs } from "../../src/cli/index.ts";
+
+// parseArgs expects full argv: [bunPath, scriptPath, ...userArgs]
+function parse(...userArgs: string[]) {
+  return parseArgs(["bun", "script.ts", ...userArgs]);
+}
+
+describe("parseArgs", () => {
+  test("run command with path", () => {
+    const result = parse("run", "tests/");
+    expect(result.command).toBe("run");
+    expect(result.positional).toEqual(["tests/"]);
+    expect(result.flags).toEqual({});
+  });
+
+  test("run with all flags", () => {
+    const result = parse("run", "test.yaml", "--env", "staging", "--report", "json", "--timeout", "5000", "--bail");
+    expect(result.command).toBe("run");
+    expect(result.positional).toEqual(["test.yaml"]);
+    expect(result.flags).toEqual({
+      env: "staging",
+      report: "json",
+      timeout: "5000",
+      bail: true,
+    });
+  });
+
+  test("validate command", () => {
+    const result = parse("validate", "test.yaml");
+    expect(result.command).toBe("validate");
+    expect(result.positional).toEqual(["test.yaml"]);
+  });
+
+  test("--help flag", () => {
+    const result = parse("--help");
+    expect(result.command).toBe(undefined);
+    expect(result.flags["help"]).toBe(true);
+  });
+
+  test("-h short flag", () => {
+    const result = parse("-h");
+    expect(result.command).toBe(undefined);
+    expect(result.flags["h"]).toBe(true);
+  });
+
+  test("no arguments", () => {
+    const result = parse();
+    expect(result.command).toBe(undefined);
+    expect(result.positional).toEqual([]);
+    expect(result.flags).toEqual({});
+  });
+
+  test("--flag=value syntax", () => {
+    const result = parse("run", "tests/", "--report=json");
+    expect(result.flags["report"]).toBe("json");
+  });
+
+  test("unknown command captured as command", () => {
+    const result = parse("foobar");
+    expect(result.command).toBe("foobar");
+  });
+});

package/tests/cli/chat.test.ts

@@ -0,0 +1,38 @@
+import { describe, test, expect } from "bun:test";
+import { parseArgs } from "../../src/cli/index.ts";
+
+function parse(...userArgs: string[]) {
+  return parseArgs(["bun", "script.ts", ...userArgs]);
+}
+
+describe("chat command parsing", () => {
+  test("basic chat command", () => {
+    const result = parse("chat");
+    expect(result.command).toBe("chat");
+    expect(result.positional).toEqual([]);
+  });
+
+  test("chat with --provider openai --model gpt-4o", () => {
+    const result = parse("chat", "--provider", "openai", "--model", "gpt-4o");
+    expect(result.command).toBe("chat");
+    expect(result.flags["provider"]).toBe("openai");
+    expect(result.flags["model"]).toBe("gpt-4o");
+  });
+
+  test("chat with --safe flag", () => {
+    const result = parse("chat", "--safe");
+    expect(result.command).toBe("chat");
+    expect(result.flags["safe"]).toBe(true);
+  });
+
+  test("chat with --api-key", () => {
+    const result = parse("chat", "--provider", "anthropic", "--api-key", "sk-ant-test");
+    expect(result.flags["provider"]).toBe("anthropic");
+    expect(result.flags["api-key"]).toBe("sk-ant-test");
+  });
+
+  test("default provider is handled by command implementation", () => {
+    const result = parse("chat");
+    expect(result.flags["provider"]).toBeUndefined();
+  });
+});

package/tests/cli/ci-init.test.ts

@@ -0,0 +1,112 @@
+import { describe, test, expect, beforeEach, afterEach, mock } from "bun:test";
+import { mkdtempSync, existsSync, readFileSync, writeFileSync, mkdirSync, rmSync } from "fs";
+import { join } from "path";
+import { tmpdir } from "os";
+import { ciInitCommand } from "../../src/cli/commands/ci-init.ts";
+
+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("apitool ci init", () => {
+  let tmpDir: string;
+  let origCwd: string;
+  let restoreOutput: () => void;
+
+  beforeEach(() => {
+    tmpDir = mkdtempSync(join(tmpdir(), "apitool-ci-init-"));
+    origCwd = process.cwd();
+    process.chdir(tmpDir);
+    restoreOutput = suppressOutput();
+  });
+
+  afterEach(() => {
+    process.chdir(origCwd);
+    restoreOutput();
+    rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  test("--github creates GitHub Actions workflow", async () => {
+    const code = await ciInitCommand({ platform: "github", force: false });
+    expect(code).toBe(0);
+
+    const filePath = join(tmpDir, ".github/workflows/api-tests.yml");
+    expect(existsSync(filePath)).toBe(true);
+
+    const content = readFileSync(filePath, "utf-8");
+    expect(content).toContain("actions/checkout@v4");
+    expect(content).toContain("apitool run");
+    expect(content).toContain("--report junit");
+    expect(content).toContain("install.sh");
+  });
+
+  test("--gitlab creates GitLab CI config", async () => {
+    const code = await ciInitCommand({ platform: "gitlab", force: false });
+    expect(code).toBe(0);
+
+    const filePath = join(tmpDir, ".gitlab-ci.yml");
+    expect(existsSync(filePath)).toBe(true);
+
+    const content = readFileSync(filePath, "utf-8");
+    expect(content).toContain("api-tests:");
+    expect(content).toContain("apitool run");
+    expect(content).toContain("junit: test-results/junit.xml");
+  });
+
+  test("auto-detects GitHub when .github/ exists", async () => {
+    mkdirSync(join(tmpDir, ".github"));
+
+    const code = await ciInitCommand({ force: false });
+    expect(code).toBe(0);
+
+    expect(existsSync(join(tmpDir, ".github/workflows/api-tests.yml"))).toBe(true);
+  });
+
+  test("auto-detects GitLab when .gitlab-ci.yml exists", async () => {
+    writeFileSync(join(tmpDir, ".gitlab-ci.yml"), "# existing\n");
+
+    const code = await ciInitCommand({ platform: "gitlab", force: true });
+    expect(code).toBe(0);
+
+    const content = readFileSync(join(tmpDir, ".gitlab-ci.yml"), "utf-8");
+    expect(content).toContain("api-tests:");
+  });
+
+  test("defaults to GitHub when no platform detected", async () => {
+    const code = await ciInitCommand({ force: false });
+    expect(code).toBe(0);
+
+    expect(existsSync(join(tmpDir, ".github/workflows/api-tests.yml"))).toBe(true);
+  });
+
+  test("skips existing file without --force", async () => {
+    const dir = join(tmpDir, ".github/workflows");
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(join(dir, "api-tests.yml"), "original: true\n");
+
+    const code = await ciInitCommand({ platform: "github", force: false });
+    expect(code).toBe(0);
+
+    const content = readFileSync(join(dir, "api-tests.yml"), "utf-8");
+    expect(content).toBe("original: true\n");
+  });
+
+  test("--force overwrites existing file", async () => {
+    const dir = join(tmpDir, ".github/workflows");
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(join(dir, "api-tests.yml"), "original: true\n");
+
+    const code = await ciInitCommand({ platform: "github", force: true });
+    expect(code).toBe(0);
+
+    const content = readFileSync(join(dir, "api-tests.yml"), "utf-8");
+    expect(content).toContain("actions/checkout@v4");
+  });
+});