Rename SimplePathMatcher & SimpleStep (previously SimpleHandler)

pimterry · pimterry · commit e9ea5e44e623 · 2025-06-06T11:54:40.000+02:00
This is a breaking change only if you're manually building rule
structures yourself - there's no change to the chained rule building API
(forGet().thenReply(...))

These names sort-of made sense when we had few options, but no longer
really do. These are now called FlexiblePathMatcher (give it a path, it
will flexibly match it against the relative or absolute or protocol-less
URL automatically) and FixedResponseStep(Definition) which does exactly
what it says on the tin.
diff --git a/src/rules/matchers.ts b/src/rules/matchers.ts
@@ -189,7 +189,7 @@ export class PortMatcher extends Serializable implements RequestMatcher {
     }
 }
 
-export class SimplePathMatcher extends Serializable implements RequestMatcher {
+export class FlexiblePathMatcher extends Serializable implements RequestMatcher {
     readonly type = 'simple-path';
 
     constructor(
@@ -619,7 +619,7 @@ export const MatcherLookup = {
     'host': HostMatcher,
     'hostname': HostnameMatcher,
     'port': PortMatcher,
-    'simple-path': SimplePathMatcher,
+    'simple-path': FlexiblePathMatcher,
     'regex-path': RegexPathMatcher,
     'regex-url': RegexUrlMatcher,
     'header': HeaderMatcher,
diff --git a/src/rules/requests/request-rule-builder.ts b/src/rules/requests/request-rule-builder.ts
@@ -6,7 +6,7 @@ import { Headers, CompletedRequest, Method, MockedEndpoint, Trailers } from "../
 import type { RequestRuleData } from "./request-rule";
 
 import {
-    SimpleStepDefinition,
+    FixedResponseStepDefinition,
     PassThroughStepDefinition,
     CallbackStepDefinition,
     CallbackResponseResult,
@@ -23,7 +23,7 @@ import {
 } from "./request-step-definitions";
 import { byteLength } from "../../util/util";
 import { BaseRuleBuilder } from "../base-rule-builder";
-import { MethodMatcher, RegexPathMatcher, SimplePathMatcher, WildcardMatcher } from "../matchers";
+import { MethodMatcher, RegexPathMatcher, FlexiblePathMatcher, WildcardMatcher } from "../matchers";
 
 /**
  * @class RequestRuleBuilder
@@ -76,7 +76,7 @@ export class RequestRuleBuilder extends BaseRuleBuilder {
             if (path instanceof RegExp) {
                 this.matchers.push(new RegexPathMatcher(path));
             } else if (typeof path === 'string') {
-                this.matchers.push(new SimplePathMatcher(path));
+                this.matchers.push(new FlexiblePathMatcher(path));
             }
         }
 
@@ -151,7 +151,7 @@ export class RequestRuleBuilder extends BaseRuleBuilder {
             trailers = headersOrTrailers as Trailers | undefined;
         }
 
-        this.steps.push(new SimpleStepDefinition(
+        this.steps.push(new FixedResponseStepDefinition(
             status,
             statusMessage,
             data,
@@ -196,7 +196,7 @@ export class RequestRuleBuilder extends BaseRuleBuilder {
             // connection after the response is sent, which can confuse clients.
         }, headers);
 
-        this.steps.push(new SimpleStepDefinition(status, undefined, jsonData, headers));
+        this.steps.push(new FixedResponseStepDefinition(status, undefined, jsonData, headers));
 
         const rule: RequestRuleData = {
             ...this.buildBaseRuleData(),
diff --git a/src/rules/requests/request-step-definitions.ts b/src/rules/requests/request-step-definitions.ts
@@ -251,7 +251,7 @@ function validateCustomHeaders(
     }
 }
 
-export class SimpleStepDefinition extends Serializable implements RequestStepDefinition {
+export class FixedResponseStepDefinition extends Serializable implements RequestStepDefinition {
 
     readonly type = 'simple';
     static readonly isFinal = true;
@@ -1058,7 +1058,7 @@ export class DelayStepDefinition extends Serializable implements RequestStepDefi
 }
 
 export const StepDefinitionLookup = {
-    'simple': SimpleStepDefinition,
+    'simple': FixedResponseStepDefinition,
     'callback': CallbackStepDefinition,
     'stream': StreamStepDefinition,
     'file': FileStepDefinition,
diff --git a/src/rules/requests/request-steps.ts b/src/rules/requests/request-steps.ts
@@ -113,7 +113,7 @@ import {
     SerializedPassThroughData,
     SerializedStreamStepData,
     SERIALIZED_OMIT,
-    SimpleStepDefinition,
+    FixedResponseStepDefinition,
     StreamStepDefinition,
     TimeoutStepDefinition,
     DelayStepDefinition
@@ -165,7 +165,7 @@ export interface RequestStepOptions {
     emitEventCallback?: (type: string, event: unknown) => void;
 }
 
-export class SimpleStep extends SimpleStepDefinition {
+export class FixedResponseStep extends FixedResponseStepDefinition {
     async handle(_request: OngoingRequest, response: OngoingResponse) {
         if (this.headers) dropDefaultHeaders(response);
         writeHead(response, this.status, this.statusMessage, this.headers);
@@ -1405,7 +1405,7 @@ export class DelayStep extends DelayStepDefinition {
 }
 
 export const StepLookup: typeof StepDefinitionLookup = {
-    'simple': SimpleStep,
+    'simple': FixedResponseStep,
     'callback': CallbackStep,
     'stream': StreamStep,
     'file': FileStep,
diff --git a/test/integration/manual-rule-building.spec.ts b/test/integration/manual-rule-building.spec.ts
@@ -12,8 +12,8 @@ describe("Mockttp rule building", function () {
 
     it("should allow manually adding a single rule", async () => {
         await server.addRequestRules({
-            matchers: [new matchers.SimplePathMatcher('/endpoint')],
-            steps: [new requestSteps.SimpleStepDefinition(200, '', 'mock response')]
+            matchers: [new matchers.FlexiblePathMatcher('/endpoint')],
+            steps: [new requestSteps.FixedResponseStepDefinition(200, '', 'mock response')]
         });
 
         let response = await fetch(server.urlFor('/endpoint'));
@@ -27,21 +27,21 @@ describe("Mockttp rule building", function () {
 
         const rule = await server.addRequestRules({
             id: manualId,
-            matchers: [new matchers.SimplePathMatcher('/endpoint')],
-            steps: [new requestSteps.SimpleStepDefinition(200, '', 'mock response')]
+            matchers: [new matchers.FlexiblePathMatcher('/endpoint')],
+            steps: [new requestSteps.FixedResponseStepDefinition(200, '', 'mock response')]
         });
 
         expect(rule[0].id).to.equal(manualId);
     });
 
     it("should allow repeatedly adding rules", async () => {
         await server.addRequestRules({
-            matchers: [new matchers.SimplePathMatcher('/endpoint')],
-            steps: [new requestSteps.SimpleStepDefinition(200, '', 'first mock response')]
+            matchers: [new matchers.FlexiblePathMatcher('/endpoint')],
+            steps: [new requestSteps.FixedResponseStepDefinition(200, '', 'first mock response')]
         });
         await server.addRequestRules({
-            matchers: [new matchers.SimplePathMatcher('/endpoint')],
-            steps: [new requestSteps.SimpleStepDefinition(200, '', 'second mock response')]
+            matchers: [new matchers.FlexiblePathMatcher('/endpoint')],
+            steps: [new requestSteps.FixedResponseStepDefinition(200, '', 'second mock response')]
         });
 
         let firstResponse = await fetch(server.urlFor('/endpoint'));
@@ -55,12 +55,12 @@ describe("Mockttp rule building", function () {
 
     it("should allow completely replacing rules", async () => {
         await server.addRequestRules({
-            matchers: [new matchers.SimplePathMatcher('/endpoint')],
-            steps: [new requestSteps.SimpleStepDefinition(200, '',  'original mock response')]
+            matchers: [new matchers.FlexiblePathMatcher('/endpoint')],
+            steps: [new requestSteps.FixedResponseStepDefinition(200, '',  'original mock response')]
         });
         await server.setRequestRules({
-            matchers: [new matchers.SimplePathMatcher('/endpoint')],
-            steps: [new requestSteps.SimpleStepDefinition(200, '', 'replacement mock response')]
+            matchers: [new matchers.FlexiblePathMatcher('/endpoint')],
+            steps: [new requestSteps.FixedResponseStepDefinition(200, '', 'replacement mock response')]
         });
 
         let firstResponse = await fetch(server.urlFor('/endpoint'));
@@ -95,10 +95,10 @@ describe("Mockttp rule building", function () {
 
     it("should allow manually adding a multi-step rule", async () => {
         await server.addRequestRules({
-            matchers: [new matchers.SimplePathMatcher('/endpoint')],
+            matchers: [new matchers.FlexiblePathMatcher('/endpoint')],
             steps: [
                 new requestSteps.DelayStepDefinition(10),
-                new requestSteps.SimpleStepDefinition(200, '', 'mock response')
+                new requestSteps.FixedResponseStepDefinition(200, '', 'mock response')
             ]
         });
 
@@ -112,15 +112,15 @@ describe("Mockttp rule building", function () {
         return expect((async () => { // Funky setup to handle sync & async failure for node & browser
             await server.addRequestRules({
                 matchers: [],
-                steps: [new requestSteps.SimpleStepDefinition(200, 'mock response')]
+                steps: [new requestSteps.FixedResponseStepDefinition(200, 'mock response')]
             })
         })()).to.be.rejectedWith('Cannot create a rule without at least one matcher');
     });
 
     it("should reject rules with no steps value", async () => {
         return expect((async () => { // Funky setup to handle sync & async failure for node & browser
             await server.addRequestRules({
-                matchers: [new matchers.SimplePathMatcher('/')],
+                matchers: [new matchers.FlexiblePathMatcher('/')],
                 steps: null as any
             })
         })()).to.be.rejectedWith('Cannot create a rule with no steps');
@@ -129,7 +129,7 @@ describe("Mockttp rule building", function () {
     it("should reject rules with an empty steps list", async () => {
         return expect((async () => { // Funky setup to handle sync & async failure for node & browser
             await server.addRequestRules({
-                matchers: [new matchers.SimplePathMatcher('/')],
+                matchers: [new matchers.FlexiblePathMatcher('/')],
                 steps: []
             })
         })()).to.be.rejectedWith('Cannot create a rule with no steps');
@@ -138,9 +138,9 @@ describe("Mockttp rule building", function () {
     it("should reject rules with non-final final-only steps", async () => {
         return expect((async () => { // Funky setup to handle sync & async failure for node & browser
             await server.addRequestRules({
-                matchers: [new matchers.SimplePathMatcher('/endpoint')],
+                matchers: [new matchers.FlexiblePathMatcher('/endpoint')],
                 steps: [
-                    new requestSteps.SimpleStepDefinition(200),
+                    new requestSteps.FixedResponseStepDefinition(200),
                     new requestSteps.DelayStepDefinition(100)
                 ]
             });

Original file line number	Diff line number	Diff line change
`@@ -251,7 +251,7 @@ function validateCustomHeaders(`
`251`	`251`	`}`
`252`	`252`	`}`
`253`	`253`
`254`		`-export class SimpleStepDefinition extends Serializable implements RequestStepDefinition {`
	`254`	`+export class FixedResponseStepDefinition extends Serializable implements RequestStepDefinition {`
`255`	`255`
`256`	`256`	`readonly type = 'simple';`
`257`	`257`	`static readonly isFinal = true;`
`@@ -1058,7 +1058,7 @@ export class DelayStepDefinition extends Serializable implements RequestStepDefi`
`1058`	`1058`	`}`
`1059`	`1059`
`1060`	`1060`	`export const StepDefinitionLookup = {`
`1061`		`- 'simple': SimpleStepDefinition,`
	`1061`	`+ 'simple': FixedResponseStepDefinition,`
`1062`	`1062`	`'callback': CallbackStepDefinition,`
`1063`	`1063`	`'stream': StreamStepDefinition,`
`1064`	`1064`	`'file': FileStepDefinition,`