= [];
- router.events.subscribe(e => {
- if (e instanceof RouteConfigLoadStart || e instanceof RouteConfigLoadEnd) {
- events.push(e);
- }
- });
+ router.events.subscribe(e => {
+ if (e instanceof RouteConfigLoadStart || e instanceof RouteConfigLoadEnd) {
+ events.push(e);
+ }
+ });
- loader.stubbedModules = {expected: LoadedModule};
- const fixture = createRoot(router, RootCmp);
- router.resetConfig([{path: 'lazy', loadChildren: 'expected'}]);
+ loader.stubbedModules = {expected: LoadedModule};
+ const fixture = createRoot(router, RootCmp);
+ router.resetConfig([{path: 'lazy', loadChildren: 'expected'}]);
- router.navigateByUrl('/lazy/loaded/child');
- advance(fixture);
+ router.navigateByUrl('/lazy/loaded/child');
+ advance(fixture);
- expect(events.length).toEqual(2);
- expect(events[0].toString()).toEqual('RouteConfigLoadStart(path: lazy)');
- expect(events[1].toString()).toEqual('RouteConfigLoadEnd(path: lazy)');
- })));
+ expect(events.length).toEqual(2);
+ expect(events[0].toString()).toEqual('RouteConfigLoadStart(path: lazy)');
+ expect(events[1].toString()).toEqual('RouteConfigLoadEnd(path: lazy)');
+ })));
- it('throws an error when forRoot() is used in a lazy context',
- fakeAsync(inject(
- [Router, Location, NgModuleFactoryLoader],
- (router: Router, location: Location, loader: SpyNgModuleFactoryLoader) => {
- @Component({selector: 'lazy', template: 'should not show'})
- class LazyLoadedComponent {
- }
+ fixmeIvy('FW-561: Runtime compiler is not loaded') &&
+ it('throws an error when forRoot() is used in a lazy context',
+ fakeAsync(inject(
+ [Router, Location, NgModuleFactoryLoader],
+ (router: Router, location: Location, loader: SpyNgModuleFactoryLoader) => {
+ @Component({selector: 'lazy', template: 'should not show'})
+ class LazyLoadedComponent {
+ }
- @NgModule({
- declarations: [LazyLoadedComponent],
- imports: [RouterModule.forRoot([{path: 'loaded', component: LazyLoadedComponent}])]
- })
- class LoadedModule {
- }
+ @NgModule({
+ declarations: [LazyLoadedComponent],
+ imports:
+ [RouterModule.forRoot([{path: 'loaded', component: LazyLoadedComponent}])]
+ })
+ class LoadedModule {
+ }
- loader.stubbedModules = {expected: LoadedModule};
+ loader.stubbedModules = {expected: LoadedModule};
- const fixture = createRoot(router, RootCmp);
+ const fixture = createRoot(router, RootCmp);
- router.resetConfig([{path: 'lazy', loadChildren: 'expected'}]);
+ router.resetConfig([{path: 'lazy', loadChildren: 'expected'}]);
- let recordedError: any = null;
- router.navigateByUrl('/lazy/loaded') !.catch(err => recordedError = err);
- advance(fixture);
- expect(recordedError.message)
- .toEqual(
- `RouterModule.forRoot() called twice. Lazy loaded modules should use RouterModule.forChild() instead.`);
- })));
+ let recordedError: any = null;
+ router.navigateByUrl('/lazy/loaded') !.catch(err => recordedError = err);
+ advance(fixture);
+ expect(recordedError.message)
+ .toEqual(
+ `RouterModule.forRoot() called twice. Lazy loaded modules should use RouterModule.forChild() instead.`);
+ })));
- it('should combine routes from multiple modules into a single configuration',
- fakeAsync(inject(
- [Router, Location, NgModuleFactoryLoader],
- (router: Router, location: Location, loader: SpyNgModuleFactoryLoader) => {
- @Component({selector: 'lazy', template: 'lazy-loaded-2'})
- class LazyComponent2 {
- }
+ fixmeIvy('FW-561: Runtime compiler is not loaded') &&
+ it('should combine routes from multiple modules into a single configuration',
+ fakeAsync(inject(
+ [Router, Location, NgModuleFactoryLoader],
+ (router: Router, location: Location, loader: SpyNgModuleFactoryLoader) => {
+ @Component({selector: 'lazy', template: 'lazy-loaded-2'})
+ class LazyComponent2 {
+ }
- @NgModule({
- declarations: [LazyComponent2],
- imports: [RouterModule.forChild([{path: 'loaded', component: LazyComponent2}])]
- })
- class SiblingOfLoadedModule {
- }
+ @NgModule({
+ declarations: [LazyComponent2],
+ imports: [RouterModule.forChild([{path: 'loaded', component: LazyComponent2}])]
+ })
+ class SiblingOfLoadedModule {
+ }
- @Component({selector: 'lazy', template: 'lazy-loaded-1'})
- class LazyComponent1 {
- }
+ @Component({selector: 'lazy', template: 'lazy-loaded-1'})
+ class LazyComponent1 {
+ }
- @NgModule({
- declarations: [LazyComponent1],
- imports: [
- RouterModule.forChild([{path: 'loaded', component: LazyComponent1}]),
- SiblingOfLoadedModule
- ]
- })
- class LoadedModule {
- }
+ @NgModule({
+ declarations: [LazyComponent1],
+ imports: [
+ RouterModule.forChild([{path: 'loaded', component: LazyComponent1}]),
+ SiblingOfLoadedModule
+ ]
+ })
+ class LoadedModule {
+ }
- loader.stubbedModules = {expected1: LoadedModule, expected2: SiblingOfLoadedModule};
+ loader.stubbedModules = {
+ expected1: LoadedModule,
+ expected2: SiblingOfLoadedModule
+ };
- const fixture = createRoot(router, RootCmp);
+ const fixture = createRoot(router, RootCmp);
- router.resetConfig([
- {path: 'lazy1', loadChildren: 'expected1'},
- {path: 'lazy2', loadChildren: 'expected2'}
- ]);
+ router.resetConfig([
+ {path: 'lazy1', loadChildren: 'expected1'},
+ {path: 'lazy2', loadChildren: 'expected2'}
+ ]);
- router.navigateByUrl('/lazy1/loaded');
- advance(fixture);
- expect(location.path()).toEqual('/lazy1/loaded');
+ router.navigateByUrl('/lazy1/loaded');
+ advance(fixture);
+ expect(location.path()).toEqual('/lazy1/loaded');
- router.navigateByUrl('/lazy2/loaded');
- advance(fixture);
- expect(location.path()).toEqual('/lazy2/loaded');
- })));
+ router.navigateByUrl('/lazy2/loaded');
+ advance(fixture);
+ expect(location.path()).toEqual('/lazy2/loaded');
+ })));
- it('should allow lazy loaded module in named outlet',
- fakeAsync(inject(
- [Router, NgModuleFactoryLoader], (router: Router, loader: SpyNgModuleFactoryLoader) => {
+ fixmeIvy('FW-561: Runtime compiler is not loaded') &&
+ it('should allow lazy loaded module in named outlet',
+ fakeAsync(inject(
+ [Router, NgModuleFactoryLoader],
+ (router: Router, loader: SpyNgModuleFactoryLoader) => {
- @Component({selector: 'lazy', template: 'lazy-loaded'})
- class LazyComponent {
- }
+ @Component({selector: 'lazy', template: 'lazy-loaded'})
+ class LazyComponent {
+ }
- @NgModule({
- declarations: [LazyComponent],
- imports: [RouterModule.forChild([{path: '', component: LazyComponent}])]
- })
- class LazyLoadedModule {
- }
+ @NgModule({
+ declarations: [LazyComponent],
+ imports: [RouterModule.forChild([{path: '', component: LazyComponent}])]
+ })
+ class LazyLoadedModule {
+ }
- loader.stubbedModules = {lazyModule: LazyLoadedModule};
+ loader.stubbedModules = {lazyModule: LazyLoadedModule};
- const fixture = createRoot(router, RootCmp);
+ const fixture = createRoot(router, RootCmp);
- router.resetConfig([{
- path: 'team/:id',
- component: TeamCmp,
- children: [
- {path: 'user/:name', component: UserCmp},
- {path: 'lazy', loadChildren: 'lazyModule', outlet: 'right'},
- ]
- }]);
+ router.resetConfig([{
+ path: 'team/:id',
+ component: TeamCmp,
+ children: [
+ {path: 'user/:name', component: UserCmp},
+ {path: 'lazy', loadChildren: 'lazyModule', outlet: 'right'},
+ ]
+ }]);
- router.navigateByUrl('/team/22/user/john');
- advance(fixture);
+ router.navigateByUrl('/team/22/user/john');
+ advance(fixture);
- expect(fixture.nativeElement).toHaveText('team 22 [ user john, right: ]');
+ expect(fixture.nativeElement).toHaveText('team 22 [ user john, right: ]');
- router.navigateByUrl('/team/22/(user/john//right:lazy)');
- advance(fixture);
+ router.navigateByUrl('/team/22/(user/john//right:lazy)');
+ advance(fixture);
- expect(fixture.nativeElement).toHaveText('team 22 [ user john, right: lazy-loaded ]');
- })));
+ expect(fixture.nativeElement)
+ .toHaveText('team 22 [ user john, right: lazy-loaded ]');
+ })));
it('should allow componentless named outlet to render children',
fakeAsync(inject(
@@ -3793,52 +3888,55 @@ describe('Integration', () => {
});
});
- it('should use the injector of the lazily-loaded configuration',
- fakeAsync(inject(
- [Router, Location, NgModuleFactoryLoader],
- (router: Router, location: Location, loader: SpyNgModuleFactoryLoader) => {
- loader.stubbedModules = {expected: LoadedModule};
+ fixmeIvy('FW-561: Runtime compiler is not loaded') &&
+ it('should use the injector of the lazily-loaded configuration',
+ fakeAsync(inject(
+ [Router, Location, NgModuleFactoryLoader],
+ (router: Router, location: Location, loader: SpyNgModuleFactoryLoader) => {
+ loader.stubbedModules = {expected: LoadedModule};
- const fixture = createRoot(router, RootCmp);
+ const fixture = createRoot(router, RootCmp);
- router.resetConfig([{
- path: 'eager-parent',
- component: EagerParentComponent,
- children: [{path: 'lazy', loadChildren: 'expected'}]
- }]);
+ router.resetConfig([{
+ path: 'eager-parent',
+ component: EagerParentComponent,
+ children: [{path: 'lazy', loadChildren: 'expected'}]
+ }]);
- router.navigateByUrl('/eager-parent/lazy/lazy-parent/lazy-child');
- advance(fixture);
+ router.navigateByUrl('/eager-parent/lazy/lazy-parent/lazy-child');
+ advance(fixture);
- expect(location.path()).toEqual('/eager-parent/lazy/lazy-parent/lazy-child');
- expect(fixture.nativeElement).toHaveText('eager-parent lazy-parent lazy-child');
- })));
+ expect(location.path()).toEqual('/eager-parent/lazy/lazy-parent/lazy-child');
+ expect(fixture.nativeElement).toHaveText('eager-parent lazy-parent lazy-child');
+ })));
});
- it('works when given a callback',
- fakeAsync(inject(
- [Router, Location, NgModuleFactoryLoader], (router: Router, location: Location) => {
- @Component({selector: 'lazy', template: 'lazy-loaded'})
- class LazyLoadedComponent {
- }
+ fixmeIvy('FW-561: Runtime compiler is not loaded') &&
+ it('works when given a callback',
+ fakeAsync(inject(
+ [Router, Location, NgModuleFactoryLoader], (router: Router, location: Location) => {
+ @Component({selector: 'lazy', template: 'lazy-loaded'})
+ class LazyLoadedComponent {
+ }
- @NgModule({
- declarations: [LazyLoadedComponent],
- imports: [RouterModule.forChild([{path: 'loaded', component: LazyLoadedComponent}])],
- })
- class LoadedModule {
- }
+ @NgModule({
+ declarations: [LazyLoadedComponent],
+ imports:
+ [RouterModule.forChild([{path: 'loaded', component: LazyLoadedComponent}])],
+ })
+ class LoadedModule {
+ }
- const fixture = createRoot(router, RootCmp);
+ const fixture = createRoot(router, RootCmp);
- router.resetConfig([{path: 'lazy', loadChildren: () => LoadedModule}]);
+ router.resetConfig([{path: 'lazy', loadChildren: () => LoadedModule}]);
- router.navigateByUrl('/lazy/loaded');
- advance(fixture);
+ router.navigateByUrl('/lazy/loaded');
+ advance(fixture);
- expect(location.path()).toEqual('/lazy/loaded');
- expect(fixture.nativeElement).toHaveText('lazy-loaded');
- })));
+ expect(location.path()).toEqual('/lazy/loaded');
+ expect(fixture.nativeElement).toHaveText('lazy-loaded');
+ })));
it('error emit an error when cannot load a config',
fakeAsync(inject(
@@ -3864,59 +3962,62 @@ describe('Integration', () => {
]);
})));
- it('should work with complex redirect rules',
- fakeAsync(inject(
- [Router, Location, NgModuleFactoryLoader],
- (router: Router, location: Location, loader: SpyNgModuleFactoryLoader) => {
- @Component({selector: 'lazy', template: 'lazy-loaded'})
- class LazyLoadedComponent {
- }
+ fixmeIvy('FW-561: Runtime compiler is not loaded') &&
+ it('should work with complex redirect rules',
+ fakeAsync(inject(
+ [Router, Location, NgModuleFactoryLoader],
+ (router: Router, location: Location, loader: SpyNgModuleFactoryLoader) => {
+ @Component({selector: 'lazy', template: 'lazy-loaded'})
+ class LazyLoadedComponent {
+ }
- @NgModule({
- declarations: [LazyLoadedComponent],
- imports: [RouterModule.forChild([{path: 'loaded', component: LazyLoadedComponent}])],
- })
- class LoadedModule {
- }
+ @NgModule({
+ declarations: [LazyLoadedComponent],
+ imports:
+ [RouterModule.forChild([{path: 'loaded', component: LazyLoadedComponent}])],
+ })
+ class LoadedModule {
+ }
- loader.stubbedModules = {lazy: LoadedModule};
- const fixture = createRoot(router, RootCmp);
+ loader.stubbedModules = {lazy: LoadedModule};
+ const fixture = createRoot(router, RootCmp);
- router.resetConfig(
- [{path: 'lazy', loadChildren: 'lazy'}, {path: '**', redirectTo: 'lazy'}]);
+ router.resetConfig(
+ [{path: 'lazy', loadChildren: 'lazy'}, {path: '**', redirectTo: 'lazy'}]);
- router.navigateByUrl('/lazy/loaded');
- advance(fixture);
+ router.navigateByUrl('/lazy/loaded');
+ advance(fixture);
- expect(location.path()).toEqual('/lazy/loaded');
- })));
+ expect(location.path()).toEqual('/lazy/loaded');
+ })));
- it('should work with wildcard route',
- fakeAsync(inject(
- [Router, Location, NgModuleFactoryLoader],
- (router: Router, location: Location, loader: SpyNgModuleFactoryLoader) => {
- @Component({selector: 'lazy', template: 'lazy-loaded'})
- class LazyLoadedComponent {
- }
+ fixmeIvy('FW-561: Runtime compiler is not loaded') &&
+ it('should work with wildcard route',
+ fakeAsync(inject(
+ [Router, Location, NgModuleFactoryLoader],
+ (router: Router, location: Location, loader: SpyNgModuleFactoryLoader) => {
+ @Component({selector: 'lazy', template: 'lazy-loaded'})
+ class LazyLoadedComponent {
+ }
- @NgModule({
- declarations: [LazyLoadedComponent],
- imports: [RouterModule.forChild([{path: '', component: LazyLoadedComponent}])],
- })
- class LazyLoadedModule {
- }
+ @NgModule({
+ declarations: [LazyLoadedComponent],
+ imports: [RouterModule.forChild([{path: '', component: LazyLoadedComponent}])],
+ })
+ class LazyLoadedModule {
+ }
- loader.stubbedModules = {lazy: LazyLoadedModule};
- const fixture = createRoot(router, RootCmp);
+ loader.stubbedModules = {lazy: LazyLoadedModule};
+ const fixture = createRoot(router, RootCmp);
- router.resetConfig([{path: '**', loadChildren: 'lazy'}]);
+ router.resetConfig([{path: '**', loadChildren: 'lazy'}]);
- router.navigateByUrl('/lazy');
- advance(fixture);
+ router.navigateByUrl('/lazy');
+ advance(fixture);
- expect(location.path()).toEqual('/lazy');
- expect(fixture.nativeElement).toHaveText('lazy-loaded');
- })));
+ expect(location.path()).toEqual('/lazy');
+ expect(fixture.nativeElement).toHaveText('lazy-loaded');
+ })));
describe('preloading', () => {
beforeEach(() => {
@@ -3926,50 +4027,52 @@ describe('Integration', () => {
preloader.setUpPreloading();
});
- it('should work',
- fakeAsync(inject(
- [Router, Location, NgModuleFactoryLoader],
- (router: Router, location: Location, loader: SpyNgModuleFactoryLoader) => {
- @Component({selector: 'lazy', template: 'should not show'})
- class LazyLoadedComponent {
- }
+ fixmeIvy('FW-561: Runtime compiler is not loaded') &&
+ it('should work',
+ fakeAsync(inject(
+ [Router, Location, NgModuleFactoryLoader],
+ (router: Router, location: Location, loader: SpyNgModuleFactoryLoader) => {
+ @Component({selector: 'lazy', template: 'should not show'})
+ class LazyLoadedComponent {
+ }
- @NgModule({
- declarations: [LazyLoadedComponent],
- imports: [RouterModule.forChild(
- [{path: 'LoadedModule2', component: LazyLoadedComponent}])]
- })
- class LoadedModule2 {
- }
+ @NgModule({
+ declarations: [LazyLoadedComponent],
+ imports: [RouterModule.forChild(
+ [{path: 'LoadedModule2', component: LazyLoadedComponent}])]
+ })
+ class LoadedModule2 {
+ }
- @NgModule({
- imports:
- [RouterModule.forChild([{path: 'LoadedModule1', loadChildren: 'expected2'}])]
- })
- class LoadedModule1 {
- }
+ @NgModule({
+ imports: [RouterModule.forChild(
+ [{path: 'LoadedModule1', loadChildren: 'expected2'}])]
+ })
+ class LoadedModule1 {
+ }
- loader.stubbedModules = {expected: LoadedModule1, expected2: LoadedModule2};
+ loader.stubbedModules = {expected: LoadedModule1, expected2: LoadedModule2};
- const fixture = createRoot(router, RootCmp);
+ const fixture = createRoot(router, RootCmp);
- router.resetConfig([
- {path: 'blank', component: BlankCmp}, {path: 'lazy', loadChildren: 'expected'}
- ]);
+ router.resetConfig([
+ {path: 'blank', component: BlankCmp},
+ {path: 'lazy', loadChildren: 'expected'}
+ ]);
- router.navigateByUrl('/blank');
- advance(fixture);
+ router.navigateByUrl('/blank');
+ advance(fixture);
- const config = router.config as any;
- const firstConfig = config[1]._loadedConfig !;
+ const config = router.config as any;
+ const firstConfig = config[1]._loadedConfig !;
- expect(firstConfig).toBeDefined();
- expect(firstConfig.routes[0].path).toEqual('LoadedModule1');
+ expect(firstConfig).toBeDefined();
+ expect(firstConfig.routes[0].path).toEqual('LoadedModule1');
- const secondConfig = firstConfig.routes[0]._loadedConfig !;
- expect(secondConfig).toBeDefined();
- expect(secondConfig.routes[0].path).toEqual('LoadedModule2');
- })));
+ const secondConfig = firstConfig.routes[0]._loadedConfig !;
+ expect(secondConfig).toBeDefined();
+ expect(secondConfig.routes[0].path).toEqual('LoadedModule2');
+ })));
});
@@ -4135,41 +4238,43 @@ describe('Integration', () => {
class LazyLoadedModule {
}
- it('should not ignore empty path when in legacy mode',
- fakeAsync(inject(
- [Router, NgModuleFactoryLoader],
- (router: Router, loader: SpyNgModuleFactoryLoader) => {
- router.relativeLinkResolution = 'legacy';
- loader.stubbedModules = {expected: LazyLoadedModule};
+ fixmeIvy('FW-561: Runtime compiler is not loaded') &&
+ it('should not ignore empty path when in legacy mode',
+ fakeAsync(inject(
+ [Router, NgModuleFactoryLoader],
+ (router: Router, loader: SpyNgModuleFactoryLoader) => {
+ router.relativeLinkResolution = 'legacy';
+ loader.stubbedModules = {expected: LazyLoadedModule};
- const fixture = createRoot(router, RootCmp);
+ const fixture = createRoot(router, RootCmp);
- router.resetConfig([{path: 'lazy', loadChildren: 'expected'}]);
+ router.resetConfig([{path: 'lazy', loadChildren: 'expected'}]);
- router.navigateByUrl('/lazy/foo/bar');
- advance(fixture);
+ router.navigateByUrl('/lazy/foo/bar');
+ advance(fixture);
- const link = fixture.nativeElement.querySelector('a');
- expect(link.getAttribute('href')).toEqual('/lazy/foo/bar/simple');
- })));
+ const link = fixture.nativeElement.querySelector('a');
+ expect(link.getAttribute('href')).toEqual('/lazy/foo/bar/simple');
+ })));
- it('should ignore empty path when in corrected mode',
- fakeAsync(inject(
- [Router, NgModuleFactoryLoader],
- (router: Router, loader: SpyNgModuleFactoryLoader) => {
- router.relativeLinkResolution = 'corrected';
- loader.stubbedModules = {expected: LazyLoadedModule};
+ fixmeIvy('FW-561: Runtime compiler is not loaded') &&
+ it('should ignore empty path when in corrected mode',
+ fakeAsync(inject(
+ [Router, NgModuleFactoryLoader],
+ (router: Router, loader: SpyNgModuleFactoryLoader) => {
+ router.relativeLinkResolution = 'corrected';
+ loader.stubbedModules = {expected: LazyLoadedModule};
- const fixture = createRoot(router, RootCmp);
+ const fixture = createRoot(router, RootCmp);
- router.resetConfig([{path: 'lazy', loadChildren: 'expected'}]);
+ router.resetConfig([{path: 'lazy', loadChildren: 'expected'}]);
- router.navigateByUrl('/lazy/foo/bar');
- advance(fixture);
+ router.navigateByUrl('/lazy/foo/bar');
+ advance(fixture);
- const link = fixture.nativeElement.querySelector('a');
- expect(link.getAttribute('href')).toEqual('/lazy/foo/simple');
- })));
+ const link = fixture.nativeElement.querySelector('a');
+ expect(link.getAttribute('href')).toEqual('/lazy/foo/simple');
+ })));
});
});
@@ -4216,142 +4321,145 @@ describe('Integration', () => {
}
}
- it('should support attaching & detaching fragments',
- fakeAsync(inject([Router, Location], (router: Router, location: Location) => {
- const fixture = createRoot(router, RootCmp);
+ fixmeIvy('FW-???: assertion failures') &&
+ it('should support attaching & detaching fragments',
+ fakeAsync(inject([Router, Location], (router: Router, location: Location) => {
+ const fixture = createRoot(router, RootCmp);
- router.routeReuseStrategy = new AttachDetachReuseStrategy();
+ router.routeReuseStrategy = new AttachDetachReuseStrategy();
- router.resetConfig([
- {
- path: 'a',
- component: TeamCmp,
- children: [{path: 'b', component: SimpleCmp}],
- },
- {path: 'c', component: UserCmp},
- ]);
+ router.resetConfig([
+ {
+ path: 'a',
+ component: TeamCmp,
+ children: [{path: 'b', component: SimpleCmp}],
+ },
+ {path: 'c', component: UserCmp},
+ ]);
- router.navigateByUrl('/a/b');
- advance(fixture);
- const teamCmp = fixture.debugElement.children[1].componentInstance;
- const simpleCmp = fixture.debugElement.children[1].children[1].componentInstance;
- expect(location.path()).toEqual('/a/b');
- expect(teamCmp).toBeDefined();
- expect(simpleCmp).toBeDefined();
+ router.navigateByUrl('/a/b');
+ advance(fixture);
+ const teamCmp = fixture.debugElement.children[1].componentInstance;
+ const simpleCmp = fixture.debugElement.children[1].children[1].componentInstance;
+ expect(location.path()).toEqual('/a/b');
+ expect(teamCmp).toBeDefined();
+ expect(simpleCmp).toBeDefined();
- router.navigateByUrl('/c');
- advance(fixture);
- expect(location.path()).toEqual('/c');
- expect(fixture.debugElement.children[1].componentInstance).toBeAnInstanceOf(UserCmp);
+ router.navigateByUrl('/c');
+ advance(fixture);
+ expect(location.path()).toEqual('/c');
+ expect(fixture.debugElement.children[1].componentInstance).toBeAnInstanceOf(UserCmp);
- router.navigateByUrl('/a;p=1/b;p=2');
- advance(fixture);
- const teamCmp2 = fixture.debugElement.children[1].componentInstance;
- const simpleCmp2 = fixture.debugElement.children[1].children[1].componentInstance;
- expect(location.path()).toEqual('/a;p=1/b;p=2');
- expect(teamCmp2).toBe(teamCmp);
- expect(simpleCmp2).toBe(simpleCmp);
+ router.navigateByUrl('/a;p=1/b;p=2');
+ advance(fixture);
+ const teamCmp2 = fixture.debugElement.children[1].componentInstance;
+ const simpleCmp2 = fixture.debugElement.children[1].children[1].componentInstance;
+ expect(location.path()).toEqual('/a;p=1/b;p=2');
+ expect(teamCmp2).toBe(teamCmp);
+ expect(simpleCmp2).toBe(simpleCmp);
- expect(teamCmp.route).toBe(router.routerState.root.firstChild);
- expect(teamCmp.route.snapshot).toBe(router.routerState.snapshot.root.firstChild);
- expect(teamCmp.route.snapshot.params).toEqual({p: '1'});
- expect(teamCmp.route.firstChild.snapshot.params).toEqual({p: '2'});
- })));
+ expect(teamCmp.route).toBe(router.routerState.root.firstChild);
+ expect(teamCmp.route.snapshot).toBe(router.routerState.snapshot.root.firstChild);
+ expect(teamCmp.route.snapshot.params).toEqual({p: '1'});
+ expect(teamCmp.route.firstChild.snapshot.params).toEqual({p: '2'});
+ })));
- it('should support shorter lifecycles',
- fakeAsync(inject([Router, Location], (router: Router, location: Location) => {
- const fixture = createRoot(router, RootCmp);
- router.routeReuseStrategy = new ShortLifecycle();
+ fixmeIvy('FW-???: assertion failures') &&
+ it('should support shorter lifecycles',
+ fakeAsync(inject([Router, Location], (router: Router, location: Location) => {
+ const fixture = createRoot(router, RootCmp);
+ router.routeReuseStrategy = new ShortLifecycle();
- router.resetConfig([{path: 'a', component: SimpleCmp}]);
+ router.resetConfig([{path: 'a', component: SimpleCmp}]);
- router.navigateByUrl('/a');
- advance(fixture);
- const simpleCmp1 = fixture.debugElement.children[1].componentInstance;
- expect(location.path()).toEqual('/a');
+ router.navigateByUrl('/a');
+ advance(fixture);
+ const simpleCmp1 = fixture.debugElement.children[1].componentInstance;
+ expect(location.path()).toEqual('/a');
- router.navigateByUrl('/a;p=1');
- advance(fixture);
- expect(location.path()).toEqual('/a;p=1');
- const simpleCmp2 = fixture.debugElement.children[1].componentInstance;
- expect(simpleCmp1).not.toBe(simpleCmp2);
- })));
+ router.navigateByUrl('/a;p=1');
+ advance(fixture);
+ expect(location.path()).toEqual('/a;p=1');
+ const simpleCmp2 = fixture.debugElement.children[1].componentInstance;
+ expect(simpleCmp1).not.toBe(simpleCmp2);
+ })));
- it('should not mount the component of the previously reused route when the outlet was not instantiated at the time of route activation',
- fakeAsync(() => {
- @Component({
- selector: 'root-cmp',
- template:
- '
'
- })
- class RootCmpWithCondOutlet implements OnDestroy {
- private subscription: Subscription;
- public isToolpanelShowing: boolean = false;
+ fixmeIvy('FW-???: Error: Cannot match any routes. URL Segment: \'a\'') &&
+ it('should not mount the component of the previously reused route when the outlet was not instantiated at the time of route activation',
+ fakeAsync(() => {
+ @Component({
+ selector: 'root-cmp',
+ template:
+ '
'
+ })
+ class RootCmpWithCondOutlet implements OnDestroy {
+ private subscription: Subscription;
+ public isToolpanelShowing: boolean = false;
- constructor(router: Router) {
- this.subscription =
- router.events.pipe(filter(event => event instanceof NavigationEnd))
- .subscribe(
- () => this.isToolpanelShowing =
- !!router.parseUrl(router.url).root.children['toolpanel']);
- }
+ constructor(router: Router) {
+ this.subscription =
+ router.events.pipe(filter(event => event instanceof NavigationEnd))
+ .subscribe(
+ () => this.isToolpanelShowing =
+ !!router.parseUrl(router.url).root.children['toolpanel']);
+ }
- public ngOnDestroy(): void { this.subscription.unsubscribe(); }
- }
+ public ngOnDestroy(): void { this.subscription.unsubscribe(); }
+ }
- @Component({selector: 'tool-1-cmp', template: 'Tool 1 showing'})
- class Tool1Component {
- }
+ @Component({selector: 'tool-1-cmp', template: 'Tool 1 showing'})
+ class Tool1Component {
+ }
- @Component({selector: 'tool-2-cmp', template: 'Tool 2 showing'})
- class Tool2Component {
- }
+ @Component({selector: 'tool-2-cmp', template: 'Tool 2 showing'})
+ class Tool2Component {
+ }
- @NgModule({
- declarations: [RootCmpWithCondOutlet, Tool1Component, Tool2Component],
- imports: [
- CommonModule,
- RouterTestingModule.withRoutes([
- {path: 'a', outlet: 'toolpanel', component: Tool1Component},
- {path: 'b', outlet: 'toolpanel', component: Tool2Component},
- ]),
- ],
- })
- class TestModule {
- }
+ @NgModule({
+ declarations: [RootCmpWithCondOutlet, Tool1Component, Tool2Component],
+ imports: [
+ CommonModule,
+ RouterTestingModule.withRoutes([
+ {path: 'a', outlet: 'toolpanel', component: Tool1Component},
+ {path: 'b', outlet: 'toolpanel', component: Tool2Component},
+ ]),
+ ],
+ })
+ class TestModule {
+ }
- TestBed.configureTestingModule({imports: [TestModule]});
+ TestBed.configureTestingModule({imports: [TestModule]});
- const router: Router = TestBed.get(Router);
- router.routeReuseStrategy = new AttachDetachReuseStrategy();
+ const router: Router = TestBed.get(Router);
+ router.routeReuseStrategy = new AttachDetachReuseStrategy();
- const fixture = createRoot(router, RootCmpWithCondOutlet);
+ const fixture = createRoot(router, RootCmpWithCondOutlet);
- // Activate 'tool-1'
- router.navigate([{outlets: {toolpanel: 'a'}}]);
- advance(fixture);
- expect(fixture).toContainComponent(Tool1Component, '(a)');
+ // Activate 'tool-1'
+ router.navigate([{outlets: {toolpanel: 'a'}}]);
+ advance(fixture);
+ expect(fixture).toContainComponent(Tool1Component, '(a)');
- // Deactivate 'tool-1'
- router.navigate([{outlets: {toolpanel: null}}]);
- advance(fixture);
- expect(fixture).not.toContainComponent(Tool1Component, '(b)');
+ // Deactivate 'tool-1'
+ router.navigate([{outlets: {toolpanel: null}}]);
+ advance(fixture);
+ expect(fixture).not.toContainComponent(Tool1Component, '(b)');
- // Activate 'tool-1'
- router.navigate([{outlets: {toolpanel: 'a'}}]);
- advance(fixture);
- expect(fixture).toContainComponent(Tool1Component, '(c)');
+ // Activate 'tool-1'
+ router.navigate([{outlets: {toolpanel: 'a'}}]);
+ advance(fixture);
+ expect(fixture).toContainComponent(Tool1Component, '(c)');
- // Deactivate 'tool-1'
- router.navigate([{outlets: {toolpanel: null}}]);
- advance(fixture);
- expect(fixture).not.toContainComponent(Tool1Component, '(d)');
+ // Deactivate 'tool-1'
+ router.navigate([{outlets: {toolpanel: null}}]);
+ advance(fixture);
+ expect(fixture).not.toContainComponent(Tool1Component, '(d)');
- // Activate 'tool-2'
- router.navigate([{outlets: {toolpanel: 'b'}}]);
- advance(fixture);
- expect(fixture).toContainComponent(Tool2Component, '(e)');
- }));
+ // Activate 'tool-2'
+ router.navigate([{outlets: {toolpanel: 'b'}}]);
+ advance(fixture);
+ expect(fixture).toContainComponent(Tool2Component, '(e)');
+ }));
});
});
diff --git a/packages/router/test/operators/prioritized_guard_value.spec.ts b/packages/router/test/operators/prioritized_guard_value.spec.ts
index 54de147987..8ee10e699e 100644
--- a/packages/router/test/operators/prioritized_guard_value.spec.ts
+++ b/packages/router/test/operators/prioritized_guard_value.spec.ts
@@ -8,6 +8,7 @@
import {TestBed} from '@angular/core/testing';
+import {RouterTestingModule} from '@angular/router/testing';
import {Observable, Observer, of } from 'rxjs';
import {every, mergeMap} from 'rxjs/operators';
import {TestScheduler} from 'rxjs/testing';
@@ -15,7 +16,6 @@ import {TestScheduler} from 'rxjs/testing';
import {prioritizedGuardValue} from '../../src/operators/prioritized_guard_value';
import {Router} from '../../src/router';
import {UrlTree} from '../../src/url_tree';
-import {RouterTestingModule} from '../../testing/src/router_testing_module';
describe('prioritizedGuardValue operator', () => {
diff --git a/packages/router/test/regression_integration.spec.ts b/packages/router/test/regression_integration.spec.ts
index ab1d0681be..9aab369a86 100644
--- a/packages/router/test/regression_integration.spec.ts
+++ b/packages/router/test/regression_integration.spec.ts
@@ -9,21 +9,22 @@
import {CommonModule} from '@angular/common';
import {Component, ContentChild, NgModule, TemplateRef, Type, ViewChild, ViewContainerRef} from '@angular/core';
import {ComponentFixture, TestBed, fakeAsync, tick} from '@angular/core/testing';
-import {getDOM} from '@angular/platform-browser/src/dom/dom_adapter';
+import {fixmeIvy} from '@angular/private/testing';
import {Router} from '@angular/router';
import {RouterTestingModule} from '@angular/router/testing';
describe('Integration', () => {
describe('routerLinkActive', () => {
- it('should not cause infinite loops in the change detection - #15825', fakeAsync(() => {
- @Component({selector: 'simple', template: 'simple'})
- class SimpleCmp {
- }
+ fixmeIvy('FW-662: Components without selector are not supported') &&
+ it('should not cause infinite loops in the change detection - #15825', fakeAsync(() => {
+ @Component({selector: 'simple', template: 'simple'})
+ class SimpleCmp {
+ }
- @Component({
- selector: 'some-root',
- template: `
+ @Component({
+ selector: 'some-root',
+ template: `
@@ -31,36 +32,37 @@ describe('Integration', () => {
`
- })
- class MyCmp {
- show: boolean = false;
- }
+ })
+ class MyCmp {
+ show: boolean = false;
+ }
- @NgModule({
- imports: [CommonModule, RouterTestingModule],
- declarations: [MyCmp, SimpleCmp],
- entryComponents: [SimpleCmp],
- })
- class MyModule {
- }
+ @NgModule({
+ imports: [CommonModule, RouterTestingModule],
+ declarations: [MyCmp, SimpleCmp],
+ entryComponents: [SimpleCmp],
+ })
+ class MyModule {
+ }
- TestBed.configureTestingModule({imports: [MyModule]});
+ TestBed.configureTestingModule({imports: [MyModule]});
- const router: Router = TestBed.get(Router);
- const fixture = createRoot(router, MyCmp);
- router.resetConfig([{path: 'simple', component: SimpleCmp}]);
+ const router: Router = TestBed.get(Router);
+ const fixture = createRoot(router, MyCmp);
+ router.resetConfig([{path: 'simple', component: SimpleCmp}]);
- router.navigateByUrl('/simple');
- advance(fixture);
+ router.navigateByUrl('/simple');
+ advance(fixture);
- const instance = fixture.componentInstance;
- instance.show = true;
- expect(() => advance(fixture)).not.toThrow();
- }));
+ const instance = fixture.componentInstance;
+ instance.show = true;
+ expect(() => advance(fixture)).not.toThrow();
+ }));
- it('should set isActive right after looking at its children -- #18983', fakeAsync(() => {
- @Component({
- template: `
+ fixmeIvy('FW-662: Components without selector are not supported') &&
+ it('should set isActive right after looking at its children -- #18983', fakeAsync(() => {
+ @Component({
+ template: `
isActive: {{rla.isActive}}
@@ -71,43 +73,43 @@ describe('Integration', () => {
`
- })
- class ComponentWithRouterLink {
- // TODO(issue/24571): remove '!'.
- @ViewChild(TemplateRef) templateRef !: TemplateRef;
- // TODO(issue/24571): remove '!'.
- @ViewChild('container', {read: ViewContainerRef}) container !: ViewContainerRef;
+ })
+ class ComponentWithRouterLink {
+ // TODO(issue/24571): remove '!'.
+ @ViewChild(TemplateRef) templateRef !: TemplateRef;
+ // TODO(issue/24571): remove '!'.
+ @ViewChild('container', {read: ViewContainerRef}) container !: ViewContainerRef;
- addLink() {
- this.container.createEmbeddedView(this.templateRef, {$implicit: '/simple'});
- }
+ addLink() {
+ this.container.createEmbeddedView(this.templateRef, {$implicit: '/simple'});
+ }
- removeLink() { this.container.clear(); }
- }
+ removeLink() { this.container.clear(); }
+ }
- @Component({template: 'simple'})
- class SimpleCmp {
- }
+ @Component({template: 'simple'})
+ class SimpleCmp {
+ }
- TestBed.configureTestingModule({
- imports: [RouterTestingModule.withRoutes([{path: 'simple', component: SimpleCmp}])],
- declarations: [ComponentWithRouterLink, SimpleCmp]
- });
+ TestBed.configureTestingModule({
+ imports: [RouterTestingModule.withRoutes([{path: 'simple', component: SimpleCmp}])],
+ declarations: [ComponentWithRouterLink, SimpleCmp]
+ });
- const router: Router = TestBed.get(Router);
- const fixture = createRoot(router, ComponentWithRouterLink);
- router.navigateByUrl('/simple');
- advance(fixture);
+ const router: Router = TestBed.get(Router);
+ const fixture = createRoot(router, ComponentWithRouterLink);
+ router.navigateByUrl('/simple');
+ advance(fixture);
- fixture.componentInstance.addLink();
- fixture.detectChanges();
+ fixture.componentInstance.addLink();
+ fixture.detectChanges();
- fixture.componentInstance.removeLink();
- advance(fixture);
- advance(fixture);
+ fixture.componentInstance.removeLink();
+ advance(fixture);
+ advance(fixture);
- expect(fixture.nativeElement.innerHTML).toContain('isActive: false');
- }));
+ expect(fixture.nativeElement.innerHTML).toContain('isActive: false');
+ }));
});
diff --git a/packages/router/test/router.spec.ts b/packages/router/test/router.spec.ts
index 81da038b92..56c13a4a28 100644
--- a/packages/router/test/router.spec.ts
+++ b/packages/router/test/router.spec.ts
@@ -8,6 +8,7 @@
import {Location} from '@angular/common';
import {TestBed, inject} from '@angular/core/testing';
+import {RouterTestingModule} from '@angular/router/testing';
import {of } from 'rxjs';
import {Routes} from '../src/config';
@@ -20,7 +21,6 @@ import {RouterStateSnapshot, createEmptyStateSnapshot} from '../src/router_state
import {DefaultUrlSerializer, UrlTree} from '../src/url_tree';
import {getAllRouteGuards} from '../src/utils/preactivation';
import {TreeNode} from '../src/utils/tree';
-import {RouterTestingModule} from '../testing/src/router_testing_module';
import {Logger, createActivatedRouteSnapshot, provideTokenLogger} from './helpers';
diff --git a/packages/router/test/router_preloader.spec.ts b/packages/router/test/router_preloader.spec.ts
index 8df0e8bc46..5b65c9eaca 100644
--- a/packages/router/test/router_preloader.spec.ts
+++ b/packages/router/test/router_preloader.spec.ts
@@ -8,10 +8,11 @@
import {Compiler, Component, NgModule, NgModuleFactoryLoader, NgModuleRef} from '@angular/core';
import {TestBed, fakeAsync, inject, tick} from '@angular/core/testing';
+import {fixmeIvy} from '@angular/private/testing';
+import {PreloadAllModules, PreloadingStrategy, RouterPreloader} from '@angular/router';
import {Route, RouteConfigLoadEnd, RouteConfigLoadStart, Router, RouterModule} from '../index';
import {LoadedRouterConfig} from '../src/config';
-import {PreloadAllModules, PreloadingStrategy, RouterPreloader} from '../src/router_preloader';
import {RouterTestingModule, SpyNgModuleFactoryLoader} from '../testing';
describe('RouterPreloader', () => {
@@ -35,19 +36,20 @@ describe('RouterPreloader', () => {
});
});
- it('should work',
- fakeAsync(inject(
- [NgModuleFactoryLoader, RouterPreloader, Router],
- (loader: SpyNgModuleFactoryLoader, preloader: RouterPreloader, router: Router) => {
- loader.stubbedModules = {expected: LoadedModule};
+ fixmeIvy('FW-561: Runtime compiler is not loaded') &&
+ it('should work',
+ fakeAsync(inject(
+ [NgModuleFactoryLoader, RouterPreloader, Router],
+ (loader: SpyNgModuleFactoryLoader, preloader: RouterPreloader, router: Router) => {
+ loader.stubbedModules = {expected: LoadedModule};
- preloader.preload().subscribe(() => {});
+ preloader.preload().subscribe(() => {});
- tick();
+ tick();
- const c = router.config;
- expect((c[0] as any)._loadedConfig).not.toBeDefined();
- })));
+ const c = router.config;
+ expect((c[0] as any)._loadedConfig).not.toBeDefined();
+ })));
});
describe('should preload configurations', () => {
@@ -58,63 +60,64 @@ describe('RouterPreloader', () => {
});
});
- it('should work',
- fakeAsync(inject(
- [NgModuleFactoryLoader, RouterPreloader, Router, NgModuleRef],
- (loader: SpyNgModuleFactoryLoader, preloader: RouterPreloader, router: Router,
- testModule: NgModuleRef) => {
- const events: Array = [];
- @NgModule({
- declarations: [LazyLoadedCmp],
- imports:
- [RouterModule.forChild([{path: 'LoadedModule2', component: LazyLoadedCmp}])]
- })
- class LoadedModule2 {
- }
+ fixmeIvy('FW-561: Runtime compiler is not loaded') &&
+ it('should work',
+ fakeAsync(inject(
+ [NgModuleFactoryLoader, RouterPreloader, Router, NgModuleRef],
+ (loader: SpyNgModuleFactoryLoader, preloader: RouterPreloader, router: Router,
+ testModule: NgModuleRef) => {
+ const events: Array = [];
+ @NgModule({
+ declarations: [LazyLoadedCmp],
+ imports: [RouterModule.forChild(
+ [{path: 'LoadedModule2', component: LazyLoadedCmp}])]
+ })
+ class LoadedModule2 {
+ }
- @NgModule({
- imports:
- [RouterModule.forChild([{path: 'LoadedModule1', loadChildren: 'expected2'}])]
- })
- class LoadedModule1 {
- }
+ @NgModule({
+ imports: [RouterModule.forChild(
+ [{path: 'LoadedModule1', loadChildren: 'expected2'}])]
+ })
+ class LoadedModule1 {
+ }
- router.events.subscribe(e => {
- if (e instanceof RouteConfigLoadEnd || e instanceof RouteConfigLoadStart) {
- events.push(e);
- }
- });
+ router.events.subscribe(e => {
+ if (e instanceof RouteConfigLoadEnd || e instanceof RouteConfigLoadStart) {
+ events.push(e);
+ }
+ });
- loader.stubbedModules = {
- expected: LoadedModule1,
- expected2: LoadedModule2,
- };
+ loader.stubbedModules = {
+ expected: LoadedModule1,
+ expected2: LoadedModule2,
+ };
- preloader.preload().subscribe(() => {});
+ preloader.preload().subscribe(() => {});
- tick();
+ tick();
- const c = router.config;
- expect(c[0].loadChildren).toEqual('expected');
+ const c = router.config;
+ expect(c[0].loadChildren).toEqual('expected');
- const loadedConfig: LoadedRouterConfig = (c[0] as any)._loadedConfig !;
- const module: any = loadedConfig.module;
- expect(loadedConfig.routes[0].path).toEqual('LoadedModule1');
- expect(module._parent).toBe(testModule);
+ const loadedConfig: LoadedRouterConfig = (c[0] as any)._loadedConfig !;
+ const module: any = loadedConfig.module;
+ expect(loadedConfig.routes[0].path).toEqual('LoadedModule1');
+ expect(module._parent).toBe(testModule);
- const loadedConfig2: LoadedRouterConfig =
- (loadedConfig.routes[0] as any)._loadedConfig !;
- const module2: any = loadedConfig2.module;
- expect(loadedConfig2.routes[0].path).toEqual('LoadedModule2');
- expect(module2._parent).toBe(module);
+ const loadedConfig2: LoadedRouterConfig =
+ (loadedConfig.routes[0] as any)._loadedConfig !;
+ const module2: any = loadedConfig2.module;
+ expect(loadedConfig2.routes[0].path).toEqual('LoadedModule2');
+ expect(module2._parent).toBe(module);
- expect(events.map(e => e.toString())).toEqual([
- 'RouteConfigLoadStart(path: lazy)',
- 'RouteConfigLoadEnd(path: lazy)',
- 'RouteConfigLoadStart(path: LoadedModule1)',
- 'RouteConfigLoadEnd(path: LoadedModule1)',
- ]);
- })));
+ expect(events.map(e => e.toString())).toEqual([
+ 'RouteConfigLoadStart(path: lazy)',
+ 'RouteConfigLoadEnd(path: lazy)',
+ 'RouteConfigLoadStart(path: LoadedModule1)',
+ 'RouteConfigLoadEnd(path: LoadedModule1)',
+ ]);
+ })));
});
describe('should support modules that have already been loaded', () => {
@@ -125,57 +128,59 @@ describe('RouterPreloader', () => {
});
});
- it('should work', fakeAsync(inject(
- [NgModuleFactoryLoader, RouterPreloader, Router, NgModuleRef, Compiler],
- (loader: SpyNgModuleFactoryLoader, preloader: RouterPreloader,
- router: Router, testModule: NgModuleRef, compiler: Compiler) => {
- @NgModule()
- class LoadedModule2 {
- }
+ fixmeIvy('FW-???: Cannot read property \'declarations\' of undefined') &&
+ it('should work',
+ fakeAsync(inject(
+ [NgModuleFactoryLoader, RouterPreloader, Router, NgModuleRef, Compiler],
+ (loader: SpyNgModuleFactoryLoader, preloader: RouterPreloader, router: Router,
+ testModule: NgModuleRef, compiler: Compiler) => {
+ @NgModule()
+ class LoadedModule2 {
+ }
- const module2 = compiler.compileModuleSync(LoadedModule2).create(null);
+ const module2 = compiler.compileModuleSync(LoadedModule2).create(null);
- @NgModule({
- imports: [RouterModule.forChild([
- {
- path: 'LoadedModule2',
- loadChildren: 'no',
- _loadedConfig: {
- routes: [{path: 'LoadedModule3', loadChildren: 'expected3'}],
- module: module2,
- }
- },
- ])]
- })
- class LoadedModule1 {
- }
+ @NgModule({
+ imports: [RouterModule.forChild([
+ {
+ path: 'LoadedModule2',
+ loadChildren: 'no',
+ _loadedConfig: {
+ routes: [{path: 'LoadedModule3', loadChildren: 'expected3'}],
+ module: module2,
+ }
+ },
+ ])]
+ })
+ class LoadedModule1 {
+ }
- @NgModule({imports: [RouterModule.forChild([])]})
- class LoadedModule3 {
- }
+ @NgModule({imports: [RouterModule.forChild([])]})
+ class LoadedModule3 {
+ }
- loader.stubbedModules = {
- expected: LoadedModule1,
- expected3: LoadedModule3,
- };
+ loader.stubbedModules = {
+ expected: LoadedModule1,
+ expected3: LoadedModule3,
+ };
- preloader.preload().subscribe(() => {});
+ preloader.preload().subscribe(() => {});
- tick();
+ tick();
- const c = router.config;
+ const c = router.config;
- const loadedConfig: LoadedRouterConfig = (c[0] as any)._loadedConfig !;
- const module: any = loadedConfig.module;
- expect(module._parent).toBe(testModule);
+ const loadedConfig: LoadedRouterConfig = (c[0] as any)._loadedConfig !;
+ const module: any = loadedConfig.module;
+ expect(module._parent).toBe(testModule);
- const loadedConfig2: LoadedRouterConfig =
- (loadedConfig.routes[0] as any)._loadedConfig !;
- const loadedConfig3: LoadedRouterConfig =
- (loadedConfig2.routes[0] as any)._loadedConfig !;
- const module3: any = loadedConfig3.module;
- expect(module3._parent).toBe(module2);
- })));
+ const loadedConfig2: LoadedRouterConfig =
+ (loadedConfig.routes[0] as any)._loadedConfig !;
+ const loadedConfig3: LoadedRouterConfig =
+ (loadedConfig2.routes[0] as any)._loadedConfig !;
+ const module3: any = loadedConfig3.module;
+ expect(module3._parent).toBe(module2);
+ })));
});
describe('should ignore errors', () => {
@@ -195,20 +200,21 @@ describe('RouterPreloader', () => {
});
});
- it('should work',
- fakeAsync(inject(
- [NgModuleFactoryLoader, RouterPreloader, Router],
- (loader: SpyNgModuleFactoryLoader, preloader: RouterPreloader, router: Router) => {
- loader.stubbedModules = {expected2: LoadedModule};
+ fixmeIvy('FW-561: Runtime compiler is not loaded') &&
+ it('should work',
+ fakeAsync(inject(
+ [NgModuleFactoryLoader, RouterPreloader, Router],
+ (loader: SpyNgModuleFactoryLoader, preloader: RouterPreloader, router: Router) => {
+ loader.stubbedModules = {expected2: LoadedModule};
- preloader.preload().subscribe(() => {});
+ preloader.preload().subscribe(() => {});
- tick();
+ tick();
- const c = router.config;
- expect((c[0] as any)._loadedConfig).not.toBeDefined();
- expect((c[1] as any)._loadedConfig).toBeDefined();
- })));
+ const c = router.config;
+ expect((c[0] as any)._loadedConfig).not.toBeDefined();
+ expect((c[1] as any)._loadedConfig).toBeDefined();
+ })));
});
describe('should copy loaded configs', () => {
@@ -224,21 +230,22 @@ describe('RouterPreloader', () => {
});
});
- it('should work',
- fakeAsync(inject(
- [NgModuleFactoryLoader, RouterPreloader, Router],
- (loader: SpyNgModuleFactoryLoader, preloader: RouterPreloader, router: Router) => {
- loader.stubbedModules = {expected: LoadedModule};
+ fixmeIvy('FW-561: Runtime compiler is not loaded') &&
+ it('should work',
+ fakeAsync(inject(
+ [NgModuleFactoryLoader, RouterPreloader, Router],
+ (loader: SpyNgModuleFactoryLoader, preloader: RouterPreloader, router: Router) => {
+ loader.stubbedModules = {expected: LoadedModule};
- preloader.preload().subscribe(() => {});
+ preloader.preload().subscribe(() => {});
- tick();
+ tick();
- const c = router.config as{_loadedConfig: LoadedRouterConfig}[];
- expect(c[0]._loadedConfig).toBeDefined();
- expect(c[0]._loadedConfig !.routes).not.toBe(configs);
- expect(c[0]._loadedConfig !.routes[0]).not.toBe(configs[0]);
- expect(c[0]._loadedConfig !.routes[0].component).toBe(configs[0].component);
- })));
+ const c = router.config as{_loadedConfig: LoadedRouterConfig}[];
+ expect(c[0]._loadedConfig).toBeDefined();
+ expect(c[0]._loadedConfig !.routes).not.toBe(configs);
+ expect(c[0]._loadedConfig !.routes[0]).not.toBe(configs[0]);
+ expect(c[0]._loadedConfig !.routes[0].component).toBe(configs[0].component);
+ })));
});
});
diff --git a/packages/router/test/spy_ng_module_factory_loader.spec.ts b/packages/router/test/spy_ng_module_factory_loader.spec.ts
index 076f5c2a9f..6ddb2d7503 100644
--- a/packages/router/test/spy_ng_module_factory_loader.spec.ts
+++ b/packages/router/test/spy_ng_module_factory_loader.spec.ts
@@ -7,7 +7,7 @@
*/
import {fakeAsync, tick} from '@angular/core/testing';
-import {SpyNgModuleFactoryLoader} from '../testing/src/router_testing_module';
+import {SpyNgModuleFactoryLoader} from '@angular/router/testing';
describe('SpyNgModuleFactoryLoader', () => {
it('should invoke the compiler when the setter is called', () => {