Improve unit tests

Author: David Sargent

src/app/common/states/event-source.service.spec.ts

@@ -13,10 +13,32 @@ describe('EventSourceService', () => {
       providers: [EventSourceService]
     });
     eventSourceService = TestBed.get(EventSourceService);
-    spyOn(eventSourceService, 'forUrl').and.returnValue(mockEventSource);
+    spyOn(eventSourceService, '_forUrl').and.returnValue(mockEventSource);
   });
 
   it('should be created', inject([EventSourceService], (service: EventSourceService) => {
     expect(service).toBeTruthy();
   }));
+
+  it('should properly called the error handler', (done => {
+    eventSourceService.forUrl(uri, (eventSource) => {
+      expect(eventSource).toBeTruthy();
+      done();
+    });
+    sources[uri].emitError(null);
+  }));
+
+  it('should properly ignore unspecified error handlers', (done => {
+    eventSourceService.forUrl(uri, null);
+    sources[uri].emitError(null);
+
+    setTimeout(() => {
+      done();
+    }, 3500);
+  }));
+
+  it('should remember the connection after it is made', () => {
+    eventSourceService.forUrl(uri, null);
+    expect(eventSourceService['connections'][uri]).toBeTruthy();
+  });
 });

src/app/common/states/event-source.service.ts

@@ -4,6 +4,7 @@ import {isNullOrUndefined} from 'util';
 
 @Injectable()
 export class EventSourceService {
+  readonly TIME_BETWEEN_RETRIES = 3;
   private EventSource: any = window['EventSource'];
   private connections: any = {};
   constructor() { }
@@ -18,9 +19,13 @@ export class EventSourceService {
     return newCon.conn;
   }
 
+  _forUrl(url: string): EventSource {
+    return new this.EventSource(url);
+  }
+
   private createEventStreamConnection(url: string, err: (EventSource) => void) {
     const newCon = {
-      conn: new this.EventSource(url),
+      conn: this._forUrl(url),
       errorHandler: err,
       errorHandlerCalled: false
     };
@@ -30,17 +35,20 @@ export class EventSourceService {
         return;
       }
       newCon.errorHandlerCalled = true;
-      console.log('SSE Connection failed. Retrying in 5 seconds...');
+      console.log(`SSE Connection failed. Retrying in ${this.TIME_BETWEEN_RETRIES} seconds...`);
       let connection = this.connections[url];
       let timeoutCalled = false;
       setTimeout(() => {
         if (connection != null && !timeoutCalled) {
           timeoutCalled = true;
           this.connections[url] = this.createEventStreamConnection(url, err);
-          connection.errorHandler(this.connections[url]);
+          if (typeof connection.errorHandler === 'function') {
+            connection.errorHandler(this.connections[url]);
+          }
+
           connection = null;
         }
-      }, 5000, this);
+      }, this.TIME_BETWEEN_RETRIES * 1000, this);
     };
     return newCon;
   }

src/app/common/states/notification.service.spec.ts

@@ -2,13 +2,16 @@ import { TestBed, inject } from '@angular/core/testing';
 import EventSourceMock, { sources } from 'eventsourcemock';
 import { NotificationService } from './notification.service';
 import {EventSourceService} from './event-source.service';
-import {StoreModule} from '@ngrx/store';
+import {Store, StoreModule} from '@ngrx/store';
 import {reducers} from '../../action-reducer-map';
+import {UpdatePlannedRoute} from './actions/notification.action';
 
 describe('NotificationService', () => {
+  const DEFAULT_TIMEOUT = jasmine.DEFAULT_TIMEOUT_INTERVAL;
   let uri: string;
 
   beforeEach(() => {
+    jasmine.DEFAULT_TIMEOUT_INTERVAL = 10000;
     uri = 'http://localhost:1234/events';
     const mockEventSource = new EventSourceMock(uri);
 
@@ -19,6 +22,8 @@ describe('NotificationService', () => {
       providers: [NotificationService, EventSourceService]
     });
     const eventSourceService = TestBed.get(EventSourceService);
+    const store = TestBed.get(Store);
+    spyOn(store, 'dispatch').and.callThrough();
     spyOn(eventSourceService, 'forUrl').and.returnValue(mockEventSource);
   });
 
@@ -35,52 +40,50 @@ describe('NotificationService', () => {
     });
   }
 
-  it('should be able to update', (done) => {
-    // Arrange
+  it('should use the EventSourceService', () => {
+    const eventSourceService = TestBed.get(EventSourceService);
     const service = TestBed.get(NotificationService);
-    const source = sources[uri];
-    const expectedCost = 1234.56;
-    const expectedCostString = expectedCost.toLocaleString('en-US', { currency: 'USD', style: 'currency' });
-    const message = mockNotificationEvent(NotificationService.ESTIMATED_PRICE, {
-      cost: expectedCost
-    });
 
-    // Act
-    source.emitOpen();
-    const observable = service.getCurrentPriceEstimate();
-    observable.subscribe(val => {
-      // Assert
-      expect(val).toBe(expectedCostString);
-      done();
-    });
+    service.onInit();
 
-    source.emitMessage(message);
+    expect(eventSourceService.forUrl).toHaveBeenCalled();
   });
 
-  it('should use last available value', (done) => {
+  it('should respond correctly to EventSource failing', () => {
+
+    const service = TestBed.get(NotificationService);
+    const eventSourceService = TestBed.get(EventSourceService);
+    spyOn(service, 'bindToNotificationEventSource').and.callThrough();
+    //spyOn(eventSourceService, 'forUrl');
+
+    service.onInit();
+    sources[uri].emitError(new Event(null, null));
+
+    expect(eventSourceService.forUrl).toHaveBeenCalledTimes(2);
+    expect(service.bindToNotificationEventSource).toHaveBeenCalledTimes(1);
+  });
+
+  it('should be able to update the app state', () => {
     // Arrange
+    const store = TestBed.get(Store);
     const service = TestBed.get(NotificationService);
     const source = sources[uri];
-    const expectedCost = 1248.16;
-    const expectedCostString = expectedCost.toLocaleString('en-US', { currency: 'USD', style: 'currency' });
-    const messageA = mockNotificationEvent(NotificationService.ESTIMATED_PRICE, {
-      cost: 0.01
-    });
-    const messageB = mockNotificationEvent(NotificationService.ESTIMATED_PRICE, {
-      cost: expectedCost
-    });
+    const expectedCost = 1234.56;
+    let body = {
+      cost: expectedCost,
+      origin: null,
+      destination: null,
+      distance: 0,
+      duration: 0
+    };
+    const message = mockNotificationEvent(NotificationService.ESTIMATED_PRICE, body);
 
     // Act
     source.emitOpen();
-    source.emitMessage(messageA);
-    source.emitMessage(messageB);
-    setTimeout(() => {
-        const observable = service.getCurrentPriceEstimate();
-        observable.subscribe(val => {
-          // Assert
-          expect(val).toBe(expectedCostString);
-          done();
-        });
-      }, 1000);
+    source.emitMessage(message);
+
+    // Assert
+    expect(service._isActive).toBeTruthy();
+    expect(store.dispatch).toHaveBeenCalledWith(new UpdatePlannedRoute(body));
   });
 });

src/app/common/states/notification.service.ts

@@ -35,7 +35,7 @@ export class NotificationService {
     private eventSourceService: EventSourceService,
     private zone: NgZone
   ) {
-    this.subject = new BehaviorSubject<any>({ RoutingKey: NotificationService.NOTHING, Data: null});
+    this.subject = new BehaviorSubject<any>({ RoutingKey: NotificationService.NOTHING, Data: new Route() });
     this.onInit();
   }
 
@@ -72,12 +72,9 @@ export class NotificationService {
 
   listenForRouteUpdates() {
     this._subscription = this.newObservableForKey(NotificationService.ESTIMATED_PRICE).subscribe(next =>
-      this.passengerStore.dispatch(new UpdatePlannedRoute(next as Route)));
-  }
-
-  getCurrentPriceEstimate(): Observable<string> {
-    return this.newObservableForKey(NotificationService.ESTIMATED_PRICE).map(val => {
-      return val['cost'].toLocaleString('en-US', { style: 'currency', currency: 'USD' });
+    {
+      //console.log(next);
+      this.passengerStore.dispatch(new UpdatePlannedRoute(next as Route))
     });
   }
 

src/app/common/states/reducers/notification.reducer.ts

@@ -9,6 +9,7 @@ initialState.duration = 0;
 export function notificationReducer(state: Route = initialState, action: PlannedRouteAction): Route {
   switch (action.type) {
     case 'UPDATE_ROUTE':
+      console.log(action['data']);
       return (action as UpdatePlannedRoute).data;
 
     default: