acelga-bus/dist/spec/corebus/bulkDispatcher.spec.js

An extensible typescript message bus with support for middlewares

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const dispatcher_1 = require("@src/corebus/dispatcher");
const bulkDispatcher_1 = require("@src/corebus/bulkDispatcher");
const allParallelScheduler_1 = require("@src/corebus/allParallelScheduler");
const pipelineFactory_1 = require("@src/corebus/pipelineFactory");
const pipelineThrowError_1 = require("./mocks/pipelineThrowError");
const pipelinePromiseReject_1 = require("./mocks/pipelinePromiseReject");
const sequentialScheduller_1 = require("@src/corebus/sequentialScheduller");
const pipeline_1 = require("@src/corebus/pipeline");
class CustomEvent {
}
class OtherEvent {
}
describe('BulkDispatcher', () => {
    let dispatcher;
    let scheduler;
    let bulkDispatcher;
    let errorLogger;
    beforeEach(() => {
        scheduler = new allParallelScheduler_1.default();
        errorLogger = (error) => { };
        dispatcher = new dispatcher_1.Dispatcher();
        bulkDispatcher = new bulkDispatcher_1.default(dispatcher, scheduler, pipelineFactory_1.pipelineFactory, errorLogger);
    });
    it('should dispatch the event to the correct handler', (done) => {
        const handler1 = jest.fn((event) => {
            expect(event).toBeInstanceOf(CustomEvent);
            return Promise.resolve();
        });
        const handler11 = jest.fn((event) => {
            expect(event).toBeInstanceOf(CustomEvent);
            return Promise.resolve();
        });
        const handler2 = jest.fn((event) => {
            expect(event).toBeInstanceOf(OtherEvent);
            return Promise.resolve();
        });
        const handlerAny = jest.fn((event) => {
            expect(event).toBeInstanceOf(CustomEvent);
            return Promise.resolve();
        });
        bulkDispatcher.on(CustomEvent, handler1);
        bulkDispatcher.on(CustomEvent, handler2);
        bulkDispatcher.off(CustomEvent, handler2);
        bulkDispatcher.on(CustomEvent, handler11);
        bulkDispatcher.on(OtherEvent, handler2);
        bulkDispatcher.onAny(handlerAny);
        bulkDispatcher.trigger([new CustomEvent()])
            .then(() => {
            expect(handler1.mock.calls.length).toBe(1);
            expect(handler11.mock.calls.length).toBe(1);
            expect(handler2.mock.calls.length).toBe(0);
            expect(handlerAny.mock.calls.length).toBe(1);
            done();
        });
    });
    it('should return the errors in case of error', (done) => {
        const handler1 = jest.fn((event) => {
            expect(event).toBeInstanceOf(CustomEvent);
            return Promise.resolve();
        });
        const handler11 = jest.fn((event) => {
            expect(event).toBeInstanceOf(CustomEvent);
            return Promise.reject(new Error('hola'));
        });
        const handler2 = jest.fn((event) => {
            expect(event).toBeInstanceOf(OtherEvent);
            return Promise.resolve();
        });
        bulkDispatcher.on(CustomEvent, handler1);
        bulkDispatcher.on(CustomEvent, handler11);
        bulkDispatcher.on(OtherEvent, handler2);
        bulkDispatcher.trigger([new CustomEvent()])
            .catch(errors => {
            expect(errors).toEqual([{ error: new Error('hola'), event: new CustomEvent() }]);
            expect(handler1.mock.calls.length).toBe(1);
            expect(handler11.mock.calls.length).toBe(1);
            expect(handler2.mock.calls.length).toBe(0);
            done();
        });
    });
    it('should return the error in case of internal error (case pipeline throw error)', (done) => {
        const customBulkDispatcher = new bulkDispatcher_1.default(dispatcher, scheduler, pipelineThrowError_1.pipelineThrowErrorFactory, errorLogger);
        const handler2 = jest.fn((event) => {
            expect(event).toBeInstanceOf(OtherEvent);
            return Promise.resolve();
        });
        customBulkDispatcher.on(OtherEvent, handler2);
        customBulkDispatcher.trigger([new OtherEvent()])
            .catch(errors => {
            expect(errors).toEqual(new Error('executeContinueOnError'));
            expect(handler2.mock.calls.length).toBe(0);
            done();
        });
    });
    it('should return the error in case of internal error (case pipeline promise reject)', (done) => {
        const customErrorLogger = jest.fn(errorLogger);
        const customBulkDispatcher = new bulkDispatcher_1.default(dispatcher, scheduler, pipelinePromiseReject_1.pipelinePromiseRejectFactory, customErrorLogger);
        const handler2 = jest.fn((event) => {
            expect(event).toBeInstanceOf(OtherEvent);
            return Promise.resolve();
        });
        customBulkDispatcher.on(OtherEvent, handler2);
        customBulkDispatcher.trigger([new OtherEvent()])
            .then(() => {
            expect(customErrorLogger).toHaveBeenCalledTimes(1);
            expect(handler2.mock.calls.length).toBe(0);
            done();
        });
    });
    it('should stop if preserve order is true', (done) => {
        const customerScheduler = new sequentialScheduller_1.default(true);
        const customBulkDispatcher = new bulkDispatcher_1.default(dispatcher, customerScheduler, pipelineFactory_1.pipelineFactory, errorLogger);
        const handler2 = jest.fn((event) => {
            expect(event).toBeInstanceOf(OtherEvent);
            return Promise.reject();
        });
        customBulkDispatcher.on(OtherEvent, handler2);
        customBulkDispatcher.trigger([new OtherEvent(), new OtherEvent(), new OtherEvent()])
            .catch(errors => {
            expect(errors).toEqual([{
                    error: undefined,
                    event: new OtherEvent(),
                }, {
                    error: new pipeline_1.NotExecutedByOrderPresentation(),
                    event: new OtherEvent(),
                }, {
                    error: new pipeline_1.NotExecutedByOrderPresentation(),
                    event: new OtherEvent(),
                }]);
            expect(handler2.mock.calls.length).toBe(1);
            done();
        });
    });
});
//# sourceMappingURL=bulkDispatcher.spec.js.map