Add tests for items effects

Author: jdgarvey

libs/common-data/src/lib/state/items/items.effects.spec.ts

@@ -2,35 +2,91 @@ import { TestBed } from '@angular/core/testing';
 import { provideMockActions } from '@ngrx/effects/testing';
 import { StoreModule } from '@ngrx/store';
 import { DataPersistence } from '@nrwl/nx';
-import { hot } from '@nrwl/nx/testing';
-import { Observable } from 'rxjs';
+import { cold, hot } from '@nrwl/nx/testing';
+import { Observable, of } from 'rxjs';
 
-import { ItemsLoaded, LoadItems } from './items.actions';
+import { AddItem, DeleteItem, ItemAdded, ItemDeleted, ItemsLoaded, ItemUpdated, LoadItems, UpdateItem } from './items.actions';
 import { ItemsEffects } from './items.effects';
+import { Item, ItemsService } from '@workspace/common-data';
 
-describe('ItemsEffects', () => {
+class ItemsServiceMock {
+  all() {}
+  create(item) {}
+  update(item) {}
+  delete(item) {}
+}
+
+fdescribe('ItemsEffects', () => {
   let actions$: Observable<any>;
   let effects$: ItemsEffects;
+  let itemsService: ItemsService;
 
   beforeEach(() => {
     TestBed.configureTestingModule({
       imports: [StoreModule.forRoot({})],
       providers: [
         ItemsEffects,
         DataPersistence,
-        provideMockActions(() => actions$)
+        provideMockActions(() => actions$),
+        {provide: ItemsService, useClass: ItemsServiceMock}
       ]
     });
 
     effects$ = TestBed.get(ItemsEffects);
+    itemsService = TestBed.get(ItemsService);
   });
 
-  describe('someEffect', () => {
-    it('should work', () => {
+  describe('`loadItems$`', () => {
+    it('should trigger `ItemsLoaded` action with data from `ItemsService.all`', () => {
+      const items = [{id: 'csa-132', name: 'Test', description: 'Testing', price: 4313}];
+      spyOn(itemsService, 'all').and.returnValue(of(items));
+
       actions$ = hot('-a-|', { a: new LoadItems() });
-      expect(effects$.loadItems$).toBeObservable(
-        hot('-a-|', { a: new ItemsLoaded([]) })
-      );
+      const expected$ = cold('-a-|', { a: new ItemsLoaded(items) });
+
+      expect(effects$.loadItems$).toBeObservable(expected$);
+      expect(itemsService.all).toHaveBeenCalled();
+    });
+  });
+
+  describe('`addItem$`', () => {
+    it('should trigger `ItemAdded` action with data from `ItemsService.create`', () => {
+      const item = {id: null, name: 'Test', description: 'Testing', price: 4313};
+      const createdItem = {...item, id: 'jhh14-created'};
+      spyOn(itemsService, 'create').and.returnValue(of(createdItem));
+
+      actions$ = hot('-a-|', { a: new AddItem(item) });
+      const expected$ = cold('-a-|', { a: new ItemAdded(createdItem) });
+
+      expect(effects$.addItem$).toBeObservable(expected$);
+      expect(itemsService.create).toHaveBeenCalledWith(item);
+    });
+  });
+
+  describe('`updateItem$`', () => {
+    it('should trigger `ItemUpdated` action with data from `ItemsService.update`', () => {
+      const item = {id: 'jhh14-updated', name: 'Test', description: 'Testing', price: 4313};
+      const updatedItem = {...item, name: 'Updated', description: 'Different'};
+      spyOn(itemsService, 'update').and.returnValue(of(updatedItem));
+
+      actions$ = hot('-a-|', { a: new UpdateItem(item) });
+      const expected$ = cold('-a-|', { a: new ItemUpdated(updatedItem) });
+
+      expect(effects$.updateItem$).toBeObservable(expected$);
+      expect(itemsService.update).toHaveBeenCalledWith(item);
+    });
+  });
+
+  describe('`deleteItem$`', () => {
+    it('should trigger `ItemDeleted` action with data from `ItemsService.delete`', () => {
+      const item = {id: 'jhh14-deleted', name: 'Test', description: 'Testing', price: 4313};
+      spyOn(itemsService, 'delete').and.returnValue(of(item));
+
+      actions$ = hot('-a-|', { a: new DeleteItem(item) });
+      const expected$ = cold('-a-|', { a: new ItemDeleted(item) });
+
+      expect(effects$.deleteItem$).toBeObservable(expected$);
+      expect(itemsService.delete).toHaveBeenCalledWith(item);
     });
   });
 });

libs/common-data/src/lib/state/items/items.reducer.spec.ts

@@ -4,14 +4,14 @@ import { Action } from '@ngrx/store';
 import { Item } from '@workspace/common-data';
 import { selectCurrentItem, selectCurrentItemId } from '../index';
 
-fdescribe('itemsReducer', () => {
+describe('itemsReducer', () => {
   it('should return state with unknown action', () => {
     const action = {type: 'DoesNotExist', payload: 'Sample'} as Action;
     const actual = itemsReducer(initialState, action as any);
     expect(actual).toEqual(initialState);
   });
 
-  it(`${ItemsActionTypes.ItemsLoaded} action`, () => {
+  it(`${ItemsActionTypes.ItemsLoaded} action should replace state with payload`, () => {
     const exampleItems: Item[] = [{id: 'cb1234-sa', name: 'test', description: 'testing', price: 10}];
     const entities = {
       'cb1234-sa': exampleItems[0]
@@ -22,7 +22,7 @@ fdescribe('itemsReducer', () => {
     expect(state.entities).toEqual(entities);
   });
 
-  it(`${ItemsActionTypes.ItemAdded} action`, () => {
+  it(`${ItemsActionTypes.ItemAdded} action should add item to state`, () => {
     const addedItem: Item = {id: 'added-item', name: 'added', description: 'added testing', price: 1001};
     const entities = {
       'added-item': addedItem
@@ -33,7 +33,7 @@ fdescribe('itemsReducer', () => {
     expect(state.entities).toEqual(entities);
   });
 
-  it(`${ItemsActionTypes.ItemUpdated} action`, () => {
+  it(`${ItemsActionTypes.ItemUpdated} action should update item in state`, () => {
     const existingEntities = { 'existing-item': { id: 'existing-item', name: 'existing', description: 'existing testing', price: 1001 } };
     const existingState = {...initialState, entities: existingEntities};
 
@@ -44,7 +44,7 @@ fdescribe('itemsReducer', () => {
     expect(state.entities['existing-item']).toEqual(updatedItem);
   });
 
-  it(`${ItemsActionTypes.ItemDeleted} action`, () => {
+  it(`${ItemsActionTypes.ItemDeleted} action should remove item from state`, () => {
     const existingEntities = {
       'existing-item': { id: 'existing-item', name: 'existing', description: 'existing testing', price: 1001 },
       'another-item': { id: 'another-item', name: 'another', description: 'another testing', price: 5824 },
@@ -58,43 +58,42 @@ fdescribe('itemsReducer', () => {
     expect(state.entities['another-item']).not.toBeTruthy();
   });
 
-  it(`${ItemsActionTypes.ItemSelected} action`, () => {
+  it(`${ItemsActionTypes.ItemSelected} action should set 'selectedItemId' in state`, () => {
     const selectedItem = 'item-id';
 
     const action: ItemSelected = new ItemSelected(selectedItem);
     const state = itemsReducer(initialState, action);
     expect(state.selectedItemId).toBe(selectedItem);
   });
 
-  // -------------------------------------------------------------------
-  // SELECTORS
-  // -------------------------------------------------------------------
-  it('`selectCurrentItemId` should get currently selected item ID', () => {
-    const state = {items: {...initialState, selectedItemId: '123'}};
-    expect(selectCurrentItemId(state)).toBe('123');
-  });
-
-  describe('`selectCurrentItem`', () => {
-    it('should get currently selected item', () => {
-      const state = {
-        items: {
-          ...initialState,
-          selectedItemId: '123',
-          entities: { '123': { id: '123', name: 'Test', description: 'Testing', price: 134 } }
-        }
-      };
-      expect(selectCurrentItem(state)).toBe(state.items.entities['123']);
+  describe('selectors', () => {
+    it('`selectCurrentItemId` should get currently selected item ID', () => {
+      const state = {items: {...initialState, selectedItemId: '123'}};
+      expect(selectCurrentItemId(state)).toBe('123');
     });
 
-    it('should return an empty item if no selected item', () => {
-      const state = {
-        items: {
-          ...initialState,
-          selectedItemId: null,
-          entities: { '123': { id: '123', name: 'Test', description: 'Testing', price: 134 } }
-        }
-      };
-      expect(selectCurrentItem(state)).toEqual({ id: null, name: '', price: 0, description: '' });
-    });
+    describe('`selectCurrentItem`', () => {
+      it('should get currently selected item', () => {
+        const state = {
+          items: {
+            ...initialState,
+            selectedItemId: '123',
+            entities: { '123': { id: '123', name: 'Test', description: 'Testing', price: 134 } }
+          }
+        };
+        expect(selectCurrentItem(state)).toBe(state.items.entities['123']);
+      });
+
+      it('should return an empty item if no selected item', () => {
+        const state = {
+          items: {
+            ...initialState,
+            selectedItemId: null,
+            entities: { '123': { id: '123', name: 'Test', description: 'Testing', price: 134 } }
+          }
+        };
+        expect(selectCurrentItem(state)).toEqual({ id: null, name: '', price: 0, description: '' });
+      });
+    })
   });
 });