Move request step definition materialization into the impl classes

This allows us to more easily control this process for cases that need
to instantiate impl-only fields etc. It also helps demarcate the two
step process: first we turn data into definition (for remote clients)
then we turn definition into implementation.

Author: pimterry

src/rules/requests/request-rule.ts

@@ -55,21 +55,21 @@ export class RequestRule implements RequestRule {
         this.matchers = data.matchers;
         this.completionChecker = data.completionChecker;
 
-        this.steps = data.steps.map((stepDefinition, i) => {
-            const step = Object.assign(
-                Object.create(StepLookup[stepDefinition.type].prototype),
-                stepDefinition
-            ) as RequestStepImpl;
+        this.steps = data.steps.map(<S extends RequestStepDefinition>(stepDefinition: S, i: number) => {
+            const StepImplClass = StepLookup[stepDefinition.type];
 
-            if (StepLookup[step.type].isFinal && i !== data.steps.length - 1) {
+            if (StepImplClass.isFinal && i !== data.steps.length - 1) {
                 throw new Error(
                     `Cannot create a rule with a final step before the last position ("${
-                        step.explain()
+                        stepDefinition.explain()
                     }" in position ${i + 1} of ${data.steps.length})`
                 );
             }
 
-            return step;
+            // All step impls have a fromDefinition static method that turns a definition into a
+            // full impl (copying data and initializing any impl-only fields). Note that for remote clients,
+            // the definition itself has already been deserialized by impl.deserialize(data) beforehand.
+            return StepImplClass.fromDefinition(stepDefinition as any) as RequestStepImpl;
         });
     }
 

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

@@ -755,11 +755,6 @@ export class PassThroughStep extends Serializable implements RequestStepDefiniti
 
     public readonly simulateConnectionErrors: boolean;
 
-    // Used in subclass - awkwardly needs to be initialized here to ensure that its set when using a
-    // step built from a definition. In future, we could improve this (compose instead of inheritance
-    // to better control step construction?) but this will do for now.
-    protected outgoingSockets = new Set<net.Socket>();
-
     constructor(options: PassThroughStepOptions = {}) {
         super();
 

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

@@ -165,13 +165,19 @@ export interface RequestStepImpl extends RequestStepDefinition {
     >;
 }
 
+const copyDefinitionToImpl = (defn: RequestStepDefinition): RequestStepImpl =>
+    Object.assign(Object.create(StepLookup[defn.type].prototype), defn);
+
 export interface RequestStepOptions {
     emitEventCallback?: (type: string, event: unknown) => void;
     keyLogStream?: Writable;
     debug: boolean;
 }
 
 export class FixedResponseStepImpl extends FixedResponseStep {
+
+    static readonly fromDefinition = copyDefinitionToImpl;
+
     async handle(_request: OngoingRequest, response: OngoingResponse) {
         if (this.headers) dropDefaultHeaders(response);
         writeHead(response, this.status, this.statusMessage, this.headers);
@@ -231,6 +237,8 @@ async function writeResponseFromCallback(
 
 export class CallbackStepImpl extends CallbackStep {
 
+    static readonly fromDefinition = copyDefinitionToImpl;
+
     async handle(request: OngoingRequest, response: OngoingResponse) {
         let req = await waitForCompletedRequest(request);
 
@@ -285,6 +293,8 @@ export class CallbackStepImpl extends CallbackStep {
 
 export class StreamStepImpl extends StreamStep {
 
+    static readonly fromDefinition = copyDefinitionToImpl;
+
     async handle(request: OngoingRequest, response: OngoingResponse) {
         if (!this.stream.done) {
             if (this.headers) dropDefaultHeaders(response);
@@ -366,6 +376,9 @@ export class StreamStepImpl extends StreamStep {
 }
 
 export class FileStepImpl extends FileStep {
+
+    static readonly fromDefinition = copyDefinitionToImpl;
+
     async handle(_request: OngoingRequest, response: OngoingResponse) {
         // Read the file first, to ensure we error cleanly if it's unavailable
         const fileContents = await fs.readFile(this.filePath);
@@ -423,6 +436,11 @@ const h2ProtocolQueue = new Map();
 
 export class PassThroughStepImpl extends PassThroughStep {
 
+    // In this case, we actually use the constructor, to ensure we initialize fields as normal:
+    static readonly fromDefinition = (defn: PassThroughStep) => Object.assign(new PassThroughStepImpl(), defn);
+
+    protected outgoingSockets = new Set<net.Socket>();
+
     private _trustedCACertificates: MaybePromise<Array<string> | undefined>;
     private async trustedCACertificates(): Promise<Array<string> | undefined> {
         if (!this.extraCACertificates.length) return undefined;
@@ -1379,6 +1397,9 @@ export class PassThroughStepImpl extends PassThroughStep {
 }
 
 export class CloseConnectionStepImpl extends CloseConnectionStep {
+
+    static readonly fromDefinition = () => new CloseConnectionStepImpl();
+
     async handle(request: OngoingRequest) {
         const socket: net.Socket = (request as any).socket;
         socket.end();
@@ -1387,6 +1408,9 @@ export class CloseConnectionStepImpl extends CloseConnectionStep {
 }
 
 export class ResetConnectionStepImpl extends ResetConnectionStep {
+
+    static readonly fromDefinition = () => new ResetConnectionStepImpl();
+
     constructor() {
         super();
         requireSocketResetSupport();
@@ -1408,13 +1432,19 @@ export class ResetConnectionStepImpl extends ResetConnectionStep {
 }
 
 export class TimeoutStepImpl extends TimeoutStep {
+
+    static readonly fromDefinition = () => new TimeoutStepImpl();
+
     async handle() {
         // Do nothing, leaving the socket open but never sending a response.
         return new Promise<void>(() => {});
     }
 }
 
 export class JsonRpcResponseStepImpl extends JsonRpcResponseStep {
+
+    static readonly fromDefinition = copyDefinitionToImpl;
+
     async handle(request: OngoingRequest, response: OngoingResponse) {
         const data: any = await request.body.asJson()
             .catch(() => {}); // Handle parsing errors with the check below
@@ -1436,13 +1466,19 @@ export class JsonRpcResponseStepImpl extends JsonRpcResponseStep {
 }
 
 export class DelayStepImpl extends DelayStep {
+
+    static readonly fromDefinition = copyDefinitionToImpl;
+
     async handle(): Promise<{ continue: true }> {
         await delay(this.delayMs);
         return { continue: true };
     }
 }
 
 export class WaitForRequestBodyStepImpl extends WaitForRequestBodyStep {
+
+    static readonly fromDefinition = () => new WaitForRequestBodyStepImpl();
+
     async handle(request: OngoingRequest): Promise<{ continue: true }> {
         await request.body.asBuffer();
         return { continue: true };
@@ -1458,6 +1494,8 @@ const encodeWebhookBody = (body: Buffer) => {
 
 export class WebhookStepImpl extends WebhookStep {
 
+   static readonly fromDefinition = copyDefinitionToImpl;
+
     private sendEvent(data: {
         eventType: string;
         eventData: {};
@@ -1530,7 +1568,7 @@ export class WebhookStepImpl extends WebhookStep {
     }
 }
 
-export const StepLookup: typeof StepDefinitionLookup = {
+export const StepLookup = {
     'simple': FixedResponseStepImpl,
     'callback': CallbackStepImpl,
     'stream': StreamStepImpl,