Throw an error when defining a rule with a premature always-final step

Author: pimterry

src/rules/requests/request-rule.ts

@@ -51,17 +51,23 @@ export class RequestRule implements RequestRule {
         this.matchers = data.matchers;
         this.completionChecker = data.completionChecker;
 
-        this.steps = data.steps.map((step) => {
-            if ('handle' in step) {
-                return step;
-            } else {
-                // We transform the definition into a real step, by creating an instance of the raw step (which is
-                // a subtype of the definition with the same constructor) and copying the fields across.
-                return Object.assign(
-                    Object.create(StepLookup[step.type].prototype),
-                    step
+        this.steps = data.steps.map((stepDefinition, i) => {
+            const step = 'handle' in stepDefinition
+                ? stepDefinition
+                : Object.assign(
+                    Object.create(StepLookup[stepDefinition.type].prototype),
+                    stepDefinition
+                ) as RequestStep;
+
+            if (StepLookup[step.type].isFinal && i !== data.steps.length - 1) {
+                throw new Error(
+                    `Cannot create a rule with a final step before the last position ("${
+                        step.explain()
+                    }" in position ${i + 1} of ${data.steps.length})`
                 );
             }
+
+            return step;
         });
     }
 

src/rules/requests/request-step-definitions.ts

@@ -252,7 +252,9 @@ function validateCustomHeaders(
 }
 
 export class SimpleStepDefinition extends Serializable implements RequestStepDefinition {
+
     readonly type = 'simple';
+    static readonly isFinal = true;
 
     constructor(
         public status: number,
@@ -300,7 +302,9 @@ export interface CallbackRequestMessage {
 }
 
 export class CallbackStepDefinition extends Serializable implements RequestStepDefinition {
+
     readonly type = 'callback';
+    static readonly isFinal = true;
 
     constructor(
         public callback: (request: CompletedRequest) => MaybePromise<CallbackResponseResult>
@@ -356,7 +360,9 @@ type StreamStepEventMessage =
     { type: 'nil' };
 
 export class StreamStepDefinition extends Serializable implements RequestStepDefinition {
+
     readonly type = 'stream';
+    static readonly isFinal = true;
 
     constructor(
         public status: number,
@@ -416,7 +422,9 @@ export class StreamStepDefinition extends Serializable implements RequestStepDef
 }
 
 export class FileStepDefinition extends Serializable implements RequestStepDefinition {
+
     readonly type = 'file';
+    static readonly isFinal = true;
 
     constructor(
         public status: number,
@@ -715,7 +723,9 @@ export interface BeforePassthroughResponseRequest {
 export const SERIALIZED_OMIT = "__mockttp__transform__omit__";
 
 export class PassThroughStepDefinition extends Serializable implements RequestStepDefinition {
+
     readonly type = 'passthrough';
+    static readonly isFinal = true;
 
     public readonly forwarding?: ForwardingOptions;
 
@@ -980,6 +990,7 @@ export class PassThroughStepDefinition extends Serializable implements RequestSt
 
 export class CloseConnectionStepDefinition extends Serializable implements RequestStepDefinition {
     readonly type = 'close-connection';
+    static readonly isFinal = true;
 
     explain() {
         return 'close the connection';
@@ -988,6 +999,7 @@ export class CloseConnectionStepDefinition extends Serializable implements Reque
 
 export class ResetConnectionStepDefinition extends Serializable implements RequestStepDefinition {
     readonly type = 'reset-connection';
+    static readonly isFinal = true;
 
     explain() {
         return 'reset the connection';
@@ -996,6 +1008,7 @@ export class ResetConnectionStepDefinition extends Serializable implements Reque
 
 export class TimeoutStepDefinition extends Serializable implements RequestStepDefinition {
     readonly type = 'timeout';
+    static readonly isFinal = true;
 
     explain() {
         return 'time out (never respond)';
@@ -1004,6 +1017,7 @@ export class TimeoutStepDefinition extends Serializable implements RequestStepDe
 
 export class JsonRpcResponseStepDefinition extends Serializable implements RequestStepDefinition {
     readonly type = 'json-rpc-response';
+    static readonly isFinal = true;
 
     constructor(
         public readonly result:

src/rules/websockets/websocket-rule.ts

@@ -64,17 +64,23 @@ export class WebSocketRule implements WebSocketRule {
         this.matchers = data.matchers;
         this.completionChecker = data.completionChecker;
 
-        this.steps = data.steps.map((step) => {
-            if ('handle' in step) {
-                return step;
-            } else {
-                // We transform the definition into a real step, by creating an instance of the raw step (which is
-                // a subtype of the definition with the same constructor) and copying the fields across.
-                return Object.assign(
-                    Object.create(WsStepLookup[step.type].prototype),
-                    step
+        this.steps = data.steps.map((stepDefinition, i) => {
+            const step = 'handle' in stepDefinition
+                ? stepDefinition
+                : Object.assign(
+                    Object.create(WsStepLookup[stepDefinition.type].prototype),
+                    stepDefinition
+                ) as WebSocketStep;
+
+            if (WsStepLookup[step.type].isFinal && i !== data.steps.length - 1) {
+                throw new Error(
+                    `Cannot create a rule with a final step before the last position ("${
+                        step.explain()
+                    }" in position ${i + 1} of ${data.steps.length})`
                 );
             }
+
+            return step;
         });
     }
 

src/rules/websockets/websocket-step-definitions.ts

@@ -59,7 +59,9 @@ export interface SerializedPassThroughWebSocketData {
 }
 
 export class PassThroughWebSocketStepDefinition extends Serializable implements WebSocketStepDefinition {
+
     readonly type = 'ws-passthrough';
+    static readonly isFinal = true;
 
     // Same lookup configuration as normal request PassThroughStep:
     public readonly lookupOptions: PassThroughLookupOptions | undefined;
@@ -144,6 +146,7 @@ export class PassThroughWebSocketStepDefinition extends Serializable implements
 export class EchoWebSocketStepDefinition extends Serializable implements WebSocketStepDefinition {
 
     readonly type = 'ws-echo';
+    static readonly isFinal = true;
 
     explain(): string {
         return "echo all websocket messages";
@@ -153,6 +156,7 @@ export class EchoWebSocketStepDefinition extends Serializable implements WebSock
 export class ListenWebSocketStepDefinition extends Serializable implements WebSocketStepDefinition {
 
     readonly type = 'ws-listen';
+    static readonly isFinal = true;
 
     explain(): string {
         return "silently accept websocket messages without responding";
@@ -162,6 +166,7 @@ export class ListenWebSocketStepDefinition extends Serializable implements WebSo
 export class RejectWebSocketStepDefinition extends Serializable implements WebSocketStepDefinition {
 
     readonly type = 'ws-reject';
+    static readonly isFinal = true;
 
     constructor(
         public readonly statusCode: number,

test/integration/manual-rule-building.spec.ts

@@ -119,4 +119,18 @@ describe("Mockttp rule building", function () {
             })
         })()).to.be.rejectedWith('Cannot create a rule with no steps');
     });
+
+    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')],
+                steps: [
+                    new requestSteps.SimpleStepDefinition(200),
+                    new requestSteps.SimpleStepDefinition(200)
+                ]
+            });
+        })()).to.be.rejectedWith(
+            'Cannot create a rule with a final step before the last position ("respond with status 200" in position 1 of 2)'
+        );
+    });
 });