refactor(router): Update tests to not use deprecated string tokens (angular#60378)

This replaces string tokens in the router tests with functional guads.

PR Close angular#60378

Author: atscott

packages/router/test/apply_redirects.spec.ts

@@ -6,11 +6,10 @@
  * found in the LICENSE file at https://angular.dev/license
  */
 
-import {EnvironmentInjector, inject, Injectable, NgModuleRef} from '@angular/core';
+import {EnvironmentInjector, inject, Injectable} from '@angular/core';
 import {fakeAsync, TestBed, tick} from '@angular/core/testing';
-import {provideRouter, withRouterConfig} from '@angular/router';
-import {firstValueFrom, Observable, of} from 'rxjs';
-import {delay, map, tap} from 'rxjs/operators';
+import {Observable, of} from 'rxjs';
+import {delay, tap} from 'rxjs/operators';
 
 import {Route, Routes} from '../src/models';
 import {recognize} from '../src/recognize';
@@ -584,24 +583,28 @@ describe('redirects', () => {
 
       let passedUrlSegments: UrlSegment[];
 
-      const guard = {
-        canLoad: (route: Route, urlSegments: UrlSegment[]) => {
-          passedUrlSegments = urlSegments;
-          return true;
-        },
-      };
-      const injector = {get: (token: any) => (token === 'guard' ? guard : {injector})};
-
       const config = [
         {
           path: 'a',
           component: ComponentA,
-          canLoad: ['guard'],
+          canLoad: [
+            (route: Route, urlSegments: UrlSegment[]) => {
+              passedUrlSegments = urlSegments;
+              return true;
+            },
+          ],
           loadChildren: jasmine.createSpy('children'),
         },
       ];
 
-      recognize(<any>injector, <any>loader, null, config, tree('a/b'), serializer).subscribe(
+      recognize(
+        TestBed.inject(EnvironmentInjector),
+        <any>loader,
+        null,
+        config,
+        tree('a/b'),
+        serializer,
+      ).subscribe(
         ({tree: r}) => {
           expectTreeToBe(r, '/a/b');
           expect(passedUrlSegments.length).toBe(2);
@@ -710,7 +713,7 @@ describe('redirects', () => {
       });
     });
 
-    it('should not load the configuration of a wildcard route if there is a match', () => {
+    it('should not load the configuration of a wildcard route if there is a match', async () => {
       const loadedConfig = {
         routes: [{path: '', component: ComponentB}],
         injector: TestBed.inject(EnvironmentInjector),
@@ -727,20 +730,23 @@ describe('redirects', () => {
         {path: '**', loadChildren: jasmine.createSpy('children')},
       ];
 
-      recognize(
-        TestBed.inject(EnvironmentInjector),
-        <any>loader,
-        null,
-        config,
-        tree(''),
-        serializer,
-      ).forEach(({tree: r}) => {
-        expect(loader.loadChildren.calls.count()).toEqual(1);
-        expect(loader.loadChildren.calls.first().args).not.toContain(
-          jasmine.objectContaining({
-            loadChildren: jasmine.createSpy('children'),
-          }),
-        );
+      await new Promise<void>((resolve) => {
+        recognize(
+          TestBed.inject(EnvironmentInjector),
+          <any>loader,
+          null,
+          config,
+          tree(''),
+          serializer,
+        ).forEach(({tree: r}) => {
+          expect(loader.loadChildren.calls.count()).toEqual(1);
+          expect(loader.loadChildren.calls.first().args).not.toContain(
+            jasmine.objectContaining({
+              loadChildren: jasmine.createSpy('children'),
+            }),
+          );
+          resolve();
+        });
       });
     });
 

packages/router/test/computed_state_restoration.spec.ts

@@ -70,7 +70,6 @@ describe('`restoredState#ɵrouterPageId`', () => {
     TestBed.configureTestingModule({
       imports: [TestModule],
       providers: [
-        {provide: 'alwaysFalse', useValue: (a: any) => false},
         {provide: Location, useClass: SpyLocation},
         provideRouter(
           [
@@ -106,7 +105,7 @@ describe('`restoredState#ɵrouterPageId`', () => {
             {
               path: 'loaded',
               loadChildren: () => of(ModuleWithSimpleCmpAsRoute),
-              canLoad: ['alwaysFalse'],
+              canLoad: [() => false],
             },
           ],
           withRouterConfig({

packages/router/test/helpers.ts

@@ -23,14 +23,6 @@ export class Logger {
   }
 }
 
-export function provideTokenLogger(token: string, returnValue = true as boolean | UrlTree) {
-  return {
-    provide: token,
-    useFactory: (logger: Logger) => () => (logger.add(token), returnValue),
-    deps: [Logger],
-  };
-}
-
 export declare type ARSArgs = {
   url?: UrlSegment[];
   params?: Params;

packages/router/test/integration/duplicate_in_flight_navigations.spec.ts

@@ -34,18 +34,7 @@ export function duplicateInFlightNavigationsIntegrationSuite() {
 
     beforeEach(() => {
       TestBed.configureTestingModule({
-        providers: [
-          {
-            provide: 'in1Second',
-            useValue: (c: any, a: ActivatedRouteSnapshot, b: RouterStateSnapshot) => {
-              let res: any = null;
-              const p = new Promise((_) => (res = _));
-              setTimeout(() => res(true), 1000);
-              return p;
-            },
-          },
-          RedirectingGuard,
-        ],
+        providers: [RedirectingGuard],
       });
     });
 
@@ -54,7 +43,13 @@ export function duplicateInFlightNavigationsIntegrationSuite() {
       const location = TestBed.inject(Location);
       const fixture = createRoot(router, RootCmp);
 
-      router.resetConfig([{path: 'simple', component: SimpleCmp, canActivate: ['in1Second']}]);
+      router.resetConfig([
+        {
+          path: 'simple',
+          component: SimpleCmp,
+          canActivate: [() => new Promise((resolve) => setTimeout(resolve, 1000))],
+        },
+      ]);
 
       // Trigger two location changes to the same URL.
       // Because of the guard the order will look as follows:
@@ -162,8 +157,16 @@ export function duplicateInFlightNavigationsIntegrationSuite() {
     it('should accurately track currentNavigation', fakeAsync(() => {
       const router = TestBed.inject(Router);
       router.resetConfig([
-        {path: 'one', component: SimpleCmp, canActivate: ['in1Second']},
-        {path: 'two', component: BlankCmp, canActivate: ['in1Second']},
+        {
+          path: 'one',
+          component: SimpleCmp,
+          canActivate: [() => new Promise((resolve) => setTimeout(resolve, 1000))],
+        },
+        {
+          path: 'two',
+          component: BlankCmp,
+          canActivate: [() => new Promise((resolve) => setTimeout(resolve, 1000))],
+        },
       ]);
 
       router.events.subscribe((e) => {

packages/router/test/integration/eager_url_update_strategy.spec.ts

@@ -53,14 +53,6 @@ export function eagerUrlUpdateStrategyIntegrationSuite() {
       const serializer = new DefaultUrlSerializer();
       TestBed.configureTestingModule({
         providers: [
-          {
-            provide: 'authGuardFail',
-            useValue: (a: any, b: any) => {
-              return new Promise((res) => {
-                setTimeout(() => res(serializer.parse('/login')), 1);
-              });
-            },
-          },
           AuthGuard,
           DelayedGuard,
           provideRouter([], withRouterConfig({urlUpdateStrategy: 'eager'})),
@@ -102,7 +94,16 @@ export function eagerUrlUpdateStrategyIntegrationSuite() {
         advance(fixture);
 
         router.resetConfig([
-          {path: 'team/:id', component: SimpleCmp, canActivate: ['authGuardFail']},
+          {
+            path: 'team/:id',
+            component: SimpleCmp,
+            canActivate: [
+              () =>
+                new Promise((res) => {
+                  setTimeout(() => res(new DefaultUrlSerializer().parse('/login')), 1);
+                }),
+            ],
+          },
           {path: 'login', component: AbsoluteSimpleLinkCmp},
         ]);