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

An extensible typescript message bus with support for middlewares

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const index_1 = require("@src/index");
const utils_1 = require("./utils");
describe('Bus', () => {
    let bus;
    let add2;
    let half;
    let sub2;
    let mul5;
    let sub1;
    let add3;
    let end;
    beforeAll(() => {
        bus = new index_1.Bus();
        add2 = utils_1.CustomEventOperationMiddleware(2, utils_1.Operation.Add);
        half = utils_1.CustomEventOperationMiddleware(2, utils_1.Operation.Divide);
        sub2 = utils_1.CustomEventOperationMiddleware(2, utils_1.Operation.Substract);
        mul5 = utils_1.CustomEventOperationMiddleware(5, utils_1.Operation.Multiply);
        sub1 = utils_1.CustomEventOperationMiddleware(1, utils_1.Operation.Substract);
        add3 = utils_1.CustomEventOperationMiddleware(3, utils_1.Operation.Add);
        end = utils_1.CustomEventOperationMiddleware(1, utils_1.Operation.Void);
    });
    it('should exist', () => {
        expect(bus instanceof index_1.Bus).toBeTruthy();
    });
    it('should send and receive messages', (done) => {
        const event = new utils_1.EmptyEvent();
        bus.on(utils_1.EmptyEvent, (e) => {
            expect(e).toEqual(event);
            done();
        });
        bus.publish(event);
    });
    it('should send and receive messages to all subscrivers', (done) => {
        const event = new utils_1.EmptyEvent();
        const fn1 = jest.fn((e) => expect(e).toBeInstanceOf(utils_1.EmptyEvent));
        const fn2 = jest.fn((e) => expect(e).toBeInstanceOf(utils_1.EmptyEvent));
        const fn3 = jest.fn((e) => expect(e).toBeInstanceOf(utils_1.EmptyEvent));
        bus.on(utils_1.EmptyEvent, fn1);
        bus.on(utils_1.EmptyEvent, fn2);
        bus.on(utils_1.EmptyEvent, fn3);
        bus.publish(event);
        setTimeout(() => {
            expect(fn1.mock.calls.length).toBe(1);
            expect(fn2.mock.calls.length).toBe(1);
            expect(fn3.mock.calls.length).toBe(1);
            done();
        }, 0);
    });
    it('should send and receive messages to the correct destination (inherited classes)', (done) => {
        const event = new utils_1.EmptyEvent();
        class Event2 extends utils_1.EmptyEvent {
        }
        const event2 = new Event2();
        bus.on(Event2, (e) => {
            expect(e).toBeInstanceOf(Event2);
            done();
        });
        bus.publish(event);
        bus.publish(event2);
    });
    it('should send and receive messages to the correct destination (independen classes)', (done) => {
        const event = new utils_1.EmptyEvent();
        class Event2 {
        }
        const event2 = new Event2();
        bus.on(Event2, (e) => {
            expect(e).toBeInstanceOf(Event2);
            done();
        });
        bus.publish(event);
        bus.publish(event2);
    });
    it('should send and receive messages to the correct destination (no callbacks)', (done) => {
        const customBus = new index_1.Bus();
        const event = new utils_1.EmptyEvent();
        class Event2 {
        }
        class Event3 {
        }
        const event2 = new Event2();
        const event3 = new Event3();
        const fn = jest.fn();
        customBus.on(Event3, fn);
        setTimeout(() => {
            expect(fn.mock.calls.length).toBe(0);
            done();
        }, 5);
        customBus.publish(event);
        customBus.publish(event2);
    });
    describe('Middlewares', () => {
        it('should apply the middlewares only one time', (done) => {
            const customBus = new index_1.Bus();
            const event = new utils_1.CustomEventNumber(1);
            customBus.pushMiddleware(add2);
            customBus.on(utils_1.CustomEventNumber, (eventResult) => {
                expect(eventResult.data).toBe(3);
                done();
            });
            customBus.publish(event);
        });
        it('Middlewares should be executed in the correct order', (done) => {
            const customBus = new index_1.Bus();
            const event = new utils_1.CustomEventNumber(2);
            customBus.unshiftMiddleware(half);
            customBus.pushMiddleware(sub2);
            customBus.pushMiddleware(mul5);
            customBus.unshiftMiddleware(sub1);
            customBus.pushMiddleware(add3);
            customBus.on(utils_1.CustomEventNumber, (eventResult) => {
                expect(eventResult.data).toBe(10.5);
                done();
            });
            customBus.publish(event);
        });
        it('Middlewares should stop the execution if they return void', (done) => {
            const customBus = new index_1.Bus();
            const event = new utils_1.CustomEventNumber(2);
            customBus.unshiftMiddleware(half);
            customBus.pushMiddleware(mul5);
            customBus.unshiftMiddleware(end);
            customBus.unshiftMiddleware(sub1);
            customBus.pushMiddleware(add3);
            const fn = jest.fn();
            customBus.on(utils_1.CustomEventNumber, fn);
            customBus.publish(event);
            setTimeout(() => {
                expect(fn.mock.calls.length).toBe(0);
                done();
            }, 5);
        });
    });
    describe('Publisher', () => {
        it('should allow to have different sets of middlewares in every publisher', (done) => {
            const customBus = new index_1.Bus();
            const pubA = customBus.createPublisher();
            const pubB = customBus.createPublisher();
            const event = new utils_1.CustomEventNumber(4);
            customBus.unshiftMiddleware(half);
            pubA.pushMiddleware(sub2);
            pubA.pushMiddleware(half);
            pubB.unshiftMiddleware(add2);
            pubB.pushMiddleware(mul5);
            const handler = jest.fn((eventResult) => Promise.resolve());
            customBus.on(utils_1.CustomEventNumber, handler);
            customBus.publish(event);
            pubA.publish(event);
            pubB.publish(event);
            setTimeout(() => {
                expect(handler.mock.calls.filter(call => call[0].data === 2).length).toBe(1);
                expect(handler.mock.calls.filter(call => call[0].data === 1).length).toBe(1);
                expect(handler.mock.calls.filter(call => call[0].data === 30).length).toBe(1);
                done();
            }, 5);
        });
    });
});
//# sourceMappingURL=bus.spec.js.map