@schmock/core 2.2.3 → 2.3.1

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

@@ -1,331 +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");
-
-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, response) => ({
-          context: ctx,
-          response: {
-            ...response,
-            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/interceptor.steps.ts

@@ -1,260 +0,0 @@
-/// <reference path="../../schmock.d.ts" />
-
-import { describeFeature, loadFeature } from "@amiceli/vitest-cucumber";
-import { expect, vi } from "vitest";
-import { schmock } from "../index.js";
-
-const feature = await loadFeature("../../features/fetch-interceptor.feature");
-
-describeFeature(feature, ({ Scenario, AfterEachScenario }) => {
-  let mock: Schmock.CallableMockInstance;
-  let handle: Schmock.InterceptHandle | undefined;
-  let originalFetch: typeof globalThis.fetch;
-  let savedFetch: ReturnType<typeof vi.fn>;
-  let fetchResponse: Response | undefined;
-
-  function setup() {
-    originalFetch = globalThis.fetch;
-    savedFetch = vi.fn().mockResolvedValue(new Response("real backend"));
-    globalThis.fetch = savedFetch;
-    mock = schmock();
-    fetchResponse = undefined;
-  }
-
-  AfterEachScenario(() => {
-    handle?.restore();
-    handle = undefined;
-    globalThis.fetch = originalFetch;
-  });
-
-  Scenario("Intercept a matched fetch request", ({ Given, When, Then, And }) => {
-    Given("a Schmock instance with route \"GET /api/users\" returning users", () => {
-      setup();
-      mock("GET /api/users", [{ id: 1, name: "Alice" }]);
-    });
-
-    And("fetch is intercepted", () => {
-      handle = mock.intercept();
-    });
-
-    When("I fetch \"/api/users\"", async () => {
-      fetchResponse = await fetch("http://localhost/api/users");
-    });
-
-    Then("the fetch response status should be 200", () => {
-      expect(fetchResponse?.status).toBe(200);
-    });
-
-    And("the fetch response body should be the mocked users", async () => {
-      const body = await fetchResponse?.json();
-      expect(body).toEqual([{ id: 1, name: "Alice" }]);
-    });
-  });
-
-  Scenario("Passthrough for unmatched routes", ({ Given, When, Then, And }) => {
-    Given("a Schmock instance with route \"GET /api/users\" returning users", () => {
-      setup();
-      mock("GET /api/users", [{ id: 1 }]);
-    });
-
-    And("fetch is intercepted with passthrough enabled", () => {
-      handle = mock.intercept({ passthrough: true });
-    });
-
-    When("I fetch \"/api/other\"", async () => {
-      fetchResponse = await fetch("http://localhost/api/other");
-    });
-
-    Then("the original fetch should have been called", () => {
-      expect(savedFetch).toHaveBeenCalled();
-    });
-  });
-
-  Scenario("Passthrough disabled returns 404", ({ Given, When, Then, And }) => {
-    Given("a Schmock instance with route \"GET /api/users\" returning users", () => {
-      setup();
-      mock("GET /api/users", [{ id: 1 }]);
-    });
-
-    And("fetch is intercepted with passthrough disabled", () => {
-      handle = mock.intercept({ passthrough: false });
-    });
-
-    When("I fetch \"/api/other\"", async () => {
-      fetchResponse = await fetch("http://localhost/api/other");
-    });
-
-    Then("the fetch response status should be 404", () => {
-      expect(fetchResponse?.status).toBe(404);
-    });
-  });
-
-  Scenario("Restore puts original fetch back", ({ Given, When, Then, And }) => {
-    let savedRef: typeof globalThis.fetch;
-
-    Given("a Schmock instance with route \"GET /api/users\" returning users", () => {
-      setup();
-      mock("GET /api/users", [{ id: 1 }]);
-    });
-
-    And("fetch is intercepted", () => {
-      savedRef = globalThis.fetch;
-      handle = mock.intercept();
-    });
-
-    When("I restore the interceptor", () => {
-      handle?.restore();
-    });
-
-    Then("globalThis.fetch should be the original function", () => {
-      expect(globalThis.fetch).toBe(savedRef);
-    });
-  });
-
-  Scenario("BaseUrl filters which requests are intercepted", ({ Given, When, Then, And }) => {
-    Given("a Schmock instance with route \"GET /api/users\" returning users", () => {
-      setup();
-      mock("GET /api/users", [{ id: 1 }]);
-    });
-
-    And("fetch is intercepted with baseUrl \"/api\"", () => {
-      handle = mock.intercept({ baseUrl: "/api" });
-    });
-
-    When("I fetch \"/other/endpoint\"", async () => {
-      await fetch("http://localhost/other/endpoint");
-    });
-
-    Then("the original fetch should have been called", () => {
-      expect(savedFetch).toHaveBeenCalled();
-    });
-  });
-
-  Scenario("Origin-form baseUrl intercepts matching origin only", ({ Given, When, Then, And }) => {
-    Given("a Schmock instance with route \"GET /api/users\" returning users", () => {
-      setup();
-      mock("GET /api/users", [{ id: 1 }]);
-    });
-
-    And("fetch is intercepted with baseUrl \"https://api.example.com\"", () => {
-      handle = mock.intercept({ baseUrl: "https://api.example.com" });
-    });
-
-    When("I fetch \"https://api.example.com/api/users\"", async () => {
-      fetchResponse = await fetch("https://api.example.com/api/users");
-    });
-
-    Then("the response status should be {int}", (_, status: number) => {
-      expect(fetchResponse?.status).toBe(status);
-    });
-
-    When("I fetch \"https://other.example.com/api/users\"", async () => {
-      await fetch("https://other.example.com/api/users");
-    });
-
-    Then("the original fetch should have been called", () => {
-      expect(savedFetch).toHaveBeenCalled();
-    });
-  });
-
-  Scenario("Origin-form baseUrl with a path prefix requires both to match", ({ Given, When, Then, And }) => {
-    Given("a Schmock instance with route \"GET /v1/users\" returning users", () => {
-      setup();
-      mock("GET /v1/users", [{ id: 1 }]);
-    });
-
-    And("fetch is intercepted with baseUrl \"https://api.example.com/v1\"", () => {
-      handle = mock.intercept({ baseUrl: "https://api.example.com/v1" });
-    });
-
-    When("I fetch \"https://api.example.com/v1/users\"", async () => {
-      fetchResponse = await fetch("https://api.example.com/v1/users");
-    });
-
-    Then("the response status should be {int}", (_, status: number) => {
-      expect(fetchResponse?.status).toBe(status);
-    });
-
-    When("I fetch \"https://api.example.com/users\"", async () => {
-      await fetch("https://api.example.com/users");
-    });
-
-    Then("the original fetch should have been called", () => {
-      expect(savedFetch).toHaveBeenCalled();
-    });
-  });
-
-  Scenario("beforeRequest hook modifies the request", ({ Given, When, Then, And }) => {
-    Given("a Schmock instance with route \"GET /api/users\" that reads headers", () => {
-      setup();
-      mock("GET /api/users", ({ headers }) => [200, { token: headers["x-token"] }]);
-    });
-
-    And("fetch is intercepted with a beforeRequest hook that adds a header", () => {
-      handle = mock.intercept({
-        beforeRequest: (req) => ({
-          ...req,
-          headers: { ...req.headers, "x-token": "injected" },
-        }),
-      });
-    });
-
-    When("I fetch \"/api/users\"", async () => {
-      fetchResponse = await fetch("http://localhost/api/users");
-    });
-
-    Then("the response should contain the injected header value", async () => {
-      const body = await fetchResponse?.json();
-      expect(body).toEqual({ token: "injected" });
-    });
-  });
-
-  Scenario("beforeResponse hook modifies the response", ({ Given, When, Then, And }) => {
-    Given("a Schmock instance with route \"GET /api/users\" returning users", () => {
-      setup();
-      mock("GET /api/users", [{ id: 1 }]);
-    });
-
-    And("fetch is intercepted with a beforeResponse hook that adds a header", () => {
-      handle = mock.intercept({
-        beforeResponse: (res) => ({
-          ...res,
-          headers: { ...res.headers, "x-mock": "true" },
-        }),
-      });
-    });
-
-    When("I fetch \"/api/users\"", async () => {
-      fetchResponse = await fetch("http://localhost/api/users");
-    });
-
-    Then("the fetch response should have the injected header", () => {
-      expect(fetchResponse?.headers.get("x-mock")).toBe("true");
-    });
-  });
-
-  Scenario("Double intercept throws an error", ({ Given, When, Then, And }) => {
-    let error: Error | undefined;
-
-    Given("a Schmock instance with route \"GET /api/users\" returning users", () => {
-      setup();
-      mock("GET /api/users", [{ id: 1 }]);
-    });
-
-    And("fetch is intercepted", () => {
-      handle = mock.intercept();
-    });
-
-    When("I try to intercept again", () => {
-      try {
-        mock.intercept();
-      } catch (e) {
-        error = e as Error;
-      }
-    });
-
-    Then("it should throw an error about already intercepting", () => {
-      expect(error?.message).toMatch(/already intercepting/i);
-    });
-  });
-});