@kirrosh/apitool 0.4.3

package/tests/reporter/console.test.ts

@@ -0,0 +1,256 @@
+import { describe, test, expect, mock, afterEach } from "bun:test";
+import {
+  formatDuration,
+  formatStep,
+  formatFailures,
+  formatSuiteResult,
+  formatGrandTotal,
+  consoleReporter,
+} from "../../src/core/reporter/console.ts";
+import type { TestRunResult, StepResult } from "../../src/core/runner/types.ts";
+
+function makeStep(overrides?: Partial<StepResult>): StepResult {
+  return {
+    name: "Test step",
+    status: "pass",
+    duration_ms: 100,
+    request: { method: "GET", url: "http://localhost/test", headers: {} },
+    response: {
+      status: 200,
+      headers: {},
+      body: "{}",
+      body_parsed: {},
+      duration_ms: 100,
+    },
+    assertions: [],
+    captures: {},
+    ...overrides,
+  };
+}
+
+function makeResult(overrides?: Partial<TestRunResult>): TestRunResult {
+  return {
+    suite_name: "Test Suite",
+    started_at: "2024-01-01T00:00:00.000Z",
+    finished_at: "2024-01-01T00:00:01.000Z",
+    total: 1,
+    passed: 1,
+    failed: 0,
+    skipped: 0,
+    steps: [makeStep()],
+    ...overrides,
+  };
+}
+
+// --- formatDuration ---
+
+describe("formatDuration", () => {
+  test("milliseconds for < 1000ms", () => {
+    expect(formatDuration(450)).toBe("450ms");
+    expect(formatDuration(0)).toBe("0ms");
+    expect(formatDuration(999)).toBe("999ms");
+  });
+
+  test("seconds with one decimal for >= 1000ms", () => {
+    expect(formatDuration(1000)).toBe("1.0s");
+    expect(formatDuration(1200)).toBe("1.2s");
+    expect(formatDuration(59999)).toBe("60.0s");
+  });
+
+  test("minutes + seconds for >= 60000ms", () => {
+    expect(formatDuration(60000)).toBe("1m");
+    expect(formatDuration(65000)).toBe("1m 5s");
+    expect(formatDuration(125000)).toBe("2m 5s");
+  });
+});
+
+// --- formatStep (no color) ---
+
+describe("formatStep", () => {
+  test("pass step shows checkmark", () => {
+    const out = formatStep(makeStep({ name: "Create user", duration_ms: 450 }), false);
+    expect(out).toContain("\u2713");
+    expect(out).toContain("Create user");
+    expect(out).toContain("(450ms)");
+  });
+
+  test("fail step shows cross", () => {
+    const out = formatStep(makeStep({ name: "Update user", status: "fail", duration_ms: 310 }), false);
+    expect(out).toContain("\u2717");
+    expect(out).toContain("Update user");
+    expect(out).toContain("(310ms)");
+  });
+
+  test("skip step shows circle", () => {
+    const out = formatStep(makeStep({ name: "Verify", status: "skip", duration_ms: 0 }), false);
+    expect(out).toContain("\u25CB");
+    expect(out).toContain("Verify");
+    expect(out).toContain("(skipped)");
+  });
+
+  test("error step shows cross with error label", () => {
+    const out = formatStep(makeStep({ name: "Broken", status: "error", duration_ms: 0 }), false);
+    expect(out).toContain("\u2717");
+    expect(out).toContain("Broken");
+    expect(out).toContain("(error)");
+  });
+});
+
+// --- formatFailures ---
+
+describe("formatFailures", () => {
+  test("shows failed assertion details", () => {
+    const step = makeStep({
+      status: "fail",
+      assertions: [
+        { field: "status", rule: "equals 200", passed: false, actual: 500, expected: 200 },
+        { field: "body.name", rule: "type string", passed: true, actual: "John", expected: "string" },
+      ],
+    });
+    const out = formatFailures(step, false);
+    expect(out).toContain("status: expected equals 200 but got 500");
+    expect(out).not.toContain("body.name"); // passed assertion not shown
+  });
+
+  test("shows error message for error steps", () => {
+    const step = makeStep({ status: "error", error: "Connection refused" });
+    const out = formatFailures(step, false);
+    expect(out).toContain("Error: Connection refused");
+  });
+
+  test("returns empty for step with no failures", () => {
+    const step = makeStep({
+      status: "fail",
+      assertions: [{ field: "status", rule: "equals 200", passed: true, actual: 200, expected: 200 }],
+    });
+    const out = formatFailures(step, false);
+    expect(out).toBe("");
+  });
+});
+
+// --- formatSuiteResult ---
+
+describe("formatSuiteResult", () => {
+  test("formats mixed results correctly", () => {
+    const result = makeResult({
+      suite_name: "Users CRUD",
+      total: 3,
+      passed: 1,
+      failed: 1,
+      skipped: 1,
+      steps: [
+        makeStep({ name: "Create user", status: "pass", duration_ms: 450 }),
+        makeStep({
+          name: "Update user",
+          status: "fail",
+          duration_ms: 310,
+          assertions: [{ field: "status", rule: "equals 200", passed: false, actual: 500, expected: 200 }],
+        }),
+        makeStep({ name: "Verify deleted", status: "skip", duration_ms: 0 }),
+      ],
+    });
+
+    const out = formatSuiteResult(result, false);
+    expect(out).toContain("Users CRUD");
+    expect(out).toContain("\u2713");
+    expect(out).toContain("\u2717");
+    expect(out).toContain("\u25CB");
+    expect(out).toContain("1 passed");
+    expect(out).toContain("1 failed");
+    expect(out).toContain("1 skipped");
+    expect(out).toContain("status: expected equals 200 but got 500");
+  });
+
+  test("handles suite with zero steps", () => {
+    const result = makeResult({ total: 0, passed: 0, failed: 0, skipped: 0, steps: [] });
+    const out = formatSuiteResult(result, false);
+    expect(out).toContain("0 tests");
+  });
+});
+
+// --- formatGrandTotal ---
+
+describe("formatGrandTotal", () => {
+  test("aggregates multiple suites", () => {
+    const results = [
+      makeResult({
+        passed: 3, failed: 0, skipped: 0, total: 3,
+        started_at: "2024-01-01T00:00:00.000Z",
+        finished_at: "2024-01-01T00:00:01.000Z",
+      }),
+      makeResult({
+        passed: 1, failed: 1, skipped: 1, total: 3,
+        started_at: "2024-01-01T00:00:00.000Z",
+        finished_at: "2024-01-01T00:00:02.000Z",
+      }),
+    ];
+
+    const out = formatGrandTotal(results, false);
+    expect(out).toContain("Total:");
+    expect(out).toContain("4 passed");
+    expect(out).toContain("1 failed");
+    expect(out).toContain("1 skipped");
+    expect(out).toContain("2.0s");
+  });
+});
+
+// --- consoleReporter.report ---
+
+function captureConsoleLog() {
+  const origLog = console.log;
+  let output = "";
+  console.log = mock((...args: unknown[]) => {
+    output += args.map(String).join(" ") + "\n";
+  });
+  return {
+    getOutput: () => output,
+    restore: () => { console.log = origLog; },
+  };
+}
+
+describe("consoleReporter.report", () => {
+  let restoreFn: (() => void) | undefined;
+
+  afterEach(() => {
+    restoreFn?.();
+  });
+
+  test("writes output to stdout", () => {
+    const cap = captureConsoleLog();
+    restoreFn = cap.restore;
+
+    consoleReporter.report([makeResult({ suite_name: "My Suite" })], { color: false });
+    expect(cap.getOutput()).toContain("My Suite");
+    expect(cap.getOutput()).toContain("\u2713");
+  });
+
+  test("handles empty results", () => {
+    const cap = captureConsoleLog();
+    restoreFn = cap.restore;
+
+    consoleReporter.report([], { color: false });
+    expect(cap.getOutput()).toContain("No test suites found");
+  });
+
+  test("shows grand total for multiple suites", () => {
+    const cap = captureConsoleLog();
+    restoreFn = cap.restore;
+
+    consoleReporter.report(
+      [makeResult({ suite_name: "A" }), makeResult({ suite_name: "B" })],
+      { color: false },
+    );
+    const output = cap.getOutput();
+    expect(output).toContain("A");
+    expect(output).toContain("B");
+    expect(output).toContain("Total:");
+  });
+
+  test("no ANSI codes when color is false", () => {
+    const cap = captureConsoleLog();
+    restoreFn = cap.restore;
+
+    consoleReporter.report([makeResult()], { color: false });
+    expect(cap.getOutput()).not.toContain("\x1b[");
+  });
+});

package/tests/reporter/json.test.ts

@@ -0,0 +1,98 @@
+import { describe, test, expect, mock, afterEach } from "bun:test";
+import { jsonReporter } from "../../src/core/reporter/json.ts";
+import type { TestRunResult } from "../../src/core/runner/types.ts";
+
+function makeResult(overrides?: Partial<TestRunResult>): TestRunResult {
+  return {
+    suite_name: "Test Suite",
+    started_at: "2024-01-01T00:00:00.000Z",
+    finished_at: "2024-01-01T00:00:01.000Z",
+    total: 1,
+    passed: 1,
+    failed: 0,
+    skipped: 0,
+    steps: [
+      {
+        name: "Step 1",
+        status: "pass",
+        duration_ms: 100,
+        request: { method: "GET", url: "http://localhost/test", headers: {} },
+        response: {
+          status: 200,
+          headers: { "content-type": "application/json" },
+          body: '{"ok":true}',
+          body_parsed: { ok: true },
+          duration_ms: 100,
+        },
+        assertions: [{ field: "status", rule: "equals 200", passed: true, actual: 200, expected: 200 }],
+        captures: {},
+      },
+    ],
+    ...overrides,
+  };
+}
+
+function captureConsoleLog() {
+  const origLog = console.log;
+  let output = "";
+  console.log = mock((...args: unknown[]) => {
+    output += args.map(String).join(" ") + "\n";
+  });
+  return {
+    getOutput: () => output,
+    restore: () => { console.log = origLog; },
+  };
+}
+
+describe("JSON Reporter", () => {
+  let restoreFn: (() => void) | undefined;
+
+  afterEach(() => {
+    restoreFn?.();
+  });
+
+  test("outputs valid JSON matching input", () => {
+    const cap = captureConsoleLog();
+    restoreFn = cap.restore;
+
+    const results = [makeResult()];
+    jsonReporter.report(results);
+
+    const parsed = JSON.parse(cap.getOutput().trim());
+    expect(parsed).toEqual(results);
+  });
+
+  test("outputs pretty-printed JSON with 2-space indent", () => {
+    const cap = captureConsoleLog();
+    restoreFn = cap.restore;
+
+    jsonReporter.report([makeResult()]);
+
+    const output = cap.getOutput();
+    expect(output).toContain("\n");
+    expect(output).toContain('  "suite_name"');
+  });
+
+  test("handles multiple results", () => {
+    const cap = captureConsoleLog();
+    restoreFn = cap.restore;
+
+    const results = [makeResult({ suite_name: "Suite A" }), makeResult({ suite_name: "Suite B" })];
+    jsonReporter.report(results);
+
+    const parsed = JSON.parse(cap.getOutput().trim());
+    expect(parsed).toHaveLength(2);
+    expect(parsed[0].suite_name).toBe("Suite A");
+    expect(parsed[1].suite_name).toBe("Suite B");
+  });
+
+  test("handles empty results", () => {
+    const cap = captureConsoleLog();
+    restoreFn = cap.restore;
+
+    jsonReporter.report([]);
+
+    const parsed = JSON.parse(cap.getOutput().trim());
+    expect(parsed).toEqual([]);
+  });
+});

package/tests/reporter/junit.test.ts

@@ -0,0 +1,284 @@
+import { describe, test, expect, mock, afterEach } from "bun:test";
+import { junitReporter } from "../../src/core/reporter/junit.ts";
+import type { TestRunResult, StepResult } from "../../src/core/runner/types.ts";
+
+// ──────────────────────────────────────────────
+// Helpers
+// ──────────────────────────────────────────────
+
+function makeStep(overrides?: Partial<StepResult>): StepResult {
+  return {
+    name: "Get user",
+    status: "pass",
+    duration_ms: 450,
+    request: { method: "GET", url: "http://localhost/users/1", headers: {} },
+    response: {
+      status: 200,
+      headers: { "content-type": "application/json" },
+      body: '{"id":1}',
+      body_parsed: { id: 1 },
+      duration_ms: 450,
+    },
+    assertions: [{ field: "status", rule: "equals 200", passed: true, actual: 200, expected: 200 }],
+    captures: {},
+    ...overrides,
+  };
+}
+
+function makeResult(overrides?: Partial<TestRunResult>): TestRunResult {
+  return {
+    suite_name: "Users CRUD",
+    started_at: "2024-01-01T00:00:00.000Z",
+    finished_at: "2024-01-01T00:00:01.000Z",
+    total: 1,
+    passed: 1,
+    failed: 0,
+    skipped: 0,
+    steps: [makeStep()],
+    ...overrides,
+  };
+}
+
+function captureLog() {
+  const origLog = console.log;
+  let output = "";
+  console.log = mock((...args: unknown[]) => {
+    output += args.map(String).join(" ") + "\n";
+  });
+  return {
+    get: () => output.trim(),
+    restore: () => { console.log = origLog; },
+  };
+}
+
+// ──────────────────────────────────────────────
+// XML structure
+// ──────────────────────────────────────────────
+
+describe("JUnit Reporter — XML structure", () => {
+  let restoreFn: (() => void) | undefined;
+  afterEach(() => restoreFn?.());
+
+  test("outputs XML declaration and root element", () => {
+    const cap = captureLog();
+    restoreFn = cap.restore;
+
+    junitReporter.report([makeResult()]);
+    const xml = cap.get();
+
+    expect(xml).toContain('<?xml version="1.0" encoding="UTF-8"?>');
+    expect(xml).toContain("<testsuites");
+    expect(xml).toContain("</testsuites>");
+  });
+
+  test("root testsuites has correct aggregated attributes", () => {
+    const cap = captureLog();
+    restoreFn = cap.restore;
+
+    const results = [
+      makeResult({ total: 3, passed: 2, failed: 1, steps: [makeStep(), makeStep({ status: "fail", duration_ms: 310 }), makeStep()] }),
+      makeResult({ suite_name: "Suite B", total: 2, passed: 2, steps: [makeStep(), makeStep()] }),
+    ];
+    junitReporter.report(results);
+    const xml = cap.get();
+
+    expect(xml).toContain('tests="5"');
+    expect(xml).toContain('failures="1"');
+  });
+
+  test("each result becomes a testsuite element", () => {
+    const cap = captureLog();
+    restoreFn = cap.restore;
+
+    junitReporter.report([
+      makeResult({ suite_name: "Suite A" }),
+      makeResult({ suite_name: "Suite B" }),
+    ]);
+    const xml = cap.get();
+
+    expect(xml).toContain('name="Suite A"');
+    expect(xml).toContain('name="Suite B"');
+    expect((xml.match(/<testsuite /g) ?? []).length).toBe(2);
+  });
+
+  test("testsuite attributes: tests, failures, errors, skipped", () => {
+    const cap = captureLog();
+    restoreFn = cap.restore;
+
+    junitReporter.report([makeResult({ total: 2, passed: 1, failed: 1, skipped: 0 })]);
+    const xml = cap.get();
+
+    expect(xml).toContain('tests="2"');
+    expect(xml).toContain('failures="1"');
+    expect(xml).toContain('errors="0"');
+    expect(xml).toContain('skipped="0"');
+  });
+
+  test("passing step renders self-closing testcase", () => {
+    const cap = captureLog();
+    restoreFn = cap.restore;
+
+    junitReporter.report([makeResult()]);
+    const xml = cap.get();
+
+    expect(xml).toContain('<testcase name="Get user"');
+    expect(xml).toContain('"/>');
+    expect(xml).not.toContain("<failure");
+    expect(xml).not.toContain("<error");
+    expect(xml).not.toContain("<skipped");
+  });
+
+  test("skipped step renders <skipped/> element", () => {
+    const cap = captureLog();
+    restoreFn = cap.restore;
+
+    const step = makeStep({ name: "Verify deleted", status: "skip", duration_ms: 0 });
+    junitReporter.report([makeResult({ total: 1, passed: 0, skipped: 1, steps: [step] })]);
+    const xml = cap.get();
+
+    expect(xml).toContain('<testcase name="Verify deleted"');
+    expect(xml).toContain("<skipped/>");
+  });
+
+  test("failed step renders <failure> with message", () => {
+    const cap = captureLog();
+    restoreFn = cap.restore;
+
+    const step = makeStep({
+      name: "Update user",
+      status: "fail",
+      duration_ms: 310,
+      assertions: [
+        { field: "status", rule: "equals 200", passed: false, actual: 500, expected: 200 },
+      ],
+    });
+    junitReporter.report([makeResult({ total: 1, passed: 0, failed: 1, steps: [step] })]);
+    const xml = cap.get();
+
+    expect(xml).toContain('<testcase name="Update user"');
+    expect(xml).toContain("<failure");
+    expect(xml).toContain("</failure>");
+    expect(xml).toContain("equals 200");
+  });
+
+  test("error step renders <error> element", () => {
+    const cap = captureLog();
+    restoreFn = cap.restore;
+
+    const step = makeStep({
+      name: "Create user",
+      status: "error",
+      duration_ms: 50,
+      error: "Connection refused",
+    });
+    junitReporter.report([makeResult({ total: 1, passed: 0, failed: 0, steps: [step] })]);
+    const xml = cap.get();
+
+    expect(xml).toContain("<error");
+    expect(xml).toContain("Connection refused");
+    expect(xml).toContain("</error>");
+  });
+
+  test("empty results produce empty testsuites", () => {
+    const cap = captureLog();
+    restoreFn = cap.restore;
+
+    junitReporter.report([]);
+    const xml = cap.get();
+
+    expect(xml).toContain('tests="0"');
+    expect(xml).toContain("<testsuites");
+    expect(xml).toContain("</testsuites>");
+  });
+});
+
+// ──────────────────────────────────────────────
+// Time formatting
+// ──────────────────────────────────────────────
+
+describe("JUnit Reporter — time formatting", () => {
+  let restoreFn: (() => void) | undefined;
+  afterEach(() => restoreFn?.());
+
+  test("time is in seconds with 3 decimal places", () => {
+    const cap = captureLog();
+    restoreFn = cap.restore;
+
+    junitReporter.report([makeResult({ steps: [makeStep({ duration_ms: 450 })] })]);
+    const xml = cap.get();
+
+    expect(xml).toContain('time="0.450"');
+  });
+
+  test("aggregates step times for testsuite time", () => {
+    const cap = captureLog();
+    restoreFn = cap.restore;
+
+    const steps = [makeStep({ duration_ms: 100 }), makeStep({ duration_ms: 200 })];
+    junitReporter.report([makeResult({ total: 2, passed: 2, steps })]);
+    const xml = cap.get();
+
+    // testsuite time = 0.300
+    expect(xml).toContain('time="0.300"');
+  });
+
+  test("root testsuites time is total across all suites", () => {
+    const cap = captureLog();
+    restoreFn = cap.restore;
+
+    junitReporter.report([
+      makeResult({ steps: [makeStep({ duration_ms: 100 })] }),
+      makeResult({ suite_name: "B", steps: [makeStep({ duration_ms: 200 })] }),
+    ]);
+    const xml = cap.get();
+
+    // root time = 0.300
+    const match = xml.match(/<testsuites[^>]+time="([^"]+)"/);
+    expect(match?.[1]).toBe("0.300");
+  });
+});
+
+// ──────────────────────────────────────────────
+// XML escaping
+// ──────────────────────────────────────────────
+
+describe("JUnit Reporter — XML escaping", () => {
+  let restoreFn: (() => void) | undefined;
+  afterEach(() => restoreFn?.());
+
+  test("escapes & < > in suite name", () => {
+    const cap = captureLog();
+    restoreFn = cap.restore;
+
+    junitReporter.report([makeResult({ suite_name: "A & B <Suite>" })]);
+    const xml = cap.get();
+
+    expect(xml).toContain("A &amp; B &lt;Suite&gt;");
+    expect(xml).not.toContain("A & B <Suite>");
+  });
+
+  test("escapes & < > in step name", () => {
+    const cap = captureLog();
+    restoreFn = cap.restore;
+
+    junitReporter.report([makeResult({ steps: [makeStep({ name: 'Create "item" & verify' })] })]);
+    const xml = cap.get();
+
+    expect(xml).toContain("Create &quot;item&quot; &amp; verify");
+  });
+
+  test("escapes failure message", () => {
+    const cap = captureLog();
+    restoreFn = cap.restore;
+
+    const step = makeStep({
+      status: "fail",
+      assertions: [{ field: "body", rule: "contains <html>", passed: false, actual: "<html>", expected: "json" }],
+    });
+    junitReporter.report([makeResult({ total: 1, passed: 0, failed: 1, steps: [step] })]);
+    const xml = cap.get();
+
+    expect(xml).toContain("&lt;html&gt;");
+    expect(xml).not.toContain("<html>");
+  });
+});