ng-talkback 21.0.16 → 21.0.18

package/browser/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ng-talkback/browser",
-  "version": "21.0.16",
+  "version": "21.0.18",
   "peerDependencies": {
     "@angular/common": "^21.0.0",
     "@angular/core": "^21.0.0"

package/browser-prod/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ng-talkback/browser-prod",
-  "version": "21.0.16",
+  "version": "21.0.18",
   "peerDependencies": {
     "@angular/common": "^21.0.0",
     "@angular/core": "^21.0.0"

package/lib/build-info._auto-generated_.d.ts

@@ -21,4 +21,4 @@ export declare const CURRENT_PACKAGE_TAON_VERSION = "v21";
 /**
  *  Autogenerated by current cli tool. Use *tnp release* to bump version.
  */
-export declare const CURRENT_PACKAGE_VERSION = "21.0.16";
+export declare const CURRENT_PACKAGE_VERSION = "21.0.18";

package/lib/build-info._auto-generated_.js

@@ -25,6 +25,6 @@ exports.CURRENT_PACKAGE_TAON_VERSION = 'v21';
 /**
  *  Autogenerated by current cli tool. Use *tnp release* to bump version.
  */
-exports.CURRENT_PACKAGE_VERSION = '21.0.16';
+exports.CURRENT_PACKAGE_VERSION = '21.0.18';
 // THIS FILE IS GENERATED - DO NOT MODIFY
 //# sourceMappingURL=build-info._auto-generated_.js.map

package/lib/package.json

@@ -1,4 +1,4 @@
 {
   "name": "ng-talkback/lib",
-  "version": "21.0.16"
+  "version": "21.0.18"
 }

package/lib-prod/{build-info._auto-generated_.ts → build-info._auto-generated_.js}

@@ -22,6 +22,5 @@ export const CURRENT_PACKAGE_TAON_VERSION = 'v21';
 /**
  *  Autogenerated by current cli tool. Use *tnp release* to bump version.
  */
-export const CURRENT_PACKAGE_VERSION = '21.0.16';
+export const CURRENT_PACKAGE_VERSION = '21.0.18';
 // THIS FILE IS GENERATED - DO NOT MODIFY
-      

package/lib-prod/env/{env.angular-node-app.ts → env.angular-node-app.js}

@@ -63,4 +63,4 @@ export const ENV_ANGULAR_NODE_APP_IS_CI_PROCESS = undefined;
 export const ENV_ANGULAR_NODE_APP_DOCKER_ADDITIONAL_CONTAINER = undefined;
 export const ENV_ANGULAR_NODE_APP_DOCKER_SKIP_START_IN_ORDER = undefined;
 export const ENV_ANGULAR_NODE_APP_DOCKER_SKIP_USING_MYSQL_DB = undefined;
-// THIS FILE IS GENERATED - DO NOT MODIFY
+// THIS FILE IS GENERATED - DO NOT MODIFY

package/lib-prod/env/{env.docs-webapp.ts → env.docs-webapp.js}

@@ -63,4 +63,4 @@ export const ENV_DOCS_WEBAPP_IS_CI_PROCESS = undefined;
 export const ENV_DOCS_WEBAPP_DOCKER_ADDITIONAL_CONTAINER = undefined;
 export const ENV_DOCS_WEBAPP_DOCKER_SKIP_START_IN_ORDER = undefined;
 export const ENV_DOCS_WEBAPP_DOCKER_SKIP_USING_MYSQL_DB = undefined;
-// THIS FILE IS GENERATED - DO NOT MODIFY
+// THIS FILE IS GENERATED - DO NOT MODIFY

package/lib-prod/env/{env.electron-app.ts → env.electron-app.js}

@@ -63,4 +63,4 @@ export const ENV_ELECTRON_APP_IS_CI_PROCESS = undefined;
 export const ENV_ELECTRON_APP_DOCKER_ADDITIONAL_CONTAINER = undefined;
 export const ENV_ELECTRON_APP_DOCKER_SKIP_START_IN_ORDER = undefined;
 export const ENV_ELECTRON_APP_DOCKER_SKIP_USING_MYSQL_DB = undefined;
-// THIS FILE IS GENERATED - DO NOT MODIFY
+// THIS FILE IS GENERATED - DO NOT MODIFY

package/lib-prod/env/{env.mobile-app.ts → env.mobile-app.js}

@@ -63,4 +63,4 @@ export const ENV_MOBILE_APP_IS_CI_PROCESS = undefined;
 export const ENV_MOBILE_APP_DOCKER_ADDITIONAL_CONTAINER = undefined;
 export const ENV_MOBILE_APP_DOCKER_SKIP_START_IN_ORDER = undefined;
 export const ENV_MOBILE_APP_DOCKER_SKIP_USING_MYSQL_DB = undefined;
-// THIS FILE IS GENERATED - DO NOT MODIFY
+// THIS FILE IS GENERATED - DO NOT MODIFY

package/lib-prod/env/{env.npm-lib-and-cli-tool.ts → env.npm-lib-and-cli-tool.js}

@@ -63,4 +63,4 @@ export const ENV_NPM_LIB_AND_CLI_TOOL_IS_CI_PROCESS = undefined;
 export const ENV_NPM_LIB_AND_CLI_TOOL_DOCKER_ADDITIONAL_CONTAINER = undefined;
 export const ENV_NPM_LIB_AND_CLI_TOOL_DOCKER_SKIP_START_IN_ORDER = undefined;
 export const ENV_NPM_LIB_AND_CLI_TOOL_DOCKER_SKIP_USING_MYSQL_DB = undefined;
-// THIS FILE IS GENERATED - DO NOT MODIFY
+// THIS FILE IS GENERATED - DO NOT MODIFY

package/lib-prod/env/{env.vscode-plugin.ts → env.vscode-plugin.js}

@@ -63,4 +63,4 @@ export const ENV_VSCODE_PLUGIN_IS_CI_PROCESS = undefined;
 export const ENV_VSCODE_PLUGIN_DOCKER_ADDITIONAL_CONTAINER = undefined;
 export const ENV_VSCODE_PLUGIN_DOCKER_SKIP_START_IN_ORDER = undefined;
 export const ENV_VSCODE_PLUGIN_DOCKER_SKIP_USING_MYSQL_DB = undefined;
-// THIS FILE IS GENERATED - DO NOT MODIFY
+// THIS FILE IS GENERATED - DO NOT MODIFY

package/lib-prod/es6.backend.js

@@ -0,0 +1,2 @@
+import talkbackFn from './index';
+export default talkbackFn;

package/lib-prod/features/error-rate.backend.js

@@ -0,0 +1,21 @@
+import OptionsFactory from '../options.backend';
+export default class ErrorRate {
+    constructor(options) {
+        this.options = options;
+    }
+    shouldSimulate(req, tape) {
+        const globalErrorRate = typeof (this.options.errorRate) === 'number' ? this.options.errorRate : this.options.errorRate(req);
+        const errorRate = tape && tape.meta.errorRate !== undefined ? tape.meta.errorRate : globalErrorRate;
+        OptionsFactory.validateErrorRate(errorRate);
+        const random = Math.random() * 100;
+        return random < errorRate;
+    }
+    simulate(req) {
+        this.options.logger.log(`Simulating error for ${req.url}`);
+        return {
+            status: 503,
+            headers: { 'content-type': ['text/plain'] },
+            body: Buffer.from("talkback - failure injection")
+        };
+    }
+}

package/lib-prod/features/latency.backend.js

@@ -0,0 +1,28 @@
+import OptionsFactory from '../options.backend';
+export default class Latency {
+    constructor(options) {
+        this.options = options;
+    }
+    async simulate(req, tape) {
+        const resolved = Promise.resolve();
+        const latencyGenerator = tape && tape.meta.latency !== undefined ? tape.meta.latency : this.options.latency;
+        if (!latencyGenerator) {
+            return resolved;
+        }
+        OptionsFactory.validateLatency(latencyGenerator);
+        let latency = 0;
+        const type = typeof latencyGenerator;
+        if (type === "number") {
+            latency = latencyGenerator;
+        }
+        else if (Array.isArray(latencyGenerator)) {
+            const high = latencyGenerator[1];
+            const low = latencyGenerator[0];
+            latency = Math.random() * (high - low) + low;
+        }
+        else {
+            latency = latencyGenerator(req);
+        }
+        return new Promise(r => setTimeout(r, latency));
+    }
+}

package/lib-prod/{index._auto-generated_.ts → index._auto-generated_.js}

@@ -2,4 +2,4 @@
 // This file is auto-generated during init process. Do not modify.
 // This is only placeholder.
 // Use property "shouldGenerateAutogenIndexFile: true" 
-// in taon.jsonc to enable ts exports auto generation. 
+// in taon.jsonc to enable ts exports auto generation.

package/lib-prod/index.js

@@ -0,0 +1,19 @@
+let a = 2;
+a++;
+//#region @backend
+export * from './options.backend';
+export * from './tape.backend';
+import TalkbackFactory from './talkback-factory.backend';
+import { DefaultOptions, FallbackMode, RecordMode } from './options.backend';
+const talkbackFn = (options) => {
+    return TalkbackFactory.server(options);
+};
+talkbackFn.Options = {
+    Default: DefaultOptions,
+    FallbackMode,
+    RecordMode
+};
+talkbackFn.requestHandler = (options) => TalkbackFactory.requestHandler(options);
+export const talkback = talkbackFn;
+export default talkbackFn;
+//#endregion

package/lib-prod/logger.backend.js

@@ -0,0 +1,21 @@
+export default class Logger {
+    constructor(options) {
+        this.options = options;
+        if (this.options.debug) {
+            console.debug("DEBUG mode active");
+        }
+    }
+    log(message) {
+        if (!this.options.silent || this.options.debug) {
+            console.log(message);
+        }
+    }
+    debug(message) {
+        if (this.options.debug) {
+            console.debug(message);
+        }
+    }
+    error(message) {
+        console.error(message);
+    }
+}

package/lib-prod/migrations/index.js

@@ -0,0 +1,2 @@
+//@ts-nocheck
+export * from './migrations_index._auto-generated_';

package/lib-prod/migrations/{migrations_index._auto-generated_.ts → migrations_index._auto-generated_.js}

@@ -1,5 +1,3 @@
 // THIS FILE IS GENERATED - DO NOT MODIFY
-
 // THIS FILE IS GENERATED - DO NOT MODIFY
-
 // THIS FILE IS GENERATED - DO NOT MODIFY

package/lib-prod/options.backend.js

@@ -0,0 +1,85 @@
+import Logger from './logger.backend';
+export const RecordMode = {
+    NEW: "NEW", // If no tape matches the request, proxy it and save the response to a tape
+    OVERWRITE: "OVERWRITE", // Always proxy the request and save the response to a tape, overwriting any existing one
+    DISABLED: "DISABLED", // If a matching tape exists, return it. Otherwise, don't proxy the request and use `fallbackMode` for the response
+    ALL: []
+};
+RecordMode.ALL = [RecordMode.NEW, RecordMode.OVERWRITE, RecordMode.DISABLED];
+export const FallbackMode = {
+    NOT_FOUND: "NOT_FOUND",
+    PROXY: "PROXY",
+    ALL: []
+};
+FallbackMode.ALL = [FallbackMode.NOT_FOUND, FallbackMode.PROXY];
+export const DefaultOptions = {
+    host: "",
+    port: 8080,
+    path: "./tapes/",
+    record: RecordMode.NEW,
+    fallbackMode: FallbackMode.NOT_FOUND,
+    name: "unnamed",
+    tapeNameGenerator: undefined,
+    https: {
+        enabled: false,
+        keyPath: undefined,
+        certPath: undefined
+    },
+    ignoreHeaders: ["content-length", "host"],
+    ignoreQueryParams: [],
+    ignoreBody: false,
+    bodyMatcher: undefined,
+    urlMatcher: undefined,
+    requestDecorator: undefined,
+    responseDecorator: undefined,
+    tapeDecorator: undefined,
+    latency: 0,
+    errorRate: 0,
+    silent: false,
+    summary: true,
+    debug: false,
+    logger: new Logger({})
+};
+export default class OptionsFactory {
+    static prepare(usrOpts = {}) {
+        const opts = {
+            ...DefaultOptions,
+            name: usrOpts.host,
+            ...usrOpts,
+            ignoreHeaders: [
+                ...DefaultOptions.ignoreHeaders,
+                ...(usrOpts.ignoreHeaders || [])
+            ]
+        };
+        this.logger = new Logger(opts);
+        opts.logger = this.logger;
+        this.validateOptions(opts);
+        return opts;
+    }
+    static validateOptions(opts) {
+        this.validateRecord(opts.record);
+        this.validateFallbackMode(opts.fallbackMode);
+        this.validateLatency(opts.latency);
+        this.validateErrorRate(opts.errorRate);
+    }
+    static validateRecord(record) {
+        if (typeof (record) === "string" && !RecordMode.ALL.includes(record)) {
+            throw `INVALID OPTION: record has an invalid value of '${record}'`;
+        }
+    }
+    static validateFallbackMode(fallbackMode) {
+        if (typeof (fallbackMode) === "string" && !FallbackMode.ALL.includes(fallbackMode)) {
+            throw `INVALID OPTION: fallbackMode has an invalid value of '${fallbackMode}'`;
+        }
+    }
+    static validateLatency(latency) {
+        if (Array.isArray(latency) && latency.length !== 2) {
+            throw `Invalid LATENCY option. If using a range, the array should only have 2 values [min, max]. Current=[${latency}]`;
+        }
+    }
+    static validateErrorRate(errorRate) {
+        if (typeof (errorRate) !== "function" && (errorRate < 0 || errorRate > 100)) {
+            throw `Invalid ERRORRATE option. Value should be between 0 and 100. Current=[${errorRate}]`;
+        }
+    }
+}

package/lib-prod/package.json

@@ -1,4 +1,4 @@
 {
   "name": "ng-talkback/lib-prod",
-  "version": "21.0.16"
+  "version": "21.0.18"
 }

package/lib-prod/request-handler.backend.js

@@ -0,0 +1,137 @@
+import { v4 as uuidv4 } from 'uuid';
+import axios from 'axios';
+import Tape from './tape.backend';
+import OptionsFactory, { RecordMode, FallbackMode } from './options.backend';
+import ErrorRate from './features/error-rate.backend';
+import Latency from './features/latency.backend';
+export default class RequestHandler {
+    constructor(tapeStore, options) {
+        this.tapeStore = tapeStore;
+        this.options = options;
+        this.errorRate = new ErrorRate(this.options);
+        this.latency = new Latency(this.options);
+    }
+    async handle(req) {
+        const matchingContext = {
+            id: uuidv4()
+        };
+        const recordMode = typeof (this.options.record) === "string" ? this.options.record : this.options.record(req);
+        OptionsFactory.validateRecord(recordMode);
+        if (this.options.requestDecorator) {
+            req = this.options.requestDecorator(req, matchingContext);
+            if (!req) {
+                throw new Error("requestDecorator didn't return a req object");
+            }
+        }
+        let newTape = new Tape(req, this.options);
+        let matchingTape = this.tapeStore.find(newTape);
+        let resObj, responseTape;
+        if (recordMode !== RecordMode.OVERWRITE && matchingTape) {
+            responseTape = matchingTape;
+            if (this.errorRate.shouldSimulate(req, matchingTape)) {
+                return this.errorRate.simulate(req);
+            }
+            await this.latency.simulate(req, matchingTape);
+        }
+        else {
+            if (matchingTape) {
+                responseTape = matchingTape;
+            }
+            else {
+                responseTape = newTape;
+            }
+            if (recordMode === RecordMode.NEW || recordMode === RecordMode.OVERWRITE) {
+                resObj = await this.makeRealRequest(req);
+                responseTape.res = { ...resObj };
+                if (this.options.tapeDecorator) {
+                    responseTape = this.options.tapeDecorator(responseTape, matchingContext);
+                    if (!responseTape) {
+                        throw new Error("tapeDecorator didn't return a tape object");
+                    }
+                }
+                await this.tapeStore.save(responseTape);
+            }
+            else {
+                resObj = await this.onNoRecord(req);
+                responseTape.res = { ...resObj };
+            }
+        }
+        resObj = responseTape.res;
+        if (this.options.responseDecorator) {
+            const clonedTape = await responseTape.clone();
+            const resTape = this.options.responseDecorator(clonedTape, req, matchingContext);
+            if (!resTape) {
+                throw new Error("responseDecorator didn't return a tape object");
+            }
+            if (resTape.res.headers["content-length"]) {
+                resTape.res.headers["content-length"] = resTape.res.body.length;
+            }
+            resObj = resTape.res;
+        }
+        return resObj;
+    }
+    async onNoRecord(req) {
+        const fallbackMode = typeof (this.options.fallbackMode) === "string" ? this.options.fallbackMode : this.options.fallbackMode(req);
+        OptionsFactory.validateFallbackMode(fallbackMode);
+        this.options.logger.log(`Tape for ${req.url} not found and recording is disabled (fallbackMode: ${fallbackMode})`);
+        this.options.logger.log({
+            url: req.url,
+            headers: req.headers
+        });
+        if (fallbackMode === FallbackMode.PROXY) {
+            if (this.errorRate.shouldSimulate(req, undefined)) {
+                return this.errorRate.simulate(req);
+            }
+            await this.latency.simulate(req, undefined);
+            return await this.makeRealRequest(req);
+        }
+        return {
+            status: 404,
+            headers: { "content-type": ["text/plain"] },
+            body: Buffer.from("talkback - tape not found")
+        };
+    }
+    async makeRealRequest(req) {
+        // let fetchBody: Buffer | null
+        let { method, url, body } = req;
+        // fetchBody = body
+        const headers = { ...req.headers };
+        delete headers.host;
+        const host = this.options.host;
+        // this.options.logger.log(`Making real request to ${host}${url}`)
+        // if (method === "GET" || method === "HEAD") {
+        //   fetchBody = null
+        // }
+        let urlToGetData = `${host}${url}`;
+        // console.log(`host: "${urlToGetData}"` )
+        // console.log(`url: "${url}"` )
+        var fRes = {
+            status: 400,
+            headers: {},
+            body: new Buffer('')
+        };
+        try {
+            // console.log(body.toString())
+            const r = await axios({
+                url: urlToGetData,
+                method,
+                headers,
+                data: body,
+                responseType: 'arraybuffer',
+            });
+            fRes = {
+                status: r.status,
+                headers: r.headers,
+                body: r.data
+            };
+        }
+        catch (err) {
+            fRes = {
+                status: err?.response?.status,
+                headers: err?.response?.headers,
+                body: err?.response?.data
+            };
+        }
+        return fRes;
+    }
+}

package/lib-prod/server.backend.js

@@ -0,0 +1,79 @@
+import RequestHandler from './request-handler.backend';
+import Summary from './summary.backend';
+import TapeStore from './tape-store.backend';
+import * as http from 'http';
+import { https, fse } from 'tnp-core/lib-prod';
+export default class TalkbackServer {
+    constructor(options) {
+        this.closed = false;
+        this.options = options;
+        this.tapeStore = new TapeStore(this.options);
+        this.requestHandler = new RequestHandler(this.tapeStore, this.options);
+        this.closeSignalHandler = this.close.bind(this);
+    }
+    handleRequest(rawReq, res) {
+        // console.log(`rawReq: ${rawReq.url}`)
+        let reqBody = [];
+        rawReq.on("data", (chunk) => {
+            reqBody.push(chunk);
+        }).on("end", async () => {
+            try {
+                const req = {
+                    headers: rawReq.headers,
+                    url: rawReq.url,
+                    method: rawReq.method,
+                    body: Buffer.concat(reqBody)
+                };
+                const fRes = await this.requestHandler.handle(req);
+                res.writeHead(fRes.status, fRes.headers);
+                res.end(fRes.body);
+            }
+            catch (ex) {
+                console.error("Error handling request", ex);
+                res.statusCode = 500;
+                res.end();
+            }
+        });
+    }
+    async start(callback) {
+        await this.tapeStore.load();
+        const handleRequest = this.handleRequest.bind(this);
+        const serverFactory = this.options.https.enabled ? () => {
+            const httpsOpts = {
+                key: fse.readFileSync(this.options.https.keyPath),
+                cert: fse.readFileSync(this.options.https.certPath)
+            };
+            return https.createServer(httpsOpts, handleRequest);
+        } : () => http.createServer(handleRequest);
+        this.server = serverFactory();
+        console.log(`Starting talkback on ${this.options.port}`);
+        this.server.listen(this.options.port, callback);
+        process.on("exit", this.closeSignalHandler);
+        process.on("SIGINT", this.closeSignalHandler);
+        process.on("SIGTERM", this.closeSignalHandler);
+        return this.server;
+    }
+    hasTapeBeenUsed(tapeName) {
+        return this.tapeStore.hasTapeBeenUsed(tapeName);
+    }
+    resetTapeUsage() {
+        this.tapeStore.resetTapeUsage();
+    }
+    close(callback) {
+        if (this.closed) {
+            return;
+        }
+        this.closed = true;
+        this.server.close(callback);
+        // @ts-ignore
+        process.removeListener("exit", this.closeSignalHandler);
+        // @ts-ignore
+        process.removeListener("SIGINT", this.closeSignalHandler);
+        // @ts-ignore
+        process.removeListener("SIGTERM", this.closeSignalHandler);
+        if (this.options.summary) {
+            const summary = new Summary(this.tapeStore.tapes, this.options);
+            summary.print();
+        }
+    }
+}

package/lib-prod/summary.backend.js

@@ -0,0 +1,19 @@
+export default class Summary {
+    constructor(tapes, opts) {
+        this.tapes = tapes;
+        this.opts = opts;
+    }
+    print() {
+        console.log(`===== SUMMARY (${this.opts.name}) =====`);
+        const newTapes = this.tapes.filter(t => t.new);
+        if (newTapes.length > 0) {
+            console.log("New tapes:");
+            newTapes.forEach(t => console.log(`- ${t.path}`));
+        }
+        const unusedTapes = this.tapes.filter(t => !t.used);
+        if (unusedTapes.length > 0) {
+            console.log("Unused tapes:");
+            unusedTapes.forEach(t => console.log(`- ${t.path}`));
+        }
+    }
+}

package/lib-prod/talkback-factory.backend.js

@@ -0,0 +1,16 @@
+import Options from './options.backend';
+import TapeStore from './tape-store.backend';
+import TalkbackServer from './server.backend';
+import RequestHandler from './request-handler.backend';
+export default class TalkbackFactory {
+    static server(options) {
+        const fullOptions = Options.prepare(options);
+        return new TalkbackServer(fullOptions);
+    }
+    static async requestHandler(options) {
+        const fullOptions = Options.prepare(options);
+        const tapeStore = new TapeStore(fullOptions);
+        await tapeStore.load();
+        return new RequestHandler(tapeStore, fullOptions);
+    }
+}

package/lib-prod/tape-matcher.backend.js

@@ -0,0 +1,91 @@
+import ContentEncoding from './utils/content-encoding.backend';
+import MediaType from './utils/media-type.backend';
+import { ___NS__isEqual } from 'tnp-core/lib-prod';
+export default class TapeMatcher {
+    constructor(tape, options) {
+        this.tape = tape;
+        this.options = options;
+    }
+    sameAs(otherTape) {
+        const otherReq = otherTape.req;
+        const req = this.tape.req;
+        if (!this.isSameUrl(req, otherReq)) {
+            return false;
+        }
+        if (!this.isSameMethod(req, otherReq)) {
+            return false;
+        }
+        if (!this.isSameHeaders(req, otherReq)) {
+            return false;
+        }
+        return this.options.ignoreBody || this.isSameBody(req, otherReq);
+    }
+    isSameBody(req, otherReq) {
+        const mediaType = new MediaType(req);
+        const contentEncoding = new ContentEncoding(req);
+        let sameBody;
+        if (contentEncoding.isUncompressed() && mediaType.isJSON() && req.body.length > 0 && otherReq.body.length > 0) {
+            const parsedReqBody = JSON.parse(req.body.toString());
+            const parsedOtherReqBody = JSON.parse(otherReq.body.toString());
+            sameBody = ___NS__isEqual(parsedReqBody, parsedOtherReqBody);
+        }
+        else {
+            sameBody = req.body.equals(otherReq.body);
+        }
+        if (!sameBody) {
+            if (!this.options.bodyMatcher) {
+                this.options.logger.debug(`Not same BODY ${req.body} vs ${otherReq.body}`);
+                return false;
+            }
+            const bodyMatches = this.options.bodyMatcher(this.tape, otherReq);
+            if (!bodyMatches) {
+                this.options.logger.debug(`Not same bodyMatcher ${req.body} vs ${otherReq.body}`);
+                return false;
+            }
+        }
+        return true;
+    }
+    isSameHeaders(req, otherReq) {
+        const currentHeadersLength = Object.keys(req.headers).length;
+        const otherHeadersLength = Object.keys(otherReq.headers).length;
+        const sameNumberOfHeaders = currentHeadersLength === otherHeadersLength;
+        if (!sameNumberOfHeaders) {
+            this.options.logger.debug(`Not same #HEADERS ${JSON.stringify(req.headers)} vs ${JSON.stringify(otherReq.headers)}`);
+            return false;
+        }
+        let headersSame = true;
+        Object.keys(req.headers).forEach(k => {
+            const entryHeader = req.headers[k];
+            const header = otherReq.headers[k];
+            headersSame = headersSame && entryHeader === header;
+        });
+        if (!headersSame) {
+            this.options.logger.debug(`Not same HEADERS values ${JSON.stringify(req.headers)} vs ${JSON.stringify(otherReq.headers)}`);
+            return false;
+        }
+        return true;
+    }
+    isSameMethod(req, otherReq) {
+        const sameMethod = req.method === otherReq.method;
+        if (!sameMethod) {
+            this.options.logger.debug(`Not same METHOD ${req.method} vs ${otherReq.method}`);
+            return false;
+        }
+        return true;
+    }
+    isSameUrl(req, otherReq) {
+        const sameURL = req.url === otherReq.url;
+        if (!sameURL) {
+            if (!this.options.urlMatcher) {
+                this.options.logger.debug(`Not same URL ${req.url} vs ${otherReq.url}`);
+                return false;
+            }
+            const urlMatches = this.options.urlMatcher(this.tape, otherReq);
+            if (!urlMatches) {
+                this.options.logger.debug(`Not same urlMatcher ${req.url} vs ${otherReq.url}`);
+                return false;
+            }
+        }
+        return true;
+    }
+}