@kirrosh/apitool 0.4.3

package/tests/fixtures/bail/suite-a.yaml

@@ -0,0 +1,6 @@
+name: Suite A
+tests:
+  - name: "Test A"
+    GET: /a
+    expect:
+      status: 200

package/tests/fixtures/bail/suite-b.yaml

@@ -0,0 +1,6 @@
+name: Suite B
+tests:
+  - name: "Test B"
+    GET: /b
+    expect:
+      status: 200

package/tests/fixtures/crud.yaml

@@ -0,0 +1,35 @@
+name: Users CRUD
+base_url: "{{base}}"
+headers:
+  Authorization: "Bearer {{token}}"
+  Content-Type: application/json
+
+config:
+  timeout: 10000
+  retries: 1
+
+tests:
+  - name: "Create user"
+    POST: /users
+    json:
+      name: "{{$randomName}}"
+      email: "{{$randomEmail}}"
+    expect:
+      status: 201
+      body:
+        id: { capture: user_id, type: integer }
+        name: { type: string }
+      duration: 2000
+
+  - name: "Get created user"
+    GET: /users/{{user_id}}
+    expect:
+      status: 200
+      body:
+        id: { equals: "{{user_id}}" }
+        email: { matches: ".+@.+" }
+
+  - name: "Delete user"
+    DELETE: /users/{{user_id}}
+    expect:
+      status: 204

package/tests/fixtures/invalid-missing-name.yaml

@@ -0,0 +1,5 @@
+tests:
+  - name: "Test"
+    GET: /health
+    expect:
+      status: 200

package/tests/fixtures/invalid-no-method.yaml

@@ -0,0 +1,6 @@
+name: Bad Suite
+tests:
+  - name: "No method"
+    path: /health
+    expect:
+      status: 200

package/tests/fixtures/petstore-auth.json

@@ -0,0 +1,295 @@
+{
+  "openapi": "3.0.0",
+  "info": {
+    "title": "Test Petstore",
+    "version": "1.0.0"
+  },
+  "servers": [{ "url": "http://localhost:3000", "description": "Local test server" }],
+  "components": {
+    "securitySchemes": {
+      "bearerAuth": {
+        "type": "http",
+        "scheme": "bearer",
+        "bearerFormat": "JWT"
+      }
+    },
+    "schemas": {},
+    "parameters": {}
+  },
+  "paths": {
+    "/auth/login": {
+      "post": {
+        "operationId": "login",
+        "summary": "Authenticate and get a JWT token",
+        "tags": ["auth"],
+        "requestBody": {
+          "required": true,
+          "content": {
+            "application/json": {
+              "schema": {
+                "type": "object",
+                "properties": {
+                  "username": { "type": "string", "example": "admin" },
+                  "password": { "type": "string", "example": "admin" }
+                },
+                "required": ["username", "password"]
+              }
+            }
+          }
+        },
+        "responses": {
+          "200": {
+            "description": "Login successful",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "object",
+                  "properties": {
+                    "token": { "type": "string", "example": "eyJhbGciOiJIUzI1NiIs..." }
+                  },
+                  "required": ["token"]
+                }
+              }
+            }
+          },
+          "401": {
+            "description": "Invalid credentials",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "object",
+                  "properties": {
+                    "error": { "type": "string", "example": "Not found" }
+                  },
+                  "required": ["error"]
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/pets": {
+      "get": {
+        "operationId": "listPets",
+        "summary": "List all pets",
+        "tags": ["pets"],
+        "security": [{ "bearerAuth": [] }],
+        "responses": {
+          "200": {
+            "description": "A list of pets",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "array",
+                  "items": {
+                    "type": "object",
+                    "properties": {
+                      "id": { "type": "integer", "example": 1 },
+                      "name": { "type": "string", "example": "Buddy" },
+                      "tag": { "type": "string", "example": "dog" },
+                      "status": { "type": "string", "enum": ["available", "pending", "sold"], "example": "available" }
+                    },
+                    "required": ["id", "name", "status"]
+                  }
+                }
+              }
+            }
+          }
+        }
+      },
+      "post": {
+        "operationId": "createPet",
+        "summary": "Create a pet",
+        "tags": ["pets"],
+        "security": [{ "bearerAuth": [] }],
+        "requestBody": {
+          "required": true,
+          "content": {
+            "application/json": {
+              "schema": {
+                "type": "object",
+                "properties": {
+                  "name": { "type": "string", "example": "Buddy" },
+                  "tag": { "type": "string", "example": "dog" },
+                  "status": { "type": "string", "enum": ["available", "pending", "sold"], "default": "available", "example": "available" }
+                },
+                "required": ["name"]
+              }
+            }
+          }
+        },
+        "responses": {
+          "201": {
+            "description": "Pet created",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "object",
+                  "properties": {
+                    "id": { "type": "integer", "example": 1 },
+                    "name": { "type": "string", "example": "Buddy" },
+                    "tag": { "type": "string", "example": "dog" },
+                    "status": { "type": "string", "enum": ["available", "pending", "sold"], "example": "available" }
+                  },
+                  "required": ["id", "name", "status"]
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/pets/{id}": {
+      "get": {
+        "operationId": "getPet",
+        "summary": "Get a pet by ID",
+        "tags": ["pets"],
+        "security": [{ "bearerAuth": [] }],
+        "parameters": [
+          { "schema": { "type": "string", "example": "1" }, "required": true, "name": "id", "in": "path" }
+        ],
+        "responses": {
+          "200": {
+            "description": "A pet",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "object",
+                  "properties": {
+                    "id": { "type": "integer", "example": 1 },
+                    "name": { "type": "string", "example": "Buddy" },
+                    "tag": { "type": "string", "example": "dog" },
+                    "status": { "type": "string", "enum": ["available", "pending", "sold"], "example": "available" }
+                  },
+                  "required": ["id", "name", "status"]
+                }
+              }
+            }
+          },
+          "404": {
+            "description": "Pet not found",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "object",
+                  "properties": {
+                    "error": { "type": "string", "example": "Not found" }
+                  },
+                  "required": ["error"]
+                }
+              }
+            }
+          }
+        }
+      },
+      "put": {
+        "operationId": "updatePet",
+        "summary": "Update a pet",
+        "tags": ["pets"],
+        "security": [{ "bearerAuth": [] }],
+        "parameters": [
+          { "schema": { "type": "string", "example": "1" }, "required": true, "name": "id", "in": "path" }
+        ],
+        "requestBody": {
+          "required": true,
+          "content": {
+            "application/json": {
+              "schema": {
+                "type": "object",
+                "properties": {
+                  "name": { "type": "string", "example": "Buddy" },
+                  "tag": { "type": "string", "example": "dog" },
+                  "status": { "type": "string", "enum": ["available", "pending", "sold"], "default": "available", "example": "available" }
+                },
+                "required": ["name"]
+              }
+            }
+          }
+        },
+        "responses": {
+          "200": {
+            "description": "Pet updated",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "object",
+                  "properties": {
+                    "id": { "type": "integer", "example": 1 },
+                    "name": { "type": "string", "example": "Buddy" },
+                    "tag": { "type": "string", "example": "dog" },
+                    "status": { "type": "string", "enum": ["available", "pending", "sold"], "example": "available" }
+                  },
+                  "required": ["id", "name", "status"]
+                }
+              }
+            }
+          },
+          "404": {
+            "description": "Pet not found",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "object",
+                  "properties": {
+                    "error": { "type": "string", "example": "Not found" }
+                  },
+                  "required": ["error"]
+                }
+              }
+            }
+          }
+        }
+      },
+      "delete": {
+        "operationId": "deletePet",
+        "summary": "Delete a pet",
+        "tags": ["pets"],
+        "security": [{ "bearerAuth": [] }],
+        "parameters": [
+          { "schema": { "type": "string", "example": "1" }, "required": true, "name": "id", "in": "path" }
+        ],
+        "responses": {
+          "204": { "description": "Pet deleted" },
+          "404": {
+            "description": "Pet not found",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "object",
+                  "properties": {
+                    "error": { "type": "string", "example": "Not found" }
+                  },
+                  "required": ["error"]
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/health": {
+      "get": {
+        "operationId": "healthCheck",
+        "summary": "Health check endpoint",
+        "responses": {
+          "200": {
+            "description": "Service is healthy",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "object",
+                  "properties": {
+                    "status": { "type": "string", "example": "ok" },
+                    "uptime": { "type": "number", "example": 12345 }
+                  },
+                  "required": ["status", "uptime"]
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+}

package/tests/fixtures/petstore-simple.json

@@ -0,0 +1,151 @@
+{
+  "openapi": "3.0.0",
+  "info": {
+    "title": "Simple Petstore",
+    "version": "1.0.0"
+  },
+  "servers": [{ "url": "http://localhost:3000" }],
+  "paths": {
+    "/pets": {
+      "get": {
+        "operationId": "listPets",
+        "summary": "List all pets",
+        "tags": ["pets"],
+        "parameters": [
+          {
+            "name": "limit",
+            "in": "query",
+            "required": false,
+            "schema": { "type": "integer" }
+          }
+        ],
+        "responses": {
+          "200": {
+            "description": "A list of pets",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "array",
+                  "items": {
+                    "type": "object",
+                    "properties": {
+                      "id": { "type": "integer" },
+                      "name": { "type": "string" },
+                      "species": { "type": "string" }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      },
+      "post": {
+        "operationId": "createPet",
+        "summary": "Create a pet",
+        "tags": ["pets"],
+        "requestBody": {
+          "required": true,
+          "content": {
+            "application/json": {
+              "schema": {
+                "type": "object",
+                "required": ["name", "species"],
+                "properties": {
+                  "name": { "type": "string" },
+                  "species": { "type": "string" }
+                }
+              }
+            }
+          }
+        },
+        "responses": {
+          "201": {
+            "description": "Created pet",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "object",
+                  "properties": {
+                    "id": { "type": "integer" },
+                    "name": { "type": "string" },
+                    "species": { "type": "string" }
+                  }
+                }
+              }
+            }
+          },
+          "409": {
+            "description": "Pet with this name already exists",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "object",
+                  "properties": {
+                    "error": { "type": "string" }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/pets/{petId}": {
+      "get": {
+        "operationId": "getPet",
+        "summary": "Get a pet by ID",
+        "tags": ["pets"],
+        "parameters": [
+          {
+            "name": "petId",
+            "in": "path",
+            "required": true,
+            "schema": { "type": "integer" }
+          }
+        ],
+        "responses": {
+          "200": {
+            "description": "A pet",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "object",
+                  "properties": {
+                    "id": { "type": "integer" },
+                    "name": { "type": "string" },
+                    "species": { "type": "string" }
+                  }
+                }
+              }
+            }
+          },
+          "404": {
+            "description": "Pet not found"
+          }
+        }
+      },
+      "delete": {
+        "operationId": "deletePet",
+        "summary": "Delete a pet",
+        "tags": ["pets"],
+        "parameters": [
+          {
+            "name": "petId",
+            "in": "path",
+            "required": true,
+            "schema": { "type": "integer" }
+          }
+        ],
+        "responses": {
+          "204": {
+            "description": "Pet deleted"
+          },
+          "404": {
+            "description": "Pet not found"
+          }
+        }
+      }
+    }
+  }
+}

package/tests/fixtures/post-only.yaml

@@ -0,0 +1,12 @@
+name: Write-only Suite
+tests:
+  - name: "Create item"
+    POST: /items
+    json:
+      name: "Test Item"
+    expect:
+      status: 201
+  - name: "Delete item"
+    DELETE: /items/1
+    expect:
+      status: 204

package/tests/fixtures/simple.yaml

@@ -0,0 +1,6 @@
+name: Health Check
+tests:
+  - name: "API is alive"
+    GET: /health
+    expect:
+      status: 200

package/tests/fixtures/valid/.env.yaml

@@ -0,0 +1 @@
+base: http://localhost

package/tests/fixtures/valid/a.yaml

@@ -0,0 +1,5 @@
+name: A
+tests:
+  - name: A
+    GET: /a
+    expect: {}

package/tests/fixtures/valid/b.yml

@@ -0,0 +1,5 @@
+name: B
+tests:
+  - name: B
+    POST: /b
+    expect: {}

package/tests/generator/coverage-scanner.test.ts

@@ -0,0 +1,129 @@
+import { describe, test, expect, beforeAll, afterAll } from "bun:test";
+import { scanCoveredEndpoints, filterUncoveredEndpoints } from "../../src/core/generator/coverage-scanner.ts";
+import type { EndpointInfo } from "../../src/core/generator/types.ts";
+import { tmpdir } from "os";
+import { join } from "path";
+import { rm, mkdir } from "fs/promises";
+
+const tmpDir = join(tmpdir(), `apitool-coverage-${Date.now()}`);
+
+beforeAll(async () => {
+  await mkdir(tmpDir, { recursive: true });
+});
+
+afterAll(async () => {
+  await rm(tmpDir, { recursive: true, force: true }).catch(() => {});
+});
+
+describe("scanCoveredEndpoints", () => {
+  test("extracts method+path from YAML test files", async () => {
+    const yamlContent = `
+name: Users CRUD
+base_url: http://localhost:3000
+tests:
+  - name: Create user
+    POST: /users
+    expect:
+      status: 201
+  - name: Get user
+    GET: /users/{{user_id}}
+    expect:
+      status: 200
+  - name: Delete user
+    DELETE: /users/{{user_id}}
+    expect:
+      status: 204
+`;
+    await Bun.write(join(tmpDir, "users.yaml"), yamlContent);
+
+    const covered = await scanCoveredEndpoints(tmpDir);
+
+    expect(covered).toHaveLength(3);
+    expect(covered.find((c) => c.method === "POST")?.path).toBe("/users");
+    expect(covered.find((c) => c.method === "GET")?.path).toBe("/users/{*}");
+    expect(covered.find((c) => c.method === "DELETE")?.path).toBe("/users/{*}");
+  });
+
+  test("handles nested directories", async () => {
+    const subDir = join(tmpDir, "nested");
+    await mkdir(subDir, { recursive: true });
+    await Bun.write(join(subDir, "health.yaml"), `
+name: Health
+tests:
+  - name: Health check
+    GET: /health
+    expect:
+      status: 200
+`);
+
+    const covered = await scanCoveredEndpoints(tmpDir);
+    const healthEndpoint = covered.find((c) => c.path === "/health");
+    expect(healthEndpoint).toBeDefined();
+    expect(healthEndpoint?.method).toBe("GET");
+  });
+
+  test("returns empty array for empty directory", async () => {
+    const emptyDir = join(tmpDir, "empty");
+    await mkdir(emptyDir, { recursive: true });
+    const covered = await scanCoveredEndpoints(emptyDir);
+    expect(covered).toHaveLength(0);
+  });
+});
+
+describe("filterUncoveredEndpoints", () => {
+  const makeEndpoint = (method: string, path: string): EndpointInfo => ({
+    method,
+    path,
+    tags: [],
+    parameters: [],
+    responseContentTypes: [],
+    responses: [],
+    security: [],
+  });
+
+  test("filters out covered endpoints", () => {
+    const all = [
+      makeEndpoint("GET", "/users"),
+      makeEndpoint("POST", "/users"),
+      makeEndpoint("GET", "/users/{id}"),
+      makeEndpoint("DELETE", "/users/{id}"),
+      makeEndpoint("GET", "/health"),
+    ];
+
+    const covered = [
+      { method: "GET", path: "/users", file: "users.yaml" },
+      { method: "POST", path: "/users", file: "users.yaml" },
+      { method: "GET", path: "/users/{*}", file: "users.yaml" },
+    ];
+
+    const uncovered = filterUncoveredEndpoints(all, covered);
+
+    expect(uncovered).toHaveLength(2);
+    expect(uncovered[0]!.method).toBe("DELETE");
+    expect(uncovered[0]!.path).toBe("/users/{id}");
+    expect(uncovered[1]!.method).toBe("GET");
+    expect(uncovered[1]!.path).toBe("/health");
+  });
+
+  test("returns all endpoints when nothing covered", () => {
+    const all = [
+      makeEndpoint("GET", "/users"),
+      makeEndpoint("POST", "/users"),
+    ];
+
+    const uncovered = filterUncoveredEndpoints(all, []);
+    expect(uncovered).toHaveLength(2);
+  });
+
+  test("returns empty when all covered", () => {
+    const all = [
+      makeEndpoint("GET", "/health"),
+    ];
+    const covered = [
+      { method: "GET", path: "/health", file: "health.yaml" },
+    ];
+
+    const uncovered = filterUncoveredEndpoints(all, covered);
+    expect(uncovered).toHaveLength(0);
+  });
+});