Merge pull request onehungrymind#6 from onehungrymind/feature/tests

Feature/tests

Author: Lukas Ruebbelke

apps/dashboard/src/app/app.component.spec.ts

@@ -1,5 +1,3 @@
-import 'hammerjs';
-
 import { ComponentFixture, TestBed } from '@angular/core/testing';
 import { DebugElement } from '@angular/core';
 import { AppComponent } from './app.component';

apps/dashboard/src/app/items/items.component.spec.ts

@@ -3,7 +3,7 @@
 import { TestBed, async, ComponentFixture } from '@angular/core/testing';
 
 import { ItemsComponent } from './items.component';
-import { ItemsService } from '../core';
+import { ItemsService } from '@workspace/common-data';
 
 class ItemsServiceStub {}
 

libs/common-data/src/lib/core/items/items.service.spec.ts

@@ -1,18 +1,18 @@
 /* tslint:disable:no-unused-variable */
 
 import { TestBed, inject } from '@angular/core/testing';
-import { Http } from '@angular/http';
+import { HttpClient } from '@angular/common/http';
 
 import { ItemsService } from './items.service';
 
-class HttpStub {}
+class HttpClientStub {}
 
 describe('Service: Items', () => {
   beforeEach(() => {
     TestBed.configureTestingModule({
       providers: [
         ItemsService,
-        {provide: Http, useClass: HttpStub}
+        {provide: HttpClient, useClass: HttpClientStub}
       ]
     });
   });

libs/common-data/src/lib/core/items/items.service.stub.ts

@@ -0,0 +1,8 @@
+import { of } from 'rxjs';
+
+export class ItemsServiceStub {
+  all() {return of([])}
+  create(item) {return of({})}
+  update(item) {return of({})}
+  delete(item) {return of({})}
+}

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

@@ -2,35 +2,127 @@ 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, throwError } from 'rxjs';
+import { finalize } from 'rxjs/operators';
 
-import { ItemsLoaded, LoadItems } from './items.actions';
+import { AddItem, DeleteItem, ItemAdded, ItemDeleted, ItemsLoaded, ItemUpdated, LoadItems, UpdateItem } from './items.actions';
 import { ItemsEffects } from './items.effects';
+import { ItemsService } from '../../core/items/items.service';
+import { Item } from '../../core/items/item.model';
+import { ItemsServiceStub } from '../../core/items/items.service.stub';
 
-describe('ItemsEffects', () => {
+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: ItemsServiceStub}
       ]
     });
 
     effects$ = TestBed.get(ItemsEffects);
+    itemsService = TestBed.get(ItemsService);
   });
 
-  describe('someEffect', () => {
-    it('should work', () => {
-      actions$ = hot('-a-|', { a: new LoadItems({}) });
-      expect(effects$.loadItems$).toBeObservable(
-        hot('-a-|', { a: new ItemsLoaded({}) })
-      );
+  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() });
+      const expected$ = cold('-a-|', { a: new ItemsLoaded(items) });
+
+      expect(effects$.loadItems$).toBeObservable(expected$);
+      expect(itemsService.all).toHaveBeenCalled();
+    });
+
+    it('should log errors', () => {
+      spyOn(itemsService, 'all').and.returnValue(throwError('That did not go well...'));
+      spyOn(console, 'error').and.callThrough();
+
+      actions$ = hot('-a-|', { a: new LoadItems() });
+      effects$.loadItems$
+        .pipe(finalize(() => expect(console.error).toHaveBeenCalledWith('Error', 'That did not go well...')))
+        .subscribe();
+    });
+  });
+
+  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);
+    });
+
+    it('should log errors', () => {
+      spyOn(itemsService, 'create').and.returnValue(throwError('That did not go well...'));
+      spyOn(console, 'error').and.callThrough();
+
+      actions$ = hot('-a-|', { a: new AddItem({} as Item) });
+      effects$.addItem$
+        .pipe(finalize(() => expect(console.error).toHaveBeenCalledWith('Error', 'That did not go well...')))
+        .subscribe();
+    });
+  });
+
+  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);
+    });
+
+    it('should log errors', () => {
+      spyOn(itemsService, 'update').and.returnValue(throwError('That did not go well...'));
+      spyOn(console, 'error').and.callThrough();
+
+      actions$ = hot('-a-|', { a: new UpdateItem({} as Item) });
+      effects$.updateItem$
+        .pipe(finalize(() => expect(console.error).toHaveBeenCalledWith('Error', 'That did not go well...')))
+        .subscribe();
+    });
+  });
+
+  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);
+    });
+
+    it('should log errors', () => {
+      spyOn(itemsService, 'delete').and.returnValue(throwError('That did not go well...'));
+      spyOn(console, 'error').and.callThrough();
+
+      actions$ = hot('-a-|', { a: new DeleteItem({} as Item) });
+      effects$.deleteItem$
+        .pipe(finalize(() => expect(console.error).toHaveBeenCalledWith('Error', 'That did not go well...')))
+        .subscribe();
     });
   });
 });

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

@@ -1,15 +1,164 @@
-import { inject, TestBed } from '@angular/core/testing';
-
+import { TestBed } from '@angular/core/testing';
+import { Store, StoreModule } from '@ngrx/store';
+import { readFirst } from '@nrwl/nx/testing';
+import { NgModule } from '@angular/core';
+import { EffectsModule } from '@ngrx/effects';
+import { NxModule } from '@nrwl/nx';
+import { Item } from '../../core/items/item.model';
+import { ItemsService } from '../../core/items/items.service';
+import { ItemsServiceStub } from '../../core/items/items.service.stub';
+import { itemsReducer, ItemsState } from './items.reducer';
 import { ItemsFacade } from './items.facade';
+import { ItemsEffects } from './items.effects';
+import * as ItemsActions from './items.actions';
+
+interface TestSchema {
+  'items' : ItemsState
+}
+
+fdescribe('ItemsFacade', () => {
+  let facade: ItemsFacade;
+  let store: Store<TestSchema>;
+  let createItem;
+  let itemsService: ItemsService;
 
-describe('ItemsFacade', () => {
   beforeEach(() => {
-    TestBed.configureTestingModule({
-      providers: [ItemsFacade]
+    createItem = ( id:string, name = '', description = '', price = 0 ): Item => ({
+      id,
+      name: name ? `name-${id}` : id,
+      description: description,
+      price: price,
     });
   });
 
-  it('should be created', inject([ItemsFacade], (service: ItemsFacade) => {
-    expect(service).toBeTruthy();
-  }));
+  describe('used in NgModule', () => {
+
+    beforeEach(() => {
+      @NgModule({
+        imports: [
+          NxModule.forRoot(),
+          StoreModule.forRoot({items: itemsReducer}),
+          EffectsModule.forRoot([ItemsEffects]),
+        ],
+        providers: [
+          {provide: ItemsService, useClass: ItemsServiceStub},
+        ]
+      })
+      class RootModule {}
+      TestBed.configureTestingModule({ imports: [RootModule] });
+
+      itemsService = TestBed.get(ItemsService);
+      store = TestBed.get(Store);
+      facade = TestBed.get(ItemsFacade);
+    });
+
+    it('allItems$ should return the current list', async (done) => {
+      try {
+        let list = await readFirst(facade.allItems$);
+
+        expect(list.length).toBe(0);
+
+        store.dispatch(new ItemsActions.ItemsLoaded([
+          createItem('AAA'),
+          createItem('BBB')
+        ]));
+
+        list = await readFirst(facade.allItems$);
+
+        expect(list.length).toBe(2);
+
+        done();
+      } catch (err) {
+        done.fail(err);
+      }
+    });
+
+    it('currentItem$ should return the currently selectedItem', async (done) => {
+      try {
+        let current = await readFirst(facade.currentItem$);
+
+        expect(current.id).toBeNull();
+
+        store.dispatch(new ItemsActions.ItemsLoaded([
+          createItem('AAA'),
+          createItem('BBB')
+        ]));
+
+        store.dispatch(new ItemsActions.ItemSelected('BBB'));
+
+        current = await readFirst(facade.currentItem$);
+
+        expect(current.id).toBe('BBB');
+
+        done();
+      } catch (err) {
+        done.fail(err);
+      }
+    });
+
+    it('mutations$ should only stream mutative actions', () => {
+      const addItemAction = new ItemsActions.AddItem({} as Item),
+        updateItemAction = new ItemsActions.UpdateItem({} as Item),
+        deleteItemAction = new ItemsActions.DeleteItem({} as Item);
+
+      const actions = [];
+      facade.mutations$.subscribe(mutation => {
+        actions.push(mutation);
+      });
+
+      store.dispatch(addItemAction);
+      store.dispatch(new ItemsActions.LoadItems());
+      store.dispatch(updateItemAction);
+      store.dispatch(new ItemsActions.ItemSelected({}));
+      store.dispatch(deleteItemAction);
+
+      const expectedActions = [
+        addItemAction,
+        updateItemAction,
+        deleteItemAction
+      ];
+
+      expect(actions).toEqual(expectedActions);
+    });
+
+    describe('dispatchers', () => {
+
+      beforeEach(() => {
+        spyOn(store, 'dispatch');
+      });
+
+      it('#selectItem should dispatch `ItemSelected` action with an item ID', () => {
+        const expectedAction = new ItemsActions.ItemSelected('AAA');
+        facade.selectItem('AAA');
+        expect(store.dispatch).toHaveBeenCalledWith(expectedAction);
+      });
+
+      it('#loadAll should dispatch `LoadItems` action', () => {
+        const expectedAction = new ItemsActions.LoadItems();
+        facade.loadAll();
+        expect(store.dispatch).toHaveBeenCalledWith(expectedAction);
+      });
+
+      it('#addItem should dispatch `AddItem` action with an item', () => {
+        const item = createItem('AAA');
+        const expectedAction = new ItemsActions.AddItem(item);
+        facade.addItem(item);
+        expect(store.dispatch).toHaveBeenCalledWith(expectedAction);
+      });
+
+      it('#updateItem should dispatch `UpdateItem` action with an item', () => {
+        const item = createItem('AAA');
+        const expectedAction = new ItemsActions.UpdateItem(item);
+        facade.updateItem(item);
+        expect(store.dispatch).toHaveBeenCalledWith(expectedAction);
+      });
+
+      it('#deleteItem should dispatch `DeleteItem` action with an item', () => {
+        const item = createItem('AAA');
+        const expectedAction = new ItemsActions.DeleteItem(item);
+        facade.deleteItem(item);
+        expect(store.dispatch).toHaveBeenCalledWith(expectedAction);
+      });
+    });
+  });
 });

libs/common-data/src/lib/state/items/items.facade.ts

@@ -14,13 +14,14 @@ export class ItemsFacade {
   allItems$ = this.store.pipe(select(selectAllItems));
   currentItem$ = this.store.pipe(select(selectCurrentItem));
 
-  mutations$ = this.actions$.pipe(
-    filter(action =>
-      action.type === ItemsActionTypes.AddItem
-      || action.type === ItemsActionTypes.UpdateItem
-      || action.type === ItemsActionTypes.DeleteItem
-    )
-  );
+  mutations$ = this.actions$
+    .pipe(
+      filter(action =>
+        action.type === ItemsActionTypes.AddItem
+        || action.type === ItemsActionTypes.UpdateItem
+        || action.type === ItemsActionTypes.DeleteItem
+      )
+    );
 
   constructor(private store: Store<ItemsState>, private actions$: ActionsSubject) {}