@hubspot/api-client/lib/test/unit/middlewareMergeStrategy.spec.js

NodeJS v3 [HubSpot API](https://developers.hubspot.com/docs/api/overview) SDK(Client) files

"use strict";
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());
    });
};
Object.defineProperty(exports, "__esModule", { value: true });
const send_1 = require("../../codegen/events/send");
const http_1 = require("../../codegen/events/send/http/http");
const rxjsStub_1 = require("../../codegen/events/send/rxjsStub");
const ObservableAPI_1 = require("../../codegen/events/send/types/ObservableAPI");
class MockResponseBody {
    text() {
        return __awaiter(this, void 0, void 0, function* () {
            return '';
        });
    }
    binary() {
        return __awaiter(this, void 0, void 0, function* () {
            return Buffer.from('');
        });
    }
}
const mockHttpApi = {
    send(requestContext) {
        void requestContext;
        return (0, rxjsStub_1.from)(Promise.resolve(new http_1.ResponseContext(204, { 'content-type': 'application/json' }, new MockResponseBody())));
    },
};
const createTrackingMiddleware = (name, trace) => ({
    pre(requestContext) {
        return __awaiter(this, void 0, void 0, function* () {
            trace.push(`pre:${name}`);
            return requestContext;
        });
    },
    post(responseContext) {
        return __awaiter(this, void 0, void 0, function* () {
            trace.push(`post:${name}`);
            return responseContext;
        });
    },
});
const createObservableTrackingMiddleware = (name, trace) => ({
    pre(requestContext) {
        trace.push(`pre:${name}`);
        return (0, rxjsStub_1.from)(Promise.resolve(requestContext));
    },
    post(responseContext) {
        trace.push(`post:${name}`);
        return (0, rxjsStub_1.from)(Promise.resolve(responseContext));
    },
});
describe('Middleware merge strategy', () => {
    it('runs global middleware when call middleware is not provided', () => __awaiter(void 0, void 0, void 0, function* () {
        const trace = [];
        const globalMiddleware = createTrackingMiddleware('global', trace);
        const api = new send_1.BatchApi((0, send_1.createConfiguration)({
            promiseMiddleware: [globalMiddleware],
            httpApi: mockHttpApi,
        }));
        yield api.send({ inputs: [] });
        expect(trace).toEqual(['pre:global', 'post:global']);
    }));
    it('replaces global middleware by default when call middleware is provided', () => __awaiter(void 0, void 0, void 0, function* () {
        const trace = [];
        const globalMiddleware = createTrackingMiddleware('global', trace);
        const callMiddleware = createTrackingMiddleware('call', trace);
        const api = new send_1.BatchApi((0, send_1.createConfiguration)({
            promiseMiddleware: [globalMiddleware],
            httpApi: mockHttpApi,
        }));
        yield api.send({ inputs: [] }, { middleware: [callMiddleware] });
        expect(trace).toEqual(['pre:call', 'post:call']);
    }));
    it('appends call middleware after global middleware when strategy is append', () => __awaiter(void 0, void 0, void 0, function* () {
        const trace = [];
        const globalMiddleware = createTrackingMiddleware('global', trace);
        const callMiddleware = createTrackingMiddleware('call', trace);
        const api = new send_1.BatchApi((0, send_1.createConfiguration)({
            promiseMiddleware: [globalMiddleware],
            httpApi: mockHttpApi,
        }));
        yield api.send({ inputs: [] }, {
            middleware: [callMiddleware],
            middlewareMergeStrategy: 'append',
        });
        expect(trace).toEqual(['pre:global', 'pre:call', 'post:call', 'post:global']);
    }));
    it('prepends call middleware before global middleware when strategy is prepend', () => __awaiter(void 0, void 0, void 0, function* () {
        const trace = [];
        const globalMiddleware = createTrackingMiddleware('global', trace);
        const callMiddleware = createTrackingMiddleware('call', trace);
        const api = new send_1.BatchApi((0, send_1.createConfiguration)({
            promiseMiddleware: [globalMiddleware],
            httpApi: mockHttpApi,
        }));
        yield api.send({ inputs: [] }, {
            middleware: [callMiddleware],
            middlewareMergeStrategy: 'prepend',
        });
        expect(trace).toEqual(['pre:call', 'pre:global', 'post:global', 'post:call']);
    }));
    it('does not mutate call middleware array order across requests', () => __awaiter(void 0, void 0, void 0, function* () {
        const trace = [];
        const firstCallMiddleware = createTrackingMiddleware('call-first', trace);
        const secondCallMiddleware = createTrackingMiddleware('call-second', trace);
        const callMiddleware = [firstCallMiddleware, secondCallMiddleware];
        const api = new send_1.BatchApi((0, send_1.createConfiguration)({
            promiseMiddleware: [],
            httpApi: mockHttpApi,
        }));
        yield api.send({ inputs: [] }, { middleware: callMiddleware });
        expect(trace).toEqual(['pre:call-first', 'pre:call-second', 'post:call-second', 'post:call-first']);
        expect(callMiddleware).toEqual([firstCallMiddleware, secondCallMiddleware]);
        trace.length = 0;
        yield api.send({ inputs: [] }, { middleware: callMiddleware });
        expect(trace).toEqual(['pre:call-first', 'pre:call-second', 'post:call-second', 'post:call-first']);
    }));
    it('does not mutate observable call middleware order across requests', () => __awaiter(void 0, void 0, void 0, function* () {
        const trace = [];
        const firstCallMiddleware = createObservableTrackingMiddleware('call-first', trace);
        const secondCallMiddleware = createObservableTrackingMiddleware('call-second', trace);
        const callMiddleware = [firstCallMiddleware, secondCallMiddleware];
        const configuration = (0, send_1.createConfiguration)({
            middleware: [],
            httpApi: mockHttpApi,
        });
        const api = new ObservableAPI_1.ObservableBatchApi(configuration);
        yield api.send({ inputs: [] }, { middleware: callMiddleware }).toPromise();
        expect(trace).toEqual(['pre:call-first', 'pre:call-second', 'post:call-second', 'post:call-first']);
        expect(callMiddleware).toEqual([firstCallMiddleware, secondCallMiddleware]);
        trace.length = 0;
        yield api.send({ inputs: [] }, { middleware: callMiddleware }).toPromise();
        expect(trace).toEqual(['pre:call-first', 'pre:call-second', 'post:call-second', 'post:call-first']);
    }));
});
//# sourceMappingURL=middlewareMergeStrategy.spec.js.map