@schmock/core 2.2.3 → 2.3.1

package/src/steps/basic-usage.steps.ts

@@ -1,245 +0,0 @@
-import { describeFeature, loadFeature } from "@amiceli/vitest-cucumber";
-import { expect } from "vitest";
-import type { CallableMockInstance } from "../types";
-import { schmock } from "../index";
-
-const feature = await loadFeature("../../features/basic-usage.feature");
-
-describeFeature(feature, ({ Scenario }) => {
-  let mock: CallableMockInstance;
-  let response: any;
-
-  Scenario("Simplest possible mock - plain text", ({ Given, When, Then, And }) => {
-    Given("I create a plain text mock returning {string} at {string}", (_, text: string, route: string) => {
-      const [method, path] = route.split(" ");
-      mock = schmock();
-      mock(`${method} ${path}` as Schmock.RouteKey, text);
-    });
-
-    When("I request {string}", async (_, request: string) => {
-      const [method, path] = request.split(" ");
-      response = await mock.handle(method as any, path);
-    });
-
-    Then("I should receive text {string}", (_, expectedText: string) => {
-      expect(response.body).toBe(expectedText);
-    });
-
-    And("the content-type should be {string}", (_, contentType: string) => {
-      expect(response.headers?.["content-type"]).toBe(contentType);
-    });
-  });
-
-  Scenario("Return JSON without specifying contentType", ({ Given, When, Then, And }) => {
-    Given("I create a mock returning a JSON array at {string}", (_, route: string) => {
-      const [method, path] = route.split(" ");
-      mock = schmock();
-      mock(`${method} ${path}` as Schmock.RouteKey, [{ id: 1, name: "John" }]);
-    });
-
-    When("I request {string}", async (_, request: string) => {
-      const [method, path] = request.split(" ");
-      response = await mock.handle(method as any, path);
-    });
-
-    Then("I should receive:", (_, docString: string) => {
-      const expected = JSON.parse(docString);
-      expect(response.body).toEqual(expected);
-    });
-
-    And("the content-type should be {string}", (_, contentType: string) => {
-      expect(response.headers?.["content-type"]).toBe(contentType);
-    });
-  });
-
-  Scenario("Return object without contentType", ({ Given, When, Then, And }) => {
-    Given("I create a mock returning a JSON object at {string}", (_, route: string) => {
-      const [method, path] = route.split(" ");
-      mock = schmock();
-      mock(`${method} ${path}` as Schmock.RouteKey, { id: 1, name: "John" });
-    });
-
-    When("I request {string}", async (_, request: string) => {
-      const [method, path] = request.split(" ");
-      response = await mock.handle(method as any, path);
-    });
-
-    Then("I should receive:", (_, docString: string) => {
-      const expected = JSON.parse(docString);
-      expect(response.body).toEqual(expected);
-    });
-
-    And("the content-type should be {string}", (_, contentType: string) => {
-      expect(response.headers?.["content-type"]).toBe(contentType);
-    });
-  });
-
-  Scenario("Empty mock instance", ({ Given, When, Then }) => {
-    Given("I create an empty mock with no routes", () => {
-      mock = schmock();
-    });
-
-    When("I request {string}", async (_, request: string) => {
-      const [method, path] = request.split(" ");
-      response = await mock.handle(method as any, path);
-    });
-
-    Then("the status should be {int}", (_, status: number) => {
-      expect(response.status).toBe(status);
-    });
-  });
-
-  Scenario("Null response", ({ Given, When, Then, And }) => {
-    Given("I create a mock returning null at {string}", (_, route: string) => {
-      const [method, path] = route.split(" ");
-      mock = schmock();
-      mock(`${method} ${path}` as Schmock.RouteKey, null);
-    });
-
-    When("I request {string}", async (_, request: string) => {
-      const [method, path] = request.split(" ");
-      response = await mock.handle(method as any, path);
-    });
-
-    Then("I should receive empty response", () => {
-      expect(response.body).toBeUndefined();
-    });
-
-    And("the status should be {int}", (_, status: number) => {
-      expect(response.status).toBe(status);
-    });
-  });
-
-  Scenario("Function returning string", ({ Given, When, Then }) => {
-    Given("I create a mock with a string generator at {string}", (_, route: string) => {
-      const [method, path] = route.split(" ");
-      mock = schmock();
-      mock(`${method} ${path}` as Schmock.RouteKey, () => "Dynamic response");
-    });
-
-    When("I request {string}", async (_, request: string) => {
-      const [method, path] = request.split(" ");
-      response = await mock.handle(method as any, path);
-    });
-
-    Then("I should receive text {string}", (_, expectedText: string) => {
-      expect(response.body).toBe(expectedText);
-    });
-  });
-
-  Scenario("Function returning object", ({ Given, When, Then, And }) => {
-    Given("I create a mock with an object generator at {string}", (_, route: string) => {
-      const [method, path] = route.split(" ");
-      mock = schmock();
-      mock(`${method} ${path}` as Schmock.RouteKey, () => ({ timestamp: Date.now() }));
-    });
-
-    When("I request {string}", async (_, request: string) => {
-      const [method, path] = request.split(" ");
-      response = await mock.handle(method as any, path);
-    });
-
-    Then("the response should be valid JSON", () => {
-      expect(() => JSON.parse(JSON.stringify(response.body))).not.toThrow();
-    });
-
-    And("the response should have property {string}", (_, property: string) => {
-      expect(response.body).toHaveProperty(property);
-    });
-  });
-
-  Scenario("Multiple routes", ({ Given, When, Then, And }) => {
-    let homeResponse: any;
-    let aboutResponse: any;
-    let contactResponse: any;
-
-    Given("I create a mock with three routes", () => {
-      mock = schmock();
-      mock("GET /", "Home");
-      mock("GET /about", "About Us");
-      mock("GET /contact", { email: "test@example.com" });
-    });
-
-    When("I make three requests to different routes", async () => {
-      homeResponse = await mock.handle("GET", "/");
-      aboutResponse = await mock.handle("GET", "/about");
-      contactResponse = await mock.handle("GET", "/contact");
-    });
-
-    Then("the home route should return {string}", (_, expectedText: string) => {
-      expect(homeResponse.body).toBe(expectedText);
-    });
-
-    And("the about route should return {string}", (_, expectedText: string) => {
-      expect(aboutResponse.body).toBe(expectedText);
-    });
-
-    And("the contact route should return:", (_, docString: string) => {
-      const expected = JSON.parse(docString);
-      expect(contactResponse.body).toEqual(expected);
-    });
-  });
-
-  Scenario("Override contentType detection", ({ Given, When, Then, And }) => {
-    Given("I create a mock with explicit text/plain contentType at {string}", (_, route: string) => {
-      const [method, path] = route.split(" ");
-      mock = schmock();
-      mock(`${method} ${path}` as Schmock.RouteKey, { foo: "bar" }, { contentType: "text/plain" });
-    });
-
-    When("I request {string}", async (_, request: string) => {
-      const [method, path] = request.split(" ");
-      response = await mock.handle(method as any, path);
-    });
-
-    Then("I should receive text {string}", (_, expectedText: string) => {
-      expect(response.body).toBe(expectedText);
-    });
-
-    And("the content-type should be {string}", (_, contentType: string) => {
-      expect(response.headers?.["content-type"]).toBe(contentType);
-    });
-  });
-
-  Scenario("HTML response", ({ Given, When, Then, And }) => {
-    Given("I create a mock returning HTML at {string}", (_, route: string) => {
-      const [method, path] = route.split(" ");
-      mock = schmock();
-      mock(`${method} ${path}` as Schmock.RouteKey, "<h1>Hello</h1>", { contentType: "text/html" });
-    });
-
-    When("I request {string}", async (_, request: string) => {
-      const [method, path] = request.split(" ");
-      response = await mock.handle(method as any, path);
-    });
-
-    Then("I should receive text {string}", (_, expectedText: string) => {
-      expect(response.body).toBe(expectedText);
-    });
-
-    And("the content-type should be {string}", (_, contentType: string) => {
-      expect(response.headers?.["content-type"]).toBe(contentType);
-    });
-  });
-
-  Scenario("Binary/buffer response detection", ({ Given, When, Then, And }) => {
-    Given("I create a mock returning a Buffer at {string}", (_, route: string) => {
-      const [method, path] = route.split(" ");
-      mock = schmock();
-      mock(`${method} ${path}` as Schmock.RouteKey, Buffer.from("binary data") as unknown as Schmock.Generator);
-    });
-
-    When("I request {string}", async (_, request: string) => {
-      const [method, path] = request.split(" ");
-      response = await mock.handle(method as any, path);
-    });
-
-    Then("I should receive buffer data", () => {
-      expect(Buffer.isBuffer(response.body)).toBe(true);
-    });
-
-    And("the content-type should be {string}", (_, contentType: string) => {
-      expect(response.headers?.["content-type"]).toBe(contentType);
-    });
-  });
-});

package/src/steps/developer-experience.steps.ts

@@ -1,204 +0,0 @@
-import { describeFeature, loadFeature } from "@amiceli/vitest-cucumber";
-import { expect } from "vitest";
-import { schmock } from "../index";
-import type { CallableMockInstance, Plugin, PluginContext } from "../types";
-
-const feature = await loadFeature("../../features/developer-experience.feature");
-
-describeFeature(feature, ({ Scenario }) => {
-  let mock: CallableMockInstance;
-  let response: any;
-  let responses: any[] = [];
-
-  Scenario("State confusion between global and local state", ({ Given, When, Then, And }) => {
-    Given("I create a mock with global state and a local state counter", () => {
-      mock = schmock({ state: { global: 1 } });
-      mock("GET /counter", ({ state }) => {
-        const current = (state.local as number | undefined) || 0;
-        state.local = current + 1;
-        return { global: state.global, local: state.local };
-      });
-    });
-
-    When("I request {string} twice", async (_, request: string) => {
-      const [method, path] = request.split(" ");
-      responses = [];
-      responses.push(await mock.handle(method as any, path));
-      responses.push(await mock.handle(method as any, path));
-    });
-
-    Then("the first response should have:", (_, docString: string) => {
-      const expected = JSON.parse(docString);
-      expect(responses[0].body).toEqual(expected);
-    });
-
-    And("the second response should have:", (_, docString: string) => {
-      const expected = JSON.parse(docString);
-      expect(responses[1].body).toEqual(expected);
-    });
-  });
-
-  Scenario("Route precedence with similar paths", ({ Given, When, Then, And }) => {
-    Given("I create a mock with an exact route and a parameterized route on {string}", (_, basePath: string) => {
-      mock = schmock();
-      mock(`GET ${basePath}/profile`, { type: "profile" });
-      mock(`GET ${basePath}/:id`, ({ params }) => ({ type: "user", id: params.id }));
-    });
-
-    When("I test both route precedence scenarios", async () => {
-      responses = [];
-      responses.push(await mock.handle("GET", "/users/profile"));
-      responses.push(await mock.handle("GET", "/users/123"));
-    });
-
-    Then("the profile route should return exact match:", (_, docString: string) => {
-      const expected = JSON.parse(docString);
-      expect(responses[0].body).toEqual(expected);
-    });
-
-    And("the parameterized route should match with param:", (_, docString: string) => {
-      const expected = JSON.parse(docString);
-      expect(responses[1].body).toEqual(expected);
-    });
-  });
-
-  Scenario("Plugin order affecting results", ({ Given, When, Then }) => {
-    Given("I create a mock with two plugins that each set a step number", () => {
-      mock = schmock();
-      const plugin1: Plugin = {
-        name: "first",
-        process: (ctx: PluginContext, response: unknown) => ({
-          context: ctx,
-          response: { ...(response as Record<string, unknown>), step: 1 },
-        }),
-      };
-      const plugin2: Plugin = {
-        name: "second",
-        process: (ctx: PluginContext, response: unknown) => ({
-          context: ctx,
-          response: { ...(response as Record<string, unknown>), step: 2 },
-        }),
-      };
-      mock("GET /order", { original: true }).pipe(plugin1).pipe(plugin2);
-    });
-
-    When("I request {string}", async (_, request: string) => {
-      const [method, path] = request.split(" ");
-      response = await mock.handle(method as any, path);
-    });
-
-    Then("I should receive:", (_, docString: string) => {
-      const expected = JSON.parse(docString);
-      expect(response.body).toEqual(expected);
-    });
-  });
-
-  Scenario("Plugin expecting different context structure", ({ Given, When, Then }) => {
-    Given("I create a mock with a plugin that reads context properties", () => {
-      mock = schmock();
-      const plugin: Plugin = {
-        name: "context-reader",
-        process: (ctx: PluginContext, _response: unknown) => ({
-          context: ctx,
-          response: {
-            method: ctx.method,
-            path: ctx.path,
-            hasBody: !!ctx.body,
-            hasQuery: !!ctx.query && Object.keys(ctx.query).length > 0,
-          },
-        }),
-      };
-      mock("POST /analyze", null).pipe(plugin);
-    });
-
-    When("I request {string} with body:", async (_, request: string, docString: string) => {
-      const [method, fullPath] = request.split(" ");
-      const [path, queryString] = fullPath.split("?");
-
-      const query: Record<string, string> = {};
-      if (queryString) {
-        queryString.split("&").forEach((param) => {
-          const [key, value] = param.split("=");
-          query[key] = value || "";
-        });
-      }
-
-      const body = JSON.parse(docString);
-      response = await mock.handle(method as any, path, { body, query });
-    });
-
-    Then("I should receive:", (_, docString: string) => {
-      const expected = JSON.parse(docString);
-      expect(response.body).toEqual(expected);
-    });
-  });
-
-  Scenario("Response tuple format edge cases", ({ Given, When, Then, And }) => {
-    Given("I create a mock with three tuple response routes", () => {
-      mock = schmock();
-      mock("GET /created", [201, null]);
-      mock("GET /with-headers", [200, { data: true }, { "x-custom": "header" }]);
-      mock("GET /empty-with-status", [204, null]);
-    });
-
-    When("I test all tuple response formats", async () => {
-      responses = [];
-      responses.push(await mock.handle("GET", "/created"));
-      responses.push(await mock.handle("GET", "/with-headers"));
-      responses.push(await mock.handle("GET", "/empty-with-status"));
-    });
-
-    Then("the created endpoint should return status 201 with empty body", () => {
-      expect(responses[0].status).toBe(201);
-      expect(responses[0].body).toBeUndefined();
-    });
-
-    And("the headers endpoint should return status 200 with data and custom header", () => {
-      expect(responses[1].status).toBe(200);
-      expect(responses[1].body).toEqual({ data: true });
-      expect(responses[1].headers?.["x-custom"]).toBe("header");
-    });
-
-    And("the empty endpoint should return status 204 with null body", () => {
-      expect(responses[2].status).toBe(204);
-      expect(responses[2].body).toBeUndefined();
-    });
-  });
-
-  Scenario("Registering duplicate routes first route wins", ({ Given, When, Then }) => {
-    Given("I create a mock with two routes on {string} with different data", (_, route: string) => {
-      mock = schmock();
-      mock(route as Schmock.RouteKey, [{ id: 1 }]);
-      mock(route as Schmock.RouteKey, [{ id: 2 }]);
-    });
-
-    When("I request {string}", async (_, request: string) => {
-      const [method, path] = request.split(" ");
-      response = await mock.handle(method as any, path);
-    });
-
-    Then("the first route response should win:", (_, docString: string) => {
-      const expected = JSON.parse(docString);
-      expect(response.body).toEqual(expected);
-    });
-  });
-
-  Scenario("Duplicate routes are not duplicated in getRoutes()", ({ Given, When, Then }) => {
-    let routesList: ReturnType<typeof mock.getRoutes>;
-
-    Given("I create a mock with two routes on {string} with different data", (_, route: string) => {
-      mock = schmock();
-      mock(route as Schmock.RouteKey, [{ id: 1 }]);
-      mock(route as Schmock.RouteKey, [{ id: 2 }]);
-    });
-
-    When("I call getRoutes", () => {
-      routesList = mock.getRoutes();
-    });
-
-    Then("only one route entry is returned", () => {
-      expect(routesList).toHaveLength(1);
-    });
-  });
-
-});