@kirrosh/apitool 0.4.3

package/tests/cli/commands.test.ts

@@ -0,0 +1,316 @@
+import { describe, test, expect, mock, afterEach } from "bun:test";
+import { tmpdir } from "os";
+import { join } from "path";
+import { existsSync, unlinkSync } from "fs";
+import { runCommand } from "../../src/cli/commands/run.ts";
+import { validateCommand } from "../../src/cli/commands/validate.ts";
+import { parseArgs } from "../../src/cli/index.ts";
+import { closeDb } from "../../src/db/schema.ts";
+
+function tryUnlink(path: string): void {
+  for (const suffix of ["", "-wal", "-shm"]) {
+    try { unlinkSync(path + suffix); } catch { /* ignore on Windows */ }
+  }
+}
+
+const FIXTURES = `${import.meta.dir}/../fixtures`;
+const originalFetch = globalThis.fetch;
+
+// Helper to mock fetch responses
+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;
+}
+
+function restoreFetch() {
+  globalThis.fetch = originalFetch;
+}
+
+// Suppress stdout/stderr during tests
+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;
+  };
+}
+
+function tmpDb(): string {
+  return join(tmpdir(), `apitool-cmd-test-${Date.now()}-${Math.random().toString(36).slice(2)}.db`);
+}
+
+describe("runCommand", () => {
+  let restore: () => void;
+
+  afterEach(() => {
+    restore?.();
+    restoreFetch();
+    closeDb();
+  });
+
+  test("returns 0 when all tests pass", async () => {
+    mockFetchResponses([{ status: 200, body: { id: 1 } }]);
+    restore = suppressOutput();
+
+    const code = await runCommand({
+      path: `${FIXTURES}/simple.yaml`,
+      report: "console",
+      bail: false,
+      noDb: true,
+    });
+    expect(code).toBe(0);
+  });
+
+  test("returns 1 when a test fails", async () => {
+    // simple.yaml expects status 200, we return 500
+    mockFetchResponses([{ status: 500, body: { error: "fail" } }]);
+    restore = suppressOutput();
+
+    const code = await runCommand({
+      path: `${FIXTURES}/simple.yaml`,
+      report: "console",
+      bail: false,
+      noDb: true,
+    });
+    expect(code).toBe(1);
+  });
+
+  test("returns 2 for invalid path", async () => {
+    restore = suppressOutput();
+
+    const code = await runCommand({
+      path: `${FIXTURES}/nonexistent.yaml`,
+      report: "console",
+      bail: false,
+      noDb: true,
+    });
+    expect(code).toBe(2);
+  });
+
+  test("--timeout overrides suite config", async () => {
+    mockFetchResponses([{ status: 200, body: {} }]);
+    restore = suppressOutput();
+
+    const code = await runCommand({
+      path: `${FIXTURES}/simple.yaml`,
+      report: "json",
+      timeout: 1000,
+      bail: false,
+      noDb: true,
+    });
+    expect(code).toBe(0);
+  });
+
+  test("works with json reporter", async () => {
+    mockFetchResponses([{ status: 200, body: {} }]);
+
+    let output = "";
+    const origLog = console.log;
+    const origErr = process.stderr.write;
+    console.log = mock((...args: unknown[]) => {
+      output += args.map(String).join(" ") + "\n";
+    });
+    process.stderr.write = mock(() => true) as typeof process.stderr.write;
+    restore = () => {
+      console.log = origLog;
+      process.stderr.write = origErr;
+    };
+
+    const code = await runCommand({
+      path: `${FIXTURES}/simple.yaml`,
+      report: "json",
+      bail: false,
+      noDb: true,
+    });
+
+    expect(code).toBe(0);
+    const parsed = JSON.parse(output.trim());
+    expect(Array.isArray(parsed)).toBe(true);
+    expect(parsed[0].suite_name).toBe("Health Check");
+  });
+
+  test("works with junit reporter", async () => {
+    mockFetchResponses([{ status: 200, body: {} }]);
+
+    let output = "";
+    const origLog = console.log;
+    const origErr = process.stderr.write;
+    console.log = mock((...args: unknown[]) => {
+      output += args.map(String).join(" ") + "\n";
+    });
+    process.stderr.write = mock(() => true) as typeof process.stderr.write;
+    restore = () => {
+      console.log = origLog;
+      process.stderr.write = origErr;
+    };
+
+    const code = await runCommand({
+      path: `${FIXTURES}/simple.yaml`,
+      report: "junit",
+      bail: false,
+      noDb: true,
+    });
+
+    expect(code).toBe(0);
+    expect(output).toContain('<?xml version="1.0" encoding="UTF-8"?>');
+    expect(output).toContain("<testsuites");
+    expect(output).toContain("Health Check");
+  });
+
+  test("bail stops after first failed suite", async () => {
+    // bail/ directory has 2 YAML files, each expects status 200
+    // We return 500 so both would fail, but bail should stop after first
+    let fetchCallCount = 0;
+    globalThis.fetch = mock(async () => {
+      fetchCallCount++;
+      return new Response(JSON.stringify({ error: "fail" }), {
+        status: 500,
+        headers: { "Content-Type": "application/json" },
+      });
+    }) as unknown as typeof fetch;
+
+    restore = suppressOutput();
+
+    const code = await runCommand({
+      path: `${FIXTURES}/bail`,
+      report: "console",
+      bail: true,
+      noDb: true,
+    });
+
+    expect(code).toBe(1);
+    // With bail, only the first suite should have run
+    expect(fetchCallCount).toBe(1);
+  });
+
+  test("saves results to DB when noDb is false", async () => {
+    mockFetchResponses([{ status: 200, body: {} }]);
+    const db = tmpDb();
+    restore = suppressOutput();
+
+    try {
+      const code = await runCommand({
+        path: `${FIXTURES}/simple.yaml`,
+        report: "console",
+        bail: false,
+        noDb: false,
+        dbPath: db,
+      });
+      expect(code).toBe(0);
+      expect(existsSync(db)).toBe(true);
+
+      const { getDb } = await import("../../src/db/schema.ts");
+      const runs = getDb(db).query("SELECT * FROM runs").all();
+      expect(runs).toHaveLength(1);
+    } finally {
+      closeDb();
+      tryUnlink(db);
+    }
+  });
+
+  test("--no-db skips DB creation", async () => {
+    mockFetchResponses([{ status: 200, body: {} }]);
+    const db = tmpDb();
+    restore = suppressOutput();
+
+    const code = await runCommand({
+      path: `${FIXTURES}/simple.yaml`,
+      report: "console",
+      bail: false,
+      noDb: true,
+      dbPath: db,
+    });
+
+    expect(code).toBe(0);
+    expect(existsSync(db)).toBe(false);
+  });
+});
+
+describe("validateCommand", () => {
+  let restore: () => void;
+
+  afterEach(() => {
+    restore?.();
+  });
+
+  test("returns 0 for valid YAML", async () => {
+    restore = suppressOutput();
+    const code = await validateCommand({ path: `${FIXTURES}/simple.yaml` });
+    expect(code).toBe(0);
+  });
+
+  test("returns 2 for invalid YAML", async () => {
+    restore = suppressOutput();
+    const code = await validateCommand({ path: `${FIXTURES}/invalid-missing-name.yaml` });
+    expect(code).toBe(2);
+  });
+
+  test("returns 0 for valid directory", async () => {
+    restore = suppressOutput();
+    const code = await validateCommand({ path: `${FIXTURES}/valid` });
+    expect(code).toBe(0);
+  });
+
+  test("returns 2 for nonexistent path", async () => {
+    restore = suppressOutput();
+    const code = await validateCommand({ path: `${FIXTURES}/nonexistent.yaml` });
+    expect(code).toBe(2);
+  });
+});
+
+describe("parseArgs", () => {
+  test("parses --auth-token flag", () => {
+    const result = parseArgs(["bun", "script.ts", "run", "tests/", "--auth-token", "my-secret-token"]);
+    expect(result.command).toBe("run");
+    expect(result.positional).toEqual(["tests/"]);
+    expect(result.flags["auth-token"]).toBe("my-secret-token");
+  });
+
+  test("parses --auth-token with = syntax", () => {
+    const result = parseArgs(["bun", "script.ts", "run", "tests/", "--auth-token=my-token"]);
+    expect(result.flags["auth-token"]).toBe("my-token");
+  });
+});
+
+describe("runCommand with --auth-token", () => {
+  let restore: () => void;
+
+  afterEach(() => {
+    restore?.();
+    restoreFetch();
+    closeDb();
+  });
+
+  test("auth token is injected into requests via env", async () => {
+    let capturedHeaders: Record<string, string> = {};
+    globalThis.fetch = mock(async (_url: string | URL | Request, init?: RequestInit) => {
+      capturedHeaders = Object.fromEntries(Object.entries(init?.headers ?? {}));
+      return new Response(JSON.stringify({ status: "ok" }), {
+        status: 200,
+        headers: { "Content-Type": "application/json" },
+      });
+    }) as unknown as typeof fetch;
+    restore = suppressOutput();
+
+    const code = await runCommand({
+      path: `${FIXTURES}/auth-token-test.yaml`,
+      report: "console",
+      bail: false,
+      noDb: true,
+      authToken: "test-jwt-token-123",
+    });
+
+    // The test file should use {{auth_token}} in Authorization header
+    expect(capturedHeaders["Authorization"]).toBe("Bearer test-jwt-token-123");
+    expect(code).toBe(0);
+  });
+});

package/tests/cli/coverage.test.ts

@@ -0,0 +1,58 @@
+import { describe, test, expect, mock, beforeEach, afterAll } from "bun:test";
+
+// Mock the generator modules
+mock.module("../../src/core/generator/openapi-reader.ts", () => ({
+  readOpenApiSpec: mock(() => Promise.resolve({
+    info: { title: "Test API", version: "1.0" },
+    paths: {},
+  })),
+  extractEndpoints: mock(() => [
+    { method: "GET", path: "/users", tags: [], parameters: [], responses: [] },
+    { method: "POST", path: "/users", tags: [], parameters: [], responses: [] },
+    { method: "GET", path: "/users/{id}", tags: [], parameters: [], responses: [] },
+  ]),
+  extractSecuritySchemes: mock(() => []),
+}));
+
+mock.module("../../src/core/generator/coverage-scanner.ts", () => ({
+  scanCoveredEndpoints: mock(() => Promise.resolve([
+    { method: "GET", path: "/users", file: "tests/users.yaml" },
+  ])),
+  filterUncoveredEndpoints: mock((all: any[], covered: any[]) => {
+    // Simulate 2 uncovered
+    return all.slice(1);
+  }),
+}));
+
+afterAll(() => { mock.restore(); });
+
+import { coverageCommand } from "../../src/cli/commands/coverage.ts";
+import { readOpenApiSpec, extractEndpoints } from "../../src/core/generator/openapi-reader.ts";
+import { scanCoveredEndpoints } from "../../src/core/generator/coverage-scanner.ts";
+
+describe("coverageCommand", () => {
+  beforeEach(() => {
+    (readOpenApiSpec as ReturnType<typeof mock>).mockClear();
+    (extractEndpoints as ReturnType<typeof mock>).mockClear();
+    (scanCoveredEndpoints as ReturnType<typeof mock>).mockClear();
+  });
+
+  test("returns 1 when there are uncovered endpoints", async () => {
+    const code = await coverageCommand({ spec: "spec.yaml", tests: "./tests" });
+    expect(code).toBe(1);
+    expect(readOpenApiSpec).toHaveBeenCalledWith("spec.yaml");
+    expect(scanCoveredEndpoints).toHaveBeenCalledWith("./tests");
+  });
+
+  test("returns 2 on error", async () => {
+    (readOpenApiSpec as ReturnType<typeof mock>).mockRejectedValueOnce(new Error("File not found"));
+    const code = await coverageCommand({ spec: "bad.yaml", tests: "./tests" });
+    expect(code).toBe(2);
+  });
+
+  test("returns 1 when no endpoints in spec", async () => {
+    (extractEndpoints as ReturnType<typeof mock>).mockReturnValueOnce([]);
+    const code = await coverageCommand({ spec: "empty.yaml", tests: "./tests" });
+    expect(code).toBe(1);
+  });
+});

package/tests/cli/doctor.test.ts

@@ -0,0 +1,39 @@
+import { describe, test, expect, afterEach } from "bun:test";
+import { tmpdir } from "os";
+import { join } from "path";
+import { unlinkSync } from "fs";
+import { closeDb } from "../../src/db/schema.ts";
+import { doctorCommand } from "../../src/cli/commands/doctor.ts";
+
+function tmpDb(): string {
+  return join(tmpdir(), `apitool-doctor-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 */ }
+  }
+}
+
+describe("doctorCommand", () => {
+  let dbPath: string;
+
+  afterEach(() => {
+    closeDb();
+    if (dbPath) tryUnlink(dbPath);
+  });
+
+  test("runs with valid db path and returns 0 or 1", async () => {
+    dbPath = tmpDb();
+    const code = await doctorCommand({ dbPath });
+    // Should succeed (0) or have non-fatal warnings (1) — never crash
+    expect(code === 0 || code === 1).toBe(true);
+  });
+
+  test("handles invalid db path gracefully", async () => {
+    dbPath = "/nonexistent/path/to/db.sqlite";
+    const code = await doctorCommand({ dbPath });
+    // Database check will fail, so code should be 1
+    expect(code).toBe(1);
+  });
+});

package/tests/cli/envs.test.ts

@@ -0,0 +1,181 @@
+import { describe, test, expect, beforeEach, afterEach } from "bun:test";
+import { tmpdir } from "os";
+import { join } from "path";
+import { unlinkSync, writeFileSync } from "fs";
+import { getDb, closeDb } from "../../src/db/schema.ts";
+import { upsertEnvironment, getEnvironment } from "../../src/db/queries.ts";
+import { envsCommand, parseKeyValuePairs, parseYamlEnv, toYaml } from "../../src/cli/commands/envs.ts";
+
+function tmpDb(): string {
+  return join(tmpdir(), `apitool-envs-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 */ }
+  }
+}
+
+describe("parseKeyValuePairs", () => {
+  test("parses KEY=VALUE strings", () => {
+    expect(parseKeyValuePairs(["base_url=https://api.example.com", "token=abc"])).toEqual({
+      base_url: "https://api.example.com",
+      token: "abc",
+    });
+  });
+
+  test("handles = in value", () => {
+    expect(parseKeyValuePairs(["key=val=ue"])).toEqual({ key: "val=ue" });
+  });
+
+  test("skips invalid pairs", () => {
+    expect(parseKeyValuePairs(["noeq", "good=yes"])).toEqual({ good: "yes" });
+  });
+});
+
+describe("envsCommand", () => {
+  let dbPath: string;
+
+  beforeEach(() => {
+    dbPath = tmpDb();
+    getDb(dbPath);
+  });
+
+  afterEach(() => {
+    closeDb();
+    tryUnlink(dbPath);
+  });
+
+  test("list shows empty message when no envs", () => {
+    const code = envsCommand({ action: "list", dbPath });
+    expect(code).toBe(0);
+  });
+
+  test("list shows environments", () => {
+    upsertEnvironment("dev", { base_url: "http://localhost" });
+    const code = envsCommand({ action: "list", dbPath });
+    expect(code).toBe(0);
+  });
+
+  test("get returns variables", () => {
+    upsertEnvironment("staging", { base_url: "https://staging.api.com", token: "abc" });
+    const code = envsCommand({ action: "get", name: "staging", dbPath });
+    expect(code).toBe(0);
+  });
+
+  test("get returns 1 for missing env", () => {
+    const code = envsCommand({ action: "get", name: "nonexistent", dbPath });
+    expect(code).toBe(1);
+  });
+
+  test("get returns 2 without name", () => {
+    const code = envsCommand({ action: "get", dbPath });
+    expect(code).toBe(2);
+  });
+
+  test("set creates environment", () => {
+    const code = envsCommand({ action: "set", name: "prod", pairs: ["base_url=https://prod.api.com"], dbPath });
+    expect(code).toBe(0);
+    // Verify via get
+    const code2 = envsCommand({ action: "get", name: "prod", dbPath });
+    expect(code2).toBe(0);
+  });
+
+  test("set returns 2 without name", () => {
+    const code = envsCommand({ action: "set", pairs: ["k=v"], dbPath });
+    expect(code).toBe(2);
+  });
+
+  test("set returns 2 without pairs", () => {
+    const code = envsCommand({ action: "set", name: "prod", dbPath });
+    expect(code).toBe(2);
+  });
+
+  test("delete removes environment", () => {
+    upsertEnvironment("tmp", { key: "val" });
+    const code = envsCommand({ action: "delete", name: "tmp", dbPath });
+    expect(code).toBe(0);
+    // Verify deleted
+    const code2 = envsCommand({ action: "get", name: "tmp", dbPath });
+    expect(code2).toBe(1);
+  });
+
+  test("delete returns 1 for missing env", () => {
+    const code = envsCommand({ action: "delete", name: "ghost", dbPath });
+    expect(code).toBe(1);
+  });
+
+  test("import loads YAML file into DB", () => {
+    const yamlFile = join(tmpdir(), `apitool-import-${Date.now()}.yaml`);
+    writeFileSync(yamlFile, "base_url: https://api.example.com\ntoken: secret123\n");
+    try {
+      const code = envsCommand({ action: "import", name: "imported", file: yamlFile, dbPath });
+      expect(code).toBe(0);
+      const vars = getEnvironment("imported");
+      expect(vars).toEqual({ base_url: "https://api.example.com", token: "secret123" });
+    } finally {
+      try { unlinkSync(yamlFile); } catch {}
+    }
+  });
+
+  test("import returns 2 without name", () => {
+    const code = envsCommand({ action: "import", file: "some.yaml", dbPath });
+    expect(code).toBe(2);
+  });
+
+  test("import returns 2 without file", () => {
+    const code = envsCommand({ action: "import", name: "test", dbPath });
+    expect(code).toBe(2);
+  });
+
+  test("import returns 1 for nonexistent file", () => {
+    const code = envsCommand({ action: "import", name: "test", file: "/nonexistent/file.yaml", dbPath });
+    expect(code).toBe(1);
+  });
+
+  test("export outputs YAML", () => {
+    upsertEnvironment("exportme", { base: "http://localhost", key: "val" });
+    const code = envsCommand({ action: "export", name: "exportme", dbPath });
+    expect(code).toBe(0);
+  });
+
+  test("export returns 1 for missing env", () => {
+    const code = envsCommand({ action: "export", name: "ghost", dbPath });
+    expect(code).toBe(1);
+  });
+
+  test("export returns 2 without name", () => {
+    const code = envsCommand({ action: "export", dbPath });
+    expect(code).toBe(2);
+  });
+});
+
+describe("parseYamlEnv", () => {
+  test("parses simple key: value pairs", () => {
+    expect(parseYamlEnv("base: http://localhost\ntoken: abc")).toEqual({
+      base: "http://localhost",
+      token: "abc",
+    });
+  });
+
+  test("strips quotes", () => {
+    expect(parseYamlEnv('key: "hello world"')).toEqual({ key: "hello world" });
+  });
+
+  test("skips comments and blank lines", () => {
+    expect(parseYamlEnv("# comment\n\nkey: val")).toEqual({ key: "val" });
+  });
+});
+
+describe("toYaml", () => {
+  test("serializes flat record", () => {
+    const yaml = toYaml({ name: "dev", token: "abc" });
+    expect(yaml).toContain("name: dev");
+    expect(yaml).toContain("token: abc");
+  });
+
+  test("quotes values with special chars", () => {
+    const yaml = toYaml({ url: "http://host:3000/path" });
+    expect(yaml).toContain('"http://host:3000/path"');
+  });
+});

package/tests/cli/init.test.ts

@@ -0,0 +1,80 @@
+import { describe, test, expect, beforeEach, afterEach, mock } from "bun:test";
+import { mkdtempSync, existsSync, readFileSync, writeFileSync, rmSync } from "fs";
+import { join } from "path";
+import { tmpdir } from "os";
+import { initCommand } from "../../src/cli/commands/init.ts";
+
+// Suppress stdout/stderr during tests
+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 init", () => {
+  let tmpDir: string;
+  let origCwd: string;
+  let restoreOutput: () => void;
+
+  beforeEach(() => {
+    tmpDir = mkdtempSync(join(tmpdir(), "apitool-init-"));
+    origCwd = process.cwd();
+    process.chdir(tmpDir);
+    restoreOutput = suppressOutput();
+  });
+
+  afterEach(() => {
+    process.chdir(origCwd);
+    restoreOutput();
+    rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  test("creates example test and env files", async () => {
+    const code = await initCommand({ force: false });
+    expect(code).toBe(0);
+
+    expect(existsSync(join(tmpDir, "tests/example.yaml"))).toBe(true);
+    expect(existsSync(join(tmpDir, ".env.dev.yaml"))).toBe(true);
+
+    const testContent = readFileSync(join(tmpDir, "tests/example.yaml"), "utf-8");
+    expect(testContent).toContain("Example Smoke Test");
+    expect(testContent).toContain("base_url");
+
+    const envContent = readFileSync(join(tmpDir, ".env.dev.yaml"), "utf-8");
+    expect(envContent).toContain("jsonplaceholder");
+  });
+
+  test("skips existing files without --force", async () => {
+    writeFileSync(join(tmpDir, ".env.dev.yaml"), "original: true\n");
+
+    const code = await initCommand({ force: false });
+    expect(code).toBe(0);
+
+    // tests/example.yaml should be created
+    expect(existsSync(join(tmpDir, "tests/example.yaml"))).toBe(true);
+
+    // .env.dev.yaml should NOT be overwritten
+    const envContent = readFileSync(join(tmpDir, ".env.dev.yaml"), "utf-8");
+    expect(envContent).toBe("original: true\n");
+  });
+
+  test("--force overwrites existing files", async () => {
+    writeFileSync(join(tmpDir, ".env.dev.yaml"), "original: true\n");
+
+    const code = await initCommand({ force: true });
+    expect(code).toBe(0);
+
+    const envContent = readFileSync(join(tmpDir, ".env.dev.yaml"), "utf-8");
+    expect(envContent).toContain("jsonplaceholder");
+  });
+
+  test("returns 0 exit code", async () => {
+    const code = await initCommand({ force: false });
+    expect(code).toBe(0);
+  });
+});