@kirrosh/apitool 0.4.3

package/tests/mcp/explore-api.test.ts

@@ -0,0 +1,49 @@
+import { describe, test, expect, mock, beforeEach, afterAll } from "bun:test";
+
+mock.module("../../src/core/generator/openapi-reader.ts", () => ({
+  readOpenApiSpec: mock(() => Promise.resolve({
+    info: { title: "Pet Store", version: "1.0.0" },
+    servers: [{ url: "https://petstore.io/v1" }],
+    paths: {},
+  })),
+  extractEndpoints: mock(() => [
+    { method: "GET", path: "/pets", summary: "List pets", tags: ["pets"], parameters: [{ name: "limit", in: "query", required: false }], responses: [{ statusCode: 200, description: "OK" }], requestBodySchema: undefined },
+    { method: "POST", path: "/pets", summary: "Create pet", tags: ["pets"], parameters: [], responses: [{ statusCode: 201, description: "Created" }], requestBodySchema: { type: "object" } },
+    { method: "GET", path: "/users", summary: "List users", tags: ["users"], parameters: [], responses: [{ statusCode: 200, description: "OK" }], requestBodySchema: undefined },
+  ]),
+  extractSecuritySchemes: mock(() => [
+    { name: "bearerAuth", type: "http", scheme: "bearer" },
+  ]),
+}));
+
+afterAll(() => { mock.restore(); });
+
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { registerExploreApiTool } from "../../src/mcp/tools/explore-api.ts";
+
+describe("MCP explore_api", () => {
+  test("returns spec info and endpoints", async () => {
+    const server = new McpServer({ name: "test", version: "0.0.1" });
+    registerExploreApiTool(server);
+
+    const tool = (server as any)._registeredTools["explore_api"];
+    const result = await tool.handler({ specPath: "petstore.yaml" });
+    const parsed = JSON.parse(result.content[0].text);
+    expect(parsed.title).toBe("Pet Store");
+    expect(parsed.totalEndpoints).toBe(3);
+    expect(parsed.endpoints).toHaveLength(3);
+    expect(parsed.securitySchemes).toHaveLength(1);
+  });
+
+  test("filters by tag", async () => {
+    const server = new McpServer({ name: "test", version: "0.0.1" });
+    registerExploreApiTool(server);
+
+    const tool = (server as any)._registeredTools["explore_api"];
+    const result = await tool.handler({ specPath: "petstore.yaml", tag: "pets" });
+    const parsed = JSON.parse(result.content[0].text);
+    expect(parsed.filteredByTag).toBe("pets");
+    expect(parsed.matchingEndpoints).toBe(2);
+    expect(parsed.endpoints).toHaveLength(2);
+  });
+});

package/tests/mcp/generate-missing-tests.test.ts

@@ -0,0 +1,69 @@
+import { describe, test, expect, mock, afterAll } from "bun:test";
+
+const mockEndpoints = [
+  { method: "GET", path: "/pets", summary: "List pets", tags: ["pets"], parameters: [], responses: [{ statusCode: 200, description: "OK" }], security: [] },
+  { method: "POST", path: "/pets", summary: "Create pet", tags: ["pets"], parameters: [], responses: [{ statusCode: 201, description: "Created" }], security: [] },
+  { method: "GET", path: "/users", summary: "List users", tags: ["users"], parameters: [], responses: [{ statusCode: 200, description: "OK" }], security: [] },
+];
+
+mock.module("../../src/core/generator/openapi-reader.ts", () => ({
+  readOpenApiSpec: mock(() => Promise.resolve({
+    info: { title: "Pet Store", version: "1.0.0" },
+    servers: [{ url: "https://petstore.io/v1" }],
+    paths: {},
+  })),
+  extractEndpoints: mock(() => mockEndpoints),
+  extractSecuritySchemes: mock(() => []),
+}));
+
+const mockScanCovered = mock(() => Promise.resolve([
+  { method: "GET", path: "/pets", file: "tests/pets.yaml" },
+]));
+
+mock.module("../../src/core/generator/coverage-scanner.ts", () => ({
+  scanCoveredEndpoints: mockScanCovered,
+  filterUncoveredEndpoints: mock((all: any[], covered: any[]) => {
+    const coveredSet = new Set(covered.map((c: any) => `${c.method} ${c.path}`));
+    return all.filter((ep: any) => !coveredSet.has(`${ep.method} ${ep.path}`));
+  }),
+}));
+
+afterAll(() => { mock.restore(); });
+
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { registerGenerateMissingTestsTool } from "../../src/mcp/tools/generate-missing-tests.ts";
+
+describe("MCP generate_missing_tests", () => {
+  test("partially covered → guide with only uncovered endpoints", async () => {
+    const server = new McpServer({ name: "test", version: "0.0.1" });
+    registerGenerateMissingTestsTool(server);
+
+    const tool = (server as any)._registeredTools["generate_missing_tests"];
+    const result = await tool.handler({ specPath: "petstore.yaml", testsDir: "./tests/" });
+
+    expect(result.isError).toBeUndefined();
+    const text = result.content[0].text;
+    expect(text).toContain("Coverage: 1/3 endpoints covered (33%)");
+    expect(text).toContain("2 uncovered endpoints");
+    expect(text).toContain("POST /pets");
+    expect(text).toContain("GET /users");
+  });
+
+  test("all covered → fullyCovered response", async () => {
+    mockScanCovered.mockImplementationOnce(() => Promise.resolve([
+      { method: "GET", path: "/pets", file: "a.yaml" },
+      { method: "POST", path: "/pets", file: "a.yaml" },
+      { method: "GET", path: "/users", file: "b.yaml" },
+    ]));
+
+    const server = new McpServer({ name: "test", version: "0.0.1" });
+    registerGenerateMissingTestsTool(server);
+
+    const tool = (server as any)._registeredTools["generate_missing_tests"];
+    const result = await tool.handler({ specPath: "petstore.yaml", testsDir: "./tests/" });
+
+    const parsed = JSON.parse(result.content[0].text);
+    expect(parsed.fullyCovered).toBe(true);
+    expect(parsed.percentage).toBe(100);
+  });
+});

package/tests/mcp/manage-environment.test.ts

@@ -0,0 +1,89 @@
+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 } from "../../src/db/queries.ts";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { registerManageEnvironmentTool } from "../../src/mcp/tools/manage-environment.ts";
+
+function tmpDb(): string {
+  return join(tmpdir(), `apitool-mcp-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 */ }
+  }
+}
+
+describe("MCP manage_environment", () => {
+  let dbPath: string;
+
+  beforeEach(() => {
+    closeDb();
+    dbPath = tmpDb();
+    getDb(dbPath);
+  });
+
+  afterEach(() => {
+    closeDb();
+    tryUnlink(dbPath);
+  });
+
+  test("list returns array", async () => {
+    const server = new McpServer({ name: "test", version: "0.0.1" });
+    registerManageEnvironmentTool(server, dbPath);
+    const tool = (server as any)._registeredTools["manage_environment"];
+    const result = await tool.handler({ action: "list" });
+    const parsed = JSON.parse(result.content[0].text);
+    expect(Array.isArray(parsed)).toBe(true);
+  });
+
+  test("set and get environment", async () => {
+    const server = new McpServer({ name: "test", version: "0.0.1" });
+    registerManageEnvironmentTool(server, dbPath);
+    const tool = (server as any)._registeredTools["manage_environment"];
+
+    // Set
+    const setResult = await tool.handler({ action: "set", name: "dev", variables: { base_url: "http://localhost" } });
+    const setParsed = JSON.parse(setResult.content[0].text);
+    expect(setParsed.success).toBe(true);
+
+    // Get
+    const getResult = await tool.handler({ action: "get", name: "dev" });
+    const getParsed = JSON.parse(getResult.content[0].text);
+    expect(getParsed.name).toBe("dev");
+    expect(getParsed.variables.base_url).toBe("http://localhost");
+  });
+
+  test("delete environment", async () => {
+    upsertEnvironment("tmp", { key: "val" });
+    const server = new McpServer({ name: "test", version: "0.0.1" });
+    registerManageEnvironmentTool(server, dbPath);
+    const tool = (server as any)._registeredTools["manage_environment"];
+
+    const result = await tool.handler({ action: "delete", name: "tmp" });
+    const parsed = JSON.parse(result.content[0].text);
+    expect(parsed.success).toBe(true);
+    expect(parsed.deleted).toBe("tmp");
+  });
+
+  test("get missing env returns error", async () => {
+    const server = new McpServer({ name: "test", version: "0.0.1" });
+    registerManageEnvironmentTool(server, dbPath);
+    const tool = (server as any)._registeredTools["manage_environment"];
+
+    const result = await tool.handler({ action: "get", name: "ghost" });
+    expect(result.isError).toBe(true);
+  });
+
+  test("delete missing env returns error", async () => {
+    const server = new McpServer({ name: "test", version: "0.0.1" });
+    registerManageEnvironmentTool(server, dbPath);
+    const tool = (server as any)._registeredTools["manage_environment"];
+
+    const result = await tool.handler({ action: "delete", name: "ghost" });
+    expect(result.isError).toBe(true);
+  });
+});

package/tests/mcp/save-test-suite.test.ts

@@ -0,0 +1,116 @@
+import { describe, test, expect, beforeEach, afterEach } from "bun:test";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { registerSaveTestSuiteTool } from "../../src/mcp/tools/save-test-suite.ts";
+import { existsSync, rmSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+
+const TEST_DIR = join(import.meta.dir, ".tmp-save-test");
+
+describe("MCP save_test_suite", () => {
+  let handler: (args: Record<string, unknown>) => Promise<any>;
+
+  beforeEach(() => {
+    const server = new McpServer({ name: "test", version: "0.0.1" });
+    registerSaveTestSuiteTool(server);
+    handler = (server as any)._registeredTools["save_test_suite"].handler;
+    if (existsSync(TEST_DIR)) rmSync(TEST_DIR, { recursive: true });
+  });
+
+  afterEach(() => {
+    if (existsSync(TEST_DIR)) rmSync(TEST_DIR, { recursive: true });
+  });
+
+  const VALID_YAML = `name: "Test Suite"
+base_url: "http://localhost:3000"
+tests:
+  - name: "Get items"
+    GET: "/items"
+    expect:
+      status: 200
+`;
+
+  test("saves valid YAML and returns success", async () => {
+    const filePath = join(TEST_DIR, "test.yaml");
+    const result = await handler({ filePath, content: VALID_YAML });
+    const parsed = JSON.parse(result.content[0].text);
+
+    expect(parsed.saved).toBe(true);
+    expect(parsed.suite.name).toBe("Test Suite");
+    expect(parsed.suite.tests).toBe(1);
+    expect(existsSync(filePath)).toBe(true);
+  });
+
+  test("creates nested directories", async () => {
+    const filePath = join(TEST_DIR, "nested", "deep", "test.yaml");
+    const result = await handler({ filePath, content: VALID_YAML });
+    const parsed = JSON.parse(result.content[0].text);
+
+    expect(parsed.saved).toBe(true);
+    expect(existsSync(filePath)).toBe(true);
+  });
+
+  test("rejects invalid YAML syntax", async () => {
+    const filePath = join(TEST_DIR, "bad.yaml");
+    const result = await handler({ filePath, content: "name: [invalid yaml\n  broken:" });
+    const parsed = JSON.parse(result.content[0].text);
+
+    expect(parsed.saved).toBe(false);
+    expect(parsed.error).toContain("YAML parse error");
+  });
+
+  test("rejects YAML that fails validation", async () => {
+    const filePath = join(TEST_DIR, "invalid.yaml");
+    const invalidYaml = `name: "Bad Suite"
+tests: []
+`;
+    const result = await handler({ filePath, content: invalidYaml });
+    const parsed = JSON.parse(result.content[0].text);
+
+    expect(parsed.saved).toBe(false);
+    expect(parsed.error).toContain("Validation");
+  });
+
+  test("refuses to overwrite existing file without flag", async () => {
+    mkdirSync(TEST_DIR, { recursive: true });
+    const filePath = join(TEST_DIR, "existing.yaml");
+    await Bun.write(filePath, VALID_YAML);
+
+    const result = await handler({ filePath, content: VALID_YAML });
+    const parsed = JSON.parse(result.content[0].text);
+
+    expect(parsed.saved).toBe(false);
+    expect(parsed.error).toContain("already exists");
+  });
+
+  test("overwrites existing file with overwrite=true", async () => {
+    mkdirSync(TEST_DIR, { recursive: true });
+    const filePath = join(TEST_DIR, "existing.yaml");
+    await Bun.write(filePath, "old content");
+
+    const result = await handler({ filePath, content: VALID_YAML, overwrite: true });
+    const parsed = JSON.parse(result.content[0].text);
+
+    expect(parsed.saved).toBe(true);
+    const content = await Bun.file(filePath).text();
+    expect(content).toBe(VALID_YAML);
+  });
+
+  test("preserves original YAML content (no re-serialization)", async () => {
+    const yamlWithComments = `# This is a test suite
+name: "With Comments"
+base_url: "http://localhost:3000"
+tests:
+  - name: "Get items"
+    GET: "/items"
+    expect:
+      status: 200
+`;
+    const filePath = join(TEST_DIR, "comments.yaml");
+    const result = await handler({ filePath, content: yamlWithComments });
+    const parsed = JSON.parse(result.content[0].text);
+
+    expect(parsed.saved).toBe(true);
+    const written = await Bun.file(filePath).text();
+    expect(written).toBe(yamlWithComments);
+  });
+});

package/tests/mcp/send-request.test.ts

@@ -0,0 +1,79 @@
+import { describe, test, expect, mock, beforeEach, afterAll } from "bun:test";
+
+mock.module("../../src/core/runner/http-client.ts", () => ({
+  executeRequest: mock(() => Promise.resolve({
+    status: 200,
+    headers: { "content-type": "application/json" },
+    body: '{"ok":true}',
+    body_parsed: { ok: true },
+    duration_ms: 55,
+  })),
+  DEFAULT_FETCH_OPTIONS: { timeout: 30000, retries: 0, retry_delay: 1000, follow_redirects: true },
+}));
+
+mock.module("../../src/core/parser/variables.ts", () => ({
+  loadEnvironment: mock(() => Promise.resolve({ base_url: "https://api.test.com" })),
+  substituteString: mock((template: string, vars: Record<string, unknown>) => {
+    if (typeof template !== "string") return template;
+    return template.replace(/\{\{(.+?)\}\}/g, (_, key: string) => String(vars[key] ?? `{{${key}}}`));
+  }),
+  substituteDeep: mock((value: any, vars: Record<string, unknown>) => {
+    if (typeof value === "object" && value !== null) {
+      const result: Record<string, unknown> = {};
+      for (const [k, v] of Object.entries(value)) {
+        result[k] = typeof v === "string"
+          ? v.replace(/\{\{(.+?)\}\}/g, (_, key: string) => String(vars[key] ?? `{{${key}}}`))
+          : v;
+      }
+      return result;
+    }
+    return value;
+  }),
+  GENERATORS: {},
+}));
+
+afterAll(() => { mock.restore(); });
+
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { registerSendRequestTool } from "../../src/mcp/tools/send-request.ts";
+import { executeRequest } from "../../src/core/runner/http-client.ts";
+
+describe("MCP send_request", () => {
+  beforeEach(() => {
+    (executeRequest as ReturnType<typeof mock>).mockClear();
+  });
+
+  test("registers and handles GET request", async () => {
+    const server = new McpServer({ name: "test", version: "0.0.1" });
+    registerSendRequestTool(server);
+
+    const tool = (server as any)._registeredTools["send_request"];
+    expect(tool).toBeDefined();
+
+    const result = await tool.handler({ method: "GET", url: "https://api.test.com/data" });
+    const parsed = JSON.parse(result.content[0].text);
+    expect(parsed.status).toBe(200);
+    expect(parsed.duration_ms).toBe(55);
+  });
+
+  test("interpolates variables from environment", async () => {
+    const server = new McpServer({ name: "test", version: "0.0.1" });
+    registerSendRequestTool(server);
+
+    const tool = (server as any)._registeredTools["send_request"];
+    await tool.handler({ method: "GET", url: "{{base_url}}/users", envName: "dev" });
+    expect(executeRequest).toHaveBeenCalledTimes(1);
+  });
+
+  test("returns error on failure", async () => {
+    (executeRequest as ReturnType<typeof mock>).mockRejectedValueOnce(new Error("timeout"));
+    const server = new McpServer({ name: "test", version: "0.0.1" });
+    registerSendRequestTool(server);
+
+    const tool = (server as any)._registeredTools["send_request"];
+    const result = await tool.handler({ method: "GET", url: "https://bad.host/" });
+    expect(result.isError).toBe(true);
+    const parsed = JSON.parse(result.content[0].text);
+    expect(parsed.error).toBe("timeout");
+  });
+});

package/tests/mcp/setup-api.test.ts

@@ -0,0 +1,106 @@
+import { describe, test, expect, mock, afterAll, beforeEach } from "bun:test";
+import { mkdirSync, existsSync, readFileSync, rmSync } from "fs";
+import { join, resolve } from "path";
+import { tmpdir } from "os";
+
+// Mock the DB layer
+const mockFindCollectionByNameOrId = mock(() => null);
+const mockCreateCollection = mock(() => 42);
+const mockUpsertEnvironment = mock(() => {});
+const mockNormalizePath = mock((p: string) => p.replace(/\\/g, "/"));
+
+mock.module("../../src/db/queries.ts", () => ({
+  findCollectionByNameOrId: mockFindCollectionByNameOrId,
+  createCollection: mockCreateCollection,
+  upsertEnvironment: mockUpsertEnvironment,
+  normalizePath: mockNormalizePath,
+}));
+
+mock.module("../../src/db/schema.ts", () => ({
+  getDb: mock(() => ({})),
+}));
+
+mock.module("../../src/core/generator/index.ts", () => ({
+  readOpenApiSpec: mock(() => Promise.resolve({
+    servers: [{ url: "https://petstore.io/v2" }],
+  })),
+  extractEndpoints: mock(() => [
+    { method: "GET", path: "/pets" },
+    { method: "POST", path: "/pets" },
+  ]),
+}));
+
+mock.module("../../src/cli/commands/envs.ts", () => ({
+  toYaml: mock((vars: Record<string, string>) =>
+    Object.entries(vars).map(([k, v]) => `${k}: ${v}`).join("\n")
+  ),
+}));
+
+afterAll(() => { mock.restore(); });
+
+import { setupApi } from "../../src/core/setup-api.ts";
+
+describe("setupApi", () => {
+  let tempDir: string;
+
+  beforeEach(() => {
+    tempDir = join(tmpdir(), `apitool-test-${Date.now()}`);
+    mockFindCollectionByNameOrId.mockImplementation(() => null);
+    mockCreateCollection.mockImplementation(() => 42);
+  });
+
+  test("creates API with spec → collection created, dirs exist, env written", async () => {
+    const dir = join(tempDir, "petstore");
+    const result = await setupApi({
+      name: "petstore",
+      spec: "https://petstore.io/v2/swagger.json",
+      dir,
+    });
+
+    expect(result.created).toBe(true);
+    expect(result.collectionId).toBe(42);
+    expect(result.baseUrl).toBe("https://petstore.io/v2");
+    expect(result.specEndpoints).toBe(2);
+    expect(existsSync(join(dir, "tests"))).toBe(true);
+    expect(existsSync(join(dir, ".env.yaml"))).toBe(true);
+
+    // Cleanup
+    rmSync(dir, { recursive: true, force: true });
+  });
+
+  test("duplicate name throws error", async () => {
+    mockFindCollectionByNameOrId.mockImplementation(() => ({ id: 1, name: "petstore" }));
+
+    await expect(setupApi({
+      name: "petstore",
+      dir: join(tempDir, "dup"),
+    })).rejects.toThrow("already exists");
+  });
+
+  test("without spec → collection created without openapi_spec", async () => {
+    const dir = join(tempDir, "nospec");
+    const result = await setupApi({
+      name: "nospec-api",
+      dir,
+    });
+
+    expect(result.created).toBe(true);
+    expect(result.specEndpoints).toBe(0);
+    expect(result.baseUrl).toBe("");
+
+    rmSync(dir, { recursive: true, force: true });
+  });
+
+  test("custom envVars are passed through", async () => {
+    const dir = join(tempDir, "withenv");
+    await setupApi({
+      name: "myapi",
+      dir,
+      envVars: { token: "abc123" },
+    });
+
+    expect(mockUpsertEnvironment).toHaveBeenCalled();
+
+    rmSync(dir, { recursive: true, force: true });
+  });
+});