accounts-frontend/packages/app/services/authFlow/AuthFlow.test.ts

import expect from 'app/test/unexpected';
import sinon, { SinonStub } from 'sinon';

import AuthFlow from 'app/services/authFlow/AuthFlow';
import AbstractState from 'app/services/authFlow/AbstractState';
import localStorage from 'app/services/localStorage';

import OAuthState from 'app/services/authFlow/OAuthState';
import RegisterState from 'app/services/authFlow/RegisterState';
import RecoverPasswordState from 'app/services/authFlow/RecoverPasswordState';
import ForgotPasswordState from 'app/services/authFlow/ForgotPasswordState';
import ActivationState from 'app/services/authFlow/ActivationState';
import ResendActivationState from 'app/services/authFlow/ResendActivationState';
import LoginState from 'app/services/authFlow/LoginState';
import CompleteState from 'app/services/authFlow/CompleteState';
import ChooseAccountState from 'app/services/authFlow/ChooseAccountState';
import { Store } from 'redux';

describe('AuthFlow', () => {
    let flow: AuthFlow;
    let actions: { test: SinonStub };

    beforeEach(() => {
        actions = {
            test: sinon.stub().named('actions.test'),
        };
        actions.test.returns('passed');

        // @ts-ignore
        flow = new AuthFlow(actions);
    });

    it('should not allow to mutate actions', () => {
        expect(
            // @ts-ignore
            () => (flow.actions.foo = 'bar'),
            'to throw',
            /readonly|not extensible/,
        );
        // @ts-ignore
        expect(() => (flow.actions.test = 'hacked'), 'to throw', /read ?only/);
    });

    describe('#setStore', () => {
        it('should create #navigate, #getState, #dispatch', () => {
            flow.setStore({
                // @ts-ignore
                getState() {},
                // @ts-ignore
                dispatch() {},
            });

            expect(flow.getState, 'to be defined');
            expect(flow.dispatch, 'to be defined');
            expect(flow.navigate, 'to be defined');
        });
    });

    describe('#restoreOAuthState', () => {
        let oauthData: Record<string, string>;

        beforeEach(() => {
            oauthData = { foo: 'bar' };
            localStorage.setItem(
                'oauthData',
                JSON.stringify({
                    timestamp: Date.now() - 10,
                    payload: oauthData,
                }),
            );

            sinon.stub(flow, 'run').named('flow.run');
            const promiseLike = { then: (fn: Function) => fn() || promiseLike };
            // @ts-ignore
            flow.run.returns(promiseLike);
            sinon.stub(flow, 'setState').named('flow.setState');
        });

        afterEach(() => {
            localStorage.removeItem('oauthData');
        });

        it('should call to restoreOAuthState', () => {
            // @ts-ignore
            sinon.stub(flow, 'restoreOAuthState').named('flow.restoreOAuthState');

            flow.handleRequest(
                { path: '/', query: new URLSearchParams(''), params: {} },
                () => {},
                () => {},
            );

            // @ts-ignore
            expect(flow.restoreOAuthState, 'was called');
        });

        it('should restore oauth state from localStorage', () => {
            flow.handleRequest(
                { path: '/', query: new URLSearchParams(''), params: {} },
                () => {},
                () => {},
            );

            expect(flow.run, 'to have a call satisfying', ['oAuthValidate', oauthData]);
        });

        it('should transition to CompleteState', () => {
            flow.handleRequest(
                { path: '/', query: new URLSearchParams(''), params: {} },
                () => {},
                () => {},
            );

            expect(flow.setState, 'to have a call satisfying', [expect.it('to be a', CompleteState)]);
        });

        it('should not handle current request', () => {
            flow.handleRequest(
                { path: '/', query: new URLSearchParams(''), params: {} },
                () => {},
                () => {},
            );

            expect(flow.setState, 'was called once');
        });

        it('should call onReady after state restoration', () => {
            const onReady = sinon.stub().named('onReady');

            flow.handleRequest(
                { path: '/login', query: new URLSearchParams(''), params: {} },
                // @ts-ignore
                null,
                onReady,
            );

            expect(onReady, 'was called');
        });

        it('should not restore oauth state for /register route', () => {
            flow.handleRequest(
                { path: '/register', query: new URLSearchParams(''), params: {} },
                () => {},
                () => {},
            );

            expect(flow.run, 'was not called'); // this.run('oAuthValidate'...
        });

        it('should not restore outdated (>1h) oauth state', () => {
            localStorage.setItem(
                'oauthData',
                JSON.stringify({
                    timestamp: Date.now() - 2 * 60 * 60 * 1000,
                    payload: oauthData,
                }),
            );

            flow.handleRequest(
                { path: '/', query: new URLSearchParams(''), params: {} },
                () => {},
                () => {},
            );

            expect(flow.run, 'was not called');
        });
    });

    describe('#setState', () => {
        it('should change state', () => {
            const state = new AbstractState();
            flow.setState(state);

            expect(flow.state, 'to be', state);
        });

        it('should call #enter() on new state and pass reference to itself', () => {
            const state = new AbstractState();
            const spy = sinon.spy(state, 'enter').named('state.enter');

            flow.setState(state);

            expect(spy, 'was called once');
            expect(spy, 'to have a call satisfying', [flow]);
        });

        it('should call `leave` on previous state if any', () => {
            class State1 extends AbstractState {}
            class State2 extends AbstractState {}

            const state1 = new State1();
            const state2 = new State2();
            const spy1 = sinon.spy(state1, 'leave');
            const spy2 = sinon.spy(state2, 'leave');

            flow.setState(state1);
            flow.setState(state2);

            expect(spy1, 'was called once');
            expect(spy1, 'to have a call satisfying', [flow]);
            expect(spy2, 'was not called');
        });

        it('should return promise, if #enter returns it', () => {
            const state = new AbstractState();
            const expected = Promise.resolve();

            state.enter = () => expected;

            const actual = flow.setState(state);

            expect(actual, 'to be', expected);
        });

        it('should throw if no state', () => {
            // @ts-ignore
            expect(() => flow.setState(), 'to throw', 'State is required');
        });
    });

    describe('#run', () => {
        let store: Store;

        beforeEach(() => {
            // @ts-ignore
            store = {
                getState() {},
                dispatch: sinon.stub().named('store.dispatch'),
            };

            flow.setStore(store);
        });

        it('should dispatch an action', () => {
            // @ts-ignore
            flow.run('test');

            expect(store.dispatch, 'was called once');
            expect(store.dispatch, 'to have a call satisfying', ['passed']);
        });

        it('should dispatch an action with payload given', () => {
            // @ts-ignore
            flow.run('test', 'arg');

            expect(actions.test, 'was called once');
            expect(actions.test, 'to have a call satisfying', ['arg']);
        });

        it('should resolve to action dispatch result', () => {
            const expected = 'dispatch called';
            // @ts-ignore
            store.dispatch.returns(expected);

            // @ts-ignore
            return expect(flow.run('test'), 'to be fulfilled with', expected);
        });

        it('throws when running unexisted action', () => {
            // @ts-ignore
            expect(() => flow.run('123'), 'to throw', 'Action 123 does not exists');
        });
    });

    describe('#goBack', () => {
        it('should call goBack on state passing itself as argument', () => {
            const state = new AbstractState();
            sinon.stub(state, 'goBack').named('state.goBack');
            flow.setState(state);

            flow.goBack();

            expect(state.goBack, 'was called once');
            expect(state.goBack, 'to have a call satisfying', [flow]);
        });
    });

    describe('#resolve', () => {
        it('should call resolve on state passing itself and payload as arguments', () => {
            const state = new AbstractState();
            sinon.stub(state, 'resolve').named('state.resolve');
            flow.setState(state);

            const expectedPayload = { foo: 'bar' };

            flow.resolve(expectedPayload);

            expect(state.resolve, 'was called once');
            expect(state.resolve, 'to have a call satisfying', [flow, expectedPayload]);
        });
    });

    describe('#reject', () => {
        it('should call reject on state passing itself and payload as arguments', () => {
            const state = new AbstractState();
            sinon.stub(state, 'reject').named('state.reject');
            flow.setState(state);

            const expectedPayload = { foo: 'bar' };

            flow.reject(expectedPayload);

            expect(state.reject, 'was called once');
            expect(state.reject, 'to have a call satisfying', [flow, expectedPayload]);
        });
    });

    describe('#handleRequest()', () => {
        beforeEach(() => {
            sinon.stub(flow, 'setState').named('flow.setState');
            sinon.stub(flow, 'run').named('flow.run');
        });

        Object.entries({
            '/': LoginState,
            '/login': LoginState,
            '/password': LoginState,
            '/accept-rules': LoginState,
            '/oauth/permissions': LoginState,
            '/oauth/choose-account': LoginState,
            '/oauth/finish': LoginState,
            '/oauth2/v1/foo': OAuthState,
            '/oauth2/v1': OAuthState,
            '/oauth2': OAuthState,
            '/register': RegisterState,
            '/choose-account': ChooseAccountState,
            '/recover-password': RecoverPasswordState,
            '/recover-password/key123': RecoverPasswordState,
            '/forgot-password': ForgotPasswordState,
            '/activation': ActivationState,
            '/resend-activation': ResendActivationState,
        }).forEach(([path, type]) => {
            it(`should transition to ${type.name} if ${path}`, () => {
                flow.handleRequest(
                    { path, query: new URLSearchParams({}), params: {} },
                    () => {},
                    () => {},
                );

                expect(flow.setState, 'was called once');
                expect(flow.setState, 'to have a call satisfying', [expect.it('to be a', type)]);
            });
        });

        it('should call callback', () => {
            const callback = sinon.stub().named('callback');

            flow.handleRequest({ path: '/', query: new URLSearchParams({}), params: {} }, () => {}, callback);

            expect(callback, 'was called once');
        });

        it('should not call callback till returned from #enter() promise will be resolved', () => {
            let resolve: Function;
            const promise: Promise<void> = {
                // @ts-ignore
                then: (cb: Function) => {
                    resolve = cb;
                },
            };
            const callback = sinon.stub().named('callback');

            const state = new AbstractState();
            state.enter = () => promise;

            flow.setState = AuthFlow.prototype.setState.bind(flow, state);

            flow.handleRequest({ path: '/', query: new URLSearchParams({}), params: {} }, () => {}, callback);

            // @ts-ignore
            expect(resolve, 'to be', callback);

            expect(callback, 'was not called');
            // @ts-ignore
            resolve();
            expect(callback, 'was called once');
        });

        it('should not handle the same request twice', () => {
            const path = '/oauth2';
            const callback = sinon.stub();

            flow.handleRequest({ path, query: new URLSearchParams({}), params: {} }, () => {}, callback);
            flow.handleRequest({ path, query: new URLSearchParams({}), params: {} }, () => {}, callback);

            expect(flow.setState, 'was called once');
            expect(flow.setState, 'to have a call satisfying', [expect.it('to be a', OAuthState)]);
            expect(callback, 'was called twice');
        });

        it('throws if unsupported request', () => {
            const replace = sinon.stub().named('replace');

            flow.handleRequest({ path: '/foo/bar', query: new URLSearchParams({}), params: {} }, replace);

            expect(replace, 'to have a call satisfying', ['/404']);
        });
    });

    describe('#getRequest()', () => {
        beforeEach(() => {
            sinon.stub(flow, 'setState').named('flow.setState');
            sinon.stub(flow, 'run').named('flow.run');
        });

        it('should return request with path, query, params', () => {
            const request = { path: '/', query: new URLSearchParams({}), params: {} };

            flow.handleRequest(
                request,
                () => {},
                () => {},
            );

            expect(flow.getRequest(), 'to satisfy', {
                ...request,
                query: expect.it('to be an', URLSearchParams),
                params: {},
            });
        });

        it('should return a copy of current request', () => {
            const request = {
                path: '/',
                query: new URLSearchParams({ foo: 'bar' }),
                params: { baz: 'bud' },
            };

            flow.handleRequest(
                request,
                () => {},
                () => {},
            );

            expect(flow.getRequest(), 'to equal', request);
            expect(flow.getRequest(), 'not to be', request);
        });
    });
});