mocktp 0.0.1-security → 3.15.3

package/dist/rules/websockets/websocket-rule-builder.d.ts

@@ -0,0 +1,173 @@
+import { MockedEndpoint, Headers } from "../../types";
+import type { WebSocketRuleData } from "./websocket-rule";
+import { PassThroughWebSocketHandlerOptions } from './websocket-handler-definitions';
+import { BaseRuleBuilder } from "../base-rule-builder";
+/**
+ * @class WebSocketRuleBuilder
+
+ * A builder for defining websocket mock rules. Create one using
+ * `.forAnyWebSocket(path)` on a Mockttp instance, then call whatever
+ * methods you'd like here to define more precise matching behaviour,
+ * control how the connection is handled, and how many times this
+ * rule should be applied.
+ *
+ * When you're done, call a `.thenX()` method to register the configured rule
+ * with the server. These return a promise for a MockedEndpoint, which can be
+ * used to verify the details of the requests matched by the rule.
+ *
+ * This returns a promise because rule registration can be asynchronous,
+ * either when using a remote server or testing in the browser. Wait for the
+ * promise returned by `.thenX()` methods to guarantee that the rule has taken
+ * effect before sending requests to it.
+ */
+export declare class WebSocketRuleBuilder extends BaseRuleBuilder {
+    private addRule;
+    /**
+     * Mock rule builders should be constructed through the Mockttp instance you're
+     * using, not directly. You shouldn't ever need to call this constructor.
+     */
+    constructor(addRule: (rule: WebSocketRuleData) => Promise<MockedEndpoint>);
+    /**
+     * Pass matched websockets through to their real destination. This works
+     * for proxied requests only, and direct requests will be rejected with
+     * an error.
+     *
+     * This method takes options to configure how the request is passed
+     * through. See {@link PassThroughWebSocketHandlerOptions} for the full
+     * details of the options available.
+     *
+     * Calling this method registers the rule with the server, so it
+     * starts to handle requests.
+     *
+     * This method returns a promise that resolves with a mocked endpoint.
+     * Wait for the promise to confirm that the rule has taken effect
+     * before sending requests to be matched. The mocked endpoint
+     * can be used to assert on the requests matched by this rule.
+     *
+     * @category Responses
+     */
+    thenPassThrough(options?: PassThroughWebSocketHandlerOptions): Promise<MockedEndpoint>;
+    /**
+     * Forward matched websockets on to the specified forwardToUrl. The url
+     * specified must not include a path or an error will be thrown.
+     * The path portion of the original request url is used instead.
+     *
+     * The url may optionally contain a protocol. If it does, it will override
+     * the protocol (and potentially the port, if unspecified) of the request.
+     * If no protocol is specified, the protocol (and potentially the port)
+     * of the original request URL will be used instead.
+     *
+     * This method takes options to configure how the request is passed
+     * through. See {@link PassThroughWebSocketHandlerOptions} for the full
+     * details of the options available.
+     *
+     * Calling this method registers the rule with the server, so it
+     * starts to handle requests.
+     *
+     * This method returns a promise that resolves with a mocked endpoint.
+     * Wait for the promise to confirm that the rule has taken effect
+     * before sending requests to be matched. The mocked endpoint
+     * can be used to assert on the requests matched by this rule.
+     *
+     * @category Responses
+     */
+    thenForwardTo(forwardToLocation: string, options?: Omit<PassThroughWebSocketHandlerOptions, 'forwarding'> & {
+        forwarding?: Omit<PassThroughWebSocketHandlerOptions['forwarding'], 'targetHost'>;
+    }): Promise<MockedEndpoint>;
+    /**
+     * Accept incoming WebSocket connections, and echo every message
+     * received on the WebSocket back to the client.
+     *
+     * Calling this method registers the rule with the server, so it
+     * starts to handle requests.
+     *
+     * This method returns a promise that resolves with a mocked endpoint.
+     * Wait for the promise to confirm that the rule has taken effect
+     * before sending requests to be matched. The mocked endpoint
+     * can be used to assert on the requests matched by this rule.
+     *
+     * @category Responses
+     */
+    thenEcho(): Promise<MockedEndpoint>;
+    /**
+     * Accept incoming WebSocket connections, and simply listen to
+     * incoming messages without ever sending anything in return.
+     *
+     * Calling this method registers the rule with the server, so it
+     * starts to handle requests.
+     *
+     * This method returns a promise that resolves with a mocked endpoint.
+     * Wait for the promise to confirm that the rule has taken effect
+     * before sending requests to be matched. The mocked endpoint
+     * can be used to assert on the requests matched by this rule.
+     *
+     * @category Responses
+     */
+    thenPassivelyListen(): Promise<MockedEndpoint>;
+    /**
+     * Rejects connections, sending an HTTP response with the given
+     * status, message and body, to explicitly refuse the WebSocket
+     * handshake.
+     *
+     * Calling this method registers the rule with the server, so it
+     * starts to handle requests.
+     *
+     * This method returns a promise that resolves with a mocked endpoint.
+     * Wait for the promise to confirm that the rule has taken effect
+     * before sending requests to be matched. The mocked endpoint
+     * can be used to assert on the requests matched by this rule.
+     *
+     * @category Responses
+     */
+    thenRejectConnection(statusCode: number, statusMessage?: string, headers?: Headers, body?: Buffer | string): Promise<MockedEndpoint>;
+    /**
+     * Close connections that match this rule immediately, without accepting
+     * the socket or sending any other response.
+     *
+     * Calling this method registers the rule with the server, so it
+     * starts to handle requests.
+     *
+     * This method returns a promise that resolves with a mocked endpoint.
+     * Wait for the promise to confirm that the rule has taken effect
+     * before sending requests to be matched. The mocked endpoint
+     * can be used to assert on the requests matched by this rule.
+     *
+     * @category Responses
+     */
+    thenCloseConnection(): Promise<MockedEndpoint>;
+    /**
+     * Reset connections that match this rule immediately, sending a TCP
+     * RST packet directly, without accepting the socket or sending any
+     * other response, and without cleanly closing the TCP connection.
+     *
+     * This is only supported in Node.js versions (>=16.17, >=18.3.0, or
+     * later), where `net.Socket` includes the `resetAndDestroy` method.
+     *
+     * Calling this method registers the rule with the server, so it
+     * starts to handle requests.
+     *
+     * This method returns a promise that resolves with a mocked endpoint.
+     * Wait for the promise to confirm that the rule has taken effect
+     * before sending requests to be matched. The mocked endpoint
+     * can be used to assert on the requests matched by this rule.
+     *
+     * @category Responses
+     */
+    thenResetConnection(): Promise<MockedEndpoint>;
+    /**
+     * Hold open connections that match this rule, but never respond
+     * with anything at all, typically causing a timeout on the client side.
+     *
+     * Calling this method registers the rule with the server, so it
+     * starts to handle requests.
+     *
+     * This method returns a promise that resolves with a mocked endpoint.
+     * Wait for the promise to confirm that the rule has taken effect
+     * before sending requests to be matched. The mocked endpoint
+     * can be used to assert on the requests matched by this rule.
+     *
+     * @category Responses
+     */
+    thenTimeout(): Promise<MockedEndpoint>;
+}
+//# sourceMappingURL=websocket-rule-builder.d.ts.map

package/dist/rules/websockets/websocket-rule-builder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"websocket-rule-builder.d.ts","sourceRoot":"","sources":["../../../src/rules/websockets/websocket-rule-builder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AACtD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAE1D,OAAO,EAKH,kCAAkC,EAIrC,MAAM,iCAAiC,CAAC;AAEzC,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAGvD;;;;;;;;;;;;;;;;;GAiBG;AACH,qBAAa,oBAAqB,SAAQ,eAAe;IAOjD,OAAO,CAAC,OAAO;IALnB;;;OAGG;gBAES,OAAO,EAAE,CAAC,IAAI,EAAE,iBAAiB,KAAK,OAAO,CAAC,cAAc,CAAC;IAQzE;;;;;;;;;;;;;;;;;;OAkBG;IACH,eAAe,CAAC,OAAO,GAAE,kCAAuC,GAAG,OAAO,CAAC,cAAc,CAAC;IAS1F;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACG,aAAa,CACf,iBAAiB,EAAE,MAAM,EACzB,OAAO,GAAE,IAAI,CAAC,kCAAkC,EAAE,YAAY,CAAC,GAAG;QAC9D,UAAU,CAAC,EAAE,IAAI,CAAC,kCAAkC,CAAC,YAAY,CAAC,EAAE,YAAY,CAAC,CAAA;KAC/E,GACP,OAAO,CAAC,cAAc,CAAC;IAe1B;;;;;;;;;;;;;OAaG;IACH,QAAQ,IAAI,OAAO,CAAC,cAAc,CAAC;IASnC;;;;;;;;;;;;;OAaG;IACH,mBAAmB,IAAI,OAAO,CAAC,cAAc,CAAC;IAS9C;;;;;;;;;;;;;;OAcG;IACH,oBAAoB,CAChB,UAAU,EAAE,MAAM,EAClB,aAAa,CAAC,EAAE,MAAM,EACtB,OAAO,CAAC,EAAE,OAAO,EACjB,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM,GACvB,OAAO,CAAC,cAAc,CAAC;IAc1B;;;;;;;;;;;;;OAaG;IACH,mBAAmB,IAAI,OAAO,CAAC,cAAc,CAAC;IAS9C;;;;;;;;;;;;;;;;;OAiBG;IACH,mBAAmB,IAAI,OAAO,CAAC,cAAc,CAAC;IAS9C;;;;;;;;;;;;;OAaG;IACH,WAAW,IAAI,OAAO,CAAC,cAAc,CAAC;CAQzC"}

package/dist/rules/websockets/websocket-rule-builder.js

@@ -0,0 +1,232 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebSocketRuleBuilder = void 0;
+const websocket_handler_definitions_1 = require("./websocket-handler-definitions");
+const base_rule_builder_1 = require("../base-rule-builder");
+const matchers_1 = require("../matchers");
+/**
+ * @class WebSocketRuleBuilder
+
+ * A builder for defining websocket mock rules. Create one using
+ * `.forAnyWebSocket(path)` on a Mockttp instance, then call whatever
+ * methods you'd like here to define more precise matching behaviour,
+ * control how the connection is handled, and how many times this
+ * rule should be applied.
+ *
+ * When you're done, call a `.thenX()` method to register the configured rule
+ * with the server. These return a promise for a MockedEndpoint, which can be
+ * used to verify the details of the requests matched by the rule.
+ *
+ * This returns a promise because rule registration can be asynchronous,
+ * either when using a remote server or testing in the browser. Wait for the
+ * promise returned by `.thenX()` methods to guarantee that the rule has taken
+ * effect before sending requests to it.
+ */
+class WebSocketRuleBuilder extends base_rule_builder_1.BaseRuleBuilder {
+    /**
+     * Mock rule builders should be constructed through the Mockttp instance you're
+     * using, not directly. You shouldn't ever need to call this constructor.
+     */
+    constructor(addRule) {
+        super();
+        this.addRule = addRule;
+        // By default, websockets just match everything:
+        this.matchers.push(new matchers_1.WildcardMatcher());
+    }
+    /**
+     * Pass matched websockets through to their real destination. This works
+     * for proxied requests only, and direct requests will be rejected with
+     * an error.
+     *
+     * This method takes options to configure how the request is passed
+     * through. See {@link PassThroughWebSocketHandlerOptions} for the full
+     * details of the options available.
+     *
+     * Calling this method registers the rule with the server, so it
+     * starts to handle requests.
+     *
+     * This method returns a promise that resolves with a mocked endpoint.
+     * Wait for the promise to confirm that the rule has taken effect
+     * before sending requests to be matched. The mocked endpoint
+     * can be used to assert on the requests matched by this rule.
+     *
+     * @category Responses
+     */
+    thenPassThrough(options = {}) {
+        const rule = {
+            ...this.buildBaseRuleData(),
+            handler: new websocket_handler_definitions_1.PassThroughWebSocketHandlerDefinition(options)
+        };
+        return this.addRule(rule);
+    }
+    /**
+     * Forward matched websockets on to the specified forwardToUrl. The url
+     * specified must not include a path or an error will be thrown.
+     * The path portion of the original request url is used instead.
+     *
+     * The url may optionally contain a protocol. If it does, it will override
+     * the protocol (and potentially the port, if unspecified) of the request.
+     * If no protocol is specified, the protocol (and potentially the port)
+     * of the original request URL will be used instead.
+     *
+     * This method takes options to configure how the request is passed
+     * through. See {@link PassThroughWebSocketHandlerOptions} for the full
+     * details of the options available.
+     *
+     * Calling this method registers the rule with the server, so it
+     * starts to handle requests.
+     *
+     * This method returns a promise that resolves with a mocked endpoint.
+     * Wait for the promise to confirm that the rule has taken effect
+     * before sending requests to be matched. The mocked endpoint
+     * can be used to assert on the requests matched by this rule.
+     *
+     * @category Responses
+     */
+    async thenForwardTo(forwardToLocation, options = {}) {
+        const rule = {
+            ...this.buildBaseRuleData(),
+            handler: new websocket_handler_definitions_1.PassThroughWebSocketHandlerDefinition({
+                ...options,
+                forwarding: {
+                    ...options.forwarding,
+                    targetHost: forwardToLocation
+                }
+            })
+        };
+        return this.addRule(rule);
+    }
+    /**
+     * Accept incoming WebSocket connections, and echo every message
+     * received on the WebSocket back to the client.
+     *
+     * Calling this method registers the rule with the server, so it
+     * starts to handle requests.
+     *
+     * This method returns a promise that resolves with a mocked endpoint.
+     * Wait for the promise to confirm that the rule has taken effect
+     * before sending requests to be matched. The mocked endpoint
+     * can be used to assert on the requests matched by this rule.
+     *
+     * @category Responses
+     */
+    thenEcho() {
+        const rule = {
+            ...this.buildBaseRuleData(),
+            handler: new websocket_handler_definitions_1.EchoWebSocketHandlerDefinition()
+        };
+        return this.addRule(rule);
+    }
+    /**
+     * Accept incoming WebSocket connections, and simply listen to
+     * incoming messages without ever sending anything in return.
+     *
+     * Calling this method registers the rule with the server, so it
+     * starts to handle requests.
+     *
+     * This method returns a promise that resolves with a mocked endpoint.
+     * Wait for the promise to confirm that the rule has taken effect
+     * before sending requests to be matched. The mocked endpoint
+     * can be used to assert on the requests matched by this rule.
+     *
+     * @category Responses
+     */
+    thenPassivelyListen() {
+        const rule = {
+            ...this.buildBaseRuleData(),
+            handler: new websocket_handler_definitions_1.ListenWebSocketHandlerDefinition()
+        };
+        return this.addRule(rule);
+    }
+    /**
+     * Rejects connections, sending an HTTP response with the given
+     * status, message and body, to explicitly refuse the WebSocket
+     * handshake.
+     *
+     * Calling this method registers the rule with the server, so it
+     * starts to handle requests.
+     *
+     * This method returns a promise that resolves with a mocked endpoint.
+     * Wait for the promise to confirm that the rule has taken effect
+     * before sending requests to be matched. The mocked endpoint
+     * can be used to assert on the requests matched by this rule.
+     *
+     * @category Responses
+     */
+    thenRejectConnection(statusCode, statusMessage, headers, body) {
+        const rule = {
+            ...this.buildBaseRuleData(),
+            handler: new websocket_handler_definitions_1.RejectWebSocketHandlerDefinition(statusCode, statusMessage, headers, body)
+        };
+        return this.addRule(rule);
+    }
+    /**
+     * Close connections that match this rule immediately, without accepting
+     * the socket or sending any other response.
+     *
+     * Calling this method registers the rule with the server, so it
+     * starts to handle requests.
+     *
+     * This method returns a promise that resolves with a mocked endpoint.
+     * Wait for the promise to confirm that the rule has taken effect
+     * before sending requests to be matched. The mocked endpoint
+     * can be used to assert on the requests matched by this rule.
+     *
+     * @category Responses
+     */
+    thenCloseConnection() {
+        const rule = {
+            ...this.buildBaseRuleData(),
+            handler: new websocket_handler_definitions_1.CloseConnectionHandlerDefinition()
+        };
+        return this.addRule(rule);
+    }
+    /**
+     * Reset connections that match this rule immediately, sending a TCP
+     * RST packet directly, without accepting the socket or sending any
+     * other response, and without cleanly closing the TCP connection.
+     *
+     * This is only supported in Node.js versions (>=16.17, >=18.3.0, or
+     * later), where `net.Socket` includes the `resetAndDestroy` method.
+     *
+     * Calling this method registers the rule with the server, so it
+     * starts to handle requests.
+     *
+     * This method returns a promise that resolves with a mocked endpoint.
+     * Wait for the promise to confirm that the rule has taken effect
+     * before sending requests to be matched. The mocked endpoint
+     * can be used to assert on the requests matched by this rule.
+     *
+     * @category Responses
+     */
+    thenResetConnection() {
+        const rule = {
+            ...this.buildBaseRuleData(),
+            handler: new websocket_handler_definitions_1.ResetConnectionHandlerDefinition()
+        };
+        return this.addRule(rule);
+    }
+    /**
+     * Hold open connections that match this rule, but never respond
+     * with anything at all, typically causing a timeout on the client side.
+     *
+     * Calling this method registers the rule with the server, so it
+     * starts to handle requests.
+     *
+     * This method returns a promise that resolves with a mocked endpoint.
+     * Wait for the promise to confirm that the rule has taken effect
+     * before sending requests to be matched. The mocked endpoint
+     * can be used to assert on the requests matched by this rule.
+     *
+     * @category Responses
+     */
+    thenTimeout() {
+        const rule = {
+            ...this.buildBaseRuleData(),
+            handler: new websocket_handler_definitions_1.TimeoutHandlerDefinition()
+        };
+        return this.addRule(rule);
+    }
+}
+exports.WebSocketRuleBuilder = WebSocketRuleBuilder;
+//# sourceMappingURL=websocket-rule-builder.js.map

package/dist/rules/websockets/websocket-rule-builder.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"websocket-rule-builder.js","sourceRoot":"","sources":["../../../src/rules/websockets/websocket-rule-builder.ts"],"names":[],"mappings":"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"}

package/dist/rules/websockets/websocket-rule.d.ts

@@ -0,0 +1,34 @@
+import * as net from 'net';
+import { OngoingRequest, CompletedRequest, Explainable } from "../../types";
+import { MaybePromise } from '../../util/type-utils';
+import * as matchers from "../matchers";
+import * as completionCheckers from "../completion-checkers";
+import { WebSocketHandler } from "./websocket-handlers";
+import type { WebSocketHandlerDefinition } from "./websocket-handler-definitions";
+export interface WebSocketRule extends Explainable {
+    id: string;
+    requests: Promise<CompletedRequest>[];
+    matches(request: OngoingRequest): MaybePromise<boolean>;
+    handle(request: OngoingRequest, response: net.Socket, head: Buffer, record: boolean): Promise<void>;
+    isComplete(): boolean | null;
+}
+export interface WebSocketRuleData {
+    id?: string;
+    priority?: number;
+    matchers: matchers.RequestMatcher[];
+    handler: WebSocketHandler | WebSocketHandlerDefinition;
+    completionChecker?: completionCheckers.RuleCompletionChecker;
+}
+export declare class WebSocketRule implements WebSocketRule {
+    private matchers;
+    private handler;
+    private completionChecker?;
+    id: string;
+    readonly priority: number;
+    requests: Promise<CompletedRequest>[];
+    requestCount: number;
+    constructor(data: WebSocketRuleData);
+    explain(withoutExactCompletion?: boolean): string;
+    dispose(): void;
+}
+//# sourceMappingURL=websocket-rule.d.ts.map

package/dist/rules/websockets/websocket-rule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"websocket-rule.d.ts","sourceRoot":"","sources":["../../../src/rules/websockets/websocket-rule.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,GAAG,MAAM,KAAK,CAAC;AAG3B,OAAO,EACH,cAAc,EACd,gBAAgB,EAChB,WAAW,EAEd,MAAM,aAAa,CAAC;AAErB,OAAO,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAIrD,OAAO,KAAK,QAAQ,MAAM,aAAa,CAAC;AACxC,OAAO,KAAK,kBAAkB,MAAM,wBAAwB,CAAC;AAC7D,OAAO,EAAE,gBAAgB,EAAmB,MAAM,sBAAsB,CAAC;AACzE,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,iCAAiC,CAAC;AAGlF,MAAM,WAAW,aAAc,SAAQ,WAAW;IAC9C,EAAE,EAAE,MAAM,CAAC;IACX,QAAQ,EAAE,OAAO,CAAC,gBAAgB,CAAC,EAAE,CAAC;IAGtC,OAAO,CAAC,OAAO,EAAE,cAAc,GAAG,YAAY,CAAC,OAAO,CAAC,CAAC;IACxD,MAAM,CAAC,OAAO,EAAE,cAAc,EAAE,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACpG,UAAU,IAAI,OAAO,GAAG,IAAI,CAAC;CAChC;AAED,MAAM,WAAW,iBAAiB;IAC9B,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,QAAQ,CAAC,cAAc,EAAE,CAAC;IACpC,OAAO,EAAE,gBAAgB,GAAG,0BAA0B,CAAC;IACvD,iBAAiB,CAAC,EAAE,kBAAkB,CAAC,qBAAqB,CAAC;CAChE;AAED,qBAAa,aAAc,YAAW,aAAa;IAC/C,OAAO,CAAC,QAAQ,CAA4B;IAC5C,OAAO,CAAC,OAAO,CAAmB;IAClC,OAAO,CAAC,iBAAiB,CAAC,CAA2C;IAE9D,EAAE,EAAE,MAAM,CAAC;IAClB,SAAgB,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,EAAE,OAAO,CAAC,gBAAgB,CAAC,EAAE,CAAM;IAC3C,YAAY,SAAK;gBAEZ,IAAI,EAAE,iBAAiB;IAiEnC,OAAO,CAAC,sBAAsB,UAAQ,GAAG,MAAM;IAe/C,OAAO;CAKV"}

package/dist/rules/websockets/websocket-rule.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebSocketRule = void 0;
+const uuid_1 = require("uuid");
+const types_1 = require("../../types");
+const request_utils_1 = require("../../util/request-utils");
+const rule_serialization_1 = require("../rule-serialization");
+const matchers = require("../matchers");
+const websocket_handlers_1 = require("./websocket-handlers");
+class WebSocketRule {
+    constructor(data) {
+        this.requests = [];
+        this.requestCount = 0;
+        (0, rule_serialization_1.validateMockRuleData)(data);
+        this.id = data.id || (0, uuid_1.v4)();
+        this.priority = data.priority ?? types_1.RulePriority.DEFAULT;
+        this.matchers = data.matchers;
+        if ('handle' in data.handler) {
+            this.handler = data.handler;
+        }
+        else {
+            // We transform the definition into a real handler, by creating an raw instance of the handler (which is
+            // a subtype of the definition with the same constructor) and copying the fields across.
+            this.handler = Object.assign(Object.create(websocket_handlers_1.WsHandlerLookup[data.handler.type].prototype), data.handler);
+        }
+        this.completionChecker = data.completionChecker;
+    }
+    matches(request) {
+        return matchers.matchesAll(request, this.matchers);
+    }
+    handle(req, res, head, record) {
+        let handlerPromise = (async () => {
+            return this.handler.handle(req, res, head);
+        })();
+        // Requests are added to rule.requests as soon as they start being handled,
+        // as promises, which resolve only when the response & request body is complete.
+        if (record) {
+            this.requests.push(Promise.race([
+                // When the handler resolves, the request is completed:
+                handlerPromise,
+                // If the response is closed before the handler completes (due to aborts, handler
+                // timeouts, whatever) then that also counts as the request being completed:
+                new Promise((resolve) => res.on('close', resolve))
+            ])
+                .catch(() => { }) // Ignore handler errors here - we're only tracking the request
+                .then(() => (0, request_utils_1.waitForCompletedRequest)(req)));
+        }
+        // Even if traffic recording is disabled, the number of matched
+        // requests is still tracked
+        this.requestCount += 1;
+        return handlerPromise;
+    }
+    isComplete() {
+        if (this.completionChecker) {
+            // If we have a specific rule, use that
+            return this.completionChecker.isComplete(this.requestCount);
+        }
+        else if (this.requestCount === 0) {
+            // Otherwise, by default we're definitely incomplete if we've seen no requests
+            return false;
+        }
+        else {
+            // And we're _maybe_ complete if we've seen at least one request. In reality, we're incomplete
+            // but we should be used anyway if we're at any point we're the last matching rule for a request.
+            return null;
+        }
+    }
+    explain(withoutExactCompletion = false) {
+        let explanation = `Match websockets ${matchers.explainMatchers(this.matchers)}, ` +
+            `and then ${this.handler.explain()}`;
+        if (this.completionChecker) {
+            explanation += `, ${this.completionChecker.explain(withoutExactCompletion ? undefined : this.requestCount)}.`;
+        }
+        else {
+            explanation += '.';
+        }
+        return explanation;
+    }
+    dispose() {
+        this.handler.dispose();
+        this.matchers.forEach(m => m.dispose());
+        if (this.completionChecker)
+            this.completionChecker.dispose();
+    }
+}
+exports.WebSocketRule = WebSocketRule;
+//# sourceMappingURL=websocket-rule.js.map

package/dist/rules/websockets/websocket-rule.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"websocket-rule.js","sourceRoot":"","sources":["../../../src/rules/websockets/websocket-rule.ts"],"names":[],"mappings":"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"}

package/dist/serialization/body-serialization.d.ts

@@ -0,0 +1,43 @@
+import { CompletedBody, Headers } from "../types";
+import { Replace } from "../util/type-utils";
+export declare function withSerializedBodyReader<T extends {
+    body: CompletedBody;
+}>(input: T): Replace<T, {
+    body: string;
+}>;
+export declare function withDeserializedBodyReader<T extends {
+    headers: Headers;
+    body: CompletedBody;
+}>(input: Replace<T, {
+    body: string;
+}>): T;
+/**
+ * Serialize a callback result (callback handlers, BeforeRequest/Response etc)
+ * to transform all the many possible buffer formats into either base64-encoded
+ * buffer data, or undefined.
+ */
+export declare function withSerializedCallbackBuffers<T extends {
+    body?: CompletedBody | Buffer | Uint8Array | ArrayBuffer | string;
+    rawBody?: Buffer | Uint8Array;
+}>(input: T): Replace<T, {
+    body: string | undefined;
+}>;
+export type WithSerializedCallbackBuffers<T extends {
+    body?: any;
+}> = Replace<T, {
+    body?: string;
+    rawBody?: string;
+}>;
+/**
+ * Deserialize a callback result (callback handlers, BeforeRequest/Response etc)
+ * to build buffer data (or undefined) from the base64-serialized data
+ * produced by withSerializedCallbackBuffers
+ */
+export declare function withDeserializedCallbackBuffers<T extends {
+    body?: Buffer | Uint8Array | string;
+    rawBody?: Buffer | Uint8Array;
+}>(input: Replace<T, {
+    body?: string;
+    rawBody?: string;
+}>): T;
+//# sourceMappingURL=body-serialization.d.ts.map

package/dist/serialization/body-serialization.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"body-serialization.d.ts","sourceRoot":"","sources":["../../src/serialization/body-serialization.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,aAAa,EAAE,OAAO,EAAE,MAAM,UAAU,CAAC;AAGlD,OAAO,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAI7C,wBAAgB,wBAAwB,CAAC,CAAC,SAAS;IAC/C,IAAI,EAAE,aAAa,CAAA;CACtB,EAAE,KAAK,EAAE,CAAC,GAAG,OAAO,CAAC,CAAC,EAAE;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC,CAKzC;AAED,wBAAgB,0BAA0B,CAAC,CAAC,SAAS;IAAE,OAAO,EAAE,OAAO,CAAC;IAAC,IAAI,EAAE,aAAa,CAAA;CAAE,EAC1F,KAAK,EAAE,OAAO,CAAC,CAAC,EAAE;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC,GACpC,CAAC,CAKH;AAED;;;;GAIG;AACH,wBAAgB,6BAA6B,CAAC,CAAC,SAAS;IACpD,IAAI,CAAC,EAAE,aAAa,GAAG,MAAM,GAAG,UAAU,GAAG,WAAW,GAAG,MAAM,CAAC;IAClE,OAAO,CAAC,EAAE,MAAM,GAAG,UAAU,CAAA;CAChC,EAAE,KAAK,EAAE,CAAC,GAAG,OAAO,CAAC,CAAC,EAAE;IAAE,IAAI,EAAE,MAAM,GAAG,SAAS,CAAA;CAAE,CAAC,CAsBrD;AAED,MAAM,MAAM,6BAA6B,CAAC,CAAC,SAAS;IAAE,IAAI,CAAC,EAAE,GAAG,CAAA;CAAE,IAC9D,OAAO,CAAC,CAAC,EAAE;IAAE,IAAI,CAAC,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,CAAC;AAEpD;;;;GAIG;AACH,wBAAgB,+BAA+B,CAAC,CAAC,SAAS;IACtD,IAAI,CAAC,EAAE,MAAM,GAAG,UAAU,GAAG,MAAM,CAAC;IACpC,OAAO,CAAC,EAAE,MAAM,GAAG,UAAU,CAAA;CAChC,EACG,KAAK,EAAE,OAAO,CAAC,CAAC,EAAE;IAAE,IAAI,CAAC,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,GACvD,CAAC,CAUH"}

package/dist/serialization/body-serialization.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withSerializedBodyReader = withSerializedBodyReader;
+exports.withDeserializedBodyReader = withDeserializedBodyReader;
+exports.withSerializedCallbackBuffers = withSerializedCallbackBuffers;
+exports.withDeserializedCallbackBuffers = withDeserializedCallbackBuffers;
+const _ = require("lodash");
+const base64_arraybuffer_1 = require("base64-arraybuffer");
+const buffer_utils_1 = require("../util/buffer-utils");
+const request_utils_1 = require("../util/request-utils");
+const serialization_1 = require("./serialization");
+function withSerializedBodyReader(input) {
+    return {
+        ...input,
+        body: (0, buffer_utils_1.asBuffer)(input.body.buffer).toString('base64')
+    };
+}
+function withDeserializedBodyReader(input) {
+    return {
+        ...input,
+        body: (0, request_utils_1.buildBodyReader)((0, serialization_1.deserializeBuffer)(input.body), input.headers)
+    };
+}
+/**
+ * Serialize a callback result (callback handlers, BeforeRequest/Response etc)
+ * to transform all the many possible buffer formats into either base64-encoded
+ * buffer data, or undefined.
+ */
+function withSerializedCallbackBuffers(input) {
+    let serializedBody;
+    if (!input.body) {
+        serializedBody = undefined;
+    }
+    else if (_.isString(input.body)) {
+        serializedBody = (0, serialization_1.serializeBuffer)((0, buffer_utils_1.asBuffer)(input.body));
+    }
+    else if (_.isBuffer(input.body)) {
+        serializedBody = (0, serialization_1.serializeBuffer)(input.body);
+    }
+    else if (_.isArrayBuffer(input.body) || _.isTypedArray(input.body)) {
+        serializedBody = (0, base64_arraybuffer_1.encode)(input.body);
+    }
+    else if ((0, request_utils_1.isMockttpBody)(input.body)) {
+        serializedBody = (0, serialization_1.serializeBuffer)((0, buffer_utils_1.asBuffer)(input.body.buffer));
+    }
+    return {
+        ...input,
+        body: serializedBody,
+        rawBody: input.rawBody
+            ? (0, serialization_1.serializeBuffer)((0, buffer_utils_1.asBuffer)(input.rawBody))
+            : undefined
+    };
+}
+/**
+ * Deserialize a callback result (callback handlers, BeforeRequest/Response etc)
+ * to build buffer data (or undefined) from the base64-serialized data
+ * produced by withSerializedCallbackBuffers
+ */
+function withDeserializedCallbackBuffers(input) {
+    return {
+        ...input,
+        body: input.body !== undefined
+            ? Buffer.from(input.body, 'base64')
+            : undefined,
+        rawBody: input.rawBody !== undefined
+            ? Buffer.from(input.rawBody, 'base64')
+            : undefined
+    };
+}
+//# sourceMappingURL=body-serialization.js.map