accounts-frontend/packages/app/services/request/PromiseMiddlewareLayer.test.ts

import sinon from 'sinon';
import expect from 'app/test/unexpected';

import PromiseMiddlewareLayer from 'app/services/request/PromiseMiddlewareLayer';

describe('PromiseMiddlewareLayer', () => {
    describe('#add()', () => {
        let layer: PromiseMiddlewareLayer;

        beforeEach(() => {
            layer = new PromiseMiddlewareLayer();
        });

        it('should have no middlewares by default', () => {
            // @ts-ignore
            expect(layer.middlewares, 'to have length', 0);
        });

        it('should add middleware into layer', () => {
            layer.add({});

            // @ts-ignore
            expect(layer.middlewares, 'to have length', 1);
        });

        it('throws if middleware is not object', () => {
            // @ts-ignore
            expect(() => layer.add(1), 'to throw', 'A middleware must be an object');
        });
    });

    describe('#run()', () => {
        it('should return promise', () => {
            const layer: any = new PromiseMiddlewareLayer();

            expect(layer.run('then'), 'to be a', Promise);
        });

        testAction('then');
        testAction('catch');

        function testAction(name: string) {
            describe(`run('${name}')`, () => {
                it('should run middleware', () => {
                    const layer: any = new PromiseMiddlewareLayer();
                    const middleware = {
                        [name]: sinon.spy(() => Promise.resolve()).named(`middleware.${name}`),
                    };

                    layer.add(middleware);

                    return layer.run(name).then(() => {
                        expect(middleware[name], 'was called once');
                    });
                });

                it('should pass data', () => {
                    const layer: any = new PromiseMiddlewareLayer();
                    const middleware = {
                        [name]: sinon.spy(() => Promise.resolve()).named(`middleware.${name}`),
                    };
                    const data = {};

                    layer.add(middleware);

                    return layer.run(name, data).then(() => {
                        expect(middleware[name], 'to have a call satisfying', [data]);
                    });
                });

                it('should call multiple middlewares', async () => {
                    const layer: any = new PromiseMiddlewareLayer();
                    const initialValue = 'initialValue';
                    const options = { foo: 'bar' };
                    const firstMethod = name === 'catch' ? 'reject' : 'resolve';
                    const middleware1 = {
                        [name]: sinon.spy(() => (Promise[firstMethod] as any)('new data')).named(`middleware1.${name}`),
                    };
                    const middleware2 = {
                        [name]: sinon.spy(() => Promise.resolve('the last data')).named(`middleware2.${name}`),
                    };

                    layer.add(middleware1);
                    layer.add(middleware2);

                    const resp = await layer.run(name, initialValue, options);

                    expect(middleware1[name], 'to have a call satisfying', [initialValue, options]);
                    expect(middleware2[name], 'to have a call satisfying', ['new data', options]);
                    expect(resp, 'to equal', 'the last data');
                });
            });
        }

        it('should not call wrong actions', () => {
            const layer: any = new PromiseMiddlewareLayer();
            const middleware = {
                then: () => {},
                wrongAction: sinon.spy(() => Promise.resolve()).named('middleware.wrongAction'),
            };

            layer.add(middleware as any);

            return layer.run('then').then(() => {
                expect(middleware.wrongAction, 'was not called');
            });
        });

        it('should not call next catch middleware if previous was resolved', () => {
            const layer: any = new PromiseMiddlewareLayer();
            const middleware1 = {
                catch: () => Promise.resolve(),
            };
            const middleware2 = {
                catch: sinon.spy(() => {}).named('middleware2.catch'),
            };

            layer.add(middleware1);
            layer.add(middleware2);

            return layer.run('catch').then(() => {
                expect(middleware2.catch, 'was not called');
            });
        });

        it('should pass restart callback if any', () => {
            const layer: any = new PromiseMiddlewareLayer();
            const middleware = {
                catch: sinon.spy(() => Promise.resolve()).named('middleware.catch'),
            };
            const callback = async () => {};

            layer.add(middleware);

            return layer.run('catch', {}, {}, callback).then(() => {
                expect(middleware.catch, 'to have a call satisfying', [{}, {}, expect.it('to be', callback)]);
            });
        });
    });
});