accounts-frontend/packages/app/components/accounts/reducer.test.ts

import expect from 'app/test/unexpected';

import { updateToken } from './actions';
import { add, remove, activate, reset } from './actions/pure-actions';
import { AccountsState } from './index';
import accounts, { Account } from './reducer';

const account: Account = {
    id: 1,
    username: 'username',
    email: 'email@test.com',
    token: 'foo',
} as Account;

describe('Accounts reducer', () => {
    let initial: AccountsState;

    beforeEach(() => {
        initial = accounts(undefined, {} as any);
    });

    it('should be empty', () =>
        expect(accounts(undefined, {} as any), 'to equal', {
            active: null,
            available: [],
        }));

    it('should return last state if unsupported action', () =>
        expect(accounts({ state: 'foo' } as any, {} as any), 'to equal', {
            state: 'foo',
        }));

    describe('accounts:activate', () => {
        it('sets active account', () => {
            expect(accounts(initial, activate(account)), 'to satisfy', {
                active: account.id,
            });
        });
    });

    describe('accounts:add', () => {
        it('adds an account', () =>
            expect(accounts(initial, add(account)), 'to satisfy', {
                available: [account],
            }));

        it('should replace if account was added for the second time', () => {
            const outdatedAccount = {
                ...account,
                someShit: true,
            };

            const updatedAccount = {
                ...account,
                token: 'newToken',
            };

            expect(accounts({ ...initial, available: [outdatedAccount] }, add(updatedAccount)), 'to satisfy', {
                available: [updatedAccount],
            });
        });

        it('should sort accounts by username', () => {
            const newAccount = {
                ...account,
                id: 2,
                username: 'abc',
            };

            expect(accounts({ ...initial, available: [account] }, add(newAccount)), 'to satisfy', {
                available: [newAccount, account],
            });
        });

        it('throws, when account is invalid', () => {
            expect(
                () =>
                    accounts(
                        initial,
                        // @ts-ignore
                        add(),
                    ),
                'to throw',
                'Invalid or empty payload passed for accounts.add',
            );
        });
    });

    describe('accounts:remove', () => {
        it('should remove an account', () =>
            expect(accounts({ ...initial, available: [account] }, remove(account)), 'to equal', initial));

        it('throws, when account is invalid', () => {
            expect(
                () =>
                    accounts(
                        initial,
                        // @ts-ignore
                        remove(),
                    ),
                'to throw',
                'Invalid or empty payload passed for accounts.remove',
            );
        });
    });

    describe('actions:reset', () => {
        it('should reset accounts state', () =>
            expect(accounts({ ...initial, available: [account] }, reset()), 'to equal', initial));
    });

    describe('accounts:updateToken', () => {
        it('should update token', () => {
            const newToken = 'newToken';

            expect(accounts({ active: account.id, available: [account] }, updateToken(newToken)), 'to satisfy', {
                active: account.id,
                available: [
                    {
                        ...account,
                        token: newToken,
                    },
                ],
            });
        });
    });
});