@schmock/core 2.3.0 → 2.4.0

package/src/steps/http-methods.steps.ts

@@ -1,342 +0,0 @@
-import { describeFeature, loadFeature } from "@amiceli/vitest-cucumber";
-import { expect } from "vitest";
-import { schmock } from "../index";
-import type { CallableMockInstance, Plugin } from "../types";
-
-const feature = await loadFeature("../../features/http-methods.feature");
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-
-describeFeature(feature, ({ Scenario }) => {
-  let mock: CallableMockInstance;
-  let response: any;
-  let responses: any[] = [];
-
-  Scenario("GET method with query parameters", ({ Given, When, Then }) => {
-    Given("I create a mock with a GET search endpoint", () => {
-      mock = schmock();
-      mock('GET /search', ({ query }) => ({
-        results: [],
-        query: query.q,
-        page: parseInt(query.page || '1'),
-        limit: parseInt(query.limit || '10'),
-      }));
-    });
-
-    When("I make a GET request to {string}", async (_, path: string) => {
-      const [pathname, queryString] = path.split("?");
-      const query: Record<string, string> = {};
-      if (queryString) {
-        queryString.split("&").forEach((param) => {
-          const [key, value] = param.split("=");
-          query[key] = value;
-        });
-      }
-      response = await mock.handle('GET', pathname, { query });
-    });
-
-    Then("I should receive GET method response:", (_, docString: string) => {
-      const expected = JSON.parse(docString);
-      expect(response.body).toEqual(expected);
-    });
-  });
-
-  Scenario("POST method with JSON body", ({ Given, When, Then, And }) => {
-    Given("I create a mock with a POST users endpoint", () => {
-      mock = schmock();
-      mock('POST /users', ({ body }) => [201, {
-        id: 123,
-        ...(body as Record<string, unknown>),
-        createdAt: '2023-01-01T00:00:00Z',
-      }]);
-    });
-
-    When("I make a POST request to {string} with JSON body:", async (_, path: string, docString: string) => {
-      const body = JSON.parse(docString);
-      response = await mock.handle('POST', path, { body });
-    });
-
-    Then("I should receive status {int}", (_, status: number) => {
-      expect(response.status).toBe(status);
-    });
-
-    And("I should receive POST method response:", (_, docString: string) => {
-      const expected = JSON.parse(docString);
-      expect(response.body).toEqual(expected);
-    });
-  });
-
-  Scenario("PUT method for resource updates", ({ Given, When, Then }) => {
-    Given("I create a mock with a PUT users endpoint", () => {
-      mock = schmock();
-      mock('PUT /users/:id', ({ params, body }) => ({
-        id: parseInt(params.id),
-        ...(body as Record<string, unknown>),
-        updatedAt: '2023-01-01T00:00:00Z',
-      }));
-    });
-
-    When("I make a PUT request to {string} with JSON body:", async (_, path: string, docString: string) => {
-      const body = JSON.parse(docString);
-      response = await mock.handle('PUT', path, { body });
-    });
-
-    Then("I should receive PUT method response:", (_, docString: string) => {
-      const expected = JSON.parse(docString);
-      expect(response.body).toEqual(expected);
-    });
-  });
-
-  Scenario("DELETE method with confirmation", ({ Given, When, Then, And }) => {
-    Given("I create a mock with a DELETE users endpoint", () => {
-      mock = schmock();
-      mock('DELETE /users/:id', ({ params }) => [204, null]);
-    });
-
-    When("I make a DELETE request to {string}", async (_, path: string) => {
-      response = await mock.handle('DELETE', path);
-    });
-
-    Then("I should receive status {int}", (_, status: number) => {
-      expect(response.status).toBe(status);
-    });
-
-    And("the DELETE response body should be empty", () => {
-      expect(response.body).toBeUndefined();
-    });
-  });
-
-  Scenario("PATCH method for partial updates", ({ Given, When, Then }) => {
-    Given("I create a mock with a PATCH users endpoint", () => {
-      mock = schmock();
-      mock('PATCH /users/:id', ({ params, body }) => ({
-        id: parseInt(params.id),
-        email: 'existing@example.com',
-        ...(body as Record<string, unknown>),
-        updatedAt: '2023-01-01T00:00:00Z',
-      }));
-    });
-
-    When("I make a PATCH request to {string} with JSON body:", async (_, path: string, docString: string) => {
-      const body = JSON.parse(docString);
-      response = await mock.handle('PATCH', path, { body });
-    });
-
-    Then("I should receive PATCH method response:", (_, docString: string) => {
-      const expected = JSON.parse(docString);
-      expect(response.body).toEqual(expected);
-    });
-  });
-
-  Scenario("HEAD method returns headers only", ({ Given, When, Then, And }) => {
-    Given("I create a mock with a HEAD users endpoint", () => {
-      mock = schmock();
-      mock('HEAD /users/:id', ({ params }) => [200, null, {
-        'Content-Type': 'application/json',
-        'Last-Modified': 'Wed, 01 Jan 2023 00:00:00 GMT',
-        'Content-Length': '156',
-      }]);
-    });
-
-    When("I make a HEAD request to {string}", async (_, path: string) => {
-      response = await mock.handle('HEAD', path);
-    });
-
-    Then("I should receive status {int}", (_, status: number) => {
-      expect(response.status).toBe(status);
-    });
-
-    And("the HEAD response body should be empty", () => {
-      expect(response.body).toBeUndefined();
-    });
-
-    And("the HEAD response should have proper headers set", () => {
-      expect(response.headers?.['Content-Type']).toBe('application/json');
-      expect(response.headers?.['Last-Modified']).toBe('Wed, 01 Jan 2023 00:00:00 GMT');
-      expect(response.headers?.['Content-Length']).toBe('156');
-    });
-  });
-
-  Scenario("OPTIONS method for CORS preflight", ({ Given, When, Then, And }) => {
-    Given("I create a mock with an OPTIONS users endpoint", () => {
-      mock = schmock();
-      mock('OPTIONS /api/users', () => [200, null, {
-        'Access-Control-Allow-Origin': '*',
-        'Access-Control-Allow-Methods': 'GET, POST, PUT, DELETE, PATCH, OPTIONS',
-        'Access-Control-Allow-Headers': 'Content-Type, Authorization',
-      }]);
-    });
-
-    When("I make an OPTIONS request to {string}", async (_, path: string) => {
-      response = await mock.handle('OPTIONS', path);
-    });
-
-    Then("I should receive status {int}", (_, status: number) => {
-      expect(response.status).toBe(status);
-    });
-
-    And("the OPTIONS response body should be empty", () => {
-      expect(response.body).toBeUndefined();
-    });
-
-    And("the OPTIONS response should have header {string} with value {string}", (_, headerName: string, headerValue: string) => {
-      expect(response.headers?.[headerName]).toBe(headerValue);
-    });
-  });
-
-  Scenario("Multiple methods on same path", ({ Given, When, Then, And }) => {
-    Given("I create a mock with GET, POST, PUT, and DELETE on the same path", () => {
-      mock = schmock();
-      mock('GET /resource', { action: 'read' });
-      mock('POST /resource', { action: 'create' });
-      mock('PUT /resource', { action: 'update' });
-      mock('DELETE /resource', { action: 'delete' });
-    });
-
-    When("I test all methods on {string}", async (_, path: string) => {
-      responses = [];
-      responses.push(await mock.handle('GET', path));
-      responses.push(await mock.handle('POST', path));
-      responses.push(await mock.handle('PUT', path));
-      responses.push(await mock.handle('DELETE', path));
-    });
-
-    Then("the GET method should return:", (_, docString: string) => {
-      const expected = JSON.parse(docString);
-      expect(responses[0].body).toEqual(expected);
-    });
-
-    And("the POST method should return:", (_, docString: string) => {
-      const expected = JSON.parse(docString);
-      expect(responses[1].body).toEqual(expected);
-    });
-
-    And("the PUT method should return:", (_, docString: string) => {
-      const expected = JSON.parse(docString);
-      expect(responses[2].body).toEqual(expected);
-    });
-
-    And("the DELETE method should return:", (_, docString: string) => {
-      const expected = JSON.parse(docString);
-      expect(responses[3].body).toEqual(expected);
-    });
-  });
-
-  Scenario("Method-specific content types", ({ Given, When, Then, And }) => {
-    Given("I create a mock with JSON, XML, text, and upload endpoints", () => {
-      mock = schmock();
-      mock('GET /data.json', { data: 'json' });
-      mock('GET /data.xml', '<data>xml</data>', { contentType: 'application/xml' });
-      mock('GET /data.txt', 'plain text data');
-      mock('POST /upload', 'File uploaded successfully', { contentType: 'text/plain' });
-    });
-
-    When("I test method-specific content types", async () => {
-      responses = [];
-      responses.push(await mock.handle('GET', '/data.json'));
-      responses.push(await mock.handle('GET', '/data.xml'));
-      responses.push(await mock.handle('GET', '/data.txt'));
-      responses.push(await mock.handle('POST', '/upload'));
-    });
-
-    Then("the JSON endpoint should have content-type {string}", (_, contentType: string) => {
-      expect(responses[0].headers?.["content-type"]).toBe(contentType);
-    });
-
-    And("the XML endpoint should have content-type {string}", (_, contentType: string) => {
-      expect(responses[1].headers?.["content-type"]).toBe(contentType);
-    });
-
-    And("the text endpoint should have content-type {string}", (_, contentType: string) => {
-      expect(responses[2].headers?.["content-type"]).toBe(contentType);
-    });
-
-    And("the upload endpoint should have content-type {string}", (_, contentType: string) => {
-      expect(responses[3].headers?.["content-type"]).toBe(contentType);
-    });
-  });
-
-  Scenario("Method with request headers validation", ({ Given, When, Then, And }) => {
-    Given("I create a mock with authorization header checking", () => {
-      mock = schmock();
-      mock('POST /secure', ({ headers, body }) => {
-        if (headers.authorization !== 'Bearer valid-token') {
-          return [401, { error: 'Unauthorized' }];
-        }
-        return [200, { message: 'Success', data: body }];
-      });
-    });
-
-    When("I make a POST request with valid headers", async () => {
-      response = await mock.handle('POST', '/secure', {
-        headers: { authorization: 'Bearer valid-token' },
-        body: { test: true }
-      });
-    });
-
-    Then("I should receive authorized response:", (_, docString: string) => {
-      const expected = JSON.parse(docString);
-      expect(response.body).toEqual(expected);
-    });
-
-    When("I make a POST request with invalid headers", async () => {
-      response = await mock.handle('POST', '/secure', {
-        headers: { authorization: 'Bearer invalid-token' },
-        body: { test: true }
-      });
-    });
-
-    Then("I should receive status {int}", (_, status: number) => {
-      expect(response.status).toBe(status);
-    });
-
-    And("I should receive unauthorized response:", (_, docString: string) => {
-      const expected = JSON.parse(docString);
-      expect(response.body).toEqual(expected);
-    });
-  });
-
-  Scenario("Method chaining with plugins", ({ Given, When, Then, And }) => {
-    Given("I create a mock with a logger plugin on GET and POST", () => {
-      mock = schmock();
-      const loggerPlugin: Plugin = {
-        name: 'method-logger',
-        process: (ctx, pluginResponse) => {
-          if (!isRecord(pluginResponse)) {
-            throw new Error(
-              "Expected the logger plugin response to be an object",
-            );
-          }
-          return {
-            context: ctx,
-            response: {
-              ...pluginResponse,
-              method: ctx.method,
-              logged: true,
-            },
-          };
-        },
-      };
-      mock('GET /logged', { data: 'get' }).pipe(loggerPlugin);
-      mock('POST /logged', { data: 'post' }).pipe(loggerPlugin);
-    });
-
-    When("I test method chaining with plugins", async () => {
-      responses = [];
-      responses.push(await mock.handle('GET', '/logged'));
-      responses.push(await mock.handle('POST', '/logged'));
-    });
-
-    Then("the GET with plugin should return:", (_, docString: string) => {
-      const expected = JSON.parse(docString);
-      expect(responses[0].body).toEqual(expected);
-    });
-
-    And("the POST with plugin should return:", (_, docString: string) => {
-      const expected = JSON.parse(docString);
-      expect(responses[1].body).toEqual(expected);
-    });
-  });
-});

package/src/steps/lifecycle-events.steps.ts

@@ -1,149 +0,0 @@
-import { describeFeature, loadFeature } from "@amiceli/vitest-cucumber";
-import { expect } from "vitest";
-import { schmock } from "../index";
-
-const feature = await loadFeature("../../features/lifecycle-events.feature");
-
-describeFeature(feature, ({ Scenario }) => {
-  let mock: Schmock.CallableMockInstance;
-  let events: Array<{ type: string; data: unknown }>;
-  let removedFired: boolean;
-
-  function collectEvent(type: string) {
-    return (data: unknown) => {
-      events.push({ type, data });
-    };
-  }
-
-  function isRecord(value: unknown): value is Record<string, unknown> {
-    return typeof value === "object" && value !== null;
-  }
-
-  function eventData(type: string): Record<string, unknown> {
-    const event = events.find((candidate) => candidate.type === type);
-    expect(event).toBeDefined();
-    if (!event || !isRecord(event.data)) {
-      throw new Error(`Expected object payload for ${type}`);
-    }
-    return event.data;
-  }
-
-  Scenario("Events fire at correct times", ({ Given, And, When, Then }) => {
-    Given('a mock with a route "GET /items"', () => {
-      mock = schmock({ state: {} });
-      mock("GET /items", [{ id: 1 }], {});
-    });
-
-    And("I register listeners for all events", () => {
-      events = [];
-      mock.on("request:start", collectEvent("request:start"));
-      mock.on("request:match", collectEvent("request:match"));
-      mock.on("request:notfound", collectEvent("request:notfound"));
-      mock.on("request:end", collectEvent("request:end"));
-    });
-
-    When('I request "GET /items"', async () => {
-      await mock.handle("GET", "/items");
-    });
-
-    Then("the event order should be {string}", (_, expectedOrder: string) => {
-      expect(events.map((event) => event.type)).toEqual(
-        expectedOrder.split(","),
-      );
-    });
-
-    And('the "request:match" event fired with routePath "/items"', () => {
-      expect(eventData("request:match").routePath).toBe("/items");
-    });
-
-    And('the "request:end" event fired with status 200', () => {
-      expect(eventData("request:end").status).toBe(200);
-    });
-  });
-
-  Scenario(
-    "Not found event fires for unmatched routes",
-    ({ Given, And, When, Then }) => {
-      Given('a mock with a route "GET /items"', () => {
-        mock = schmock({ state: {} });
-        mock("GET /items", [{ id: 1 }], {});
-      });
-
-      And("I register listeners for all events", () => {
-        events = [];
-        mock.on("request:start", collectEvent("request:start"));
-        mock.on("request:match", collectEvent("request:match"));
-        mock.on("request:notfound", collectEvent("request:notfound"));
-        mock.on("request:end", collectEvent("request:end"));
-      });
-
-      When('I request "GET /missing"', async () => {
-        await mock.handle("GET", "/missing");
-      });
-
-      Then("the event order should be {string}", (_, expectedOrder: string) => {
-        expect(events.map((event) => event.type)).toEqual(
-          expectedOrder.split(","),
-        );
-      });
-
-      And('the "request:end" event fired with status 404', () => {
-        expect(eventData("request:end").status).toBe(404);
-      });
-    },
-  );
-
-  Scenario("Off removes listener", ({ Given, And, When, Then }) => {
-    Given('a mock with a route "GET /items"', () => {
-      mock = schmock({ state: {} });
-      mock("GET /items", [{ id: 1 }], {});
-    });
-
-    And("I register and remove a listener", () => {
-      removedFired = false;
-      const listener = () => {
-        removedFired = true;
-      };
-      mock.on("request:start", listener);
-      mock.off("request:start", listener);
-    });
-
-    When('I request "GET /items"', async () => {
-      await mock.handle("GET", "/items");
-    });
-
-    Then("the removed listener did not fire", () => {
-      expect(removedFired).toBe(false);
-    });
-  });
-
-  Scenario("Reset clears all listeners", ({ Given, And, When, Then }) => {
-    Given('a mock with a route "GET /items"', () => {
-      mock = schmock({ state: {} });
-      mock("GET /items", [{ id: 1 }], {});
-    });
-
-    And("I register listeners for all events", () => {
-      events = [];
-      mock.on("request:start", collectEvent("request:start"));
-      mock.on("request:end", collectEvent("request:end"));
-    });
-
-    When("I reset the mock", () => {
-      mock.reset();
-      events = [];
-    });
-
-    And('I add a route "GET /items" again', () => {
-      mock("GET /items", [{ id: 1 }], {});
-    });
-
-    And('I request "GET /items" after reset', async () => {
-      await mock.handle("GET", "/items");
-    });
-
-    Then("no events were collected after reset", () => {
-      expect(events).toHaveLength(0);
-    });
-  });
-});

package/src/steps/performance-reliability.steps.ts

@@ -1,90 +0,0 @@
-import { describeFeature, loadFeature } from "@amiceli/vitest-cucumber";
-import { expect } from "vitest";
-import { schmock } from "../index";
-
-const feature = await loadFeature(
-  "../../features/performance-reliability.feature",
-);
-
-function withTimeout(
-  promise: Promise<void>,
-  timeoutMs: number,
-  message: string,
-): Promise<void> {
-  let timeoutId: ReturnType<typeof setTimeout> | undefined;
-  const timeout = new Promise<never>((_, reject) => {
-    timeoutId = setTimeout(() => reject(new Error(message)), timeoutMs);
-  });
-
-  return Promise.race([promise, timeout]).finally(() => {
-    if (timeoutId !== undefined) clearTimeout(timeoutId);
-  });
-}
-
-describeFeature(feature, ({ Scenario }) => {
-  let mock: Schmock.CallableMockInstance;
-  let releaseBarrier: (() => void) | undefined;
-  let boundedBarrier: Promise<void> | undefined;
-  let arrivals = 0;
-  let responses: Schmock.Response[] = [];
-  let expectedIds: string[] = [];
-
-  Scenario(
-    "Concurrent request contexts remain isolated",
-    ({ Given, When, Then, And }) => {
-      Given(
-        "I create an asynchronous mock that waits until every request reaches a shared rendezvous",
-        () => {
-          mock = schmock();
-          arrivals = 0;
-          mock("GET /items/:id", async ({ params }) => {
-            arrivals += 1;
-            if (arrivals === expectedIds.length) releaseBarrier?.();
-            if (!boundedBarrier) {
-              throw new Error("Concurrent rendezvous was not initialized");
-            }
-            await boundedBarrier;
-            return { id: params.id };
-          });
-        },
-      );
-
-      When(
-        "I issue {int} concurrent requests with distinct route IDs",
-        async (_scenario, count: number) => {
-          expectedIds = Array.from({ length: count }, (_, index) =>
-            String(index),
-          );
-          const barrier = new Promise<void>((resolve) => {
-            releaseBarrier = resolve;
-          });
-          boundedBarrier = withTimeout(
-            barrier,
-            2_000,
-            `Timed out waiting for ${count} requests to reach the shared rendezvous`,
-          );
-          const pending = expectedIds.map((id) =>
-            mock.handle("GET", `/items/${id}`),
-          );
-          responses = await Promise.all(pending);
-        },
-      );
-
-      Then("every response should contain its corresponding route ID", () => {
-        expect(arrivals).toBe(expectedIds.length);
-        expect(responses).toHaveLength(expectedIds.length);
-        expect(responses.map((response) => response.body)).toEqual(
-          expectedIds.map((id) => ({ id })),
-        );
-      });
-
-      And("the history should contain each route ID exactly once", () => {
-        const retainedIds = mock
-          .history()
-          .map((record) => record.params.id)
-          .sort();
-        expect(retainedIds).toEqual([...expectedIds].sort());
-      });
-    },
-  );
-});