@schmock/core 1.0.0

package/src/response-parsing.test.ts

@@ -0,0 +1,255 @@
+import { describe, expect, it } from "vitest";
+import { schmock } from "./index";
+
+describe("response parsing", () => {
+  describe("tuple response formats", () => {
+    it("handles status-only tuple [status]", async () => {
+      const mock = schmock();
+      mock("GET /status-only", () => [204] as [number]);
+
+      const response = await mock.handle("GET", "/status-only");
+
+      expect(response.status).toBe(204);
+      expect(response.body).toBeUndefined();
+      expect(response.headers).toEqual({});
+    });
+
+    it("handles [status, body] tuple", async () => {
+      const mock = schmock();
+      mock("POST /create", () => [201, { id: 123, created: true }]);
+
+      const response = await mock.handle("POST", "/create");
+
+      expect(response.status).toBe(201);
+      expect(response.body).toEqual({ id: 123, created: true });
+      expect(response.headers).toEqual({});
+    });
+
+    it("handles [status, body, headers] tuple", async () => {
+      const mock = schmock();
+      mock(
+        "POST /upload",
+        () =>
+          [
+            201,
+            { fileId: "abc123" },
+            {
+              Location: "/files/abc123",
+              "Content-Type": "application/json",
+            },
+          ] as [number, any, Record<string, string>],
+      );
+
+      const response = await mock.handle("POST", "/upload");
+
+      expect(response.status).toBe(201);
+      expect(response.body).toEqual({ fileId: "abc123" });
+      expect(response.headers).toEqual({
+        Location: "/files/abc123",
+        "Content-Type": "application/json",
+      });
+    });
+
+    it("handles empty headers object in tuple", async () => {
+      const mock = schmock();
+      mock("GET /test", () => [200, "OK", {}]);
+
+      const response = await mock.handle("GET", "/test");
+
+      expect(response.status).toBe(200);
+      expect(response.body).toBe("OK");
+      expect(response.headers).toEqual({});
+    });
+
+    it("ignores extra tuple elements beyond [status, body, headers]", async () => {
+      const mock = schmock();
+      mock(
+        "GET /extra",
+        () => [200, "data", {}, "ignored", "also-ignored"] as any,
+      );
+
+      const response = await mock.handle("GET", "/extra");
+
+      expect(response.status).toBe(200);
+      expect(response.body).toBe("data");
+      expect(response.headers).toEqual({});
+    });
+
+    it("treats non-numeric first element as body, not status", async () => {
+      const mock = schmock();
+      mock("GET /array-body", () => ["item1", "item2", "item3"]);
+
+      const response = await mock.handle("GET", "/array-body");
+
+      expect(response.status).toBe(200);
+      expect(response.body).toEqual(["item1", "item2", "item3"]);
+      expect(response.headers).toEqual({ "content-type": "application/json" });
+    });
+  });
+
+  describe("various response types", () => {
+    it("handles string responses", async () => {
+      const mock = schmock();
+      mock("GET /text", () => "Simple text response");
+
+      const response = await mock.handle("GET", "/text");
+
+      expect(response.status).toBe(200);
+      expect(response.body).toBe("Simple text response");
+      expect(response.headers).toEqual({ "content-type": "application/json" });
+    });
+
+    it("handles number responses", async () => {
+      const mock = schmock();
+      mock("GET /number", () => 42);
+
+      const response = await mock.handle("GET", "/number");
+
+      expect(response.status).toBe(200);
+      expect(response.body).toBe(42);
+      expect(response.headers).toEqual({ "content-type": "application/json" });
+    });
+
+    it("handles boolean responses", async () => {
+      const mock = schmock();
+      mock("GET /bool", () => true);
+
+      const response = await mock.handle("GET", "/bool");
+
+      expect(response.status).toBe(200);
+      expect(response.body).toBe(true);
+      expect(response.headers).toEqual({ "content-type": "application/json" });
+    });
+
+    it("handles null responses", async () => {
+      const mock = schmock();
+      mock("GET /null", () => null);
+
+      const response = await mock.handle("GET", "/null");
+
+      expect(response.status).toBe(204);
+      expect(response.body).toBeUndefined();
+      expect(response.headers).toEqual({ "content-type": "application/json" });
+    });
+
+    it("handles undefined responses", async () => {
+      const mock = schmock();
+      mock("GET /undefined", () => undefined);
+
+      const response = await mock.handle("GET", "/undefined");
+
+      expect(response.status).toBe(204);
+      expect(response.body).toBeUndefined();
+      expect(response.headers).toEqual({ "content-type": "application/json" });
+    });
+
+    it("handles complex object responses", async () => {
+      const complexObject = {
+        data: {
+          users: [
+            { id: 1, name: "Alice", tags: ["admin", "active"] },
+            { id: 2, name: "Bob", meta: { lastLogin: "2023-01-01" } },
+          ],
+          pagination: {
+            page: 1,
+            limit: 10,
+            total: 2,
+          },
+        },
+        timestamp: new Date("2023-01-01T00:00:00Z"),
+      };
+
+      const mock = schmock();
+      mock("GET /complex", () => complexObject);
+
+      const response = await mock.handle("GET", "/complex");
+
+      expect(response.status).toBe(200);
+      expect(response.body).toEqual(complexObject);
+      expect(response.headers).toEqual({ "content-type": "application/json" });
+    });
+
+    it("handles empty array responses", async () => {
+      const mock = schmock();
+      mock("GET /empty-array", () => []);
+
+      const response = await mock.handle("GET", "/empty-array");
+
+      expect(response.status).toBe(200);
+      expect(response.body).toEqual([]);
+      expect(response.headers).toEqual({ "content-type": "application/json" });
+    });
+
+    it("handles empty object responses", async () => {
+      const mock = schmock();
+      mock("GET /empty-object", () => ({}));
+
+      const response = await mock.handle("GET", "/empty-object");
+
+      expect(response.status).toBe(200);
+      expect(response.body).toEqual({});
+      expect(response.headers).toEqual({ "content-type": "application/json" });
+    });
+  });
+
+  describe("async response functions", () => {
+    it("handles async response functions", async () => {
+      const mock = schmock();
+      mock("GET /async", async () => {
+        await new Promise((resolve) => setTimeout(resolve, 1));
+        return { async: true };
+      });
+
+      const response = await mock.handle("GET", "/async");
+
+      expect(response.status).toBe(200);
+      expect(response.body).toEqual({ async: true });
+    });
+
+    it("handles async tuple responses", async () => {
+      const mock = schmock();
+      mock("POST /async-create", async () => {
+        await new Promise((resolve) => setTimeout(resolve, 1));
+        return [201, { created: true }, { "X-Async": "true" }];
+      });
+
+      const response = await mock.handle("POST", "/async-create");
+
+      expect(response.status).toBe(201);
+      expect(response.body).toEqual({ created: true });
+      expect(response.headers).toEqual({ "X-Async": "true" });
+    });
+  });
+
+  describe("edge cases", () => {
+    it("handles response with circular references gracefully", async () => {
+      const mock = schmock();
+      mock("GET /circular", () => {
+        const obj: any = { name: "test" };
+        obj.self = obj; // Create circular reference
+        return obj;
+      });
+
+      const response = await mock.handle("GET", "/circular");
+
+      expect(response.status).toBe(200);
+      expect(response.body).toHaveProperty("name", "test");
+      expect(response.body).toHaveProperty("self");
+    });
+
+    it("preserves functions in response objects", async () => {
+      const mock = schmock();
+      mock("GET /with-functions", () => ({
+        data: "test",
+        fn: () => "function result",
+      }));
+
+      const response = await mock.handle("GET", "/with-functions");
+
+      expect(response.status).toBe(200);
+      expect(response.body.data).toBe("test");
+      expect(typeof response.body.fn).toBe("function");
+      expect(response.body.fn()).toBe("function result");
+    });
+  });
+});

package/src/route-matching.test.ts

@@ -0,0 +1,351 @@
+import { describe, expect, it } from "vitest";
+import { schmock } from "./index";
+
+describe("route matching", () => {
+  describe("static routes", () => {
+    it("matches exact static routes", async () => {
+      const mock = schmock();
+      mock("GET /users", "users");
+      mock("GET /posts", "posts");
+
+      const users = await mock.handle("GET", "/users");
+      const posts = await mock.handle("GET", "/posts");
+
+      expect(users.body).toBe("users");
+      expect(posts.body).toBe("posts");
+    });
+
+    it("differentiates between HTTP methods", async () => {
+      const mock = schmock();
+      mock("GET /resource", "get-response");
+      mock("POST /resource", "post-response");
+      mock("PUT /resource", "put-response");
+      mock("DELETE /resource", "delete-response");
+
+      const getRes = await mock.handle("GET", "/resource");
+      const postRes = await mock.handle("POST", "/resource");
+      const putRes = await mock.handle("PUT", "/resource");
+      const deleteRes = await mock.handle("DELETE", "/resource");
+
+      expect(getRes.body).toBe("get-response");
+      expect(postRes.body).toBe("post-response");
+      expect(putRes.body).toBe("put-response");
+      expect(deleteRes.body).toBe("delete-response");
+    });
+
+    it("handles root path correctly", async () => {
+      const mock = schmock();
+      mock("GET /", "root");
+
+      const response = await mock.handle("GET", "/");
+      expect(response.body).toBe("root");
+    });
+
+    it("case sensitive path matching", async () => {
+      const mock = schmock();
+      mock("GET /Users", "capital-users");
+
+      const response1 = await mock.handle("GET", "/Users");
+      const response2 = await mock.handle("GET", "/users");
+
+      expect(response1.body).toBe("capital-users");
+      expect(response2.status).toBe(404);
+    });
+  });
+
+  describe("parameterized routes", () => {
+    it("matches single parameter routes", async () => {
+      const mock = schmock();
+      mock("GET /users/:id", ({ params }) => ({ userId: params.id }));
+
+      const response = await mock.handle("GET", "/users/123");
+
+      expect(response.body).toEqual({ userId: "123" });
+    });
+
+    it("matches multiple parameter routes", async () => {
+      const mock = schmock();
+      mock("GET /users/:userId/posts/:postId", ({ params }) => ({
+        user: params.userId,
+        post: params.postId,
+      }));
+
+      const response = await mock.handle("GET", "/users/456/posts/789");
+
+      expect(response.body).toEqual({ user: "456", post: "789" });
+    });
+
+    it("handles parameters with special characters", async () => {
+      const mock = schmock();
+      mock("GET /files/:filename", ({ params }) => ({ file: params.filename }));
+
+      const response = await mock.handle("GET", "/files/test-file.txt");
+
+      expect(response.body).toEqual({ file: "test-file.txt" });
+    });
+
+    it("handles parameters with numbers", async () => {
+      const mock = schmock();
+      mock("GET /items/:id", ({ params }) => ({ itemId: params.id }));
+
+      const response = await mock.handle("GET", "/items/12345");
+
+      expect(response.body).toEqual({ itemId: "12345" });
+    });
+
+    it("handles parameters with underscores and hyphens", async () => {
+      const mock = schmock();
+      mock("GET /api/:snake_case/:kebab-case", ({ params }) => params);
+
+      const response = await mock.handle(
+        "GET",
+        "/api/test_value/another-value",
+      );
+
+      expect(response.body).toEqual({
+        snake_case: "test_value",
+        "kebab-case": "another-value",
+      });
+    });
+
+    it("doesn't match if parameter segment is empty", async () => {
+      const mock = schmock();
+      mock("GET /users/:id", "found");
+
+      const response = await mock.handle("GET", "/users/");
+
+      expect(response.status).toBe(404);
+    });
+
+    it("doesn't match parameters across path segments", async () => {
+      const mock = schmock();
+      mock("GET /users/:id", "found");
+
+      const response = await mock.handle("GET", "/users/123/extra");
+
+      expect(response.status).toBe(404);
+    });
+  });
+
+  describe("route precedence and conflicts", () => {
+    it("matches most recently defined route when patterns overlap", async () => {
+      const mock = schmock();
+      mock("GET /users/:id", "parameterized");
+      mock("GET /users/special", "static");
+
+      const paramResponse = await mock.handle("GET", "/users/123");
+      const staticResponse = await mock.handle("GET", "/users/special");
+
+      // The static route should be matched since it was defined later
+      expect(paramResponse.body).toBe("parameterized");
+      expect(staticResponse.body).toBe("static");
+    });
+
+    it("handles exact vs parameterized route conflicts", async () => {
+      const mock = schmock();
+      mock("GET /api/:version/users", "versioned");
+      mock("GET /api/v1/users", "v1-specific");
+
+      const versionedResponse = await mock.handle("GET", "/api/v2/users");
+      const v1Response = await mock.handle("GET", "/api/v1/users");
+
+      expect(versionedResponse.body).toBe("versioned");
+      expect(v1Response.body).toBe("v1-specific");
+    });
+
+    it("matches first matching route in definition order", async () => {
+      const mock = schmock();
+      mock("GET /:type/items", "first");
+      mock("GET /shop/:category", "second");
+
+      const response = await mock.handle("GET", "/shop/items");
+
+      // Both routes match, but with reverse order search, the second route should win
+      // /:type/items matches with type="shop"
+      // /shop/:category matches with category="items"
+      // Since we search in reverse, /shop/:category (more specific) should match
+      expect(response.body).toBe("second");
+    });
+  });
+
+  describe("complex path patterns", () => {
+    it("handles deeply nested parameterized routes", async () => {
+      const mock = schmock();
+      mock(
+        "GET /api/:version/users/:userId/posts/:postId/comments/:commentId",
+        ({ params }) => params,
+      );
+
+      const response = await mock.handle(
+        "GET",
+        "/api/v1/users/123/posts/456/comments/789",
+      );
+
+      expect(response.body).toEqual({
+        version: "v1",
+        userId: "123",
+        postId: "456",
+        commentId: "789",
+      });
+    });
+
+    it("handles mixed static and parameterized segments", async () => {
+      const mock = schmock();
+      mock(
+        "GET /api/v1/users/:userId/profile/settings/:setting",
+        ({ params }) => params,
+      );
+
+      const response = await mock.handle(
+        "GET",
+        "/api/v1/users/789/profile/settings/privacy",
+      );
+
+      expect(response.body).toEqual({
+        userId: "789",
+        setting: "privacy",
+      });
+    });
+
+    it("handles paths with similar prefixes", async () => {
+      const mock = schmock();
+      mock("GET /user", "single-user");
+      mock("GET /users", "all-users");
+      mock("GET /users/:id", "specific-user");
+
+      const singleResponse = await mock.handle("GET", "/user");
+      const allResponse = await mock.handle("GET", "/users");
+      const specificResponse = await mock.handle("GET", "/users/123");
+
+      expect(singleResponse.body).toBe("single-user");
+      expect(allResponse.body).toBe("all-users");
+      expect(specificResponse.body).toBe("specific-user");
+    });
+  });
+
+  describe("edge cases", () => {
+    it("handles empty parameter values correctly", async () => {
+      const mock = schmock();
+      mock("GET /search/:query", ({ params }) => ({ query: params.query }));
+
+      // This should not match because parameter is empty
+      const response = await mock.handle("GET", "/search/");
+
+      expect(response.status).toBe(404);
+    });
+
+    it("handles special characters in paths", async () => {
+      const mock = schmock();
+      mock("GET /files/:filename", ({ params }) => ({ file: params.filename }));
+
+      const response = await mock.handle("GET", "/files/my-file.test.json");
+
+      expect(response.body).toEqual({ file: "my-file.test.json" });
+    });
+
+    it("handles URL encoded characters in parameters", async () => {
+      const mock = schmock();
+      mock("GET /search/:query", ({ params }) => ({ query: params.query }));
+
+      // Note: This tests the raw parameter, URL decoding would happen at HTTP layer
+      const response = await mock.handle("GET", "/search/hello%20world");
+
+      expect(response.body).toEqual({ query: "hello%20world" });
+    });
+
+    it("handles very long parameter values", async () => {
+      const mock = schmock();
+      mock("GET /data/:id", ({ params }) => ({ length: params.id.length }));
+
+      const longId = "a".repeat(1000);
+      const response = await mock.handle("GET", `/data/${longId}`);
+
+      expect(response.body).toEqual({ length: 1000 });
+    });
+
+    it("handles numeric parameter values", async () => {
+      const mock = schmock();
+      mock("GET /items/:id", ({ params }) => ({
+        id: params.id,
+        type: typeof params.id,
+        parsed: Number.parseInt(params.id),
+      }));
+
+      const response = await mock.handle("GET", "/items/12345");
+
+      expect(response.body).toEqual({
+        id: "12345",
+        type: "string",
+        parsed: 12345,
+      });
+    });
+  });
+
+  describe("no route found scenarios", () => {
+    it("returns 404 for completely unmatched paths", async () => {
+      const mock = schmock();
+      mock("GET /existing", "found");
+
+      const response = await mock.handle("GET", "/nonexistent");
+
+      expect(response.status).toBe(404);
+      expect(response.body.error).toContain("Route not found");
+      expect(response.body.code).toBe("ROUTE_NOT_FOUND");
+    });
+
+    it("returns 404 for wrong HTTP method", async () => {
+      const mock = schmock();
+      mock("GET /resource", "get-only");
+
+      const response = await mock.handle("POST", "/resource");
+
+      expect(response.status).toBe(404);
+      expect(response.body.error).toContain("POST /resource");
+    });
+
+    it("returns 404 for partial path matches", async () => {
+      const mock = schmock();
+      mock("GET /api/users", "found");
+
+      const response1 = await mock.handle("GET", "/api");
+      const response2 = await mock.handle("GET", "/api/users/extra");
+
+      expect(response1.status).toBe(404);
+      expect(response2.status).toBe(404);
+    });
+  });
+
+  describe("regex pattern validation", () => {
+    it("escapes special regex characters in static paths", async () => {
+      const mock = schmock();
+      mock("GET /api/test.json", "json-file");
+      mock("GET /api/test*json", "wildcard-file");
+
+      const jsonResponse = await mock.handle("GET", "/api/test.json");
+      const wildcardResponse = await mock.handle("GET", "/api/test*json");
+      const dotResponse = await mock.handle("GET", "/api/testXjson"); // Should not match
+
+      expect(jsonResponse.body).toBe("json-file");
+      expect(wildcardResponse.body).toBe("wildcard-file");
+      expect(dotResponse.status).toBe(404);
+    });
+
+    it("handles paths with parentheses", async () => {
+      const mock = schmock();
+      mock("GET /api/(v1)/users", "versioned");
+
+      const response = await mock.handle("GET", "/api/(v1)/users");
+
+      expect(response.body).toBe("versioned");
+    });
+
+    it("handles paths with square brackets", async () => {
+      const mock = schmock();
+      mock("GET /api/[admin]/users", "admin-users");
+
+      const response = await mock.handle("GET", "/api/[admin]/users");
+
+      expect(response.body).toBe("admin-users");
+    });
+  });
+});