@kirrosh/apitool 0.4.3

package/tests/generator/data-factory.test.ts

@@ -0,0 +1,133 @@
+import { describe, test, expect } from "bun:test";
+import { generateFromSchema } from "../../src/core/generator/data-factory.ts";
+import type { OpenAPIV3 } from "openapi-types";
+
+describe("generateFromSchema", () => {
+  test("string returns placeholder", () => {
+    const result = generateFromSchema({ type: "string" } as OpenAPIV3.SchemaObject);
+    expect(result).toBe("{{$randomString}}");
+  });
+
+  test("string with email format", () => {
+    const result = generateFromSchema({ type: "string", format: "email" } as OpenAPIV3.SchemaObject);
+    expect(result).toBe("{{$randomEmail}}");
+  });
+
+  test("string with uuid format", () => {
+    const result = generateFromSchema({ type: "string", format: "uuid" } as OpenAPIV3.SchemaObject);
+    expect(result).toBe("{{$uuid}}");
+  });
+
+  test("string with name property hint", () => {
+    const result = generateFromSchema({ type: "string" } as OpenAPIV3.SchemaObject, "name");
+    expect(result).toBe("{{$randomName}}");
+  });
+
+  test("string with email property hint", () => {
+    const result = generateFromSchema({ type: "string" } as OpenAPIV3.SchemaObject, "email");
+    expect(result).toBe("{{$randomEmail}}");
+  });
+
+  test("string with id property hint", () => {
+    const result = generateFromSchema({ type: "string" } as OpenAPIV3.SchemaObject, "userId");
+    expect(result).toBe("{{$uuid}}");
+  });
+
+  test("integer returns randomInt", () => {
+    const result = generateFromSchema({ type: "integer" } as OpenAPIV3.SchemaObject);
+    expect(result).toBe("{{$randomInt}}");
+  });
+
+  test("number returns randomInt", () => {
+    const result = generateFromSchema({ type: "number" } as OpenAPIV3.SchemaObject);
+    expect(result).toBe("{{$randomInt}}");
+  });
+
+  test("boolean returns true", () => {
+    const result = generateFromSchema({ type: "boolean" } as OpenAPIV3.SchemaObject);
+    expect(result).toBe(true);
+  });
+
+  test("enum returns first value", () => {
+    const result = generateFromSchema({
+      type: "string",
+      enum: ["available", "pending", "sold"],
+    } as OpenAPIV3.SchemaObject);
+    expect(result).toBe("available");
+  });
+
+  test("object with properties", () => {
+    const schema: OpenAPIV3.SchemaObject = {
+      type: "object",
+      properties: {
+        name: { type: "string" } as OpenAPIV3.SchemaObject,
+        age: { type: "integer" } as OpenAPIV3.SchemaObject,
+      },
+    };
+    const result = generateFromSchema(schema) as Record<string, unknown>;
+    expect(result.name).toBe("{{$randomName}}");
+    expect(result.age).toBe("{{$randomInt}}");
+  });
+
+  test("array with items", () => {
+    const schema: OpenAPIV3.SchemaObject = {
+      type: "array",
+      items: { type: "string" } as OpenAPIV3.SchemaObject,
+    };
+    const result = generateFromSchema(schema) as unknown[];
+    expect(result).toHaveLength(1);
+    expect(result[0]).toBe("{{$randomString}}");
+  });
+
+  test("allOf merges schemas", () => {
+    const schema: OpenAPIV3.SchemaObject = {
+      allOf: [
+        { type: "object", properties: { id: { type: "integer" } as OpenAPIV3.SchemaObject } } as OpenAPIV3.SchemaObject,
+        { type: "object", properties: { name: { type: "string" } as OpenAPIV3.SchemaObject } } as OpenAPIV3.SchemaObject,
+      ],
+    };
+    const result = generateFromSchema(schema) as Record<string, unknown>;
+    expect(result.id).toBe("{{$randomInt}}");
+    expect(result.name).toBe("{{$randomName}}");
+  });
+
+  test("oneOf picks first variant", () => {
+    const schema: OpenAPIV3.SchemaObject = {
+      oneOf: [
+        { type: "string" } as OpenAPIV3.SchemaObject,
+        { type: "integer" } as OpenAPIV3.SchemaObject,
+      ],
+    };
+    const result = generateFromSchema(schema);
+    expect(result).toBe("{{$randomString}}");
+  });
+
+  test("anyOf picks first variant", () => {
+    const schema: OpenAPIV3.SchemaObject = {
+      anyOf: [
+        { type: "integer" } as OpenAPIV3.SchemaObject,
+        { type: "string" } as OpenAPIV3.SchemaObject,
+      ],
+    };
+    const result = generateFromSchema(schema);
+    expect(result).toBe("{{$randomInt}}");
+  });
+
+  test("nested object", () => {
+    const schema: OpenAPIV3.SchemaObject = {
+      type: "object",
+      properties: {
+        owner: {
+          type: "object",
+          properties: {
+            name: { type: "string" } as OpenAPIV3.SchemaObject,
+            email: { type: "string", format: "email" } as OpenAPIV3.SchemaObject,
+          },
+        } as OpenAPIV3.SchemaObject,
+      },
+    };
+    const result = generateFromSchema(schema) as Record<string, any>;
+    expect(result.owner.name).toBe("{{$randomName}}");
+    expect(result.owner.email).toBe("{{$randomEmail}}");
+  });
+});

package/tests/generator/openapi-reader.test.ts

@@ -0,0 +1,131 @@
+import { describe, test, expect } from "bun:test";
+import { readOpenApiSpec, extractEndpoints, extractSecuritySchemes } from "../../src/core/generator/openapi-reader.ts";
+
+const FIXTURE = "tests/fixtures/petstore-auth.json";
+
+describe("readOpenApiSpec", () => {
+  test("parses and dereferences petstore-auth spec", async () => {
+    const doc = await readOpenApiSpec(FIXTURE);
+    expect(doc.openapi).toBe("3.0.0");
+    expect(doc.info.title).toBe("Test Petstore");
+    expect(doc.paths).toBeDefined();
+  });
+
+  test("contains securitySchemes component", async () => {
+    const doc = await readOpenApiSpec(FIXTURE);
+    const schemes = doc.components?.securitySchemes;
+    expect(schemes).toBeDefined();
+    expect(schemes!.bearerAuth).toBeDefined();
+  });
+});
+
+describe("extractSecuritySchemes", () => {
+  test("extracts bearer auth scheme", async () => {
+    const doc = await readOpenApiSpec(FIXTURE);
+    const schemes = extractSecuritySchemes(doc);
+
+    expect(schemes.length).toBe(1);
+    expect(schemes[0]!.name).toBe("bearerAuth");
+    expect(schemes[0]!.type).toBe("http");
+    expect(schemes[0]!.scheme).toBe("bearer");
+    expect(schemes[0]!.bearerFormat).toBe("JWT");
+  });
+});
+
+describe("extractEndpoints", () => {
+  test("extracts all endpoints", async () => {
+    const doc = await readOpenApiSpec(FIXTURE);
+    const endpoints = extractEndpoints(doc);
+
+    expect(endpoints.length).toBe(7); // login + 5 pet routes + health
+
+    const methods = endpoints.map((e) => `${e.method} ${e.path}`);
+    expect(methods).toContain("POST /auth/login");
+    expect(methods).toContain("GET /pets");
+    expect(methods).toContain("POST /pets");
+    expect(methods).toContain("GET /pets/{id}");
+    expect(methods).toContain("PUT /pets/{id}");
+    expect(methods).toContain("DELETE /pets/{id}");
+    expect(methods).toContain("GET /health");
+  });
+
+  test("extracts operationId and summary", async () => {
+    const doc = await readOpenApiSpec(FIXTURE);
+    const endpoints = extractEndpoints(doc);
+
+    const listPets = endpoints.find((e) => e.operationId === "listPets")!;
+    expect(listPets).toBeDefined();
+    expect(listPets.summary).toBe("List all pets");
+    expect(listPets.method).toBe("GET");
+    expect(listPets.path).toBe("/pets");
+  });
+
+  test("extracts tags", async () => {
+    const doc = await readOpenApiSpec(FIXTURE);
+    const endpoints = extractEndpoints(doc);
+
+    const getPet = endpoints.find((e) => e.operationId === "getPet")!;
+    expect(getPet.tags).toEqual(["pets"]);
+
+    const health = endpoints.find((e) => e.operationId === "healthCheck")!;
+    expect(health.tags).toEqual([]);
+  });
+
+  test("extracts parameters", async () => {
+    const doc = await readOpenApiSpec(FIXTURE);
+    const endpoints = extractEndpoints(doc);
+
+    const getPet = endpoints.find((e) => e.operationId === "getPet")!;
+    expect(getPet.parameters.length).toBe(1);
+    expect(getPet.parameters[0]!.name).toBe("id");
+    expect(getPet.parameters[0]!.in).toBe("path");
+  });
+
+  test("extracts request body schema", async () => {
+    const doc = await readOpenApiSpec(FIXTURE);
+    const endpoints = extractEndpoints(doc);
+
+    const createPet = endpoints.find((e) => e.operationId === "createPet")!;
+    expect(createPet.requestBodySchema).toBeDefined();
+    expect(createPet.requestBodySchema!.type).toBe("object");
+    expect(createPet.requestBodySchema!.properties).toHaveProperty("name");
+  });
+
+  test("extracts responses with schemas", async () => {
+    const doc = await readOpenApiSpec(FIXTURE);
+    const endpoints = extractEndpoints(doc);
+
+    const getPet = endpoints.find((e) => e.operationId === "getPet")!;
+    expect(getPet.responses.length).toBe(2);
+
+    const ok = getPet.responses.find((r) => r.statusCode === 200)!;
+    expect(ok.description).toBe("A pet");
+    expect(ok.schema).toBeDefined();
+    expect(ok.schema!.type).toBe("object");
+
+    const notFound = getPet.responses.find((r) => r.statusCode === 404)!;
+    expect(notFound.description).toBe("Pet not found");
+  });
+
+  test("populates security field for protected endpoints", async () => {
+    const doc = await readOpenApiSpec(FIXTURE);
+    const endpoints = extractEndpoints(doc);
+
+    const listPets = endpoints.find((e) => e.operationId === "listPets")!;
+    expect(listPets.security).toEqual(["bearerAuth"]);
+
+    const createPet = endpoints.find((e) => e.operationId === "createPet")!;
+    expect(createPet.security).toEqual(["bearerAuth"]);
+  });
+
+  test("endpoints without security have empty security array", async () => {
+    const doc = await readOpenApiSpec(FIXTURE);
+    const endpoints = extractEndpoints(doc);
+
+    const login = endpoints.find((e) => e.operationId === "login")!;
+    expect(login.security).toEqual([]);
+
+    const health = endpoints.find((e) => e.operationId === "healthCheck")!;
+    expect(health.security).toEqual([]);
+  });
+});

package/tests/integration/auth-flow.test.ts

@@ -0,0 +1,217 @@
+import { describe, test, expect, beforeAll, afterAll } from "bun:test";
+import { OpenAPIHono, createRoute, z } from "@hono/zod-openapi";
+import { readOpenApiSpec, extractEndpoints, extractSecuritySchemes } from "../../src/core/generator/openapi-reader.ts";
+import { generateSuites, writeSuites } from "../../src/core/generator/skeleton.ts";
+import { parseFile } from "../../src/core/parser/yaml-parser.ts";
+import { runSuite } from "../../src/core/runner/executor.ts";
+import { tmpdir } from "os";
+import { join } from "path";
+import { rm, writeFile, mkdir } from "fs/promises";
+
+// Save real fetch before any mocks
+const realFetch = globalThis.fetch;
+
+// ── Inline mini-server ──────────────────────────
+
+function createPetServer() {
+  const app = new OpenAPIHono();
+  const pets: { id: number; name: string }[] = [];
+  let nextId = 1;
+
+  // Security scheme
+  const bearerAuth = app.openAPIRegistry.registerComponent("securitySchemes", "bearerAuth", {
+    type: "http",
+    scheme: "bearer",
+  });
+
+  // POST /auth/login — no security
+  const loginRoute = createRoute({
+    method: "post",
+    path: "/auth/login",
+    tags: ["Auth"],
+    summary: "Login",
+    request: {
+      body: {
+        content: {
+          "application/json": {
+            schema: z.object({
+              username: z.string(),
+              password: z.string(),
+            }),
+          },
+        },
+      },
+    },
+    responses: {
+      200: {
+        content: {
+          "application/json": {
+            schema: z.object({ token: z.string() }),
+          },
+        },
+        description: "Token",
+      },
+    },
+  });
+
+  app.openapi(loginRoute, (c) => {
+    return c.json({ token: "test-token-123" }, 200);
+  });
+
+  // GET /pets — secured
+  const listPetsRoute = createRoute({
+    method: "get",
+    path: "/pets",
+    tags: ["Pets"],
+    summary: "List all pets",
+    security: [{ bearerAuth: [] }],
+    responses: {
+      200: {
+        content: {
+          "application/json": {
+            schema: z.array(z.object({ id: z.number(), name: z.string() })),
+          },
+        },
+        description: "Pet list",
+      },
+    },
+  });
+
+  app.openapi(listPetsRoute, (c) => {
+    return c.json(pets, 200);
+  });
+
+  // POST /pets — secured
+  const createPetRoute = createRoute({
+    method: "post",
+    path: "/pets",
+    tags: ["Pets"],
+    summary: "Create a pet",
+    security: [{ bearerAuth: [] }],
+    request: {
+      body: {
+        content: {
+          "application/json": {
+            schema: z.object({ name: z.string() }),
+          },
+        },
+      },
+    },
+    responses: {
+      201: {
+        content: {
+          "application/json": {
+            schema: z.object({ id: z.number(), name: z.string() }),
+          },
+        },
+        description: "Pet created",
+      },
+    },
+  });
+
+  app.openapi(createPetRoute, (c) => {
+    const { name } = c.req.valid("json");
+    const pet = { id: nextId++, name };
+    pets.push(pet);
+    return c.json(pet, 201);
+  });
+
+  // OpenAPI spec endpoint
+  app.doc("/doc", {
+    openapi: "3.0.0",
+    info: { title: "Pet API", version: "1.0.0" },
+  });
+
+  return app;
+}
+
+// ── Tests ───────────────────────────────────────
+
+describe("Auth flow integration", () => {
+  let server: ReturnType<typeof Bun.serve>;
+  let TEST_BASE: string;
+  const tmpDir = join(tmpdir(), `apitool-auth-integration-${Date.now()}`);
+
+  beforeAll(async () => {
+    globalThis.fetch = realFetch;
+    await mkdir(tmpDir, { recursive: true });
+
+    const app = createPetServer();
+    server = Bun.serve({
+      fetch: app.fetch,
+      port: 0,
+    });
+    TEST_BASE = `http://localhost:${server.port}`;
+  });
+
+  afterAll(async () => {
+    server?.stop();
+    await rm(tmpDir, { recursive: true, force: true }).catch(() => {});
+  });
+
+  test("fetch OpenAPI spec from inline server", async () => {
+    const res = await fetch(`${TEST_BASE}/doc`);
+    expect(res.ok).toBe(true);
+    const spec = await res.json() as any;
+    expect(spec.openapi).toBe("3.0.0");
+    expect(spec.components.securitySchemes.bearerAuth).toBeDefined();
+  });
+
+  test("generate auth-aware tests from live spec, then run them", async () => {
+    // Fetch and save spec
+    const res = await fetch(`${TEST_BASE}/doc`);
+    const spec = await res.json();
+    const specPath = join(tmpDir, "spec.json");
+    await writeFile(specPath, JSON.stringify(spec));
+
+    // Generate skeleton
+    const doc = await readOpenApiSpec(specPath);
+    const endpoints = extractEndpoints(doc);
+    const securitySchemes = extractSecuritySchemes(doc);
+    const suites = generateSuites(endpoints, TEST_BASE, securitySchemes);
+
+    const outputDir = join(tmpDir, "generated");
+    const { written } = await writeSuites(suites, outputDir);
+
+    // Find the pets suite (has auth + CRUD)
+    const petsFile = written.find((f) => f.includes("pets"))!;
+    expect(petsFile).toBeDefined();
+
+    // Write env file with auth credentials
+    const envPath = join(outputDir, ".env.yaml");
+    await writeFile(envPath, "auth_username: admin\nauth_password: admin\n");
+
+    // Parse and run the generated tests
+    const suite = await parseFile(petsFile);
+
+    // Login step should be generated first
+    expect(suite.tests[0]!.name).toBe("Auth: Login");
+
+    // Suite headers should include Bearer auth
+    expect(suite.headers?.Authorization).toBe("Bearer {{auth_token}}");
+
+    // Load env vars
+    const envText = await Bun.file(envPath).text();
+    const env = Bun.YAML.parse(envText) as Record<string, string>;
+
+    const result = await runSuite(suite, env);
+
+    // Login should pass and capture token
+    const loginResult = result.steps[0]!;
+    expect(loginResult.status).toBe("pass");
+    expect(loginResult.captures.auth_token).toBeDefined();
+    expect(typeof loginResult.captures.auth_token).toBe("string");
+
+    // Create pet should pass (uses captured token)
+    const createResult = result.steps.find((s) => s.name === "Create a pet");
+    expect(createResult?.status).toBe("pass");
+    expect(createResult?.response?.status).toBe(201);
+
+    // List pets should pass
+    const listResult = result.steps.find((s) => s.name === "List all pets");
+    expect(listResult?.status).toBe("pass");
+    expect(listResult?.response?.status).toBe(200);
+
+    expect(result.passed).toBeGreaterThanOrEqual(3);
+  }, 30000);
+});

package/tests/mcp/coverage-analysis.test.ts

@@ -0,0 +1,64 @@
+import { describe, test, expect, mock, beforeEach, afterAll } from "bun:test";
+
+mock.module("../../src/core/generator/openapi-reader.ts", () => ({
+  readOpenApiSpec: mock(() => Promise.resolve({ info: { title: "API" }, paths: {} })),
+  extractEndpoints: mock(() => [
+    { method: "GET", path: "/users", summary: "List users", tags: ["users"], parameters: [], responses: [] },
+    { method: "POST", path: "/users", summary: "Create user", tags: ["users"], 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[]) => all.slice(1)),
+}));
+
+afterAll(() => { mock.restore(); });
+
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { registerCoverageAnalysisTool } from "../../src/mcp/tools/coverage-analysis.ts";
+import { readOpenApiSpec, extractEndpoints } from "../../src/core/generator/openapi-reader.ts";
+
+describe("MCP coverage_analysis", () => {
+  beforeEach(() => {
+    (readOpenApiSpec as ReturnType<typeof mock>).mockClear();
+    (extractEndpoints as ReturnType<typeof mock>).mockClear();
+  });
+
+  test("returns coverage analysis", async () => {
+    const server = new McpServer({ name: "test", version: "0.0.1" });
+    registerCoverageAnalysisTool(server);
+    const tool = (server as any)._registeredTools["coverage_analysis"];
+
+    const result = await tool.handler({ specPath: "spec.yaml", testsDir: "./tests" });
+    const parsed = JSON.parse(result.content[0].text);
+    expect(parsed.totalEndpoints).toBe(2);
+    expect(parsed.covered).toBe(1);
+    expect(parsed.uncovered).toBe(1);
+    expect(parsed.percentage).toBe(50);
+    expect(parsed.uncoveredEndpoints).toHaveLength(1);
+  });
+
+  test("returns error when spec has no endpoints", async () => {
+    (extractEndpoints as ReturnType<typeof mock>).mockReturnValueOnce([]);
+    const server = new McpServer({ name: "test", version: "0.0.1" });
+    registerCoverageAnalysisTool(server);
+    const tool = (server as any)._registeredTools["coverage_analysis"];
+
+    const result = await tool.handler({ specPath: "empty.yaml", testsDir: "./tests" });
+    expect(result.isError).toBe(true);
+  });
+
+  test("returns error on spec read failure", async () => {
+    (readOpenApiSpec as ReturnType<typeof mock>).mockRejectedValueOnce(new Error("File not found"));
+    const server = new McpServer({ name: "test", version: "0.0.1" });
+    registerCoverageAnalysisTool(server);
+    const tool = (server as any)._registeredTools["coverage_analysis"];
+
+    const result = await tool.handler({ specPath: "bad.yaml", testsDir: "./tests" });
+    expect(result.isError).toBe(true);
+  });
+});

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

@@ -0,0 +1,105 @@
+import { describe, test, expect, mock, 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, schema: { type: "integer" } }],
+      responses: [
+        { statusCode: 200, description: "OK", schema: { type: "array", items: { type: "object", properties: { id: { type: "integer" }, name: { type: "string" } } } } },
+      ],
+      requestBodySchema: undefined,
+      requestBodyContentType: undefined,
+      security: [],
+    },
+    {
+      method: "POST",
+      path: "/pets",
+      summary: "Create pet",
+      tags: ["pets"],
+      parameters: [],
+      responses: [
+        { statusCode: 201, description: "Created", schema: { type: "object", required: ["id"], properties: { id: { type: "integer" }, name: { type: "string" } } } },
+        { statusCode: 400, description: "Validation error" },
+      ],
+      requestBodySchema: { type: "object", required: ["name"], properties: { name: { type: "string" }, species: { type: "string" } } },
+      requestBodyContentType: "application/json",
+      security: ["bearerAuth"],
+    },
+  ]),
+  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 with includeSchemas", () => {
+  test("without includeSchemas — no schemas in output", 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);
+
+    const postEndpoint = parsed.endpoints.find((e: any) => e.method === "POST");
+    expect(postEndpoint.hasRequestBody).toBe(true);
+    expect(postEndpoint.requestBodySchema).toBeUndefined();
+    expect(postEndpoint.responses[0].schema).toBeUndefined();
+  });
+
+  test("with includeSchemas=true — includes compressed schemas", 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", includeSchemas: true });
+    const parsed = JSON.parse(result.content[0].text);
+
+    const postEndpoint = parsed.endpoints.find((e: any) => e.method === "POST");
+
+    // Should have request body schema
+    expect(postEndpoint.requestBodySchema).toBe("{ name: string (req), species: string }");
+    expect(postEndpoint.requestBodyContentType).toBe("application/json");
+
+    // Should have response schemas
+    expect(postEndpoint.responses[0].schema).toBe("{ id: integer (req), name: string }");
+    // 400 has no schema
+    expect(postEndpoint.responses[1].schema).toBeUndefined();
+
+    // Should have security
+    expect(postEndpoint.security).toEqual(["bearerAuth"]);
+  });
+
+  test("with includeSchemas=true — GET endpoint has response schema", 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", includeSchemas: true });
+    const parsed = JSON.parse(result.content[0].text);
+
+    const getEndpoint = parsed.endpoints.find((e: any) => e.method === "GET");
+
+    // Should have response schema for 200
+    expect(getEndpoint.responses[0].schema).toBe("[{ id: integer, name: string }]");
+
+    // GET has no request body
+    expect(getEndpoint.requestBodySchema).toBeUndefined();
+
+    // Parameter should have type info
+    expect(getEndpoint.parameters[0].type).toBeDefined();
+  });
+});