@blueprint-ts/core 4.1.0-beta.4 → 4.1.0-beta.6

package/dist/requests/drivers/mock/MockRequestDriver.js

@@ -0,0 +1,588 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { ResponseException } from '../../exceptions/ResponseException';
+import { isEqual } from 'lodash-es';
+import { MockRequestAssertionError } from './MockRequestAssertionError';
+import { MockResponseHandler } from './MockResponseHandler';
+function isPredicate(value) {
+    return typeof value === 'function';
+}
+function parseUrl(url) {
+    if (url instanceof URL) {
+        return url;
+    }
+    return new URL(url, 'https://mock-request.invalid');
+}
+function buildUrlWithoutQuery(url) {
+    const clone = new URL(url.toString());
+    clone.search = '';
+    return clone.toString();
+}
+function parseQuery(url) {
+    const query = {};
+    for (const [key, value] of url.searchParams.entries()) {
+        const current = query[key];
+        if (current === undefined) {
+            query[key] = value;
+            continue;
+        }
+        if (Array.isArray(current)) {
+            current.push(value);
+            continue;
+        }
+        query[key] = [current, value];
+    }
+    return query;
+}
+function stringify(value) {
+    return value === undefined ? 'undefined' : JSON.stringify(value, null, 2);
+}
+function getPredicateDescription(predicate) {
+    var _a;
+    return (_a = predicate.description) !== null && _a !== void 0 ? _a : '[custom matcher]';
+}
+function getTextBody(body) {
+    if (!body || body.kind !== 'text') {
+        return undefined;
+    }
+    return body.value;
+}
+function getJsonBody(body) {
+    const textBody = getTextBody(body);
+    if (textBody === undefined) {
+        return undefined;
+    }
+    try {
+        return JSON.parse(textBody);
+    }
+    catch (_a) {
+        return undefined;
+    }
+}
+function collectJsonDiffPaths(expected, actual, path = '', maxPaths = 10) {
+    const mismatches = [];
+    const visit = (left, right, currentPath) => {
+        if (mismatches.length >= maxPaths) {
+            return;
+        }
+        if (JSON.stringify(left) === JSON.stringify(right)) {
+            return;
+        }
+        if (Array.isArray(left) && Array.isArray(right)) {
+            if (left.length !== right.length) {
+                mismatches.push(currentPath || '(root)');
+                return;
+            }
+            left.forEach((item, index) => {
+                visit(item, right[index], currentPath ? `${currentPath}.${index}` : String(index));
+            });
+            return;
+        }
+        if (isRecord(left) && isRecord(right)) {
+            const keys = new Set([...Object.keys(left), ...Object.keys(right)]);
+            for (const key of keys) {
+                visit(left[key], right[key], currentPath ? `${currentPath}.${key}` : key);
+                if (mismatches.length >= maxPaths) {
+                    return;
+                }
+            }
+            return;
+        }
+        mismatches.push(currentPath || '(root)');
+    };
+    visit(expected, actual, path);
+    return mismatches;
+}
+function isRecord(value) {
+    return !!value && typeof value === 'object' && !Array.isArray(value);
+}
+export class MockRequestExpectationBuilder {
+    constructor(driver, criteria) {
+        this.driver = driver;
+        this.criteria = Object.assign({}, criteria);
+    }
+    withHeaders(headers) {
+        this.criteria.headers = headers;
+        return this;
+    }
+    withQuery(query) {
+        this.criteria.query = query;
+        return this;
+    }
+    withBody(body) {
+        this.criteria.body = body;
+        return this;
+    }
+    respond(response) {
+        this.driver.expect(Object.assign(Object.assign({}, this.criteria), { response }));
+        return this.driver;
+    }
+}
+export class MockRequestDriver {
+    constructor(config, expectations = [], options = {}) {
+        var _a;
+        this.config = config;
+        this.expectations = [];
+        this.history = [];
+        this.expectations.push(...expectations);
+        this.matchMode = (_a = options.matchMode) !== null && _a !== void 0 ? _a : 'ordered';
+    }
+    setMatchMode(mode) {
+        this.matchMode = mode;
+        return this;
+    }
+    ordered() {
+        return this.setMatchMode('ordered');
+    }
+    unordered() {
+        return this.setMatchMode('unordered');
+    }
+    expect(expectation) {
+        this.expectations.push(expectation);
+        return this;
+    }
+    expectAny(criteria) {
+        return new MockRequestExpectationBuilder(this, criteria);
+    }
+    reset() {
+        this.expectations = [];
+        this.history = [];
+        return this;
+    }
+    getHistory() {
+        return [...this.history];
+    }
+    assertNoPendingExpectations() {
+        this.assertExpectationsMet();
+    }
+    assertExpectationsMet() {
+        if (this.expectations.length === 0) {
+            return;
+        }
+        const nextExpectation = this.expectations[0];
+        if (!nextExpectation) {
+            return;
+        }
+        throw new MockRequestAssertionError([
+            `Expected ${this.expectations.length} more mocked request(s).`,
+            `Match mode: ${this.matchMode}`,
+            `Next expected request: ${this.describeExpectation(nextExpectation)}`
+        ].join('\n'));
+    }
+    send(url, method, headers, body, requestConfig) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            if ((_a = requestConfig === null || requestConfig === void 0 ? void 0 : requestConfig.abortSignal) === null || _a === void 0 ? void 0 : _a.aborted) {
+                throw new DOMException('The operation was aborted.', 'AbortError');
+            }
+            const actualRequest = yield this.normalizeActualRequest(url, method, headers, body);
+            const { index, expectation } = yield this.selectExpectation(actualRequest);
+            this.expectations.splice(index, 1);
+            this.history.push(this.toHistoryEntry(actualRequest));
+            const response = new MockResponseHandler(expectation.response);
+            if (!response.getRawResponse().ok) {
+                throw new ResponseException(response);
+            }
+            return response;
+        });
+    }
+    selectExpectation(actualRequest) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.expectations.length === 0) {
+                throw new MockRequestAssertionError(this.buildUnexpectedRequestMessage(actualRequest));
+            }
+            if (this.matchMode === 'ordered') {
+                const expectation = this.expectations[0];
+                if (!expectation) {
+                    throw new MockRequestAssertionError(this.buildUnexpectedRequestMessage(actualRequest));
+                }
+                const failure = yield this.matchExpectation(expectation, actualRequest);
+                if (failure) {
+                    throw new MockRequestAssertionError(this.buildMismatchMessage(failure, actualRequest));
+                }
+                return { index: 0, expectation };
+            }
+            const failures = [];
+            for (const [index, expectation] of this.expectations.entries()) {
+                const failure = yield this.matchExpectation(expectation, actualRequest);
+                if (!failure) {
+                    return { index, expectation };
+                }
+                failures.push(failure);
+            }
+            throw new MockRequestAssertionError(this.buildUnorderedMismatchMessage(actualRequest, failures));
+        });
+    }
+    matchExpectation(expectation, actualRequest) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const methodFailure = this.matchMethod(expectation.method, actualRequest, expectation);
+            if (methodFailure) {
+                return methodFailure;
+            }
+            const urlFailure = this.matchUrl(expectation, actualRequest);
+            if (urlFailure) {
+                return urlFailure;
+            }
+            const headersFailure = this.matchHeaders(expectation.headers, actualRequest, expectation);
+            if (headersFailure) {
+                return headersFailure;
+            }
+            const queryFailure = this.matchQuery(expectation.query, actualRequest, expectation);
+            if (queryFailure) {
+                return queryFailure;
+            }
+            return yield this.matchBody(expectation.body, actualRequest, expectation);
+        });
+    }
+    matchMethod(method, actualRequest, expectation) {
+        if (isPredicate(method)) {
+            if (method(actualRequest.method)) {
+                return undefined;
+            }
+            return {
+                field: 'method',
+                message: 'Method matcher returned false.',
+                expectation,
+                expectedValue: getPredicateDescription(method),
+                actualValue: actualRequest.method
+            };
+        }
+        if (method === actualRequest.method) {
+            return undefined;
+        }
+        return {
+            field: 'method',
+            message: 'HTTP method did not match.',
+            expectation,
+            expectedValue: method,
+            actualValue: actualRequest.method
+        };
+    }
+    matchUrl(expectation, actualRequest) {
+        if (isPredicate(expectation.url)) {
+            if (expectation.url(actualRequest.parsedUrl)) {
+                return undefined;
+            }
+            return {
+                field: 'url',
+                message: 'URL matcher returned false.',
+                expectation,
+                expectedValue: getPredicateDescription(expectation.url),
+                actualValue: actualRequest.url
+            };
+        }
+        const expectedUrl = parseUrl(expectation.url);
+        const actualComparableUrl = expectation.query !== undefined && expectedUrl.search.length === 0 ? actualRequest.urlWithoutQuery : actualRequest.url;
+        const expectedComparableUrl = expectation.query !== undefined && expectedUrl.search.length === 0 ? buildUrlWithoutQuery(expectedUrl) : this.normalizeUrl(expectation.url);
+        if (expectedComparableUrl === actualComparableUrl) {
+            return undefined;
+        }
+        return {
+            field: 'url',
+            message: 'URL did not match.',
+            expectation,
+            expectedValue: expectedComparableUrl,
+            actualValue: actualComparableUrl
+        };
+    }
+    matchHeaders(headers, actualRequest, expectation) {
+        if (headers === undefined) {
+            return undefined;
+        }
+        if (isPredicate(headers)) {
+            if (headers(actualRequest.headers)) {
+                return undefined;
+            }
+            return {
+                field: 'headers',
+                message: 'Header matcher returned false.',
+                expectation,
+                expectedValue: getPredicateDescription(headers),
+                actualValue: actualRequest.headers
+            };
+        }
+        const expectedHeaders = this.resolveHeaders(headers);
+        if (isEqual(expectedHeaders, actualRequest.headers)) {
+            return undefined;
+        }
+        return {
+            field: 'headers',
+            message: 'Headers did not match exactly.',
+            expectation,
+            expectedValue: expectedHeaders,
+            actualValue: actualRequest.headers
+        };
+    }
+    matchQuery(query, actualRequest, expectation) {
+        if (query === undefined) {
+            return undefined;
+        }
+        if (isPredicate(query)) {
+            if (query(actualRequest.query)) {
+                return undefined;
+            }
+            return {
+                field: 'query',
+                message: 'Query matcher returned false.',
+                expectation,
+                expectedValue: getPredicateDescription(query),
+                actualValue: actualRequest.query
+            };
+        }
+        if (isEqual(query, actualRequest.query)) {
+            return undefined;
+        }
+        return {
+            field: 'query',
+            message: 'Query parameters did not match exactly.',
+            expectation,
+            expectedValue: query,
+            actualValue: actualRequest.query
+        };
+    }
+    matchBody(body, actualRequest, expectation) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (body === undefined) {
+                return undefined;
+            }
+            if (isPredicate(body)) {
+                const context = this.createBodyMatchContext(actualRequest);
+                if (body(context)) {
+                    return undefined;
+                }
+                return {
+                    field: 'body',
+                    message: 'Body matcher returned false.',
+                    expectation,
+                    expectedValue: getPredicateDescription(body),
+                    actualValue: this.describeBodyForMessage(actualRequest.body)
+                };
+            }
+            const expectedBody = yield this.normalizeBody(body);
+            if (JSON.stringify(expectedBody) === JSON.stringify(actualRequest.body)) {
+                return undefined;
+            }
+            const expectedJson = getJsonBody(expectedBody);
+            const actualJson = getJsonBody(actualRequest.body);
+            return Object.assign({ field: 'body', message: expectedJson !== undefined && actualJson !== undefined ? 'JSON body did not match.' : 'Body did not match exactly.', expectation, expectedValue: expectedJson !== null && expectedJson !== void 0 ? expectedJson : expectedBody, actualValue: actualJson !== null && actualJson !== void 0 ? actualJson : actualRequest.body }, (expectedJson !== undefined && actualJson !== undefined ? { diffPaths: collectJsonDiffPaths(expectedJson, actualJson) } : {}));
+        });
+    }
+    createBodyMatchContext(actualRequest) {
+        return Object.assign(Object.assign({ method: actualRequest.method, url: actualRequest.url, headers: actualRequest.headers }, (actualRequest.body !== undefined ? { body: actualRequest.body } : {})), { getJson: () => getJsonBody(actualRequest.body), getText: () => getTextBody(actualRequest.body), getQuery: () => actualRequest.query });
+    }
+    normalizeActualRequest(url, method, headers, body) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const resolvedUrl = parseUrl(url);
+            const normalizedBody = yield this.normalizeBody(body === null || body === void 0 ? void 0 : body.getContent());
+            return Object.assign({ method, url: this.normalizeUrl(url), urlWithoutQuery: buildUrlWithoutQuery(resolvedUrl), parsedUrl: resolvedUrl, headers: this.resolveHeaders(Object.assign(Object.assign(Object.assign({}, (_a = this.config) === null || _a === void 0 ? void 0 : _a.headers), headers), body === null || body === void 0 ? void 0 : body.getHeaders())), query: parseQuery(resolvedUrl) }, (normalizedBody !== undefined ? { body: normalizedBody } : {}));
+        });
+    }
+    toHistoryEntry(request) {
+        return Object.assign({ method: request.method, url: request.url, headers: request.headers }, (request.body !== undefined ? { body: request.body } : {}));
+    }
+    buildUnexpectedRequestMessage(actualRequest) {
+        return ['Unexpected request received with no expectations left.', '', 'Actual request:', this.formatRequestSnapshot(actualRequest)].join('\n');
+    }
+    buildUnorderedMismatchMessage(actualRequest, failures) {
+        const pending = this.expectations.map((expectation, index) => `${index + 1}. ${this.describeExpectation(expectation)}`).join('\n');
+        const firstFailure = failures[0];
+        return [
+            'Mock request did not match any pending expectation.',
+            firstFailure ? `Closest failure: ${firstFailure.message}` : 'No expectation matched.',
+            '',
+            'Actual request:',
+            this.formatRequestSnapshot(actualRequest),
+            '',
+            'Pending expectations:',
+            pending
+        ].join('\n');
+    }
+    buildMismatchMessage(failure, actualRequest) {
+        const lines = [
+            `Mock request ${failure.field} mismatch.`,
+            failure.message,
+            '',
+            'Expected request:',
+            this.formatExpectationSnapshot(failure.expectation),
+            '',
+            'Actual request:',
+            this.formatRequestSnapshot(actualRequest)
+        ];
+        if (failure.expectedValue !== undefined || failure.actualValue !== undefined) {
+            lines.push('', `Expected ${failure.field}: ${stringify(failure.expectedValue)}`, `Actual ${failure.field}: ${stringify(failure.actualValue)}`);
+        }
+        if (failure.diffPaths && failure.diffPaths.length > 0) {
+            lines.push('', `Differing JSON paths: ${failure.diffPaths.join(', ')}`);
+        }
+        return lines.join('\n');
+    }
+    formatExpectationSnapshot(expectation) {
+        const lines = [`method: ${this.describeMatcher(expectation.method)}`, `url: ${this.describeUrlMatcher(expectation)}`];
+        if (expectation.headers !== undefined) {
+            lines.push(`headers: ${this.describeMatcher(expectation.headers)}`);
+        }
+        if (expectation.query !== undefined) {
+            lines.push(`query: ${this.describeMatcher(expectation.query)}`);
+        }
+        if (expectation.body !== undefined) {
+            lines.push(`body: ${this.describeBodyMatcher(expectation.body)}`);
+        }
+        return lines.join('\n');
+    }
+    formatRequestSnapshot(request) {
+        const lines = [
+            `method: ${request.method}`,
+            `url: ${request.url}`,
+            `headers: ${stringify(request.headers)}`,
+            `query: ${stringify(request.query)}`,
+            `body: ${stringify(this.describeBodyForMessage(request.body))}`
+        ];
+        return lines.join('\n');
+    }
+    describeExpectation(expectation) {
+        return `${this.describeMatcher(expectation.method)} ${this.describeUrlMatcher(expectation)}`;
+    }
+    describeMatcher(matcher) {
+        if (isPredicate(matcher)) {
+            return getPredicateDescription(matcher);
+        }
+        if (typeof matcher === 'object') {
+            return stringify(matcher);
+        }
+        return String(matcher);
+    }
+    describeUrlMatcher(expectation) {
+        if (isPredicate(expectation.url)) {
+            return getPredicateDescription(expectation.url);
+        }
+        const url = parseUrl(expectation.url);
+        if (expectation.query !== undefined && url.search.length === 0) {
+            return buildUrlWithoutQuery(url);
+        }
+        return this.normalizeUrl(expectation.url);
+    }
+    describeBodyMatcher(body) {
+        if (isPredicate(body)) {
+            return getPredicateDescription(body);
+        }
+        return stringify(body);
+    }
+    describeBodyForMessage(body) {
+        const json = getJsonBody(body);
+        return json !== null && json !== void 0 ? json : body;
+    }
+    normalizeUrl(url) {
+        return parseUrl(url).toString();
+    }
+    resolveHeaders(headers) {
+        const resolved = {};
+        for (const key in headers) {
+            const value = headers[key];
+            if (value === undefined) {
+                continue;
+            }
+            resolved[key] = typeof value === 'function' ? value() : value;
+        }
+        return resolved;
+    }
+    normalizeBody(body) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (body === undefined) {
+                return undefined;
+            }
+            if (body === null) {
+                return { kind: 'null' };
+            }
+            if (typeof body === 'string') {
+                return { kind: 'text', value: body };
+            }
+            if (body instanceof FormData) {
+                return yield this.normalizeFormData(body);
+            }
+            if (body instanceof Blob) {
+                const mimeType = body.type || undefined;
+                return Object.assign(Object.assign({ kind: 'binary' }, (mimeType !== undefined ? { mimeType } : {})), { bytes: Array.from(new Uint8Array(yield this.readBlob(body))) });
+            }
+            if (this.isBufferSource(body)) {
+                return {
+                    kind: 'binary',
+                    bytes: Array.from(new Uint8Array(this.toArrayBuffer(body)))
+                };
+            }
+            return {
+                kind: 'text',
+                value: JSON.stringify(body)
+            };
+        });
+    }
+    normalizeFormData(body) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const entries = [];
+            for (const [key, value] of body.entries()) {
+                if (typeof value === 'string') {
+                    entries.push({ key, value: { kind: 'text', value } });
+                    continue;
+                }
+                entries.push({
+                    key,
+                    value: Object.assign(Object.assign({ kind: 'file' }, this.getOptionalBlobDetails(value)), { bytes: Array.from(new Uint8Array(yield this.readBlob(value))) })
+                });
+            }
+            return { kind: 'form-data', entries };
+        });
+    }
+    getBlobName(value) {
+        if (typeof File !== 'undefined' && value instanceof File) {
+            return value.name;
+        }
+        return undefined;
+    }
+    getOptionalBlobDetails(value) {
+        const name = this.getBlobName(value);
+        const mimeType = value.type || undefined;
+        return Object.assign(Object.assign({}, (name !== undefined ? { name } : {})), (mimeType !== undefined ? { mimeType } : {}));
+    }
+    readBlob(value) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const blobWithReader = value;
+            if (typeof blobWithReader.arrayBuffer === 'function') {
+                return yield blobWithReader.arrayBuffer();
+            }
+            if (typeof FileReader !== 'undefined') {
+                return yield new Promise((resolve, reject) => {
+                    const reader = new FileReader();
+                    reader.onload = () => resolve(reader.result);
+                    reader.onerror = () => { var _a; return reject((_a = reader.error) !== null && _a !== void 0 ? _a : new Error('Failed to read Blob contents.')); };
+                    reader.readAsArrayBuffer(value);
+                });
+            }
+            return yield new Response(value).arrayBuffer();
+        });
+    }
+    isBufferSource(value) {
+        return value instanceof ArrayBuffer || ArrayBuffer.isView(value);
+    }
+    toArrayBuffer(value) {
+        if (value instanceof ArrayBuffer) {
+            return value.slice(0);
+        }
+        return value.buffer.slice(value.byteOffset, value.byteOffset + value.byteLength);
+    }
+}
+export function getMockRequestJsonBody(request) {
+    return getJsonBody(request.body);
+}
+export function getMockRequestTextBody(request) {
+    return getTextBody(request.body);
+}
+export function getMockRequestQuery(request) {
+    return parseQuery(parseUrl(request.url));
+}

package/dist/requests/drivers/mock/MockRequestTestHelpers.d.ts

@@ -0,0 +1,20 @@
+import { type DriverConfigContract } from '../../contracts/DriverConfigContract';
+import { type ResolvedHeadersContract } from '../../contracts/HeadersContract';
+import { type MockNormalizedRequestBody, type MockRequestBodyMatchContext, type MockRequestDriverOptions, MockRequestDriver, type MockRequestExpectation, type MockRequestHistoryEntry, type MockRequestPredicate, type MockRequestQuery, getMockRequestJsonBody, getMockRequestQuery, getMockRequestTextBody } from './MockRequestDriver';
+import { type MockResponseDefinition } from './MockResponseHandler';
+export interface InstallMockRequestDriverOptions extends MockRequestDriverOptions {
+    config?: DriverConfigContract;
+    expectations?: MockRequestExpectation[];
+}
+export declare function matchHeaders(expectedSubset: ResolvedHeadersContract): MockRequestPredicate<ResolvedHeadersContract>;
+export declare function matchQuery(expectedSubset: MockRequestQuery): MockRequestPredicate<MockRequestQuery>;
+export declare function expectJsonBody(expected: unknown, options?: {
+    partial?: boolean;
+}): MockRequestPredicate<MockRequestBodyMatchContext>;
+export declare function jsonResponse<ResponseBody extends object | string | Blob | BufferSource | null | undefined>(status: number, body: ResponseBody, headers?: ResolvedHeadersContract): MockResponseDefinition;
+export declare function validationError(errors: Record<string, string[]>, message?: string): MockResponseDefinition;
+export declare function emptyResponse(status?: number, headers?: ResolvedHeadersContract): MockResponseDefinition;
+export declare function installMockRequestDriver(options?: InstallMockRequestDriverOptions): MockRequestDriver;
+export declare function resetMockRequestDriver(): MockRequestDriver;
+export { getMockRequestJsonBody, getMockRequestTextBody, getMockRequestQuery };
+export type { MockNormalizedRequestBody, MockRequestHistoryEntry };

package/dist/requests/drivers/mock/MockRequestTestHelpers.js

@@ -0,0 +1,70 @@
+import { isEqual } from 'lodash-es';
+import { BaseRequest } from '../../BaseRequest';
+import { MockRequestDriver, getMockRequestJsonBody, getMockRequestQuery, getMockRequestTextBody } from './MockRequestDriver';
+function createPredicate(description, predicate) {
+    const matcher = ((value) => predicate(value));
+    matcher.description = description;
+    return matcher;
+}
+function matchesSubset(actual, expected) {
+    if (Array.isArray(expected)) {
+        if (!Array.isArray(actual) || actual.length < expected.length) {
+            return false;
+        }
+        return expected.every((item, index) => matchesSubset(actual[index], item));
+    }
+    if (isRecord(expected)) {
+        if (!isRecord(actual)) {
+            return false;
+        }
+        return Object.keys(expected).every((key) => matchesSubset(actual[key], expected[key]));
+    }
+    return isEqual(actual, expected);
+}
+function isRecord(value) {
+    return !!value && typeof value === 'object' && !Array.isArray(value);
+}
+export function matchHeaders(expectedSubset) {
+    return createPredicate(`headers subset ${JSON.stringify(expectedSubset)}`, (actual) => Object.entries(expectedSubset).every(([key, value]) => actual[key] === value));
+}
+export function matchQuery(expectedSubset) {
+    return createPredicate(`query subset ${JSON.stringify(expectedSubset)}`, (actual) => Object.entries(expectedSubset).every(([key, value]) => isEqual(actual[key], value)));
+}
+export function expectJsonBody(expected, options = {}) {
+    return createPredicate(options.partial ? `JSON body partial ${JSON.stringify(expected)}` : `JSON body ${JSON.stringify(expected)}`, (context) => {
+        const actual = context.getJson();
+        if (actual === undefined) {
+            return false;
+        }
+        return options.partial ? matchesSubset(actual, expected) : isEqual(actual, expected);
+    });
+}
+export function jsonResponse(status, body, headers) {
+    return Object.assign(Object.assign({ status }, (headers !== undefined ? { headers } : {})), { body });
+}
+export function validationError(errors, message = 'The given data was invalid.') {
+    return jsonResponse(422, {
+        message,
+        errors
+    });
+}
+export function emptyResponse(status = 204, headers) {
+    return Object.assign({ status }, (headers !== undefined ? { headers } : {}));
+}
+let installedMockRequestDriver;
+export function installMockRequestDriver(options = {}) {
+    var _a;
+    const driver = new MockRequestDriver(options.config, (_a = options.expectations) !== null && _a !== void 0 ? _a : [], options.matchMode !== undefined ? { matchMode: options.matchMode } : {});
+    BaseRequest.setRequestDriver(driver);
+    installedMockRequestDriver = driver;
+    return driver;
+}
+export function resetMockRequestDriver() {
+    if (!installedMockRequestDriver) {
+        return installMockRequestDriver();
+    }
+    installedMockRequestDriver.reset();
+    BaseRequest.setRequestDriver(installedMockRequestDriver);
+    return installedMockRequestDriver;
+}
+export { getMockRequestJsonBody, getMockRequestTextBody, getMockRequestQuery };