114645: Refactor Class-Based guards tests

src/app/access-control/group-registry/group-page.guard.spec.ts

@@ -1,83 +1,100 @@
-// import { GroupPageGuard } from './group-page.guard';
+import { HALEndpointService } from '../../core/shared/hal-endpoint.service';
-// import { HALEndpointService } from '../../core/shared/hal-endpoint.service';
+import { AuthorizationDataService } from '../../core/data/feature-authorization/authorization-data.service';
-// import { AuthorizationDataService } from '../../core/data/feature-authorization/authorization-data.service';
+import { ActivatedRouteSnapshot, Router, UrlTree } from '@angular/router';
-// import { ActivatedRouteSnapshot, Router } from '@angular/router';
+import { of as observableOf, Observable } from 'rxjs';
-// import { of as observableOf } from 'rxjs';
+import { AuthService } from '../../core/auth/auth.service';
-// import { AuthService } from '../../core/auth/auth.service';
+import { TestBed, waitForAsync } from '@angular/core/testing';
-// import { FeatureID } from '../../core/data/feature-authorization/feature-id';
+import { groupPageGuard } from './group-page.guard';
-//
+import { FeatureID } from '../../core/data/feature-authorization/feature-id';
-// describe('GroupPageGuard', () => {
+jasmine.DEFAULT_TIMEOUT_INTERVAL = 10000; // Increase timeout to 10 seconds
-//   const groupsEndpointUrl = 'https://test.org/api/eperson/groups';
+
-//   const groupUuid = '0d6f89df-f95a-4829-943c-f21f434fb892';
+describe('GroupPageGuard', () => {
-//   const groupEndpointUrl = `${groupsEndpointUrl}/${groupUuid}`;
+  const groupsEndpointUrl = 'https://test.org/api/eperson/groups';
-//   const routeSnapshotWithGroupId = {
+  const groupUuid = '0d6f89df-f95a-4829-943c-f21f434fb892';
-//     params: {
+  const groupEndpointUrl = `${groupsEndpointUrl}/${groupUuid}`;
-//       groupId: groupUuid,
+  const routeSnapshotWithGroupId = {
-//     }
+    params: {
-//   } as unknown as ActivatedRouteSnapshot;
+      groupId: groupUuid,
-//
+    }
-//   let guard: GroupPageGuard;
+  } as unknown as ActivatedRouteSnapshot;
-//   let halEndpointService: HALEndpointService;
+
-//   let authorizationService: AuthorizationDataService;
+  let halEndpointService: HALEndpointService;
-//   let router: Router;
+  let authorizationService: AuthorizationDataService;
-//   let authService: AuthService;
+  let router: Router;
-//
+  let authService: AuthService;
-//   beforeEach(() => {
+
-//     halEndpointService = jasmine.createSpyObj(['getEndpoint']);
+  function init() {
-//     (halEndpointService as any).getEndpoint.and.returnValue(observableOf(groupsEndpointUrl));
+    halEndpointService = jasmine.createSpyObj(['getEndpoint']);
-//
+    ( halEndpointService as any ).getEndpoint.and.returnValue(observableOf(groupsEndpointUrl));
-//     authorizationService = jasmine.createSpyObj(['isAuthorized']);
+
-//     // NOTE: value is set in beforeEach
+    authorizationService = jasmine.createSpyObj(['isAuthorized']);
-//
+    // NOTE: value is set in beforeEach
-//     router = jasmine.createSpyObj(['parseUrl']);
+
-//     (router as any).parseUrl.and.returnValue = {};
+    router = jasmine.createSpyObj(['parseUrl']);
-//
+    ( router as any ).parseUrl.and.returnValue = {};
-//     authService = jasmine.createSpyObj(['isAuthenticated']);
+
-//     (authService as any).isAuthenticated.and.returnValue(observableOf(true));
+    authService = jasmine.createSpyObj(['isAuthenticated']);
-//
+    ( authService as any ).isAuthenticated.and.returnValue(observableOf(true));
-//     guard = new GroupPageGuard(halEndpointService, authorizationService, router, authService);
+
-//   });
+    TestBed.configureTestingModule({
-//
+      providers: [
-//   it('should be created', () => {
+        { provide: AuthorizationDataService, useValue: authorizationService },
-//     expect(guard).toBeTruthy();
+        { provide: Router, useValue: router },
-//   });
+        { provide: AuthService, useValue: authService },
-//
+        { provide: HALEndpointService, useValue: halEndpointService },
-//   describe('canActivate', () => {
+      ]
-//     describe('when the current user can manage the group', () => {
+    });
-//       beforeEach(() => {
+  }
-//         (authorizationService as any).isAuthorized.and.returnValue(observableOf(true));
+
-//       });
+  beforeEach(waitForAsync(() => {
-//
+    init();
-//       it('should return true', (done) => {
+  }));
-//         guard.canActivate(
+
-//           routeSnapshotWithGroupId, { url: 'current-url'} as any
+  it('should be created', () => {
-//         ).subscribe((result) => {
+    expect(groupPageGuard).toBeTruthy();
-//           expect(authorizationService.isAuthorized).toHaveBeenCalledWith(
+  });
-//             FeatureID.CanManageGroup, groupEndpointUrl, undefined
+
-//           );
+  describe('canActivate', () => {
-//           expect(result).toBeTrue();
+    describe('when the current user can manage the group', () => {
-//           done();
+      beforeEach(() => {
-//         });
+        ( authorizationService as any ).isAuthorized.and.returnValue(observableOf(true));
-//       });
+      });
-//     });
+
-//
+      it('should return true', (done) => {
-//     describe('when the current user can not manage the group', () => {
+        const result$ = TestBed.runInInjectionContext(() => {
-//       beforeEach(() => {
+          return groupPageGuard()(routeSnapshotWithGroupId, { url: 'current-url' } as any);
-//         (authorizationService as any).isAuthorized.and.returnValue(observableOf(false));
+        }) as Observable<boolean | UrlTree>;
-//       });
+
-//
+        result$.subscribe((result) => {
-//       it('should not return true', (done) => {
+          expect(authorizationService.isAuthorized).toHaveBeenCalledWith(
-//         guard.canActivate(
+            FeatureID.CanManageGroup, groupEndpointUrl, undefined
-//           routeSnapshotWithGroupId, { url: 'current-url'} as any
+          );
-//         ).subscribe((result) => {
+          expect(result).toBeTrue();
-//           expect(authorizationService.isAuthorized).toHaveBeenCalledWith(
+          done();
-//             FeatureID.CanManageGroup, groupEndpointUrl, undefined
+        });
-//           );
+      });
-//           expect(result).not.toBeTrue();
+    });
-//           done();
+
-//         });
+    describe('when the current user can not manage the group', () => {
-//       });
+      beforeEach(() => {
-//     });
+        (authorizationService as any).isAuthorized.and.returnValue(observableOf(false));
-//   });
+      });
-//
+
-// });
+      it('should not return true', (done) => {
+        const result$ = TestBed.runInInjectionContext(() => {
+          return groupPageGuard()(routeSnapshotWithGroupId, { url: 'current-url' } as any);
+        }) as Observable<boolean | UrlTree>;
+
+        result$.subscribe((result) => {
+          expect(authorizationService.isAuthorized).toHaveBeenCalledWith(
+            FeatureID.CanManageGroup, groupEndpointUrl, undefined
+          );
+          expect(result).not.toBeTrue();
+          done();
+        });
+
+      });
+    });
+  });
+
+});

src/app/access-control/group-registry/group-page.guard.ts

@@ -4,7 +4,7 @@ import { inject } from '@angular/core';
 import { map } from 'rxjs/operators';
 import { HALEndpointService } from '../../core/shared/hal-endpoint.service';
 import {
-  StringGuardParamFn, someFeatureAuthorizationGuard, SomeFeatureGuardParamFn
+  StringGuardParamFn, someFeatureAuthorizationGuard
 } from '../../core/data/feature-authorization/feature-authorization-guard/some-feature-authorization.guard';
 import { FeatureID } from '../../core/data/feature-authorization/feature-id';
 
@@ -21,7 +21,6 @@ const defaultGroupPageGetObjectUrl: StringGuardParamFn = (
 };
 
 export const groupPageGuard = (
-  getFeatureIDs: SomeFeatureGuardParamFn,
   getObjectUrl = defaultGroupPageGetObjectUrl,
   getEPersonUuid?: StringGuardParamFn,
 ): CanActivateFn => someFeatureAuthorizationGuard(

src/app/core/data/feature-authorization/feature-authorization-guard/dso-page-single-feature.guard.spec.ts

@@ -1,87 +1,89 @@
-// import { AuthorizationDataService } from '../authorization-data.service';
+import { AuthorizationDataService } from '../authorization-data.service';
-// import { ActivatedRouteSnapshot, Resolve, Router, RouterStateSnapshot } from '@angular/router';
+import { Router, UrlTree, ResolveFn } from '@angular/router';
-// import { RemoteData } from '../../remote-data';
+import { RemoteData } from '../../remote-data';
-// import { Observable, of as observableOf } from 'rxjs';
+import { Observable, of as observableOf } from 'rxjs';
-// import { createSuccessfulRemoteDataObject$ } from '../../../../shared/remote-data.utils';
+import { createSuccessfulRemoteDataObject$ } from '../../../../shared/remote-data.utils';
-// import { DSpaceObject } from '../../../shared/dspace-object.model';
+import { DSpaceObject } from '../../../shared/dspace-object.model';
-// import { DsoPageSingleFeatureGuard } from './dso-page-single-feature.guard';
+import { AuthService } from '../../../auth/auth.service';
-// import { FeatureID } from '../feature-id';
+import { TestBed } from '@angular/core/testing';
-// import { AuthService } from '../../../auth/auth.service';
+import { dsoPageSingleFeatureGuard } from './dso-page-single-feature.guard';
-//
+import { FeatureID } from '../feature-id';
-// /**
+
-//  * Test implementation of abstract class DsoPageSingleFeatureGuard
+
-//  */
+describe('DsoPageSingleFeatureGuard', () => {
-// class DsoPageSingleFeatureGuardImpl extends DsoPageSingleFeatureGuard<any> {
+  let authorizationService: AuthorizationDataService;
-//   constructor(protected resolver: Resolve<RemoteData<any>>,
+  let router: Router;
-//               protected authorizationService: AuthorizationDataService,
+  let authService: AuthService;
-//               protected router: Router,
+  let resolver: ResolveFn<Observable<RemoteData<any>>>;
-//               protected authService: AuthService,
+  // let resolver: jasmine.SpyObj<() => Observable<RemoteData<DSpaceObject>>>;
-//               protected featureID: FeatureID) {
+  let object: DSpaceObject;
-//     super(resolver, authorizationService, router, authService);
+  let route;
-//   }
+  let parentRoute;
-//
+
-//   getFeatureID(route: ActivatedRouteSnapshot, state: RouterStateSnapshot): Observable<FeatureID> {
+  let featureId: FeatureID;
-//     return observableOf(this.featureID);
+
-//   }
+  function init() {
-// }
+    object = {
-//
+      self: 'test-selflink'
-// describe('DsoPageSingleFeatureGuard', () => {
+    } as DSpaceObject;
-//   let guard: DsoPageSingleFeatureGuard<any>;
+
-//   let authorizationService: AuthorizationDataService;
+    authorizationService = jasmine.createSpyObj('authorizationService', {
-//   let router: Router;
+      isAuthorized: observableOf(true)
-//   let authService: AuthService;
+    });
-//   let resolver: Resolve<RemoteData<any>>;
+    router = jasmine.createSpyObj('router', {
-//   let object: DSpaceObject;
+      parseUrl: {}
-//   let route;
+    });
-//   let parentRoute;
+    resolver = jasmine.createSpyObj('resolver', {
-//
+      resolve: createSuccessfulRemoteDataObject$(object)
-//   function init() {
+    });
-//     object = {
+    // resolver = jasmine.createSpy('resolver') // Mocking the resolver function
-//       self: 'test-selflink'
+    //   .and.returnValue(observableOf({})); // Returning an observable directly
-//     } as DSpaceObject;
+    authService = jasmine.createSpyObj('authService', {
-//
+      isAuthenticated: observableOf(true)
-//     authorizationService = jasmine.createSpyObj('authorizationService', {
+    });
-//       isAuthorized: observableOf(true)
+    parentRoute = {
-//     });
+      params: {
-//     router = jasmine.createSpyObj('router', {
+        id: '3e1a5327-dabb-41ff-af93-e6cab9d032f0'
-//       parseUrl: {}
+      }
-//     });
+    };
-//     resolver = jasmine.createSpyObj('resolver', {
+    route = {
-//       resolve: createSuccessfulRemoteDataObject$(object)
+      params: {
-//     });
+      },
-//     authService = jasmine.createSpyObj('authService', {
+      parent: parentRoute
-//       isAuthenticated: observableOf(true)
+    };
-//     });
+
-//     parentRoute = {
+    featureId = FeatureID.LoginOnBehalfOf;
-//       params: {
+
-//         id: '3e1a5327-dabb-41ff-af93-e6cab9d032f0'
+    TestBed.configureTestingModule({
-//       }
+      providers: [
-//     };
+        { provide: AuthorizationDataService, useValue: authorizationService },
-//     route = {
+        { provide: Router, useValue: router },
-//       params: {
+        { provide: AuthService, useValue: authService },
-//       },
+      ]
-//       parent: parentRoute
+    });
-//     };
+  }
-//     guard = new DsoPageSingleFeatureGuardImpl(resolver, authorizationService, router, authService, undefined);
+
-//   }
+  beforeEach(() => {
-//
+    init();
-//   beforeEach(() => {
+  });
-//     init();
+
-//   });
+  describe('canActivate', () => {
-//
+    it('should call authorizationService.isAuthenticated with the appropriate arguments', (done) => {
-//   describe('getObjectUrl', () => {
+      const result$ = TestBed.runInInjectionContext(() => {
-//     it('should return the resolved object\'s selflink', (done) => {
+        return dsoPageSingleFeatureGuard(
-//       guard.getObjectUrl(route, undefined).subscribe((selflink) => {
+          () => resolver, () => observableOf(featureId)
-//         expect(selflink).toEqual(object.self);
+        )(route, { url: 'current-url' } as any);
+      }) as Observable<boolean | UrlTree>;
+
+      console.log('result$', result$);
+
+      result$.subscribe(() => {
+        expect(authorizationService.isAuthorized).toHaveBeenCalledWith(featureId);
+        done();
+      });
+
+      // expect(authorizationService.isAuthorized).toHaveBeenCalledWith(featureId);
       // done();
-//       });
+    });
-//     });
+  });
-//   });
+});
-//
-//   describe('getRouteWithDSOId', () => {
-//     it('should return the route that has the UUID of the DSO', () => {
-//       const foundRoute = (guard as any).getRouteWithDSOId(route);
-//       expect(foundRoute).toBe(parentRoute);
-//     });
-//   });
-// });

src/app/core/data/feature-authorization/feature-authorization-guard/dso-page-some-feature.guard.spec.ts

@@ -1,87 +1,96 @@
-// import { AuthorizationDataService } from '../authorization-data.service';
+import { AuthorizationDataService } from '../authorization-data.service';
-// import { ActivatedRouteSnapshot, Resolve, Router, RouterStateSnapshot } from '@angular/router';
+import { Resolve, Router, UrlTree, ResolveFn } from '@angular/router';
-// import { RemoteData } from '../../remote-data';
+import { RemoteData } from '../../remote-data';
-// import { Observable, of as observableOf } from 'rxjs';
+import { Observable, of as observableOf } from 'rxjs';
-// import { createSuccessfulRemoteDataObject$ } from '../../../../shared/remote-data.utils';
+import { createSuccessfulRemoteDataObject$ } from '../../../../shared/remote-data.utils';
-// import { DSpaceObject } from '../../../shared/dspace-object.model';
+import { DSpaceObject } from '../../../shared/dspace-object.model';
-// import { FeatureID } from '../feature-id';
+import { AuthService } from '../../../auth/auth.service';
-// import { AuthService } from '../../../auth/auth.service';
+import { dsoPageSomeFeatureGuard } from './dso-page-some-feature.guard';
-// import { DsoPageSomeFeatureGuard } from './dso-page-some-feature.guard';
+import { TestBed } from '@angular/core/testing';
-//
+import { FeatureID } from '../feature-id';
-// /**
+
-//  * Test implementation of abstract class DsoPageSomeFeatureGuard
+
-//  */
+describe('DsoPageSomeFeatureGuard', () => {
-// class DsoPageSomeFeatureGuardImpl extends DsoPageSomeFeatureGuard<any> {
+  let authorizationService: AuthorizationDataService;
-//   constructor(protected resolver: Resolve<RemoteData<any>>,
+  let router: Router;
-//               protected authorizationService: AuthorizationDataService,
+  let authService: AuthService;
-//               protected router: Router,
-//               protected authService: AuthService,
-//               protected featureIDs: FeatureID[]) {
-//     super(resolver, authorizationService, router, authService);
-//   }
-//
-//   getFeatureIDs(route: ActivatedRouteSnapshot, state: RouterStateSnapshot): Observable<FeatureID[]> {
-//     return observableOf(this.featureIDs);
-//   }
-// }
-//
-// describe('DsoPageSomeFeatureGuard', () => {
-//   let guard: DsoPageSomeFeatureGuard<any>;
-//   let authorizationService: AuthorizationDataService;
-//   let router: Router;
-//   let authService: AuthService;
   // let resolver: Resolve<RemoteData<any>>;
-//   let object: DSpaceObject;
+  let resolver: ResolveFn<Observable<RemoteData<any>>>;
-//   let route;
+  let object: DSpaceObject;
-//   let parentRoute;
+  let route;
-//
+  let parentRoute;
-//   function init() {
+
-//     object = {
+  let featureIds: FeatureID[];
-//       self: 'test-selflink'
+
-//     } as DSpaceObject;
+  function init() {
-//
+    object = {
-//     authorizationService = jasmine.createSpyObj('authorizationService', {
+      self: 'test-selflink'
-//       isAuthorized: observableOf(true)
+    } as DSpaceObject;
-//     });
+
-//     router = jasmine.createSpyObj('router', {
+    authorizationService = jasmine.createSpyObj('authorizationService', {
-//       parseUrl: {}
+      isAuthorized: observableOf(true)
-//     });
+    });
+    router = jasmine.createSpyObj('router', {
+      parseUrl: {}
+    });
     // resolver = jasmine.createSpyObj('resolver', {
     //   resolve: createSuccessfulRemoteDataObject$(object)
     // });
-//     authService = jasmine.createSpyObj('authService', {
+    authService = jasmine.createSpyObj('authService', {
-//       isAuthenticated: observableOf(true)
+      isAuthenticated: observableOf(true)
-//     });
+    });
-//     parentRoute = {
+    parentRoute = {
-//       params: {
+      params: {
-//         id: '3e1a5327-dabb-41ff-af93-e6cab9d032f0'
+        id: '3e1a5327-dabb-41ff-af93-e6cab9d032f0'
-//       }
+      }
-//     };
+    };
-//     route = {
+    route = {
-//       params: {
+      params: {
-//       },
+      },
-//       parent: parentRoute
+      parent: parentRoute
-//     };
+    };
-//     guard = new DsoPageSomeFeatureGuardImpl(resolver, authorizationService, router, authService, []);
+
-//   }
+    TestBed.configureTestingModule({
-//
+      providers: [
-//   beforeEach(() => {
+        { provide: AuthorizationDataService, useValue: authorizationService },
-//     init();
+        { provide: Router, useValue: router },
-//   });
+        { provide: AuthService, useValue: authService },
-//
+      ]
-//   describe('getObjectUrl', () => {
+    });
-//     it('should return the resolved object\'s selflink', (done) => {
+
+  }
+
+  beforeEach(() => {
+    init();
+  });
+
+  describe('getObjectUrl', () => {
+    it('should return the resolved object\'s selflink', (done) => {
+
+      const result$ = TestBed.runInInjectionContext(() => {
+        return dsoPageSomeFeatureGuard(
+          () => resolver, () => observableOf(featureIds)
+        )(route, { url: 'current-url' } as any);
+      }) as Observable<boolean | UrlTree>;
+
+      console.log('result$', result$);
+
+      result$.subscribe(() => {
+        expect(authorizationService.isAuthorized).toHaveBeenCalledWith(featureIds[0]);
+        done();
+      });
+
       // guard.getObjectUrl(route, undefined).subscribe((selflink) => {
       //   expect(selflink).toEqual(object.self);
       //   done();
       // });
-//     });
+    });
-//   });
+  });
-//
+
   // describe('getRouteWithDSOId', () => {
   //   it('should return the route that has the UUID of the DSO', () => {
   //     const foundRoute = (guard as any).getRouteWithDSOId(route);
   //     expect(foundRoute).toBe(parentRoute);
   //   });
   // });
-// });
+});

src/app/core/data/feature-authorization/feature-authorization-guard/single-feature-authorization.guard.spec.ts

@@ -6,9 +6,7 @@ import { AuthService } from '../../../auth/auth.service';
 import { singleFeatureAuthorizationGuard } from './single-feature-authorization.guard';
 import { waitForAsync, TestBed } from '@angular/core/testing';
 
-
 describe('singleFeatureAuthorizationGuard', () => {
-  let guard: any;
   let authorizationService: AuthorizationDataService;
   let router: Router;
   let authService: AuthService;
@@ -45,21 +43,22 @@ describe('singleFeatureAuthorizationGuard', () => {
     init();
   }));
 
+  describe('canActivate', () => {
     it('should call authorizationService.isAuthenticated with the appropriate arguments', (done: DoneFn) => {
       const result$ = TestBed.runInInjectionContext(() => {
         return singleFeatureAuthorizationGuard(
           () => observableOf(featureId),
           () => observableOf(objectUrl),
           () => observableOf(ePersonUuid),
-      )(undefined, { url: 'current-url' } as any)
+        )(undefined, { url: 'current-url' } as any);
       }) as Observable<boolean | UrlTree>;
 
 
       result$.subscribe(() => {
         expect(authorizationService.isAuthorized).toHaveBeenCalledWith(featureId, objectUrl, ePersonUuid);
         done();
-    })
+      });
     });
 
   });
-
+});

src/app/core/data/feature-authorization/feature-authorization-guard/some-feature-authorization.guard.spec.ts

@@ -1,13 +1,12 @@
 import { AuthorizationDataService } from '../authorization-data.service';
 import { FeatureID } from '../feature-id';
 import { Observable, of as observableOf } from 'rxjs';
-import { Router, UrlTree, CanActivateFn } from '@angular/router';
+import { Router, UrlTree } from '@angular/router';
 import { AuthService } from '../../../auth/auth.service';
-import { waitForAsync, TestBed } from '@angular/core/testing';
 import { someFeatureAuthorizationGuard } from './some-feature-authorization.guard';
+import { TestBed, waitForAsync } from '@angular/core/testing';
 
-describe('someFeatureAuthorizationGuard', () => {
+describe('SomeFeatureAuthorizationGuard', () => {
-  let guard: CanActivateFn;
   let authorizationService: AuthorizationDataService;
   let router: Router;
   let authService: AuthService;
@@ -28,9 +27,11 @@ describe('someFeatureAuthorizationGuard', () => {
         return observableOf(authorizedFeatureIds.indexOf(featureId) > -1);
       }
     });
+
     router = jasmine.createSpyObj('router', {
       parseUrl: {}
     });
+
     authService = jasmine.createSpyObj('authService', {
       isAuthenticated: observableOf(true)
     });
@@ -42,26 +43,26 @@ describe('someFeatureAuthorizationGuard', () => {
         { provide: AuthService, useValue: authService },
       ]
     });
-
-    guard = someFeatureAuthorizationGuard(
-      () => observableOf(featureIds),
-      () => observableOf(objectUrl),
-      () => observableOf(ePersonUuid),
-    );
   }
 
   beforeEach(waitForAsync(() => {
     init();
   }));
 
+  describe('canActivate', () => {
     describe('when the user isn\'t authorized', () => {
       beforeEach(() => {
         authorizedFeatureIds = [];
       });
 
-    it('should not return true', (done: DoneFn) => {
+      it('should not return true', (done) => {
+
         const result$ = TestBed.runInInjectionContext(() => {
-        return guard(undefined, { url: 'current-url' } as any)
+          return someFeatureAuthorizationGuard(
+            () => observableOf(featureIds),
+            () => observableOf(objectUrl),
+            () => observableOf(ePersonUuid),
+          )(undefined, { url: 'current-url' } as any);
         }) as Observable<boolean | UrlTree>;
 
         result$.subscribe((result) => {
@@ -77,8 +78,13 @@ describe('someFeatureAuthorizationGuard', () => {
       });
 
       it('should return true', (done) => {
+
         const result$ = TestBed.runInInjectionContext(() => {
-        return guard(undefined, { url: 'current-url' } as any)
+          return someFeatureAuthorizationGuard(
+            () => observableOf(featureIds),
+            () => observableOf(objectUrl),
+            () => observableOf(ePersonUuid),
+          )(undefined, { url: 'current-url' } as any);
         }) as Observable<boolean | UrlTree>;
 
         result$.subscribe((result) => {
@@ -94,8 +100,13 @@ describe('someFeatureAuthorizationGuard', () => {
       });
 
       it('should return true', (done) => {
+
         const result$ = TestBed.runInInjectionContext(() => {
-        return guard(undefined, { url: 'current-url' } as any)
+          return someFeatureAuthorizationGuard(
+            () => observableOf(featureIds),
+            () => observableOf(objectUrl),
+            () => observableOf(ePersonUuid),
+          )(undefined, { url: 'current-url' } as any);
         }) as Observable<boolean | UrlTree>;
 
         result$.subscribe((result) => {
@@ -105,3 +116,4 @@ describe('someFeatureAuthorizationGuard', () => {
       });
     });
   });
+});