mockttp/dist/rules/requests/request-rule.js

Mock HTTP server for testing HTTP clients and stubbing webservices

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.RequestRule = void 0;
exports.explainSteps = explainSteps;
const buffer_1 = require("buffer");
const types_1 = require("../../types");
const request_utils_1 = require("../../util/request-utils");
const matchers = require("../matchers");
const request_step_impls_1 = require("./request-step-impls");
const rule_serialization_1 = require("../rule-serialization");
class RequestRule {
    constructor(data) {
        this.requests = [];
        this.requestCount = 0;
        (0, rule_serialization_1.validateMockRuleData)(data);
        this.id = data.id || crypto.randomUUID();
        this.priority = data.priority ?? types_1.RulePriority.DEFAULT;
        this.matchers = data.matchers;
        this.completionChecker = data.completionChecker;
        this.steps = data.steps.map((stepDefinition, i) => {
            const step = Object.assign(Object.create(request_step_impls_1.StepLookup[stepDefinition.type].prototype), stepDefinition);
            if (request_step_impls_1.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;
        });
    }
    matches(request) {
        return matchers.matchesAll(request, this.matchers);
    }
    handle(req, res, options) {
        let stepsPromise = (async () => {
            for (let step of this.steps) {
                const result = await step.handle(req, res, {
                    emitEventCallback: options.emitEventCallback,
                    debug: options.debug
                });
                if (!result || result.continue === false)
                    break;
            }
        })();
        // 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 (options.record) {
            this.requests.push(Promise.race([
                // When the steps all resolve, the request is completed:
                stepsPromise,
                // If the response is closed before the step completes (due to aborts, step
                // timeouts, whatever) then that also counts as the request being completed:
                new Promise((resolve) => res.on('close', resolve))
            ])
                .catch(() => { }) // Ignore step errors here - we're only tracking the request
                .then(() => (0, request_utils_1.waitForCompletedRequest)(req))
                .catch(() => {
                // If for some reason the request is not completed, we still want to record it.
                // TODO: Update the body to return the data that has been received so far.
                const initiatedRequest = (0, request_utils_1.buildInitiatedRequest)(req);
                return {
                    ...initiatedRequest,
                    body: (0, request_utils_1.buildBodyReader)(buffer_1.Buffer.from([]), req.headers),
                    rawTrailers: [],
                    trailers: {}
                };
            }));
        }
        // Even if traffic recording is disabled, the number of matched
        // requests is still tracked
        this.requestCount += 1;
        return stepsPromise;
    }
    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 requests ${matchers.explainMatchers(this.matchers)}, ` +
            `and then ${explainSteps(this.steps)}`;
        if (this.completionChecker) {
            explanation += `, ${this.completionChecker.explain(withoutExactCompletion ? undefined : this.requestCount)}.`;
        }
        else {
            explanation += '.';
        }
        return explanation;
    }
    dispose() {
        this.steps.forEach(s => s.dispose());
        this.matchers.forEach(m => m.dispose());
        if (this.completionChecker)
            this.completionChecker.dispose();
    }
}
exports.RequestRule = RequestRule;
function explainSteps(steps) {
    if (steps.length === 1)
        return steps[0].explain();
    if (steps.length === 2) {
        return `${steps[0].explain()} then ${steps[1].explain()}`;
    }
    // With 3+, we need to oxford comma separate explanations to make them readable
    return steps.slice(0, -1)
        .map((s) => s.explain())
        .join(', ') + ', and ' + steps.slice(-1)[0].explain();
}
//# sourceMappingURL=request-rule.js.map