api-json-server 1.0.1 → 1.2.0

package/tests/behavior.test.ts

@@ -0,0 +1,88 @@
+import { describe, it, expect } from "vitest";
+import { buildTestServer } from "./helpers.js";
+
+const baseSettings = {
+     delayMs: 0,
+     errorRate: 0,
+     errorStatus: 500,
+     errorResponse: { error: "Mock error" }
+};
+
+describe("behavior settings", () => {
+     it("uses error response when errorRate is 1", async () => {
+          const app = buildTestServer({
+               version: 1,
+               settings: { ...baseSettings, errorRate: 1 },
+               endpoints: [
+                    {
+                         method: "GET",
+                         path: "/always-fail",
+                         response: { ok: true },
+                         errorStatus: 503,
+                         errorResponse: { message: "Service down" }
+                    }
+               ]
+          });
+
+          const res = await app.inject({ method: "GET", url: "/always-fail" });
+          expect(res.statusCode).toBe(503);
+          expect(res.json()).toEqual({ message: "Service down" });
+
+          await app.close();
+     });
+
+     it("renders templates in error responses", async () => {
+          const app = buildTestServer({
+               version: 1,
+               settings: { ...baseSettings, errorRate: 1 },
+               endpoints: [
+                    {
+                         method: "GET",
+                         path: "/users/:id",
+                         response: { ok: true },
+                         errorStatus: 400,
+                         errorResponse: { message: "User {{params.id}} missing" }
+                    }
+               ]
+          });
+
+          const res = await app.inject({ method: "GET", url: "/users/55" });
+          expect(res.statusCode).toBe(400);
+          expect(res.json()).toEqual({ message: "User 55 missing" });
+
+          await app.close();
+     });
+
+     it("uses variant-level status codes", async () => {
+          const app = buildTestServer({
+               version: 1,
+               settings: baseSettings,
+               endpoints: [
+                    {
+                         method: "POST",
+                         path: "/login",
+                         response: { ok: true },
+                         variants: [
+                              {
+                                   name: "unauthorized",
+                                   match: { body: { password: "wrong" } },
+                                   status: 401,
+                                   response: { ok: false }
+                              }
+                         ]
+                    }
+               ]
+          });
+
+          const res = await app.inject({
+               method: "POST",
+               url: "/login",
+               payload: { password: "wrong" }
+          });
+
+          expect(res.statusCode).toBe(401);
+          expect(res.json()).toEqual({ ok: false });
+
+          await app.close();
+     });
+});

package/tests/cors.test.ts

@@ -0,0 +1,128 @@
+import { describe, it, expect } from "vitest";
+import { buildTestServer } from "./helpers.js";
+
+const baseSettings = {
+     delayMs: 0,
+     errorRate: 0,
+     errorStatus: 500,
+     errorResponse: { error: "Mock error" }
+};
+
+describe("CORS configuration", () => {
+     it("enables CORS with wildcard origin when configured", async () => {
+          const app = buildTestServer({
+               version: 1,
+               settings: {
+                    ...baseSettings,
+                    cors: {
+                         origin: "*",
+                         credentials: false
+                    }
+               },
+               endpoints: [
+                    {
+                         method: "GET",
+                         path: "/api/data",
+                         response: { data: "value" }
+                    }
+               ]
+          });
+
+          const res = await app.inject({
+               method: "GET",
+               url: "/api/data",
+               headers: { origin: "https://example.com" }
+          });
+
+          expect(res.statusCode).toBe(200);
+          expect(res.headers["access-control-allow-origin"]).toBe("*");
+
+          await app.close();
+     });
+
+     it("handles preflight OPTIONS requests", async () => {
+          const app = buildTestServer({
+               version: 1,
+               settings: {
+                    ...baseSettings,
+                    cors: {
+                         origin: "https://example.com",
+                         methods: ["GET", "POST"],
+                         credentials: true
+                    }
+               },
+               endpoints: [
+                    {
+                         method: "POST",
+                         path: "/api/data",
+                         response: { ok: true }
+                    }
+               ]
+          });
+
+          const res = await app.inject({
+               method: "OPTIONS",
+               url: "/api/data",
+               headers: {
+                    origin: "https://example.com",
+                    "access-control-request-method": "POST"
+               }
+          });
+
+          expect(res.statusCode).toBe(204);
+          expect(res.headers["access-control-allow-origin"]).toBeTruthy();
+
+          await app.close();
+     });
+
+     it("allows specific origins when configured", async () => {
+          const app = buildTestServer({
+               version: 1,
+               settings: {
+                    ...baseSettings,
+                    cors: {
+                         origin: "https://trusted.com",
+                         credentials: true
+                    }
+               },
+               endpoints: [
+                    {
+                         method: "GET",
+                         path: "/api/secure",
+                         response: { data: "secure" }
+                    }
+               ]
+          });
+
+          const res = await app.inject({
+               method: "GET",
+               url: "/api/secure",
+               headers: { origin: "https://trusted.com" }
+          });
+
+          expect(res.statusCode).toBe(200);
+          expect(res.headers["access-control-allow-origin"]).toBe("https://trusted.com");
+          expect(res.headers["access-control-allow-credentials"]).toBe("true");
+
+          await app.close();
+     });
+
+     it("works without CORS configuration", async () => {
+          const app = buildTestServer({
+               version: 1,
+               settings: baseSettings,
+               endpoints: [
+                    {
+                         method: "GET",
+                         path: "/api/data",
+                         response: { data: "value" }
+                    }
+               ]
+          });
+
+          const res = await app.inject({ method: "GET", url: "/api/data" });
+          expect(res.statusCode).toBe(200);
+
+          await app.close();
+     });
+});

package/tests/faker.test.ts

@@ -0,0 +1,175 @@
+import { describe, it, expect } from "vitest";
+import { buildTestServer } from "./helpers.js";
+
+const baseSettings = {
+     delayMs: 0,
+     errorRate: 0,
+     errorStatus: 500,
+     errorResponse: { error: "Mock error" }
+};
+
+describe("faker templates", () => {
+     it("generates deterministic faker data when fakerSeed is set", async () => {
+          const app = buildTestServer({
+               version: 1,
+               settings: { ...baseSettings, fakerSeed: 123 },
+               endpoints: [
+                    {
+                         method: "GET",
+                         path: "/profile",
+                         response: {
+                              firstName: { __faker: "person.firstName" },
+                              lastName: { __faker: "person.lastName" },
+                              email: { __faker: "internet.email" }
+                         }
+                    }
+               ]
+          });
+
+          const res1 = await app.inject({ method: "GET", url: "/profile" });
+          const res2 = await app.inject({ method: "GET", url: "/profile" });
+
+          expect(res1.statusCode).toBe(200);
+          expect(res2.statusCode).toBe(200);
+          expect(res1.json()).toEqual(res2.json());
+
+          await app.close();
+     });
+
+     it("supports faker methods with arguments", async () => {
+          const app = buildTestServer({
+               version: 1,
+               settings: { ...baseSettings, fakerSeed: 7 },
+               endpoints: [
+                    {
+                         method: "GET",
+                         path: "/token",
+                         response: {
+                              token: { __faker: { method: "string.alpha", args: [16] } }
+                         }
+                    }
+               ]
+          });
+
+          const res = await app.inject({ method: "GET", url: "/token" });
+          const body = res.json();
+
+          expect(res.statusCode).toBe(200);
+          expect(typeof body.token).toBe("string");
+          expect(body.token).toHaveLength(16);
+
+          await app.close();
+     });
+
+     it("renders repeat directives with a min/max range", async () => {
+          const app = buildTestServer({
+               version: 1,
+               settings: { ...baseSettings, fakerSeed: 55 },
+               endpoints: [
+                    {
+                         method: "GET",
+                         path: "/users",
+                         response: {
+                              users: {
+                                   __repeat: {
+                                        min: 10,
+                                        max: 15,
+                                        template: {
+                                             id: { __faker: "string.uuid" },
+                                             firstName: { __faker: "person.firstName" },
+                                             email: { __faker: "internet.email" }
+                                        }
+                                   }
+                              }
+                         }
+                    }
+               ]
+          });
+
+          const res = await app.inject({ method: "GET", url: "/users" });
+          const body = res.json();
+
+          expect(res.statusCode).toBe(200);
+          expect(Array.isArray(body.users)).toBe(true);
+          expect(body.users.length).toBeGreaterThanOrEqual(10);
+          expect(body.users.length).toBeLessThanOrEqual(15);
+          expect(typeof body.users[0].firstName).toBe("string");
+
+          await app.close();
+     });
+
+     it("renders repeat directives with a fixed count", async () => {
+          const app = buildTestServer({
+               version: 1,
+               settings: { ...baseSettings, fakerSeed: 1 },
+               endpoints: [
+                    {
+                         method: "GET",
+                         path: "/companies",
+                         response: {
+                              companies: {
+                                   __repeat: {
+                                        count: 3,
+                                        min: 0,
+                                        template: {
+                                             name: { __faker: "company.name" },
+                                             phone: { __faker: "phone.number" }
+                                        }
+                                   }
+                              }
+                         }
+                    }
+               ]
+          });
+
+          const res = await app.inject({ method: "GET", url: "/companies" });
+          const body = res.json();
+
+          expect(res.statusCode).toBe(200);
+          expect(body.companies).toHaveLength(3);
+
+          await app.close();
+     });
+
+     it("returns 500 when faker method is invalid", async () => {
+          const app = buildTestServer({
+               version: 1,
+               settings: baseSettings,
+               endpoints: [
+                    {
+                         method: "GET",
+                         path: "/bad",
+                         response: { value: { __faker: "nope.method" } }
+                    }
+               ]
+          });
+
+          const res = await app.inject({ method: "GET", url: "/bad" });
+          expect(res.statusCode).toBe(500);
+
+          await app.close();
+     });
+
+     it("returns 500 when repeat max is below min", async () => {
+          const app = buildTestServer({
+               version: 1,
+               settings: baseSettings,
+               endpoints: [
+                    {
+                         method: "GET",
+                         path: "/bad-repeat",
+                         response: {
+                              items: {
+                                   __repeat: { min: 5, max: 2, template: { id: 1 } }
+                              }
+                         }
+                    }
+               ]
+          });
+
+          const res = await app.inject({ method: "GET", url: "/bad-repeat" });
+          expect(res.statusCode).toBe(500);
+
+          await app.close();
+     });
+});

package/tests/fixtures/spec.basic.json

@@ -0,0 +1,39 @@
+{
+     "version": 1,
+     "settings": {
+       "delayMs": 0,
+       "errorRate": 0,
+       "errorStatus": 500,
+       "errorResponse": { "error": "Mock error" }
+     },
+     "endpoints": [
+       {
+         "method": "GET",
+         "path": "/users/:id",
+         "status": 200,
+         "response": { "id": "{{params.id}}", "type": "{{query.type}}"}
+       },
+       {
+         "method": "GET",
+         "path": "/search",
+         "status": 200,
+         "match": { "query": { "type": "premium" } },
+         "response": { "ok": true, "tier": "premium" }
+       },
+       {
+         "method": "POST",
+         "path": "/login",
+         "status": 200,
+         "response": { "ok": true, "message": "default" },
+         "variants": [
+           {
+             "name": "wrong password",
+             "match": { "body": { "password": "wrong" } },
+             "status": 401,
+             "response": { "ok": false, "error": "Invalid credentials" }
+           }
+         ]
+       }
+     ]
+   }
+   

package/tests/headers.test.ts

@@ -0,0 +1,124 @@
+import { describe, it, expect } from "vitest";
+import { buildTestServer } from "./helpers.js";
+
+const baseSettings = {
+     delayMs: 0,
+     errorRate: 0,
+     errorStatus: 500,
+     errorResponse: { error: "Mock error" }
+};
+
+describe("custom response headers", () => {
+     it("sets custom headers on endpoint responses", async () => {
+          const app = buildTestServer({
+               version: 1,
+               settings: baseSettings,
+               endpoints: [
+                    {
+                         method: "GET",
+                         path: "/api/data",
+                         response: { data: "value" },
+                         headers: {
+                              "X-Custom-Header": "test-value",
+                              "Cache-Control": "no-cache"
+                         }
+                    }
+               ]
+          });
+
+          const res = await app.inject({ method: "GET", url: "/api/data" });
+          expect(res.statusCode).toBe(200);
+          expect(res.headers["x-custom-header"]).toBe("test-value");
+          expect(res.headers["cache-control"]).toBe("no-cache");
+
+          await app.close();
+     });
+
+     it("supports template strings in header values", async () => {
+          const app = buildTestServer({
+               version: 1,
+               settings: baseSettings,
+               endpoints: [
+                    {
+                         method: "GET",
+                         path: "/users/:id",
+                         response: { id: "{{params.id}}" },
+                         headers: {
+                              "X-User-ID": "{{params.id}}",
+                              "X-Query-Type": "{{query.type}}"
+                         }
+                    }
+               ]
+          });
+
+          const res = await app.inject({ method: "GET", url: "/users/42?type=premium" });
+          expect(res.statusCode).toBe(200);
+          expect(res.headers["x-user-id"]).toBe("42");
+          expect(res.headers["x-query-type"]).toBe("premium");
+
+          await app.close();
+     });
+
+     it("variant headers override endpoint headers", async () => {
+          const app = buildTestServer({
+               version: 1,
+               settings: baseSettings,
+               endpoints: [
+                    {
+                         method: "GET",
+                         path: "/api/data",
+                         response: { source: "base" },
+                         headers: {
+                              "X-Source": "endpoint"
+                         },
+                         variants: [
+                              {
+                                   name: "special",
+                                   match: { query: { mode: "special" } },
+                                   response: { source: "variant" },
+                                   headers: {
+                                        "X-Source": "variant"
+                                   }
+                              }
+                         ]
+                    }
+               ]
+          });
+
+          const baseRes = await app.inject({ method: "GET", url: "/api/data" });
+          expect(baseRes.headers["x-source"]).toBe("endpoint");
+
+          const variantRes = await app.inject({ method: "GET", url: "/api/data?mode=special" });
+          expect(variantRes.headers["x-source"]).toBe("variant");
+
+          await app.close();
+     });
+
+     it("handles multiple custom headers", async () => {
+          const app = buildTestServer({
+               version: 1,
+               settings: baseSettings,
+               endpoints: [
+                    {
+                         method: "GET",
+                         path: "/api/cors-test",
+                         response: { ok: true },
+                         headers: {
+                              "Access-Control-Allow-Origin": "*",
+                              "Access-Control-Allow-Methods": "GET, POST",
+                              "X-RateLimit-Limit": "100",
+                              "X-RateLimit-Remaining": "95"
+                         }
+                    }
+               ]
+          });
+
+          const res = await app.inject({ method: "GET", url: "/api/cors-test" });
+          expect(res.headers["access-control-allow-origin"]).toBe("*");
+          expect(res.headers["access-control-allow-methods"]).toBe("GET, POST");
+          expect(res.headers["x-ratelimit-limit"]).toBe("100");
+          expect(res.headers["x-ratelimit-remaining"]).toBe("95");
+
+          await app.close();
+     });
+});

package/tests/helpers.ts

@@ -0,0 +1,28 @@
+import { readFile } from "node:fs/promises";
+import type { FastifyInstance } from "fastify";
+import { buildServer } from "../src/server.js";
+import { MockSpecSchema, type MockSpecInferSchema } from "../src/spec.js";
+
+/**
+ * Load and validate a fixture spec file.
+ */
+export async function loadFixture(path: string): Promise<MockSpecInferSchema> {
+     const raw = await readFile(path, "utf-8");
+     const json = JSON.parse(raw) as unknown;
+     return MockSpecSchema.parse(json);
+}
+
+/**
+ * Build a Fastify instance from a fixture spec file.
+ */
+export async function buildTestServerFromFixture(path: string): Promise<FastifyInstance> {
+     const spec = await loadFixture(path);
+     return buildServer(spec, { specPath: path, loadedAt: "now", logger: false });
+}
+
+/**
+ * Build a Fastify instance from an in-memory spec object.
+ */
+export function buildTestServer(spec: MockSpecInferSchema): FastifyInstance {
+     return buildServer(spec, { specPath: "inline", loadedAt: "now", logger: false });
+}