Testing Reducers

import {
  User,
  generateUser,
  generateUserMap,
  generateUserArray
} from './user.model';
import * as actions from './user.actions';
import {
  userReducer,
  initialUserState,
  getSelectedId,
  getLoading,
  getError,
  getQuery
} from './user.reducer';
import { Update } from '@ngrx/entity';

const INITIAL_STATE_WITH_ERROR = {
  ...initialUserState,
  error: 'some error'
};
const BLANK_ERROR_MESSAGE = '';

describe('userReducer', () => {
  describe('upon an undefined action', () => {
    it('should return the default state upon an undefined action', () => {
      const action = { type: 'NOT DEFINED' } as any;

      expect(userReducer(initialUserState, action)).toEqual(initialUserState);
    });
  });

  describe('upon CreateUser', () => {
    it('should set loading to true and clear any error', () => {
      const action = new actions.CreateUser({ user: generateUser() });

      expect(userReducer(INITIAL_STATE_WITH_ERROR, action)).toEqual({
        ...initialUserState,
        loading: true,
        error: BLANK_ERROR_MESSAGE
      });
    });
  });

  describe('upon CreateUserSuccess', () => {
    it('should add the given User, set loading to false, and clear any error', () => {
      const result = generateUser();
      const action = new actions.CreateUserSuccess({ result });

      expect(userReducer(INITIAL_STATE_WITH_ERROR, action)).toEqual({
        ...initialUserState,
        ...generateUserMap([result]),
        loading: false,
        error: BLANK_ERROR_MESSAGE
      });
    });
  });

  describe('upon CreateUserFail', () => {
    it('should set loading to true and echo the error', () => {
      const error = 'test create error';
      const action = new actions.CreateUserFail({ error });

      expect(userReducer(initialUserState, action)).toEqual({
        ...initialUserState,
        loading: false,
        error: `User create failed: ${error}`
      });
    });
  });

  describe('upon SearchAllUserEntities', () => {
    it('should remove User entities, set loading to true, and clear any error', () => {
      const initialUserStateWithUserEntities = {
        ...INITIAL_STATE_WITH_ERROR,
        ...generateUserMap()
      };
      const action = new actions.SearchAllUserEntities();

      expect(userReducer(initialUserStateWithUserEntities, action)).toEqual({
        ...initialUserState,
        loading: true,
        error: BLANK_ERROR_MESSAGE
      });
    });
  });

  describe('upon SearchAllUserEntitiesSuccess', () => {
    it('should add User entities, set loading to false, and clear any error', () => {
      const result = generateUserArray();
      const action = new actions.SearchAllUserEntitiesSuccess({ result });

      expect(userReducer(INITIAL_STATE_WITH_ERROR, action)).toEqual({
        ...initialUserState,
        ...generateUserMap(result),
        loading: false,
        error: BLANK_ERROR_MESSAGE
      });
    });
  });

  describe('upon SearchAllUserEntitiesFail', () => {
    it('should set loading to false and echo the error', () => {
      const error = 'test search error';
      const action = new actions.SearchAllUserEntitiesFail({ error });

      expect(userReducer(initialUserState, action)).toEqual({
        ...initialUserState,
        loading: false,
        error: `User search failed: ${error}`
      });
    });
  });

  describe('upon LoadUserById', () => {
    it('should remove user entities, set selected id, and clear any error', () => {
      const id = 8675309;
      const initialUserStateWithUserEntities = {
        ...INITIAL_STATE_WITH_ERROR,
        ...generateUserMap()
      };
      const action = new actions.LoadUserById({ id });

      expect(userReducer(initialUserStateWithUserEntities, action)).toEqual({
        ...initialUserState,
        selectedId: id,
        loading: true,
        error: BLANK_ERROR_MESSAGE
      });
    });
  });

  describe('upon LoadUserByIdSuccess', () => {
    it('should add the given User, set loading to false, and clear any error', () => {
      const result = generateUser();
      const action = new actions.LoadUserByIdSuccess({ result });

      expect(userReducer(INITIAL_STATE_WITH_ERROR, action)).toEqual({
        ...initialUserState,
        ...generateUserMap([result]),
        loading: false,
        error: BLANK_ERROR_MESSAGE
      });
    });
  });

  describe('upon LoadUserByIdFail', () => {
    it('should set loading to false and echo the error', () => {
      const error = 'test load by id error';
      const action = new actions.LoadUserByIdFail({ error });

      expect(userReducer(initialUserState, action)).toEqual({
        ...initialUserState,
        loading: false,
        error: `User load failed: ${error}`
      });
    });
  });

  describe('upon UpdateUser', () => {
    it('should set loading to true and clear any errior', () => {
      const user = generateUser();
      const action = new actions.UpdateUser({ user });

      expect(userReducer(INITIAL_STATE_WITH_ERROR, action)).toEqual({
        ...initialUserState,
        loading: true,
        error: BLANK_ERROR_MESSAGE
      });
    });
  });

  describe('upon UpdateUserSuccess', () => {
    it('should add the given User, set loading to false, and clear any error', () => {
      const user = generateUser();
      const initialUserStateWithUser = {
        ...INITIAL_STATE_WITH_ERROR,
        ...generateUserMap([user])
      };
      const updatedUser = {
        ...user,
        name: user.name + ' EDITED',
        description: user.description + ' EDITED'
      };
      const update = {
        id: updatedUser.id,
        changes: updatedUser
      } as Update<User>;
      const action = new actions.UpdateUserSuccess({ update });

      expect(userReducer(initialUserStateWithUser, action)).toEqual({
        ...initialUserStateWithUser,
        ...generateUserMap([updatedUser]),
        loading: false,
        error: BLANK_ERROR_MESSAGE
      });
    });
  });

  describe('upon UpdateUserFail', () => {
    it('should set loading to false and echo the error', () => {
      const error = 'test update error';
      const action = new actions.UpdateUserFail({ error });

      expect(userReducer(initialUserState, action)).toEqual({
        ...initialUserState,
        loading: false,
        error: `User update failed: ${error}`
      });
    });
  });

  describe('upon DeleteUserById', () => {
    it('should set the id, set loading to true, and clear any error', () => {
      const id = 4815162342;
      const action = new actions.DeleteUserById({ id });

      expect(userReducer(INITIAL_STATE_WITH_ERROR, action)).toEqual({
        ...initialUserState,
        selectedId: id,
        loading: true,
        error: BLANK_ERROR_MESSAGE
      });
    });
  });

  describe('upon DeleteUserByIdSuccess', () => {
    it('should remove the id-given user, set loading to false, and clear any error', () => {
      const id = 18009453669;
      const userToBeRemoved = generateUser(id);
      const expectedUserEntities = generateUserArray();
      const userEntitiesWithUserToBeRemoved = [
        ...expectedUserEntities,
        userToBeRemoved
      ];
      const initialUserStateWithAllUserEntities = {
        ...INITIAL_STATE_WITH_ERROR,
        ...generateUserMap(userEntitiesWithUserToBeRemoved)
      };
      const action = new actions.DeleteUserByIdSuccess({ id });

      expect(
        userReducer(initialUserStateWithAllUserEntities, action)
      ).toEqual({
        ...initialUserStateWithAllUserEntities,
        ...generateUserMap(expectedUserEntities),
        loading: false,
        error: BLANK_ERROR_MESSAGE
      });
    });
  });

  describe('upon DeleteUserByIdFail', () => {
    it('should set loading to false and echo the error', () => {
      const error = 'test delete error';
      const action = new actions.DeleteUserByIdFail({ error });

      expect(userReducer(initialUserState, action)).toEqual({
        ...initialUserState,
        loading: false,
        error: `User delete failed: ${error}`
      });
    });
  });

  describe('upon SetSearchQuery', () => {
    it('should set the query', () => {
      const query = {
        filter: 'someFilter',
        sorting: 'someSort',
        limit: 1000000000000,
        page: 888888
      };
      const action = new actions.SetSearchQuery(query);

      expect(userReducer(initialUserState, action)).toEqual({
        ...initialUserState,
        query
      });
    });
  });

  describe('upon SelectUserById', () => {
    it('should set the id and clear any error', () => {
      const id = 73;
      const action = new actions.SelectUserById({ id });

      expect(userReducer(INITIAL_STATE_WITH_ERROR, action)).toEqual({
        ...initialUserState,
        selectedId: id,
        error: BLANK_ERROR_MESSAGE
      });
    });
  });
});

describe('getters', () => {
  describe('getSelectedId', () => {
    it('should return the selected id', () => {
      expect(getSelectedId(initialUserState)).toEqual(initialUserState.selectedId);
    });
  });
  describe('getLoading', () => {
    it('should return the selected id', () => {
      expect(getLoading(initialUserState)).toEqual(initialUserState.loading);
    });
  });
  describe('getError', () => {
    it('should return the selected id', () => {
      expect(getError(INITIAL_STATE_WITH_ERROR))
        .toEqual(INITIAL_STATE_WITH_ERROR.error);
    });
  });
  describe('getQuery', () => {
    it('should return the selected id', () => {
      expect(getQuery(initialUserState))
        .toEqual(initialUserState.query);
    });
  });
});