@kirrosh/apitool 0.4.3

package/tests/mcp/tools.test.ts

@@ -0,0 +1,248 @@
+import { describe, test, expect, beforeEach, afterEach } from "bun:test";
+import { tmpdir } from "os";
+import { join, resolve } from "path";
+import { unlinkSync } from "fs";
+import { getDb, closeDb } from "../../src/db/schema.ts";
+import {
+  createRun,
+  finalizeRun,
+  saveResults,
+} from "../../src/db/queries.ts";
+import type { TestRunResult } from "../../src/core/runner/types.ts";
+
+// We test the tool handler logic directly by importing the registration functions
+// and calling the MCP server's tool handlers through a minimal test harness
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+
+function tmpDb(): string {
+  return join(tmpdir(), `apitool-mcp-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,
+  };
+}
+
+// ──────────────────────────────────────────────
+// validate_tests
+// ──────────────────────────────────────────────
+
+describe("validate_tests", () => {
+  test("validates a valid test file", async () => {
+    const { registerValidateTestsTool } = await import("../../src/mcp/tools/validate-tests.ts");
+
+    const server = new McpServer({ name: "test", version: "0.0.1" });
+    registerValidateTestsTool(server);
+
+    // Access the registered tool handler via the internal registry
+    const tool = (server as any)._registeredTools["validate_tests"];
+    expect(tool).toBeDefined();
+
+    const fixturePath = resolve("tests/fixtures/valid/a.yaml");
+    const result = await tool.handler({ testPath: fixturePath });
+
+    expect(result.content).toHaveLength(1);
+    expect(result.content[0].type).toBe("text");
+
+    const parsed = JSON.parse(result.content[0].text);
+    expect(parsed.valid).toBe(true);
+    expect(parsed.suites).toBe(1);
+    expect(parsed.tests).toBe(1);
+  });
+
+  test("returns error for invalid path", async () => {
+    const { registerValidateTestsTool } = await import("../../src/mcp/tools/validate-tests.ts");
+
+    const server = new McpServer({ name: "test", version: "0.0.1" });
+    registerValidateTestsTool(server);
+
+    const tool = (server as any)._registeredTools["validate_tests"];
+    const result = await tool.handler({ testPath: "/nonexistent/path.yaml" });
+
+    expect(result.isError).toBe(true);
+    const parsed = JSON.parse(result.content[0].text);
+    expect(parsed.valid).toBe(false);
+    expect(parsed.error).toBeDefined();
+  });
+});
+
+// ──────────────────────────────────────────────
+// query_db
+// ──────────────────────────────────────────────
+
+describe("query_db", () => {
+  let dbFile: string;
+
+  beforeEach(() => {
+    dbFile = tmpDb();
+    getDb(dbFile);
+  });
+
+  afterEach(() => {
+    closeDb();
+    tryUnlink(dbFile);
+  });
+
+  test("list_collections returns empty array on fresh DB", async () => {
+    const { registerQueryDbTool } = await import("../../src/mcp/tools/query-db.ts");
+
+    const server = new McpServer({ name: "test", version: "0.0.1" });
+    registerQueryDbTool(server, dbFile);
+
+    const tool = (server as any)._registeredTools["query_db"];
+    const result = await tool.handler({ action: "list_collections" });
+
+    const parsed = JSON.parse(result.content[0].text);
+    expect(parsed).toEqual([]);
+  });
+
+  test("list_runs returns empty array on fresh DB", async () => {
+    const { registerQueryDbTool } = await import("../../src/mcp/tools/query-db.ts");
+
+    const server = new McpServer({ name: "test", version: "0.0.1" });
+    registerQueryDbTool(server, dbFile);
+
+    const tool = (server as any)._registeredTools["query_db"];
+    const result = await tool.handler({ action: "list_runs" });
+
+    const parsed = JSON.parse(result.content[0].text);
+    expect(parsed).toEqual([]);
+  });
+
+  test("list_runs returns runs after inserting data", async () => {
+    const suiteResult = makeSuiteResult();
+    const runId = createRun({ started_at: suiteResult.started_at, trigger: "mcp" });
+    finalizeRun(runId, [suiteResult]);
+    saveResults(runId, [suiteResult]);
+
+    const { registerQueryDbTool } = await import("../../src/mcp/tools/query-db.ts");
+
+    const server = new McpServer({ name: "test", version: "0.0.1" });
+    registerQueryDbTool(server, dbFile);
+
+    const tool = (server as any)._registeredTools["query_db"];
+    const result = await tool.handler({ action: "list_runs", limit: 10 });
+
+    const parsed = JSON.parse(result.content[0].text);
+    expect(parsed).toHaveLength(1);
+    expect(parsed[0].total).toBe(2);
+    expect(parsed[0].passed).toBe(1);
+    expect(parsed[0].failed).toBe(1);
+  });
+
+  test("get_run_results returns error for non-existent run", async () => {
+    const { registerQueryDbTool } = await import("../../src/mcp/tools/query-db.ts");
+
+    const server = new McpServer({ name: "test", version: "0.0.1" });
+    registerQueryDbTool(server, dbFile);
+
+    const tool = (server as any)._registeredTools["query_db"];
+    const result = await tool.handler({ action: "get_run_results", runId: 999 });
+
+    expect(result.isError).toBe(true);
+    const parsed = JSON.parse(result.content[0].text);
+    expect(parsed.error).toContain("999");
+  });
+
+  test("get_run_results returns detailed results for existing run", async () => {
+    const suiteResult = makeSuiteResult();
+    const runId = createRun({ started_at: suiteResult.started_at, trigger: "mcp" });
+    finalizeRun(runId, [suiteResult]);
+    saveResults(runId, [suiteResult]);
+
+    const { registerQueryDbTool } = await import("../../src/mcp/tools/query-db.ts");
+
+    const server = new McpServer({ name: "test", version: "0.0.1" });
+    registerQueryDbTool(server, dbFile);
+
+    const tool = (server as any)._registeredTools["query_db"];
+    const result = await tool.handler({ action: "get_run_results", runId });
+
+    const parsed = JSON.parse(result.content[0].text);
+    expect(parsed.run.id).toBe(runId);
+    expect(parsed.run.total).toBe(2);
+    expect(parsed.results).toHaveLength(2);
+    expect(parsed.results[0].test_name).toBe("Get user");
+    expect(parsed.results[1].test_name).toBe("Create user");
+  });
+
+  test("get_run_results requires runId", async () => {
+    const { registerQueryDbTool } = await import("../../src/mcp/tools/query-db.ts");
+
+    const server = new McpServer({ name: "test", version: "0.0.1" });
+    registerQueryDbTool(server, dbFile);
+
+    const tool = (server as any)._registeredTools["query_db"];
+    const result = await tool.handler({ action: "get_run_results" });
+
+    expect(result.isError).toBe(true);
+  });
+
+  test("diagnose_failure returns only failures", async () => {
+    const suiteResult = makeSuiteResult();
+    const runId = createRun({ started_at: suiteResult.started_at, trigger: "mcp" });
+    finalizeRun(runId, [suiteResult]);
+    saveResults(runId, [suiteResult]);
+
+    const { registerQueryDbTool } = await import("../../src/mcp/tools/query-db.ts");
+
+    const server = new McpServer({ name: "test", version: "0.0.1" });
+    registerQueryDbTool(server, dbFile);
+
+    const tool = (server as any)._registeredTools["query_db"];
+    const result = await tool.handler({ action: "diagnose_failure", runId });
+
+    const parsed = JSON.parse(result.content[0].text);
+    expect(parsed.run.id).toBe(runId);
+    expect(parsed.summary.failed).toBe(1);
+    expect(parsed.failures.length).toBeGreaterThan(0);
+    expect(parsed.failures.every((f: any) => f.status === "fail" || f.status === "error")).toBe(true);
+  });
+
+  test("diagnose_failure returns error for missing run", async () => {
+    const { registerQueryDbTool } = await import("../../src/mcp/tools/query-db.ts");
+
+    const server = new McpServer({ name: "test", version: "0.0.1" });
+    registerQueryDbTool(server, dbFile);
+
+    const tool = (server as any)._registeredTools["query_db"];
+    const result = await tool.handler({ action: "diagnose_failure", runId: 9999 });
+
+    expect(result.isError).toBe(true);
+  });
+});

package/tests/parser/schema.test.ts

@@ -0,0 +1,134 @@
+import { describe, test, expect } from "bun:test";
+import { validateSuite, DEFAULT_CONFIG } from "../../src/core/parser/schema.ts";
+
+describe("validateSuite", () => {
+  test("parses minimal valid suite", () => {
+    const suite = validateSuite({
+      name: "Test",
+      tests: [{ GET: "/health", name: "Health", expect: { status: 200 } }],
+    });
+    expect(suite.name).toBe("Test");
+    expect(suite.tests).toHaveLength(1);
+    expect(suite.tests[0]!.method).toBe("GET");
+    expect(suite.tests[0]!.path).toBe("/health");
+  });
+
+  test("extracts method-as-key for all HTTP methods", () => {
+    const methods = ["GET", "POST", "PUT", "PATCH", "DELETE"] as const;
+    for (const method of methods) {
+      const suite = validateSuite({
+        name: "Test",
+        tests: [{ [method]: "/path", name: `${method} test`, expect: {} }],
+      });
+      expect(suite.tests[0]!.method).toBe(method);
+      expect(suite.tests[0]!.path).toBe("/path");
+    }
+  });
+
+  test("applies default config when config is missing", () => {
+    const suite = validateSuite({
+      name: "Test",
+      tests: [{ GET: "/health", name: "Health", expect: {} }],
+    });
+    expect(suite.config).toEqual(DEFAULT_CONFIG);
+  });
+
+  test("merges partial config with defaults", () => {
+    const suite = validateSuite({
+      name: "Test",
+      config: { timeout: 5000 },
+      tests: [{ GET: "/health", name: "Health", expect: {} }],
+    });
+    expect(suite.config.timeout).toBe(5000);
+    expect(suite.config.retries).toBe(0);
+    expect(suite.config.retry_delay).toBe(1000);
+    expect(suite.config.follow_redirects).toBe(true);
+  });
+
+  test("parses all assertion rule fields", () => {
+    const suite = validateSuite({
+      name: "Test",
+      tests: [{
+        GET: "/users",
+        name: "Test",
+        expect: {
+          status: 200,
+          duration: 1000,
+          headers: { "content-type": "application/json" },
+          body: {
+            id: { capture: "user_id", type: "integer", equals: 1 },
+            name: { contains: "John", matches: "^J.*" },
+            age: { gt: 18, lt: 100 },
+            active: { exists: true },
+          },
+        },
+      }],
+    });
+    const body = suite.tests[0]!.expect.body!;
+    expect(body["id"]!.capture).toBe("user_id");
+    expect(body["id"]!.type).toBe("integer");
+    expect(body["name"]!.contains).toBe("John");
+    expect(body["age"]!.gt).toBe(18);
+    expect(body["active"]!.exists).toBe(true);
+  });
+
+  test("parses json, form, query, headers on step", () => {
+    const suite = validateSuite({
+      name: "Test",
+      tests: [{
+        POST: "/users",
+        name: "Create",
+        headers: { "X-Custom": "value" },
+        json: { name: "John" },
+        query: { page: "1" },
+        expect: { status: 201 },
+      }],
+    });
+    const step = suite.tests[0]!;
+    expect(step.headers).toEqual({ "X-Custom": "value" });
+    expect(step.json).toEqual({ name: "John" });
+    expect(step.query).toEqual({ page: "1" });
+  });
+
+  test("throws on missing name", () => {
+    expect(() => validateSuite({
+      tests: [{ GET: "/health", name: "Health", expect: {} }],
+    })).toThrow();
+  });
+
+  test("throws on missing method key in step", () => {
+    expect(() => validateSuite({
+      name: "Test",
+      tests: [{ name: "Bad", path: "/health", expect: {} }],
+    })).toThrow();
+  });
+
+  test("throws on ambiguous method keys", () => {
+    expect(() => validateSuite({
+      name: "Test",
+      tests: [{ GET: "/a", POST: "/b", name: "Ambiguous", expect: {} }],
+    })).toThrow(/Ambiguous/);
+  });
+
+  test("throws on empty tests array", () => {
+    expect(() => validateSuite({ name: "Test", tests: [] })).toThrow();
+  });
+
+  test("throws on non-string method path", () => {
+    expect(() => validateSuite({
+      name: "Test",
+      tests: [{ GET: 123, name: "Bad", expect: {} }],
+    })).toThrow();
+  });
+
+  test("parses base_url and suite headers", () => {
+    const suite = validateSuite({
+      name: "Test",
+      base_url: "http://localhost:3000",
+      headers: { Authorization: "Bearer token" },
+      tests: [{ GET: "/health", name: "Health", expect: {} }],
+    });
+    expect(suite.base_url).toBe("http://localhost:3000");
+    expect(suite.headers).toEqual({ Authorization: "Bearer token" });
+  });
+});

package/tests/parser/variables.test.ts

@@ -0,0 +1,227 @@
+import { describe, test, expect } from "bun:test";
+import {
+  substituteString,
+  substituteDeep,
+  substituteStep,
+  extractVariableReferences,
+  loadEnvironment,
+  GENERATORS,
+} from "../../src/core/parser/variables.ts";
+import type { TestStep } from "../../src/core/parser/types.ts";
+
+describe("substituteString", () => {
+  test("replaces simple variable", () => {
+    expect(substituteString("Hello {{name}}", { name: "World" })).toBe("Hello World");
+  });
+
+  test("replaces multiple variables", () => {
+    expect(substituteString("{{a}} and {{b}}", { a: "X", b: "Y" })).toBe("X and Y");
+  });
+
+  test("returns raw value for whole-string variable (number)", () => {
+    expect(substituteString("{{count}}", { count: 42 })).toBe(42);
+  });
+
+  test("returns raw value for whole-string variable (boolean)", () => {
+    expect(substituteString("{{flag}}", { flag: true })).toBe(true);
+  });
+
+  test("returns string when variable is part of larger string", () => {
+    expect(substituteString("id-{{count}}", { count: 42 })).toBe("id-42");
+  });
+
+  test("leaves unresolved variables as-is", () => {
+    expect(substituteString("{{unknown}}", {})).toBe("{{unknown}}");
+  });
+
+  test("resolves $uuid generator", () => {
+    const result = substituteString("{{$uuid}}", {});
+    expect(typeof result).toBe("string");
+    expect(result).toMatch(/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/);
+  });
+
+  test("resolves $timestamp generator as number", () => {
+    const result = substituteString("{{$timestamp}}", {});
+    expect(typeof result).toBe("number");
+    expect(result as number).toBeGreaterThan(1000000000);
+  });
+
+  test("resolves $randomEmail generator", () => {
+    const result = substituteString("{{$randomEmail}}", {}) as string;
+    expect(result).toMatch(/.+@test\.com$/);
+  });
+
+  test("resolves $randomInt generator as number", () => {
+    const result = substituteString("{{$randomInt}}", {});
+    expect(typeof result).toBe("number");
+  });
+
+  test("resolves $randomName generator", () => {
+    const result = substituteString("{{$randomName}}", {}) as string;
+    expect(typeof result).toBe("string");
+    expect(result.length).toBeGreaterThan(0);
+  });
+
+  test("resolves $randomString generator", () => {
+    const result = substituteString("{{$randomString}}", {}) as string;
+    expect(typeof result).toBe("string");
+    expect(result).toHaveLength(8);
+  });
+
+  test("user variable takes precedence over generator", () => {
+    expect(substituteString("{{$uuid}}", { "$uuid": "custom" })).toBe("custom");
+  });
+});
+
+describe("substituteDeep", () => {
+  test("substitutes in nested objects", () => {
+    const result = substituteDeep(
+      { a: { b: "{{x}}", c: [1, "{{y}}"] } },
+      { x: "X", y: "Y" },
+    );
+    expect(result).toEqual({ a: { b: "X", c: [1, "Y"] } });
+  });
+
+  test("leaves non-string values as-is", () => {
+    const result = substituteDeep({ num: 42, bool: true, nil: null }, {});
+    expect(result).toEqual({ num: 42, bool: true, nil: null });
+  });
+
+  test("handles arrays", () => {
+    const result = substituteDeep(["{{a}}", "{{b}}"], { a: "1", b: "2" });
+    expect(result).toEqual(["1", "2"]);
+  });
+});
+
+describe("substituteStep", () => {
+  const baseStep: TestStep = {
+    name: "Test",
+    method: "GET",
+    path: "/users/{{id}}",
+    headers: { Authorization: "Bearer {{token}}" },
+    query: { page: "{{page}}" },
+    expect: {
+      status: 200,
+      body: { name: { equals: "{{name}}" } },
+    },
+  };
+
+  test("substitutes in path, headers, query, expect.body", () => {
+    const result = substituteStep(baseStep, { id: "123", token: "abc", page: "1", name: "John" });
+    expect(result.path).toBe("/users/123");
+    expect(result.headers!["Authorization"]).toBe("Bearer abc");
+    expect(result.query!["page"]).toBe("1");
+    expect(result.expect.body!["name"]!.equals).toBe("John");
+  });
+
+  test("substitutes in json body", () => {
+    const step: TestStep = {
+      name: "Create",
+      method: "POST",
+      path: "/users",
+      json: { name: "{{name}}", age: "{{age}}" },
+      expect: {},
+    };
+    const result = substituteStep(step, { name: "John", age: 30 });
+    expect((result.json as Record<string, unknown>)["name"]).toBe("John");
+    expect((result.json as Record<string, unknown>)["age"]).toBe(30);
+  });
+
+  test("substitutes in form body", () => {
+    const step: TestStep = {
+      name: "Login",
+      method: "POST",
+      path: "/login",
+      form: { username: "{{user}}" },
+      expect: {},
+    };
+    const result = substituteStep(step, { user: "admin" });
+    expect(result.form!["username"]).toBe("admin");
+  });
+});
+
+describe("extractVariableReferences", () => {
+  test("finds variable references in step", () => {
+    const step: TestStep = {
+      name: "Test",
+      method: "GET",
+      path: "/users/{{user_id}}",
+      headers: { Authorization: "Bearer {{token}}" },
+      expect: {},
+    };
+    const refs = extractVariableReferences(step);
+    expect(refs).toContain("user_id");
+    expect(refs).toContain("token");
+  });
+
+  test("excludes generator references ($ prefix)", () => {
+    const step: TestStep = {
+      name: "Test",
+      method: "POST",
+      path: "/users",
+      json: { name: "{{$randomName}}" },
+      expect: {},
+    };
+    const refs = extractVariableReferences(step);
+    expect(refs).not.toContain("$randomName");
+  });
+
+  test("returns empty array for step without variables", () => {
+    const step: TestStep = {
+      name: "Test",
+      method: "GET",
+      path: "/health",
+      expect: {},
+    };
+    expect(extractVariableReferences(step)).toEqual([]);
+  });
+});
+
+describe("loadEnvironment", () => {
+  const fixturesDir = `${import.meta.dir}/../fixtures`;
+
+  test("loads default env.yaml", () => {
+    // We have tests/fixtures/env.yaml
+    return loadEnvironment(undefined, fixturesDir).then((env) => {
+      expect(env["base"]).toBe("http://localhost:3000/api");
+      expect(env["token"]).toBe("dev-token-123");
+      expect(env["count"]).toBe("42");
+    });
+  });
+
+  test("returns empty object for non-existent env file", () => {
+    return loadEnvironment("nonexistent", fixturesDir).then((env) => {
+      expect(env).toEqual({});
+    });
+  });
+
+  test("falls back to DB when YAML not found and envName specified", async () => {
+    const { tmpdir } = await import("os");
+    const { join } = await import("path");
+    const { unlinkSync } = await import("fs");
+    const { getDb, closeDb } = await import("../../src/db/schema.ts");
+    const { upsertEnvironment } = await import("../../src/db/queries.ts");
+
+    const dbPath = join(tmpdir(), `apitool-vars-test-${Date.now()}.db`);
+    try {
+      getDb(dbPath);
+      upsertEnvironment("myenv", { base_url: "http://localhost:9000", api_key: "secret123" });
+
+      // loadEnvironment should find "myenv" in DB since no YAML file exists
+      const env = await loadEnvironment("myenv", "/nonexistent/path");
+      expect(env.base_url).toBe("http://localhost:9000");
+      expect(env.api_key).toBe("secret123");
+    } finally {
+      closeDb();
+      for (const suffix of ["", "-wal", "-shm"]) {
+        try { unlinkSync(dbPath + suffix); } catch { /* ignore */ }
+      }
+    }
+  });
+
+  test("returns empty when YAML not found and DB has no env", async () => {
+    // No YAML, no DB env — should return empty
+    const env = await loadEnvironment("nonexistent-env-xyz", "/nonexistent/path");
+    expect(env).toEqual({});
+  });
+});

package/tests/parser/yaml-parser.test.ts

@@ -0,0 +1,69 @@
+import { describe, test, expect } from "bun:test";
+import { parseFile, parseDirectory, parse } from "../../src/core/parser/yaml-parser.ts";
+
+const fixturesDir = `${import.meta.dir}/../fixtures`;
+
+describe("parseFile", () => {
+  test("parses simple.yaml correctly", async () => {
+    const suite = await parseFile(`${fixturesDir}/simple.yaml`);
+    expect(suite.name).toBe("Health Check");
+    expect(suite.tests).toHaveLength(1);
+    expect(suite.tests[0]!.method).toBe("GET");
+    expect(suite.tests[0]!.path).toBe("/health");
+    expect(suite.tests[0]!.expect.status).toBe(200);
+  });
+
+  test("parses crud.yaml with all fields", async () => {
+    const suite = await parseFile(`${fixturesDir}/crud.yaml`);
+    expect(suite.name).toBe("Users CRUD");
+    expect(suite.base_url).toBe("{{base}}");
+    expect(suite.headers!["Authorization"]).toBe("Bearer {{token}}");
+    expect(suite.config.timeout).toBe(10000);
+    expect(suite.config.retries).toBe(1);
+    expect(suite.tests).toHaveLength(3);
+
+    // Check first step
+    const createStep = suite.tests[0]!;
+    expect(createStep.method).toBe("POST");
+    expect(createStep.path).toBe("/users");
+    expect(createStep.expect.body!["id"]!.capture).toBe("user_id");
+    expect(createStep.expect.body!["id"]!.type).toBe("integer");
+  });
+
+  test("throws on invalid YAML (missing name)", async () => {
+    await expect(parseFile(`${fixturesDir}/invalid-missing-name.yaml`)).rejects.toThrow(/Validation error/);
+  });
+
+  test("throws on invalid YAML (no method)", async () => {
+    await expect(parseFile(`${fixturesDir}/invalid-no-method.yaml`)).rejects.toThrow(/Validation error/);
+  });
+
+  test("throws on non-existent file", async () => {
+    await expect(parseFile(`${fixturesDir}/nonexistent.yaml`)).rejects.toThrow(/Failed to read/);
+  });
+});
+
+describe("parseDirectory", () => {
+  test("parses valid yaml files in a clean directory", async () => {
+    const tmpDir = `${fixturesDir}/valid`;
+    const { mkdirSync, existsSync } = await import("node:fs");
+    if (!existsSync(tmpDir)) mkdirSync(tmpDir, { recursive: true });
+    await Bun.write(`${tmpDir}/a.yaml`, "name: A\ntests:\n  - name: A\n    GET: /a\n    expect: {}\n");
+    await Bun.write(`${tmpDir}/b.yml`, "name: B\ntests:\n  - name: B\n    POST: /b\n    expect: {}\n");
+    // .env.yaml should be excluded (dotfile, not scanned by default)
+    await Bun.write(`${tmpDir}/.env.yaml`, "base: http://localhost\n");
+
+    const suites = await parseDirectory(tmpDir);
+    expect(suites).toHaveLength(2);
+    const names = suites.map((s) => s.name).sort();
+    expect(names).toEqual(["A", "B"]);
+  });
+});
+
+describe("parse", () => {
+  test("parse single file returns array of one suite", async () => {
+    const suites = await parse(`${fixturesDir}/simple.yaml`);
+    expect(suites).toHaveLength(1);
+    expect(suites[0]!.name).toBe("Health Check");
+  });
+});