@kirrosh/apitool 0.4.3

package/tests/db/environments.test.ts

@@ -0,0 +1,131 @@
+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 {
+  upsertEnvironment,
+  getEnvironment,
+  listEnvironments,
+  listEnvironmentRecords,
+  getEnvironmentById,
+  deleteEnvironment,
+} from "../../src/db/queries.ts";
+
+function tmpDbPath(): string {
+  return join(tmpdir(), `apitool-env-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 */ }
+  }
+}
+
+let dbPath: string;
+
+beforeEach(() => {
+  dbPath = tmpDbPath();
+  getDb(dbPath);
+});
+
+afterEach(() => {
+  closeDb();
+  tryUnlink(dbPath);
+});
+
+describe("upsertEnvironment", () => {
+  test("creates a new environment", () => {
+    upsertEnvironment("dev", { BASE_URL: "http://localhost:3000" });
+    expect(getEnvironment("dev")).toEqual({ BASE_URL: "http://localhost:3000" });
+  });
+
+  test("updates existing environment on conflict", () => {
+    upsertEnvironment("dev", { BASE_URL: "http://old" });
+    upsertEnvironment("dev", { BASE_URL: "http://new", TOKEN: "abc" });
+    expect(getEnvironment("dev")).toEqual({ BASE_URL: "http://new", TOKEN: "abc" });
+  });
+});
+
+describe("getEnvironment", () => {
+  test("returns variables for existing env", () => {
+    upsertEnvironment("staging", { API_KEY: "key123" });
+    expect(getEnvironment("staging")).toEqual({ API_KEY: "key123" });
+  });
+
+  test("returns null for non-existent env", () => {
+    expect(getEnvironment("nonexistent")).toBeNull();
+  });
+});
+
+describe("getEnvironmentById", () => {
+  test("returns full record for existing env", () => {
+    upsertEnvironment("prod", { BASE_URL: "https://prod.example.com" });
+    const records = listEnvironmentRecords();
+    const id = records[0]!.id;
+
+    const env = getEnvironmentById(id);
+    expect(env).not.toBeNull();
+    expect(env!.name).toBe("prod");
+    expect(env!.variables).toEqual({ BASE_URL: "https://prod.example.com" });
+    expect(env!.id).toBe(id);
+  });
+
+  test("returns null for non-existent id", () => {
+    expect(getEnvironmentById(9999)).toBeNull();
+  });
+});
+
+describe("listEnvironments", () => {
+  test("returns sorted names", () => {
+    upsertEnvironment("staging", {});
+    upsertEnvironment("dev", {});
+    upsertEnvironment("prod", {});
+    expect(listEnvironments()).toEqual(["dev", "prod", "staging"]);
+  });
+
+  test("returns empty array when none exist", () => {
+    expect(listEnvironments()).toEqual([]);
+  });
+});
+
+describe("listEnvironmentRecords", () => {
+  test("returns full records with parsed variables", () => {
+    upsertEnvironment("dev", { BASE_URL: "http://localhost" });
+    upsertEnvironment("prod", { BASE_URL: "https://prod.com", TOKEN: "xyz" });
+
+    const records = listEnvironmentRecords();
+    expect(records).toHaveLength(2);
+    expect(records[0]!.name).toBe("dev");
+    expect(records[0]!.variables).toEqual({ BASE_URL: "http://localhost" });
+    expect(records[1]!.name).toBe("prod");
+    expect(records[1]!.variables).toEqual({ BASE_URL: "https://prod.com", TOKEN: "xyz" });
+    expect(typeof records[0]!.id).toBe("number");
+  });
+});
+
+describe("deleteEnvironment", () => {
+  test("deletes existing environment and returns true", () => {
+    upsertEnvironment("dev", { BASE_URL: "http://localhost" });
+    const records = listEnvironmentRecords();
+    const id = records[0]!.id;
+
+    expect(deleteEnvironment(id)).toBe(true);
+    expect(getEnvironmentById(id)).toBeNull();
+    expect(listEnvironments()).toEqual([]);
+  });
+
+  test("returns false for non-existent id", () => {
+    expect(deleteEnvironment(9999)).toBe(false);
+  });
+
+  test("does not affect other environments", () => {
+    upsertEnvironment("dev", {});
+    upsertEnvironment("prod", {});
+    const records = listEnvironmentRecords();
+    const devId = records.find(r => r.name === "dev")!.id;
+
+    deleteEnvironment(devId);
+    expect(listEnvironments()).toEqual(["prod"]);
+  });
+});

package/tests/db/queries.test.ts

@@ -0,0 +1,409 @@
+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,
+  getRunById,
+  getResultsByRunId,
+  listRuns,
+  deleteRun,
+  upsertEnvironment,
+  getEnvironment,
+  listEnvironments,
+  getDashboardStats,
+  getPassRateTrend,
+  getSlowestTests,
+  getFlakyTests,
+  countRuns,
+} from "../../src/db/queries.ts";
+import type { TestRunResult } from "../../src/core/runner/types.ts";
+
+// ──────────────────────────────────────────────
+// Helpers
+// ──────────────────────────────────────────────
+
+function tmpDb(): string {
+  return join(tmpdir(), `apitool-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 on Windows */ }
+  }
+}
+
+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 200", passed: true, actual: 200, expected: 200 }],
+        captures: {},
+      },
+      {
+        name: "Delete user",
+        status: "fail",
+        duration_ms: 80,
+        request: { method: "DELETE", url: "http://localhost/users/1", headers: {} },
+        response: { status: 500, headers: {}, body: '{"error":"oops"}', duration_ms: 80 },
+        assertions: [{ field: "status", rule: "equals 204", passed: false, actual: 500, expected: 204 }],
+        captures: {},
+      },
+    ],
+    ...overrides,
+  };
+}
+
+let dbPath: string;
+
+beforeEach(() => {
+  dbPath = tmpDb();
+  getDb(dbPath);
+});
+
+afterEach(() => {
+  closeDb();
+  tryUnlink(dbPath);
+});
+
+// ──────────────────────────────────────────────
+// createRun
+// ──────────────────────────────────────────────
+
+describe("createRun", () => {
+  test("returns a positive integer id", () => {
+    const id = createRun({ started_at: "2024-01-01T00:00:00.000Z" });
+    expect(typeof id).toBe("number");
+    expect(id).toBeGreaterThan(0);
+  });
+
+  test("ids auto-increment", () => {
+    const id1 = createRun({ started_at: "2024-01-01T00:00:00.000Z" });
+    const id2 = createRun({ started_at: "2024-01-01T00:00:01.000Z" });
+    expect(id2).toBe(id1 + 1);
+  });
+
+  test("stores started_at and environment", () => {
+    const id = createRun({ started_at: "2024-06-15T10:00:00.000Z", environment: "staging" });
+    const row = getRunById(id);
+    expect(row?.started_at).toBe("2024-06-15T10:00:00.000Z");
+    expect(row?.environment).toBe("staging");
+  });
+
+  test("defaults trigger to 'manual'", () => {
+    const id = createRun({ started_at: "2024-01-01T00:00:00.000Z" });
+    const row = getRunById(id);
+    expect(row?.trigger).toBe("manual");
+  });
+});
+
+// ──────────────────────────────────────────────
+// finalizeRun
+// ──────────────────────────────────────────────
+
+describe("finalizeRun", () => {
+  test("updates total/passed/failed/skipped/finished_at/duration_ms", () => {
+    const id = createRun({ started_at: "2024-01-01T00:00:00.000Z" });
+    finalizeRun(id, [makeSuiteResult()]);
+
+    const row = getRunById(id);
+    expect(row?.total).toBe(2);
+    expect(row?.passed).toBe(1);
+    expect(row?.failed).toBe(1);
+    expect(row?.skipped).toBe(0);
+    expect(row?.finished_at).toBe("2024-01-01T00:00:01.000Z");
+    expect(typeof row?.duration_ms).toBe("number");
+  });
+
+  test("aggregates totals across multiple suites", () => {
+    const id = createRun({ started_at: "2024-01-01T00:00:00.000Z" });
+    finalizeRun(id, [
+      makeSuiteResult({ total: 3, passed: 2, failed: 1 }),
+      makeSuiteResult({ suite_name: "B", total: 2, passed: 2, failed: 0 }),
+    ]);
+
+    const row = getRunById(id);
+    expect(row?.total).toBe(5);
+    expect(row?.passed).toBe(4);
+    expect(row?.failed).toBe(1);
+  });
+});
+
+// ──────────────────────────────────────────────
+// saveResults / getResultsByRunId
+// ──────────────────────────────────────────────
+
+describe("saveResults", () => {
+  test("inserts one row per step", () => {
+    const id = createRun({ started_at: "2024-01-01T00:00:00.000Z" });
+    saveResults(id, [makeSuiteResult()]);
+
+    const row = getDb(dbPath).query("SELECT COUNT(*) as n FROM results WHERE run_id = ?").get(id) as { n: number };
+    expect(row.n).toBe(2);
+  });
+
+  test("stores suite_name and test_name correctly", () => {
+    const id = createRun({ started_at: "2024-01-01T00:00:00.000Z" });
+    saveResults(id, [makeSuiteResult()]);
+
+    const results = getResultsByRunId(id);
+    expect(results[0]?.suite_name).toBe("Users API");
+    expect(results[0]?.test_name).toBe("Get user");
+  });
+
+  test("response_body is null for passing steps", () => {
+    const id = createRun({ started_at: "2024-01-01T00:00:00.000Z" });
+    saveResults(id, [makeSuiteResult()]);
+
+    const row = getDb(dbPath)
+      .query("SELECT response_body FROM results WHERE test_name = 'Get user'")
+      .get() as { response_body: string | null };
+    expect(row?.response_body).toBeNull();
+  });
+
+  test("response_body is stored for failing steps", () => {
+    const id = createRun({ started_at: "2024-01-01T00:00:00.000Z" });
+    saveResults(id, [makeSuiteResult()]);
+
+    const row = getDb(dbPath)
+      .query("SELECT response_body FROM results WHERE test_name = 'Delete user'")
+      .get() as { response_body: string | null };
+    expect(row?.response_body).toBe('{"error":"oops"}');
+  });
+
+  test("assertions are deserialized back from JSON", () => {
+    const id = createRun({ started_at: "2024-01-01T00:00:00.000Z" });
+    saveResults(id, [makeSuiteResult()]);
+
+    const results = getResultsByRunId(id);
+    const passStep = results.find((r) => r.test_name === "Get user")!;
+    expect(Array.isArray(passStep.assertions)).toBe(true);
+    expect(passStep.assertions[0]?.rule).toBe("equals 200");
+  });
+
+  test("handles multiple suites in one call", () => {
+    const id = createRun({ started_at: "2024-01-01T00:00:00.000Z" });
+    saveResults(id, [makeSuiteResult(), makeSuiteResult({ suite_name: "Posts API" })]);
+
+    const count = getDb(dbPath)
+      .query("SELECT COUNT(*) as n FROM results WHERE run_id = ?")
+      .get(id) as { n: number };
+    expect(count.n).toBe(4);
+  });
+
+  test("skipped steps have null response_body", () => {
+    const id = createRun({ started_at: "2024-01-01T00:00:00.000Z" });
+    const suite = makeSuiteResult({
+      total: 1,
+      passed: 0,
+      failed: 0,
+      skipped: 1,
+      steps: [{
+        name: "Skipped step",
+        status: "skip",
+        duration_ms: 0,
+        request: { method: "GET", url: "http://localhost/skip", headers: {} },
+        assertions: [],
+        captures: {},
+        error: "dependency failed",
+      }],
+    });
+    saveResults(id, [suite]);
+
+    const row = getDb(dbPath)
+      .query("SELECT response_body FROM results WHERE test_name = 'Skipped step'")
+      .get() as { response_body: string | null };
+    expect(row?.response_body).toBeNull();
+  });
+});
+
+// ──────────────────────────────────────────────
+// listRuns / deleteRun
+// ──────────────────────────────────────────────
+
+describe("listRuns", () => {
+  test("returns runs ordered by started_at DESC", () => {
+    createRun({ started_at: "2024-01-01T00:00:00.000Z" });
+    createRun({ started_at: "2024-01-03T00:00:00.000Z" });
+    createRun({ started_at: "2024-01-02T00:00:00.000Z" });
+
+    const runs = listRuns();
+    expect(runs[0]?.started_at).toBe("2024-01-03T00:00:00.000Z");
+    expect(runs[2]?.started_at).toBe("2024-01-01T00:00:00.000Z");
+  });
+
+  test("respects limit and offset", () => {
+    for (let i = 1; i <= 5; i++) {
+      createRun({ started_at: `2024-01-0${i}T00:00:00.000Z` });
+    }
+    const page = listRuns(2, 1);
+    expect(page).toHaveLength(2);
+  });
+
+  test("returns empty array when no runs", () => {
+    expect(listRuns()).toEqual([]);
+  });
+});
+
+describe("deleteRun", () => {
+  test("returns true when run exists and deletes it", () => {
+    const id = createRun({ started_at: "2024-01-01T00:00:00.000Z" });
+    expect(deleteRun(id)).toBe(true);
+    expect(getRunById(id)).toBeNull();
+  });
+
+  test("returns false when run does not exist", () => {
+    expect(deleteRun(9999)).toBe(false);
+  });
+
+  test("also deletes associated results", () => {
+    const id = createRun({ started_at: "2024-01-01T00:00:00.000Z" });
+    saveResults(id, [makeSuiteResult()]);
+    deleteRun(id);
+
+    const count = getDb(dbPath)
+      .query("SELECT COUNT(*) as n FROM results WHERE run_id = ?")
+      .get(id) as { n: number };
+    expect(count.n).toBe(0);
+  });
+});
+
+// ──────────────────────────────────────────────
+// Environments
+// ──────────────────────────────────────────────
+
+describe("environments", () => {
+  test("upsertEnvironment and getEnvironment round-trip", () => {
+    upsertEnvironment("staging", { BASE_URL: "https://staging.example.com", TOKEN: "abc" });
+    expect(getEnvironment("staging")).toEqual({ BASE_URL: "https://staging.example.com", TOKEN: "abc" });
+  });
+
+  test("upsert overwrites existing environment", () => {
+    upsertEnvironment("prod", { BASE_URL: "https://old.example.com" });
+    upsertEnvironment("prod", { BASE_URL: "https://new.example.com" });
+    expect(getEnvironment("prod")?.BASE_URL).toBe("https://new.example.com");
+  });
+
+  test("getEnvironment returns null for unknown name", () => {
+    expect(getEnvironment("nonexistent")).toBeNull();
+  });
+
+  test("listEnvironments returns all environment names sorted", () => {
+    upsertEnvironment("staging", {});
+    upsertEnvironment("prod", {});
+    upsertEnvironment("dev", {});
+    expect(listEnvironments()).toEqual(["dev", "prod", "staging"]);
+  });
+
+  test("listEnvironments returns empty array when none exist", () => {
+    expect(listEnvironments()).toEqual([]);
+  });
+});
+
+// ──────────────────────────────────────────────
+// Dashboard metrics
+// ──────────────────────────────────────────────
+
+describe("getDashboardStats", () => {
+  test("returns zeros when no runs", () => {
+    const stats = getDashboardStats();
+    expect(stats.totalRuns).toBe(0);
+    expect(stats.totalTests).toBe(0);
+    expect(stats.overallPassRate).toBe(0);
+    expect(stats.avgDuration).toBe(0);
+  });
+
+  test("returns correct aggregates", () => {
+    const id1 = createRun({ started_at: "2024-01-01T00:00:00.000Z" });
+    finalizeRun(id1, [makeSuiteResult({ total: 4, passed: 3, failed: 1 })]);
+    const id2 = createRun({ started_at: "2024-01-02T00:00:00.000Z" });
+    finalizeRun(id2, [makeSuiteResult({ total: 6, passed: 6, failed: 0 })]);
+
+    const stats = getDashboardStats();
+    expect(stats.totalRuns).toBe(2);
+    expect(stats.totalTests).toBe(10);
+    expect(stats.overallPassRate).toBe(90);
+  });
+});
+
+describe("getPassRateTrend", () => {
+  test("returns empty array when no runs", () => {
+    expect(getPassRateTrend()).toEqual([]);
+  });
+
+  test("returns pass rate per run", () => {
+    const id = createRun({ started_at: "2024-01-01T00:00:00.000Z" });
+    finalizeRun(id, [makeSuiteResult({ total: 10, passed: 8, failed: 2 })]);
+
+    const trend = getPassRateTrend(10);
+    expect(trend).toHaveLength(1);
+    expect(trend[0]!.pass_rate).toBe(80);
+  });
+});
+
+describe("getSlowestTests", () => {
+  test("returns empty array when no results", () => {
+    expect(getSlowestTests()).toEqual([]);
+  });
+
+  test("returns tests sorted by avg duration desc", () => {
+    const id = createRun({ started_at: "2024-01-01T00:00:00.000Z" });
+    saveResults(id, [makeSuiteResult()]);
+
+    const slow = getSlowestTests(5);
+    expect(slow.length).toBeGreaterThan(0);
+    expect(slow[0]!.suite_name).toBe("Users API");
+  });
+});
+
+describe("getFlakyTests", () => {
+  test("returns empty array when no flaky tests", () => {
+    expect(getFlakyTests()).toEqual([]);
+  });
+
+  test("detects flaky tests with multiple statuses", () => {
+    // Run 1: step passes
+    const id1 = createRun({ started_at: "2024-01-01T00:00:00.000Z" });
+    saveResults(id1, [makeSuiteResult({
+      steps: [{ name: "Flaky step", status: "pass", duration_ms: 100, request: { method: "GET", url: "http://x", headers: {} }, assertions: [], captures: {} }],
+    })]);
+
+    // Run 2: same step fails
+    const id2 = createRun({ started_at: "2024-01-02T00:00:00.000Z" });
+    saveResults(id2, [makeSuiteResult({
+      steps: [{ name: "Flaky step", status: "fail", duration_ms: 100, request: { method: "GET", url: "http://x", headers: {} }, assertions: [], captures: {} }],
+    })]);
+
+    const flaky = getFlakyTests(10, 5);
+    expect(flaky.length).toBe(1);
+    expect(flaky[0]!.test_name).toBe("Flaky step");
+    expect(flaky[0]!.distinct_statuses).toBe(2);
+  });
+});
+
+describe("countRuns", () => {
+  test("returns 0 when no runs", () => {
+    expect(countRuns()).toBe(0);
+  });
+
+  test("returns correct count", () => {
+    createRun({ started_at: "2024-01-01T00:00:00.000Z" });
+    createRun({ started_at: "2024-01-02T00:00:00.000Z" });
+    expect(countRuns()).toBe(2);
+  });
+});

package/tests/db/schema.test.ts

@@ -0,0 +1,141 @@
+import { describe, test, expect, afterEach } from "bun:test";
+import { tmpdir } from "os";
+import { join } from "path";
+import { existsSync, unlinkSync } from "fs";
+import { getDb, closeDb } from "../../src/db/schema.ts";
+
+function tmpDb(): string {
+  return join(tmpdir(), `apitool-test-${Date.now()}-${Math.random().toString(36).slice(2)}.db`);
+}
+
+function tryUnlink(path: string): void {
+  // WAL mode creates -wal and -shm sidecar files; cleanup is best-effort on Windows
+  for (const suffix of ["", "-wal", "-shm"]) {
+    try { unlinkSync(path + suffix); } catch { /* ignore */ }
+  }
+}
+
+describe("getDb / schema", () => {
+  let dbPath: string | undefined;
+
+  afterEach(() => {
+    closeDb();
+    if (dbPath) { tryUnlink(dbPath); dbPath = undefined; }
+  });
+
+  test("creates the db file at the given path", () => {
+    dbPath = tmpDb();
+    getDb(dbPath);
+    expect(existsSync(dbPath)).toBe(true);
+  });
+
+  test("returns the same singleton on repeated calls", () => {
+    dbPath = tmpDb();
+    const a = getDb(dbPath);
+    const b = getDb(dbPath);
+    expect(a).toBe(b);
+  });
+
+  test("creates runs table", () => {
+    dbPath = tmpDb();
+    const db = getDb(dbPath);
+    const rows = db.query("SELECT name FROM sqlite_master WHERE type='table' AND name='runs'").all();
+    expect(rows).toHaveLength(1);
+  });
+
+  test("creates results table", () => {
+    dbPath = tmpDb();
+    const db = getDb(dbPath);
+    const rows = db.query("SELECT name FROM sqlite_master WHERE type='table' AND name='results'").all();
+    expect(rows).toHaveLength(1);
+  });
+
+  test("creates environments table", () => {
+    dbPath = tmpDb();
+    const db = getDb(dbPath);
+    const rows = db.query("SELECT name FROM sqlite_master WHERE type='table' AND name='environments'").all();
+    expect(rows).toHaveLength(1);
+  });
+
+  test("creates collections table", () => {
+    dbPath = tmpDb();
+    const db = getDb(dbPath);
+    const rows = db.query("SELECT name FROM sqlite_master WHERE type='table' AND name='collections'").all();
+    expect(rows).toHaveLength(1);
+  });
+
+  test("creates all indexes", () => {
+    dbPath = tmpDb();
+    const db = getDb(dbPath);
+    const indexes = db
+      .query("SELECT name FROM sqlite_master WHERE type='index' AND name LIKE 'idx_%'")
+      .all() as { name: string }[];
+    const names = indexes.map((r) => r.name);
+    expect(names).toContain("idx_runs_started");
+    expect(names).toContain("idx_results_run");
+    expect(names).toContain("idx_results_status");
+    expect(names).toContain("idx_results_name");
+    expect(names).toContain("idx_runs_collection");
+    expect(names).toContain("idx_collections_name");
+  });
+
+  test("enables WAL journal mode", () => {
+    dbPath = tmpDb();
+    const db = getDb(dbPath);
+    const row = db.query("PRAGMA journal_mode").get() as { journal_mode: string };
+    expect(row.journal_mode).toBe("wal");
+  });
+
+  test("enables foreign keys", () => {
+    dbPath = tmpDb();
+    const db = getDb(dbPath);
+    const row = db.query("PRAGMA foreign_keys").get() as { foreign_keys: number };
+    expect(row.foreign_keys).toBe(1);
+  });
+
+  test("sets user_version to latest after migration", () => {
+    dbPath = tmpDb();
+    const db = getDb(dbPath);
+    const row = db.query("PRAGMA user_version").get() as { user_version: number };
+    expect(row.user_version).toBe(5);
+  });
+
+  test("closeDb resets singleton so next call opens fresh db", () => {
+    const path1 = tmpDb();
+    const path2 = tmpDb();
+    try {
+      const db1 = getDb(path1);
+      closeDb();
+      const db2 = getDb(path2);
+      expect(db1).not.toBe(db2);
+    } finally {
+      closeDb();
+      tryUnlink(path1);
+      tryUnlink(path2);
+      dbPath = undefined;
+    }
+  });
+
+  test("getDb() without args reuses existing singleton path", () => {
+    const path1 = tmpDb();
+    try {
+      const db1 = getDb(path1);
+      const db2 = getDb(); // no args — should reuse path1
+      expect(db2).toBe(db1);
+    } finally {
+      closeDb();
+      tryUnlink(path1);
+      dbPath = undefined;
+    }
+  });
+
+  test("re-opening existing db does not re-run migrations (idempotent)", () => {
+    dbPath = tmpDb();
+    getDb(dbPath);
+    closeDb();
+    // Should not throw or duplicate tables
+    const db = getDb(dbPath);
+    const rows = db.query("SELECT name FROM sqlite_master WHERE type='table' AND name='runs'").all();
+    expect(rows).toHaveLength(1);
+  });
+});

package/tests/fixtures/.env.yaml

@@ -0,0 +1,3 @@
+base: http://localhost:3000/api
+token: dev-token-123
+count: 42

package/tests/fixtures/auth-token-test.yaml

@@ -0,0 +1,8 @@
+name: Auth Token Test
+headers:
+  Authorization: "Bearer {{auth_token}}"
+tests:
+  - name: "Authenticated request"
+    GET: /protected
+    expect:
+      status: 200