@schmock/core 2.0.0 → 2.0.1

package/src/steps/async-support.steps.ts

@@ -64,41 +64,6 @@ describeFeature(feature, ({ Scenario }) => {
     });
   });
 
-  Scenario("Multiple async generators in different routes", ({ Given, When, Then, And }) => {
-    Given("I create a mock with async routes for posts and comments", () => {
-      mock = schmock();
-      mock("GET /async-posts", async () => {
-        await new Promise(resolve => setTimeout(resolve, 5));
-        return [{ id: 1, title: "First Post" }];
-      });
-      mock("GET /async-comments", async () => {
-        await new Promise(resolve => setTimeout(resolve, 8));
-        return [{ id: 1, comment: "Great post!" }];
-      });
-    });
-
-    When("I make concurrent requests to {string} and {string}", async (_, path1: string, path2: string) => {
-      const [posts, comments] = await Promise.all([
-        mock.handle("GET", path1),
-        mock.handle("GET", path2),
-      ]);
-      responses = [posts, comments];
-    });
-
-    Then("both responses should be returned successfully", () => {
-      expect(responses[0].status).toBe(200);
-      expect(responses[1].status).toBe(200);
-    });
-
-    And("the posts response should contain {string}", (_, text: string) => {
-      expect(JSON.stringify(responses[0].body)).toContain(text);
-    });
-
-    And("the comments response should contain {string}", (_, text: string) => {
-      expect(JSON.stringify(responses[1].body)).toContain(text);
-    });
-  });
-
   Scenario("Async plugin processing", ({ Given, When, Then, And }) => {
     Given("I create a mock with an async processing plugin at {string}", (_, route: string) => {
       const [method, path] = route.split(" ");

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

@@ -110,90 +110,6 @@ describeFeature(feature, ({ Scenario }) => {
     });
   });
 
-  Scenario("Undefined response", ({ Given, When, Then, And }) => {
-    Given("I create a mock returning undefined at {string}", (_, route: string) => {
-      const [method, path] = route.split(" ");
-      mock = schmock();
-      mock(`${method} ${path}` as Schmock.RouteKey, undefined);
-    });
-
-    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("Empty string response", ({ Given, When, Then, And }) => {
-    Given("I create a mock returning empty string at {string}", (_, route: string) => {
-      const [method, path] = route.split(" ");
-      mock = schmock();
-      mock(`${method} ${path}` as Schmock.RouteKey, "");
-    });
-
-    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("Number response", ({ Given, When, Then, And }) => {
-    Given("I create a mock returning number {int} at {string}", (_, num: number, route: string) => {
-      const [method, path] = route.split(" ");
-      mock = schmock();
-      mock(`${method} ${path}` as Schmock.RouteKey, num);
-    });
-
-    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("Boolean response", ({ Given, When, Then, And }) => {
-    Given("I create a mock returning boolean true at {string}", (_, route: string) => {
-      const [method, path] = route.split(" ");
-      mock = schmock();
-      mock(`${method} ${path}` as Schmock.RouteKey, true);
-    });
-
-    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("Function returning string", ({ Given, When, Then }) => {
     Given("I create a mock with a string generator at {string}", (_, route: string) => {
       const [method, path] = route.split(" ");

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

@@ -10,134 +10,6 @@ describeFeature(feature, ({ Scenario }) => {
   let response: any;
   let responses: any[] = [];
 
-  Scenario("Forgetting to provide response data", ({ Given, When, Then, And }) => {
-    Given("I create a mock with no response data on {string}", (_, route: string) => {
-      mock = schmock();
-      mock(route as Schmock.RouteKey, undefined);
-    });
-
-    When("I request {string}", async (_, request: string) => {
-      const [method, path] = request.split(" ");
-      response = await mock.handle(method as any, path);
-    });
-
-    Then("I should receive status {int}", (_, status: number) => {
-      expect(response.status).toBe(status);
-    });
-
-    And("the response body should be empty", () => {
-      expect(response.body).toBeUndefined();
-    });
-  });
-
-  Scenario("Using wrong parameter name in route", ({ Given, When, Then }) => {
-    Given("I create a mock with a mismatched parameter name on {string}", (_, route: string) => {
-      mock = schmock();
-      mock(route as Schmock.RouteKey, ({ params }) => ({ id: params.id }));
-    });
-
-    When("I request {string}", async (_, request: string) => {
-      const [method, path] = request.split(" ");
-      response = await mock.handle(method as any, path);
-    });
-
-    Then("the wrong parameter should be undefined", () => {
-      expect(response.body).toEqual({ id: undefined });
-    });
-  });
-
-  Scenario("Correct parameter usage", ({ Given, When, Then }) => {
-    Given("I create a mock with a matching parameter name on {string}", (_, route: string) => {
-      mock = schmock();
-      mock(route as Schmock.RouteKey, ({ params }) => ({ id: params.userId }));
-    });
-
-    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("Mixing content types without explicit configuration", ({ Given, When, Then, And }) => {
-    Given("I create a mock with JSON, text, number, and boolean routes", () => {
-      mock = schmock();
-      mock("GET /json", { data: "json" });
-      mock("GET /text", "plain text");
-      mock("GET /number", 42);
-      mock("GET /boolean", true);
-    });
-
-    When("I test all mixed content type routes", async () => {
-      responses = [];
-      responses.push(await mock.handle("GET", "/json"));
-      responses.push(await mock.handle("GET", "/text"));
-      responses.push(await mock.handle("GET", "/number"));
-      responses.push(await mock.handle("GET", "/boolean"));
-    });
-
-    Then("JSON route should have content-type {string}", (_, contentType: string) => {
-      expect(responses[0].headers?.["content-type"]).toBe(contentType);
-    });
-
-    And("text route should have content-type {string}", (_, contentType: string) => {
-      expect(responses[1].headers?.["content-type"]).toBe(contentType);
-    });
-
-    And("number route should have content-type {string}", (_, contentType: string) => {
-      expect(responses[2].headers?.["content-type"]).toBe(contentType);
-    });
-
-    And("boolean route should have content-type {string}", (_, contentType: string) => {
-      expect(responses[3].headers?.["content-type"]).toBe(contentType);
-    });
-  });
-
-  Scenario("Expecting JSON but getting string conversion", ({ Given, When, Then, And }) => {
-    Given("I create a mock returning a decimal number on {string}", (_, route: string) => {
-      mock = schmock();
-      mock(route as Schmock.RouteKey, 19.99);
-    });
-
-    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("Forgetting await with async generators", ({ Given, When, Then, And }) => {
-    Given("I create a mock with an async handler on {string}", (_, route: string) => {
-      mock = schmock();
-      mock(route as Schmock.RouteKey, async () => ({ async: true }));
-    });
-
-    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("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 } });
@@ -166,62 +38,6 @@ describeFeature(feature, ({ Scenario }) => {
     });
   });
 
-  Scenario("Query parameter edge cases", ({ Given, When, Then }) => {
-    Given("I create a mock that echoes query parameters on {string}", (_, route: string) => {
-      mock = schmock();
-      mock(route as Schmock.RouteKey, ({ query }) => ({
-        term: query.q,
-        page: query.page,
-        empty: query.empty,
-      }));
-    });
-
-    When("I request {string}", async (_, request: 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 || "";
-        });
-      }
-
-      response = await mock.handle(method as any, path, { query });
-    });
-
-    Then("I should receive:", (_, docString: string) => {
-      const expected = JSON.parse(docString);
-      expect(response.body).toEqual(expected);
-    });
-  });
-
-  Scenario("Headers case sensitivity", ({ Given, When, Then }) => {
-    Given("I create a mock that echoes headers on {string}", (_, route: string) => {
-      mock = schmock();
-      mock(route as Schmock.RouteKey, ({ headers }) => ({
-        auth: headers.authorization,
-        authUpper: headers.Authorization,
-        contentType: headers["content-type"],
-      }));
-    });
-
-    When("I request {string} with headers:", async (_, request: string, docString: string) => {
-      const [method, path] = request.split(" ");
-      const headers = JSON.parse(docString);
-      response = await mock.handle(method as any, path, { headers });
-    });
-
-    Then("the header case sensitivity should show expected values", () => {
-      expect(response.body).toEqual({
-        auth: undefined,
-        authUpper: "Bearer token",
-        contentType: undefined,
-      });
-    });
-  });
-
   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();
@@ -277,28 +93,6 @@ describeFeature(feature, ({ Scenario }) => {
     });
   });
 
-  Scenario("Namespace confusion with absolute paths", ({ Given, When, Then, And }) => {
-    Given("I create a mock with namespace {string} and a users route", (_, namespace: string) => {
-      mock = schmock({ namespace });
-      mock("GET /users", []);
-    });
-
-    When("I test both namespace scenarios", async () => {
-      responses = [];
-      responses.push(await mock.handle("GET", "/users"));
-      responses.push(await mock.handle("GET", "/api/v1/users"));
-    });
-
-    Then("the wrong namespace should receive status {int}", (_, status: number) => {
-      expect(responses[0].status).toBe(status);
-    });
-
-    And("the correct namespace should receive:", (_, docString: string) => {
-      const expected = JSON.parse(docString);
-      expect(responses[1].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();
@@ -371,46 +165,6 @@ describeFeature(feature, ({ Scenario }) => {
     });
   });
 
-  Scenario("Common typos in method names", ({ Given, When, Then, And }) => {
-    let errors: Error[] = [];
-
-    Given("I create an empty mock for testing method typos", () => {
-      mock = schmock();
-    });
-
-    When("I test all common method typos", () => {
-      errors = [];
-      const typos = ["GETS /users", "post /users", "GET/users"];
-
-      for (const typo of typos) {
-        try {
-          mock(typo as Schmock.RouteKey, "test");
-          errors.push(new Error("No error thrown"));
-        } catch (e) {
-          errors.push(e as Error);
-        }
-      }
-    });
-
-    Then("the wrong method typo should throw RouteParseError", () => {
-      expect(errors[0]).not.toBeNull();
-      expect(errors[0].constructor.name).toBe("RouteParseError");
-      expect(errors[0].message).toContain("Invalid route key format");
-    });
-
-    And("the lowercase method typo should throw RouteParseError", () => {
-      expect(errors[1]).not.toBeNull();
-      expect(errors[1].constructor.name).toBe("RouteParseError");
-      expect(errors[1].message).toContain("Invalid route key format");
-    });
-
-    And("the missing space typo should throw RouteParseError", () => {
-      expect(errors[2]).not.toBeNull();
-      expect(errors[2].constructor.name).toBe("RouteParseError");
-      expect(errors[2].message).toContain("Invalid route key format");
-    });
-  });
-
   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();
@@ -429,27 +183,4 @@ describeFeature(feature, ({ Scenario }) => {
     });
   });
 
-  Scenario("Plugin returning unexpected structure", ({ Given, When, Then, And }) => {
-    Given("I create a mock with a plugin that returns an invalid structure", () => {
-      mock = schmock();
-      const badPlugin = {
-        name: "bad-structure",
-        process: () => ({ wrong: "structure" }),
-      };
-      mock("GET /bad", "original").pipe(badPlugin as any);
-    });
-
-    When("I request {string}", async (_, request: string) => {
-      const [method, path] = request.split(" ");
-      response = await mock.handle(method as any, path);
-    });
-
-    Then("I should receive status {int}", (_, status: number) => {
-      expect(response.status).toBe(status);
-    });
-
-    And("the response should contain error {string}", (_, errorMessage: string) => {
-      expect(response.body.error).toContain(errorMessage);
-    });
-  });
 });

package/src/steps/error-handling.steps.ts

@@ -8,7 +8,6 @@ const feature = await loadFeature("../../features/error-handling.feature");
 describeFeature(feature, ({ Scenario }) => {
   let mock: CallableMockInstance;
   let response: any;
-  let error: Error | null = null;
 
   Scenario("Route not found returns 404", ({ Given, When, Then, And }) => {
     Given("I create a mock with a GET /users route returning a user list", () => {
@@ -54,48 +53,6 @@ describeFeature(feature, ({ Scenario }) => {
     });
   });
 
-  Scenario("Invalid route key throws RouteDefinitionError", ({ Given, Then, And }) => {
-    Given("I attempt to register a route with an invalid HTTP method", () => {
-      error = null;
-      try {
-        mock = schmock();
-        mock("INVALID_METHOD /path" as any, "response");
-      } catch (e) {
-        error = e as Error;
-      }
-    });
-
-    Then("it should throw a RouteDefinitionError", () => {
-      expect(error).not.toBeNull();
-      expect(error!.constructor.name).toBe("RouteParseError");
-    });
-
-    And("the error message should contain {string}", (_, message: string) => {
-      expect(error!.message).toContain("Invalid route key format");
-    });
-  });
-
-  Scenario("Empty route path throws RouteDefinitionError", ({ Given, Then, And }) => {
-    Given("I attempt to register a route with an empty path", () => {
-      error = null;
-      try {
-        mock = schmock();
-        mock("GET " as any, "response");
-      } catch (e) {
-        error = e as Error;
-      }
-    });
-
-    Then("it should throw a RouteDefinitionError", () => {
-      expect(error).not.toBeNull();
-      expect(error!.constructor.name).toBe("RouteParseError");
-    });
-
-    And("the error message should contain {string}", (_, message: string) => {
-      expect(error!.message).toContain("Invalid route key format");
-    });
-  });
-
   Scenario("Plugin throws error returns 500 with PluginError", ({ Given, When, Then, And }) => {
     Given("I create a mock with a plugin that throws {string}", (_, errorMsg: string) => {
       mock = schmock();
@@ -197,29 +154,6 @@ describeFeature(feature, ({ Scenario }) => {
     });
   });
 
-  Scenario("Invalid JSON generator with JSON content-type throws RouteDefinitionError", ({ Given, Then, And }) => {
-    Given("I attempt to register a route with a circular reference as JSON", () => {
-      error = null;
-      try {
-        mock = schmock();
-        const circularRef: Record<string, unknown> = {};
-        circularRef.self = circularRef;
-        mock("GET /invalid", circularRef, { contentType: "application/json" });
-      } catch (e) {
-        error = e as Error;
-      }
-    });
-
-    Then("it should throw a RouteDefinitionError", () => {
-      expect(error).not.toBeNull();
-      expect(error!.constructor.name).toBe("RouteDefinitionError");
-    });
-
-    And("the error message should contain {string}", (_, message: string) => {
-      expect(error!.message).toContain(message);
-    });
-  });
-
   Scenario("Namespace mismatch returns 404", ({ Given, When, Then, And }) => {
     Given("I create a mock with namespace {string} and a GET /users route", (_, namespace: string) => {
       mock = schmock({ namespace });

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

@@ -9,7 +9,6 @@ describeFeature(feature, ({ Scenario }) => {
   let mock: CallableMockInstance;
   let response: any;
   let responses: any[] = [];
-  let error: Error | null = null;
 
   Scenario("GET method with query parameters", ({ Given, When, Then }) => {
     Given("I create a mock with a GET search endpoint", () => {
@@ -255,71 +254,6 @@ describeFeature(feature, ({ Scenario }) => {
     });
   });
 
-  Scenario("Method case sensitivity", ({ Given, When, Then }) => {
-    error = null;
-
-    Given("I create an empty mock for case sensitivity testing", () => {
-      mock = schmock();
-    });
-
-    When("I attempt to create a mock with lowercase method", () => {
-      error = null;
-      try {
-        mock('get /test' as Schmock.RouteKey, { method: 'get' });
-      } catch (e) {
-        error = e as Error;
-      }
-    });
-
-    Then("it should throw RouteParseError for invalid method case", () => {
-      expect(error).not.toBeNull();
-      expect(error!.constructor.name).toBe('RouteParseError');
-      expect(error!.message).toContain('Invalid route key format');
-    });
-  });
-
-  Scenario("Unsupported HTTP methods", ({ Given, When, Then }) => {
-    error = null;
-
-    Given("I create an empty mock for unsupported method testing", () => {
-      mock = schmock();
-    });
-
-    When("I attempt to create a mock with unsupported method", () => {
-      error = null;
-      try {
-        mock('CUSTOM /endpoint' as Schmock.RouteKey, { custom: true });
-      } catch (e) {
-        error = e as Error;
-      }
-    });
-
-    Then("it should throw RouteParseError for unsupported method", () => {
-      expect(error).not.toBeNull();
-      expect(error!.constructor.name).toBe('RouteParseError');
-      expect(error!.message).toContain('Invalid route key format');
-    });
-  });
-
-  Scenario("Method with special characters in path", ({ Given, When, Then }) => {
-    Given("I create a mock with nested parameterized path segments", () => {
-      mock = schmock();
-      mock('GET /api/v1/users/:id/posts/:post-id', ({ params }) => ({
-        userId: params.id,
-        postId: params['post-id'],
-      }));
-    });
-
-    When("I make a GET request to {string}", async (_, path: string) => {
-      response = await mock.handle('GET', path);
-    });
-
-    Then("I should receive special characters response:", (_, docString: string) => {
-      const expected = JSON.parse(docString);
-      expect(response.body).toEqual(expected);
-    });
-  });
-
   Scenario("Method with request headers validation", ({ Given, When, Then, And }) => {
     Given("I create a mock with authorization header checking", () => {
       mock = schmock();

package/src/steps/request-history.steps.ts

@@ -9,57 +9,6 @@ describeFeature(feature, ({ Scenario }) => {
   let mock: CallableMockInstance;
   let response: any;
 
-  Scenario("No requests recorded initially", ({ Given, Then, And }) => {
-    Given("I create a mock with a single GET route for history", () => {
-      mock = schmock();
-      mock("GET /users", [{ id: 1 }]);
-    });
-
-    Then("the mock should not have been called", () => {
-      expect(mock.called()).toBe(false);
-    });
-
-    And("the call count should be 0", () => {
-      expect(mock.callCount()).toBe(0);
-    });
-
-    And("the history should be empty", () => {
-      expect(mock.history()).toEqual([]);
-    });
-  });
-
-  Scenario("Record a single GET request", ({ Given, When, Then, And }) => {
-    Given("I create a mock returning users at {string}", (_, route: string) => {
-      mock = schmock();
-      mock(route 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("the mock should have been called", () => {
-      expect(mock.called()).toBe(true);
-    });
-
-    And("the call count should be 1", () => {
-      expect(mock.callCount()).toBe(1);
-    });
-
-    And("the history should have 1 entry", () => {
-      expect(mock.history()).toHaveLength(1);
-    });
-
-    And("the last request method should be {string}", (_, method: string) => {
-      expect(mock.lastRequest()?.method).toBe(method);
-    });
-
-    And("the last request path should be {string}", (_, path: string) => {
-      expect(mock.lastRequest()?.path).toBe(path);
-    });
-  });
-
   Scenario("Record multiple requests", ({ Given, When, And, Then }) => {
     Given("I create a mock with GET and POST user routes", () => {
       mock = schmock();
@@ -287,30 +236,6 @@ describeFeature(feature, ({ Scenario }) => {
     );
   });
 
-  Scenario("History works with namespaced mocks", ({ Given, When, Then, And }) => {
-    Given("I create a namespaced mock under {string}", (_, namespace: string) => {
-      mock = schmock({ namespace });
-      mock("GET /users", [{ id: 1 }]);
-    });
-
-    When("I request {string}", async (_, request: string) => {
-      const [method, path] = request.split(" ");
-      response = await mock.handle(method as any, path);
-    });
-
-    Then("the mock should have been called", () => {
-      expect(mock.called()).toBe(true);
-    });
-
-    And("the call count should be 1", () => {
-      expect(mock.callCount()).toBe(1);
-    });
-
-    And("the last request path should be {string}", (_, path: string) => {
-      expect(mock.lastRequest()?.path).toBe(path);
-    });
-  });
-
   Scenario("404 requests are not recorded in history", ({ Given, When, Then, And }) => {
     Given("I create a mock with only a users route", () => {
       mock = schmock();