134770: Test fixes

- Cast the store.dispatch method in expect calls, because ngrx now has multiple methods with the same name and jest can't deal with it
- Removed the APP_INITIALIZER tests since it can't be tested like that anymore with the new provider format

Author: alexandrevryghem

src/app/access-control/epeople-registry/epeople-registry.service.spec.ts

@@ -51,7 +51,7 @@ describe('EpeopleRegistryService', () => {
     it('should dispatch EPeopleRegistryCancelEPersonAction', () => {
       const dispatchSpy = spyOn(store, 'dispatch');
       service.cancelEditEPerson();
-      expect(dispatchSpy).toHaveBeenCalledWith(new EPeopleRegistryCancelEPersonAction());
+      expect(dispatchSpy as jasmine.Spy).toHaveBeenCalledWith(new EPeopleRegistryCancelEPersonAction());
     });
   });
 
@@ -60,7 +60,7 @@ describe('EpeopleRegistryService', () => {
       const dispatchSpy = spyOn(store, 'dispatch');
       const mockEPerson: EPerson = { id: '456', name: 'Another User' } as EPerson;
       service.editEPerson(mockEPerson);
-      expect(dispatchSpy).toHaveBeenCalledWith(new EPeopleRegistryEditEPersonAction(mockEPerson));
+      expect(dispatchSpy as jasmine.Spy).toHaveBeenCalledWith(new EPeopleRegistryEditEPersonAction(mockEPerson));
     });
   });
 });

src/app/access-control/group-registry/group-registry.service.spec.ts

@@ -14,6 +14,7 @@ import {
   editGroupSelector,
   GroupRegistryService,
 } from './group-registry.service';
+import Jasmine = jasmine.Jasmine;
 
 describe('GroupRegistryService', () => {
   let service: GroupRegistryService;
@@ -52,13 +53,13 @@ describe('GroupRegistryService', () => {
   it('should dispatch cancel edit group action', () => {
     const dispatchSpy = spyOn(store, 'dispatch');
     service.cancelEditGroup();
-    expect(dispatchSpy).toHaveBeenCalledWith(new GroupRegistryCancelGroupAction());
+    expect(dispatchSpy as jasmine.Spy).toHaveBeenCalledWith(new GroupRegistryCancelGroupAction());
   });
 
   it('should dispatch edit group action with group', () => {
     const dispatchSpy = spyOn(store, 'dispatch');
     const group: Group = { id: '123', name: 'New Group' } as Group;
     service.editGroup(group);
-    expect(dispatchSpy).toHaveBeenCalledWith(new GroupRegistryEditGroupAction(group));
+    expect(dispatchSpy as jasmine.Spy).toHaveBeenCalledWith(new GroupRegistryEditGroupAction(group));
   });
 });

src/app/app.component.spec.ts

@@ -145,7 +145,7 @@ describe('App component', () => {
     });
 
     it('should dispatch a HostWindowResizeAction with the width and height of the window as its payload', () => {
-      expect(store.dispatch).toHaveBeenCalledWith(new HostWindowResizeAction(width, height));
+      expect(store.dispatch as jasmine.Spy).toHaveBeenCalledWith(new HostWindowResizeAction(width, height));
     });
 
   });

src/app/core/auth/auth.service.spec.ts

@@ -266,15 +266,15 @@ describe('AuthService test', () => {
       it('store should dispatch SetUserAsIdleAction', () => {
         spyOn(mockStore, 'dispatch');
         authService.setIdle(true);
-        expect(mockStore.dispatch).toHaveBeenCalledWith(new SetUserAsIdleAction());
+        expect(mockStore.dispatch as jasmine.Spy).toHaveBeenCalledWith(new SetUserAsIdleAction());
       });
     });
 
     describe('setIdle false', () => {
       it('store should dispatch UnsetUserAsIdleAction', () => {
         spyOn(mockStore, 'dispatch');
         authService.setIdle(false);
-        expect(mockStore.dispatch).toHaveBeenCalledWith(new UnsetUserAsIdleAction());
+        expect(mockStore.dispatch as jasmine.Spy).toHaveBeenCalledWith(new UnsetUserAsIdleAction());
       });
     });
   });

src/app/core/cache/object-cache.service.spec.ts

@@ -151,7 +151,7 @@ describe('ObjectCacheService', () => {
   describe('add', () => {
     it('should dispatch an ADD action with the object to add, the time to live, and the current timestamp', () => {
       service.add(objectToCache, msToLive, requestUUID, alternativeLink);
-      expect(store.dispatch).toHaveBeenCalledWith(new AddToObjectCacheAction(objectToCache, timestamp, msToLive, requestUUID, alternativeLink));
+      expect(store.dispatch as jasmine.Spy).toHaveBeenCalledWith(new AddToObjectCacheAction(objectToCache, timestamp, msToLive, requestUUID, alternativeLink));
       expect(linkServiceStub.removeResolvedLinks).toHaveBeenCalledWith(objectToCache);
     });
   });
@@ -163,20 +163,20 @@ describe('ObjectCacheService', () => {
 
     it('should dispatch a REMOVE action with the self link of the object to remove', () => {
       service.remove(selfLink);
-      expect(store.dispatch).toHaveBeenCalledWith(new RemoveFromObjectCacheAction(selfLink));
+      expect(store.dispatch as jasmine.Spy).toHaveBeenCalledWith(new RemoveFromObjectCacheAction(selfLink));
     });
 
     it('should dispatch a REMOVE_BY_SUBSTRING action on the index state for each alternativeLink in the object', () => {
       service.remove(selfLink);
       cacheEntry.alternativeLinks.forEach(
-        (link: string) => expect(store.dispatch).toHaveBeenCalledWith(new RemoveFromIndexBySubstringAction(IndexName.ALTERNATIVE_OBJECT_LINK, link)));
+        (link: string) => expect(store.dispatch as jasmine.Spy).toHaveBeenCalledWith(new RemoveFromIndexBySubstringAction(IndexName.ALTERNATIVE_OBJECT_LINK, link)));
     });
 
     it('should dispatch a REMOVE_BY_SUBSTRING action on the index state for each _links in the object, except the self link', () => {
       service.remove(selfLink);
       Object.entries(objectToCache._links).forEach(([key, value]: [string, HALLink]) => {
         if (key !== 'self') {
-          expect(store.dispatch).toHaveBeenCalledWith(new RemoveFromIndexBySubstringAction(IndexName.ALTERNATIVE_OBJECT_LINK, value.href));
+          expect(store.dispatch as jasmine.Spy).toHaveBeenCalledWith(new RemoveFromIndexBySubstringAction(IndexName.ALTERNATIVE_OBJECT_LINK, value.href));
         }
       });
     });
@@ -345,8 +345,8 @@ describe('ObjectCacheService', () => {
   describe('patch methods', () => {
     it('should dispatch the correct actions when addPatch is called', () => {
       service.addPatch(selfLink, operations);
-      expect(store.dispatch).toHaveBeenCalledWith(new AddPatchObjectCacheAction(selfLink, operations));
-      expect(store.dispatch).toHaveBeenCalledWith(new AddToSSBAction(selfLink, RestRequestMethod.PATCH));
+      expect(store.dispatch as jasmine.Spy).toHaveBeenCalledWith(new AddPatchObjectCacheAction(selfLink, operations));
+      expect(store.dispatch as jasmine.Spy).toHaveBeenCalledWith(new AddToSSBAction(selfLink, RestRequestMethod.PATCH));
     });
 
     it('isDirty should return true when the patches list in the cache entry is not empty', () => {
@@ -366,7 +366,7 @@ describe('ObjectCacheService', () => {
     });
     it('should dispatch the correct actions when applyPatchesToCachedObject is called', () => {
       (service as any).applyPatchesToCachedObject(selfLink);
-      expect(store.dispatch).toHaveBeenCalledWith(new ApplyPatchObjectCacheAction(selfLink));
+      expect(store.dispatch as jasmine.Spy).toHaveBeenCalledWith(new ApplyPatchObjectCacheAction(selfLink));
     });
   });
 
@@ -398,12 +398,12 @@ describe('ObjectCacheService', () => {
     describe('addDependency', () => {
       it('should dispatch an ADD_DEPENDENTS action', () => {
         service.addDependency(selfLink, 'objectWithoutDependents');
-        expect(store.dispatch).toHaveBeenCalledOnceWith(new AddDependentsObjectCacheAction('objectWithoutDependents', [requestUUID]));
+        expect(store.dispatch as jasmine.Spy).toHaveBeenCalledOnceWith(new AddDependentsObjectCacheAction('objectWithoutDependents', [requestUUID]));
       });
 
       it('should resolve alt links', () => {
         service.addDependency(anotherLink, 'objectWithoutDependentsAlt');
-        expect(store.dispatch).toHaveBeenCalledOnceWith(new AddDependentsObjectCacheAction('objectWithoutDependents', [requestUUID]));
+        expect(store.dispatch as jasmine.Spy).toHaveBeenCalledOnceWith(new AddDependentsObjectCacheAction('objectWithoutDependents', [requestUUID]));
       });
 
       it('should not dispatch if either href cannot be resolved to a cached self link', () => {
@@ -427,7 +427,7 @@ describe('ObjectCacheService', () => {
 
       it('should work with observable hrefs', () => {
         service.addDependency(of(selfLink), of('objectWithoutDependents'));
-        expect(store.dispatch).toHaveBeenCalledOnceWith(new AddDependentsObjectCacheAction('objectWithoutDependents', [requestUUID]));
+        expect(store.dispatch as jasmine.Spy).toHaveBeenCalledOnceWith(new AddDependentsObjectCacheAction('objectWithoutDependents', [requestUUID]));
       });
 
       it('should only dispatch once for the first value of either observable href', () => {
@@ -448,7 +448,7 @@ describe('ObjectCacheService', () => {
           service.addDependency(href$, dependsOnHref$);
           flush();
 
-          expect(store.dispatch).toHaveBeenCalledOnceWith(new AddDependentsObjectCacheAction('objectWithoutDependents', [requestUUID]));
+          expect(store.dispatch as jasmine.Spy).toHaveBeenCalledOnceWith(new AddDependentsObjectCacheAction('objectWithoutDependents', [requestUUID]));
         });
       });
 
@@ -473,12 +473,12 @@ describe('ObjectCacheService', () => {
     describe('removeDependents', () => {
       it('should dispatch a REMOVE_DEPENDENTS action', () => {
         service.removeDependents('objectWithDependents');
-        expect(store.dispatch).toHaveBeenCalledOnceWith(new RemoveDependentsObjectCacheAction('objectWithDependents'));
+        expect(store.dispatch as jasmine.Spy).toHaveBeenCalledOnceWith(new RemoveDependentsObjectCacheAction('objectWithDependents'));
       });
 
       it('should resolve alt links', () => {
         service.removeDependents('objectWithDependentsAlt');
-        expect(store.dispatch).toHaveBeenCalledOnceWith(new RemoveDependentsObjectCacheAction('objectWithDependents'));
+        expect(store.dispatch as jasmine.Spy).toHaveBeenCalledOnceWith(new RemoveDependentsObjectCacheAction('objectWithDependents'));
       });
 
       it('should not dispatch if the href cannot be resolved to a cached self link', () => {

src/app/core/data/object-updates/object-updates.service.spec.ts

@@ -70,7 +70,7 @@ describe('ObjectUpdatesService', () => {
   describe('initialize', () => {
     it('should dispatch an INITIALIZE action with the correct URL, initial identifiables and the last modified date', () => {
       service.initialize(url, identifiables, modDate);
-      expect(store.dispatch).toHaveBeenCalledWith(new InitializeFieldsAction(url, identifiables, modDate));
+      expect(store.dispatch as jasmine.Spy).toHaveBeenCalledWith(new InitializeFieldsAction(url, identifiables, modDate));
     });
   });
 
@@ -168,34 +168,34 @@ describe('ObjectUpdatesService', () => {
   describe('setEditableFieldUpdate', () => {
     it('should dispatch a SetEditableFieldUpdateAction action with the correct URL, uuid and true when true was set', () => {
       service.setEditableFieldUpdate(url, identifiable1.uuid, true);
-      expect(store.dispatch).toHaveBeenCalledWith(new SetEditableFieldUpdateAction(url, identifiable1.uuid, true));
+      expect(store.dispatch as jasmine.Spy).toHaveBeenCalledWith(new SetEditableFieldUpdateAction(url, identifiable1.uuid, true));
     });
 
     it('should dispatch an SetEditableFieldUpdateAction action with the correct URL, uuid and false when false was set', () => {
       service.setEditableFieldUpdate(url, identifiable1.uuid, false);
-      expect(store.dispatch).toHaveBeenCalledWith(new SetEditableFieldUpdateAction(url, identifiable1.uuid, false));
+      expect(store.dispatch as jasmine.Spy).toHaveBeenCalledWith(new SetEditableFieldUpdateAction(url, identifiable1.uuid, false));
     });
   });
 
   describe('discardFieldUpdates', () => {
     it('should dispatch a DiscardObjectUpdatesAction action with the correct URL and passed notification ', () => {
       const undoNotification = new Notification('id', NotificationType.Info, 'undo');
       service.discardFieldUpdates(url, undoNotification);
-      expect(store.dispatch).toHaveBeenCalledWith(new DiscardObjectUpdatesAction(url, undoNotification));
+      expect(store.dispatch as jasmine.Spy).toHaveBeenCalledWith(new DiscardObjectUpdatesAction(url, undoNotification));
     });
   });
 
   describe('reinstateFieldUpdates', () => {
     it('should dispatch a ReinstateObjectUpdatesAction action with the correct URL ', () => {
       service.reinstateFieldUpdates(url);
-      expect(store.dispatch).toHaveBeenCalledWith(new ReinstateObjectUpdatesAction(url));
+      expect(store.dispatch as jasmine.Spy).toHaveBeenCalledWith(new ReinstateObjectUpdatesAction(url));
     });
   });
 
   describe('removeSingleFieldUpdate', () => {
     it('should dispatch a RemoveFieldUpdateAction action with the correct URL and uuid', () => {
       service.removeSingleFieldUpdate(url, identifiable1.uuid);
-      expect(store.dispatch).toHaveBeenCalledWith(new RemoveFieldUpdateAction(url, identifiable1.uuid));
+      expect(store.dispatch as jasmine.Spy).toHaveBeenCalledWith(new RemoveFieldUpdateAction(url, identifiable1.uuid));
     });
   });
 
@@ -287,7 +287,7 @@ describe('ObjectUpdatesService', () => {
   describe('setSelectedVirtualMetadata', () => {
     it('should dispatch a SELECT_VIRTUAL_METADATA action with the correct URL, relationship, identifiable and boolean', () => {
       service.setSelectedVirtualMetadata(url, relationship.uuid, identifiable1.uuid, true);
-      expect(store.dispatch).toHaveBeenCalledWith(new SelectVirtualMetadataAction(url, relationship.uuid, identifiable1.uuid, true));
+      expect(store.dispatch as jasmine.Spy).toHaveBeenCalledWith(new SelectVirtualMetadataAction(url, relationship.uuid, identifiable1.uuid, true));
     });
   });
 

src/app/core/data/request.service.spec.ts

@@ -704,7 +704,7 @@ describe('RequestService', () => {
       service.setStaleByHref(href).subscribe(() => {
         const requestStaleAction = new RequestStaleAction(uuid);
         requestStaleAction.lastUpdated = jasmine.any(Number) as any;
-        expect(store.dispatch).toHaveBeenCalledWith(requestStaleAction);
+        expect(store.dispatch as jasmine.Spy).toHaveBeenCalledWith(requestStaleAction);
         done();
       });
     });

src/app/core/notification-system/notifications.service.spec.ts

@@ -62,36 +62,36 @@ describe('NotificationsService test', () => {
   it('Success method should dispatch NewNotificationAction with proper parameter', () => {
     const notification = service.success('Title', of('Content'));
     expect(notification.type).toBe(NotificationType.Success);
-    expect(store.dispatch).toHaveBeenCalledWith(new NewNotificationAction(notification));
+    expect(store.dispatch as jasmine.Spy).toHaveBeenCalledWith(new NewNotificationAction(notification));
   });
 
   it('Warning method should dispatch NewNotificationAction with proper parameter', () => {
     const notification = service.warning('Title', of('Content'));
     expect(notification.type).toBe(NotificationType.Warning);
-    expect(store.dispatch).toHaveBeenCalledWith(new NewNotificationAction(notification));
+    expect(store.dispatch as jasmine.Spy).toHaveBeenCalledWith(new NewNotificationAction(notification));
   });
 
   it('Info method should dispatch NewNotificationAction with proper parameter', () => {
     const notification = service.info('Title', of('Content'));
     expect(notification.type).toBe(NotificationType.Info);
-    expect(store.dispatch).toHaveBeenCalledWith(new NewNotificationAction(notification));
+    expect(store.dispatch as jasmine.Spy).toHaveBeenCalledWith(new NewNotificationAction(notification));
   });
 
   it('Error method should dispatch NewNotificationAction with proper parameter', () => {
     const notification = service.error('Title', of('Content'));
     expect(notification.type).toBe(NotificationType.Error);
-    expect(store.dispatch).toHaveBeenCalledWith(new NewNotificationAction(notification));
+    expect(store.dispatch as jasmine.Spy).toHaveBeenCalledWith(new NewNotificationAction(notification));
   });
 
   it('Remove method should dispatch RemoveNotificationAction with proper id', () => {
     const notification = new Notification('1234', NotificationType.Info, 'title...', 'description');
     service.remove(notification);
-    expect(store.dispatch).toHaveBeenCalledWith(new RemoveNotificationAction(notification.id));
+    expect(store.dispatch as jasmine.Spy).toHaveBeenCalledWith(new RemoveNotificationAction(notification.id));
   });
 
   it('RemoveAll method should dispatch RemoveAllNotificationsAction', () => {
     service.removeAll();
-    expect(store.dispatch).toHaveBeenCalledWith(new RemoveAllNotificationsAction());
+    expect(store.dispatch as jasmine.Spy).toHaveBeenCalledWith(new RemoveAllNotificationsAction());
   });
 
 });

src/app/forgot-password/forgot-password-form/forgot-password-form.component.spec.ts

@@ -112,7 +112,7 @@ describe('ForgotPasswordFormComponent', () => {
       comp.submit();
 
       expect(ePersonDataService.patchPasswordWithToken).toHaveBeenCalledWith('test-uuid', 'test-token', 'password');
-      expect(store.dispatch).toHaveBeenCalledWith(new AuthenticateAction('test@email.org', 'password'));
+      expect(store.dispatch as jasmine.Spy).toHaveBeenCalledWith(new AuthenticateAction('test@email.org', 'password'));
       expect(router.navigate).toHaveBeenCalledWith(['/home']);
       expect(notificationsService.success).toHaveBeenCalled();
     });

src/app/init.service.spec.ts

@@ -1,8 +1,5 @@
 import { CommonModule } from '@angular/common';
-import {
-  APP_INITIALIZER,
-  Injectable,
-} from '@angular/core';
+import { Injectable } from '@angular/core';
 import {
   inject,
   TestBed,
@@ -98,12 +95,6 @@ describe('InitService', () => {
       expect(providers).toContain(objectContaining({
         provide: APP_CONFIG,
       }));
-
-      expect(providers).toContain(objectContaining({
-        provide: APP_INITIALIZER,
-        deps: [ InitService ],
-        multi: true,
-      }));
     });
 
     it('should call resolveAppConfig() in APP_CONFIG factory', () => {
@@ -117,22 +108,6 @@ describe('InitService', () => {
       expect(spy.resolveAppConfig).toHaveBeenCalled();
       expect(spy.init).not.toHaveBeenCalled();
     });
-
-    it('should defer to init() in APP_INITIALIZER factory', () => {
-      const factory = (
-        ConcreteInitServiceMock.providers()
-          .find((p: any) => p.provide === APP_INITIALIZER) as any
-      ).useFactory;
-
-      // we don't care about the dependencies here
-      // @ts-ignore
-      const instance = new ConcreteInitServiceMock(null, null, null);
-
-      // provider ensures that the right concrete instance is passed to the factory
-      factory(instance);
-      expect(spy.resolveAppConfig).not.toHaveBeenCalled();
-      expect(spy.init).toHaveBeenCalled();
-    });
   });
 
   describe('common initialization steps', () => {