cargdev/angular
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

style(lint): re-format modules/@angular

Browse Source
This commit is contained in:
Alex Eagle
2016-06-08 16:38:52 -07:00
parent bbed364e7b
commit f39c9c9e75
589 changed files with 21829 additions and 24259 deletions
Download Patch File Download Diff File Expand all files Collapse all files

436
modules/@angular/router/test/integration_spec.ts
View File

@ -1,275 +1,298 @@
import {
AsyncTestCompleter,
beforeEach,
ddescribe,
xdescribe,
describe,
expect,
iit,
inject,
beforeEachProviders,
it,
xit
} from '@angular/core/testing/testing_internal';
import {fakeAsync, tick} from '@angular/core/testing';
import {ComponentFixture, TestComponentBuilder} from '@angular/compiler/testing';
import {provide, Component, ComponentResolver} from '@angular/core';
import {PromiseWrapper} from '../src/facade/async';
import {
Router,
RouterOutletMap,
RouteSegment,
Route,
ROUTER_DIRECTIVES,
Routes,
RouterUrlSerializer,
DefaultRouterUrlSerializer,
OnActivate,
CanDeactivate
} from '@angular/router';
import {SpyLocation} from '@angular/common/testing';
import {Location} from '@angular/common';
import {SpyLocation} from '@angular/common/testing';
import {ComponentFixture, TestComponentBuilder} from '@angular/compiler/testing';
import {Component, ComponentResolver, provide} from '@angular/core';
import {fakeAsync, tick} from '@angular/core/testing';
import {AsyncTestCompleter, beforeEach, beforeEachProviders, ddescribe, describe, expect, iit, inject, it, xdescribe, xit} from '@angular/core/testing/testing_internal';
import {CanDeactivate, DefaultRouterUrlSerializer, OnActivate, ROUTER_DIRECTIVES, Route, RouteSegment, Router, RouterOutletMap, RouterUrlSerializer, Routes} from '@angular/router';
import {getDOM} from '../platform_browser_private';
import {PromiseWrapper} from '../src/facade/async';
export function main() {
describe('navigation', () => {
beforeEachProviders(() => [
{provide: RouterUrlSerializer, useClass: DefaultRouterUrlSerializer},
RouterOutletMap,
{provide: Location, useClass: SpyLocation},
{provide: RouteSegment, useFactory: (r: any /** TODO #9100 */) => r.routeTree.root, deps: [Router]},
{
provide: Router,
useFactory: (resolver: any /** TODO #9100 */, urlParser: any /** TODO #9100 */, outletMap: any /** TODO #9100 */, location: any /** TODO #9100 */) => new Router(
"RootComponent", RootCmp, resolver, urlParser, outletMap, location),
deps: [ComponentResolver, RouterUrlSerializer, RouterOutletMap, Location]
}
]);
beforeEachProviders(
() =>
[{provide: RouterUrlSerializer, useClass: DefaultRouterUrlSerializer}, RouterOutletMap,
{provide: Location, useClass: SpyLocation}, {
provide: RouteSegment,
useFactory: (r: any /** TODO #9100 */) => r.routeTree.root,
deps: [Router]
},
{
provide: Router,
useFactory:
(resolver: any /** TODO #9100 */, urlParser: any /** TODO #9100 */,
outletMap: any /** TODO #9100 */, location: any /** TODO #9100 */) =>
new Router(
'RootComponent', RootCmp, resolver, urlParser, outletMap, location),
deps: [ComponentResolver, RouterUrlSerializer, RouterOutletMap, Location]
}]);
it('should update location when navigating',
fakeAsync(inject([Router, TestComponentBuilder, Location], (router: any /** TODO #9100 */, tcb: any /** TODO #9100 */, location: any /** TODO #9100 */) => {
let fixture = tcb.createFakeAsync(RootCmp);
fakeAsync(inject(
[Router, TestComponentBuilder, Location],
(router: any /** TODO #9100 */, tcb: any /** TODO #9100 */,
location: any /** TODO #9100 */) => {
let fixture = tcb.createFakeAsync(RootCmp);
router.navigateByUrl('/team/22/user/victor');
advance(fixture);
expect(location.path()).toEqual('/team/22/user/victor');
router.navigateByUrl('/team/22/user/victor');
advance(fixture);
expect(location.path()).toEqual('/team/22/user/victor');
router.navigateByUrl('/team/33/simple');
advance(fixture);
router.navigateByUrl('/team/33/simple');
advance(fixture);
expect(location.path()).toEqual('/team/33/simple');
})));
expect(location.path()).toEqual('/team/33/simple');
})));
it('should navigate back and forward',
fakeAsync(inject([Router, TestComponentBuilder, Location], (router: any /** TODO #9100 */, tcb: any /** TODO #9100 */, location: any /** TODO #9100 */) => {
let fixture = tcb.createFakeAsync(RootCmp);
fakeAsync(inject(
[Router, TestComponentBuilder, Location],
(router: any /** TODO #9100 */, tcb: any /** TODO #9100 */,
location: any /** TODO #9100 */) => {
let fixture = tcb.createFakeAsync(RootCmp);
router.navigateByUrl('/team/33/simple');
advance(fixture);
router.navigateByUrl('/team/33/simple');
advance(fixture);
router.navigateByUrl('/team/22/user/victor');
advance(fixture);
router.navigateByUrl('/team/22/user/victor');
advance(fixture);
location.back();
advance(fixture);
expect(location.path()).toEqual('/team/33/simple');
location.back();
advance(fixture);
expect(location.path()).toEqual('/team/33/simple');
location.forward();
advance(fixture);
expect(location.path()).toEqual('/team/22/user/victor');
})));
location.forward();
advance(fixture);
expect(location.path()).toEqual('/team/22/user/victor');
})));
it('should navigate when locations changes',
fakeAsync(inject([Router, TestComponentBuilder, Location], (router: any /** TODO #9100 */, tcb: any /** TODO #9100 */, location: any /** TODO #9100 */) => {
let fixture = tcb.createFakeAsync(RootCmp);
fakeAsync(inject(
[Router, TestComponentBuilder, Location],
(router: any /** TODO #9100 */, tcb: any /** TODO #9100 */,
location: any /** TODO #9100 */) => {
let fixture = tcb.createFakeAsync(RootCmp);
router.navigateByUrl('/team/22/user/victor');
advance(fixture);
router.navigateByUrl('/team/22/user/victor');
advance(fixture);
location.simulateHashChange("/team/22/user/fedor");
advance(fixture);
location.simulateHashChange('/team/22/user/fedor');
advance(fixture);
expect(fixture.debugElement.nativeElement).toHaveText('team 22 { hello fedor, aux: }');
})));
expect(fixture.debugElement.nativeElement)
.toHaveText('team 22 { hello fedor, aux: }');
})));
it('should support nested routes',
fakeAsync(inject([Router, TestComponentBuilder], (router: any /** TODO #9100 */, tcb: any /** TODO #9100 */) => {
let fixture = tcb.createFakeAsync(RootCmp);
fakeAsync(inject(
[Router, TestComponentBuilder],
(router: any /** TODO #9100 */, tcb: any /** TODO #9100 */) => {
let fixture = tcb.createFakeAsync(RootCmp);
router.navigateByUrl('/team/22/user/victor');
advance(fixture);
router.navigateByUrl('/team/22/user/victor');
advance(fixture);
expect(fixture.debugElement.nativeElement).toHaveText('team 22 { hello victor, aux: }');
})));
expect(fixture.debugElement.nativeElement)
.toHaveText('team 22 { hello victor, aux: }');
})));
it('should support aux routes',
fakeAsync(inject([Router, TestComponentBuilder], (router: any /** TODO #9100 */, tcb: any /** TODO #9100 */) => {
let fixture = tcb.createFakeAsync(RootCmp);
fakeAsync(inject(
[Router, TestComponentBuilder],
(router: any /** TODO #9100 */, tcb: any /** TODO #9100 */) => {
let fixture = tcb.createFakeAsync(RootCmp);
router.navigateByUrl('/team/22/user/victor(/simple)');
advance(fixture);
router.navigateByUrl('/team/22/user/victor(/simple)');
advance(fixture);
expect(fixture.debugElement.nativeElement)
.toHaveText('team 22 { hello victor, aux: simple }');
})));
expect(fixture.debugElement.nativeElement)
.toHaveText('team 22 { hello victor, aux: simple }');
})));
it('should deactivate outlets',
fakeAsync(inject([Router, TestComponentBuilder], (router: any /** TODO #9100 */, tcb: any /** TODO #9100 */) => {
let fixture = tcb.createFakeAsync(RootCmp);
fakeAsync(inject(
[Router, TestComponentBuilder],
(router: any /** TODO #9100 */, tcb: any /** TODO #9100 */) => {
let fixture = tcb.createFakeAsync(RootCmp);
router.navigateByUrl('/team/22/user/victor(/simple)');
advance(fixture);
router.navigateByUrl('/team/22/user/victor(/simple)');
advance(fixture);
router.navigateByUrl('/team/22/user/victor');
advance(fixture);
router.navigateByUrl('/team/22/user/victor');
advance(fixture);
expect(fixture.debugElement.nativeElement).toHaveText('team 22 { hello victor, aux: }');
})));
expect(fixture.debugElement.nativeElement)
.toHaveText('team 22 { hello victor, aux: }');
})));
it('should deactivate nested outlets',
fakeAsync(inject([Router, TestComponentBuilder], (router: any /** TODO #9100 */, tcb: any /** TODO #9100 */) => {
let fixture = tcb.createFakeAsync(RootCmp);
fakeAsync(inject(
[Router, TestComponentBuilder],
(router: any /** TODO #9100 */, tcb: any /** TODO #9100 */) => {
let fixture = tcb.createFakeAsync(RootCmp);
router.navigateByUrl('/team/22/user/victor(/simple)');
advance(fixture);
router.navigateByUrl('/team/22/user/victor(/simple)');
advance(fixture);
router.navigateByUrl('/');
advance(fixture);
router.navigateByUrl('/');
advance(fixture);
expect(fixture.debugElement.nativeElement).toHaveText('');
})));
expect(fixture.debugElement.nativeElement).toHaveText('');
})));
it('should update nested routes when url changes',
fakeAsync(inject([Router, TestComponentBuilder], (router: any /** TODO #9100 */, tcb: any /** TODO #9100 */) => {
let fixture = tcb.createFakeAsync(RootCmp);
fakeAsync(inject(
[Router, TestComponentBuilder],
(router: any /** TODO #9100 */, tcb: any /** TODO #9100 */) => {
let fixture = tcb.createFakeAsync(RootCmp);
router.navigateByUrl('/team/22/user/victor');
advance(fixture);
let team1 = fixture.debugElement.children[1].componentInstance;
router.navigateByUrl('/team/22/user/victor');
advance(fixture);
let team1 = fixture.debugElement.children[1].componentInstance;
router.navigateByUrl('/team/22/user/fedor');
advance(fixture);
let team2 = fixture.debugElement.children[1].componentInstance;
router.navigateByUrl('/team/22/user/fedor');
advance(fixture);
let team2 = fixture.debugElement.children[1].componentInstance;
expect(team1).toBe(team2);
expect(fixture.debugElement.nativeElement).toHaveText('team 22 { hello fedor, aux: }');
})));
expect(team1).toBe(team2);
expect(fixture.debugElement.nativeElement)
.toHaveText('team 22 { hello fedor, aux: }');
})));
it('should not deactivate the route if can deactivate returns false',
fakeAsync(inject([Router, TestComponentBuilder, Location], (router: any /** TODO #9100 */, tcb: any /** TODO #9100 */, location: any /** TODO #9100 */) => {
let fixture = tcb.createFakeAsync(RootCmp);
fakeAsync(inject(
[Router, TestComponentBuilder, Location],
(router: any /** TODO #9100 */, tcb: any /** TODO #9100 */,
location: any /** TODO #9100 */) => {
let fixture = tcb.createFakeAsync(RootCmp);
router.navigateByUrl('/team/22/cannotDeactivate');
advance(fixture);
router.navigateByUrl('/team/22/cannotDeactivate');
advance(fixture);
router.navigateByUrl('/team/22/user/fedor');
advance(fixture);
router.navigateByUrl('/team/22/user/fedor');
advance(fixture);
expect(fixture.debugElement.nativeElement)
.toHaveText('team 22 { cannotDeactivate, aux: }');
expect(fixture.debugElement.nativeElement)
.toHaveText('team 22 { cannotDeactivate, aux: }');
expect(location.path()).toEqual('/team/22/cannotDeactivate');
})));
expect(location.path()).toEqual('/team/22/cannotDeactivate');
})));
if (getDOM().supportsDOMEvents()) {
it("should support absolute router links",
fakeAsync(inject([Router, TestComponentBuilder], (router: any /** TODO #9100 */, tcb: any /** TODO #9100 */) => {
let fixture = tcb.createFakeAsync(RootCmp);
advance(fixture);
it('should support absolute router links',
fakeAsync(inject(
[Router, TestComponentBuilder],
(router: any /** TODO #9100 */, tcb: any /** TODO #9100 */) => {
let fixture = tcb.createFakeAsync(RootCmp);
advance(fixture);
router.navigateByUrl('/team/22/link');
advance(fixture);
expect(fixture.debugElement.nativeElement).toHaveText('team 22 { link, aux: }');
router.navigateByUrl('/team/22/link');
advance(fixture);
expect(fixture.debugElement.nativeElement).toHaveText('team 22 { link, aux: }');
let native = getDOM().querySelector(fixture.debugElement.nativeElement, "a");
expect(getDOM().getAttribute(native, "href")).toEqual("/team/33/simple");
getDOM().dispatchEvent(native, getDOM().createMouseEvent('click'));
advance(fixture);
let native = getDOM().querySelector(fixture.debugElement.nativeElement, 'a');
expect(getDOM().getAttribute(native, 'href')).toEqual('/team/33/simple');
getDOM().dispatchEvent(native, getDOM().createMouseEvent('click'));
advance(fixture);
expect(fixture.debugElement.nativeElement).toHaveText('team 33 { simple, aux: }');
})));
expect(fixture.debugElement.nativeElement).toHaveText('team 33 { simple, aux: }');
})));
it("should support relative router links",
fakeAsync(inject([Router, TestComponentBuilder], (router: any /** TODO #9100 */, tcb: any /** TODO #9100 */) => {
let fixture = tcb.createFakeAsync(RootCmp);
advance(fixture);
it('should support relative router links',
fakeAsync(inject(
[Router, TestComponentBuilder],
(router: any /** TODO #9100 */, tcb: any /** TODO #9100 */) => {
let fixture = tcb.createFakeAsync(RootCmp);
advance(fixture);
router.navigateByUrl('/team/22/relativelink');
advance(fixture);
expect(fixture.debugElement.nativeElement)
.toHaveText('team 22 { relativelink { }, aux: }');
router.navigateByUrl('/team/22/relativelink');
advance(fixture);
expect(fixture.debugElement.nativeElement)
.toHaveText('team 22 { relativelink { }, aux: }');
let native = getDOM().querySelector(fixture.debugElement.nativeElement, "a");
expect(getDOM().getAttribute(native, "href")).toEqual("/team/22/relativelink/simple");
getDOM().dispatchEvent(native, getDOM().createMouseEvent('click'));
advance(fixture);
let native = getDOM().querySelector(fixture.debugElement.nativeElement, 'a');
expect(getDOM().getAttribute(native, 'href'))
.toEqual('/team/22/relativelink/simple');
getDOM().dispatchEvent(native, getDOM().createMouseEvent('click'));
advance(fixture);
expect(fixture.debugElement.nativeElement)
.toHaveText('team 22 { relativelink { simple }, aux: }');
})));
expect(fixture.debugElement.nativeElement)
.toHaveText('team 22 { relativelink { simple }, aux: }');
})));
it("should set the router-link-active class",
fakeAsync(inject([Router, TestComponentBuilder], (router: any /** TODO #9100 */, tcb: any /** TODO #9100 */) => {
let fixture = tcb.createFakeAsync(RootCmp);
advance(fixture);
it('should set the router-link-active class',
fakeAsync(inject(
[Router, TestComponentBuilder],
(router: any /** TODO #9100 */, tcb: any /** TODO #9100 */) => {
let fixture = tcb.createFakeAsync(RootCmp);
advance(fixture);
router.navigateByUrl('/team/22/relativelink');
advance(fixture);
expect(fixture.debugElement.nativeElement)
.toHaveText('team 22 { relativelink { }, aux: }');
let link = getDOM().querySelector(fixture.debugElement.nativeElement, "a");
expect(getDOM().hasClass(link, "router-link-active")).toEqual(false);
router.navigateByUrl('/team/22/relativelink');
advance(fixture);
expect(fixture.debugElement.nativeElement)
.toHaveText('team 22 { relativelink { }, aux: }');
let link = getDOM().querySelector(fixture.debugElement.nativeElement, 'a');
expect(getDOM().hasClass(link, 'router-link-active')).toEqual(false);
getDOM().dispatchEvent(link, getDOM().createMouseEvent('click'));
advance(fixture);
getDOM().dispatchEvent(link, getDOM().createMouseEvent('click'));
advance(fixture);
expect(getDOM().hasClass(link, "router-link-active")).toEqual(true);
})));
expect(getDOM().hasClass(link, 'router-link-active')).toEqual(true);
})));
it("should update router links when router changes",
fakeAsync(inject([Router, TestComponentBuilder], (router: any /** TODO #9100 */, tcb: any /** TODO #9100 */) => {
let fixture = tcb.createFakeAsync(RootCmp);
advance(fixture);
it('should update router links when router changes',
fakeAsync(inject(
[Router, TestComponentBuilder],
(router: any /** TODO #9100 */, tcb: any /** TODO #9100 */) => {
let fixture = tcb.createFakeAsync(RootCmp);
advance(fixture);
router.navigateByUrl('/team/22/link(simple)');
advance(fixture);
expect(fixture.debugElement.nativeElement).toHaveText('team 22 { link, aux: simple }');
router.navigateByUrl('/team/22/link(simple)');
advance(fixture);
expect(fixture.debugElement.nativeElement)
.toHaveText('team 22 { link, aux: simple }');
let native = getDOM().querySelector(fixture.debugElement.nativeElement, "a");
expect(getDOM().getAttribute(native, "href")).toEqual("/team/33/simple(aux:simple)");
let native = getDOM().querySelector(fixture.debugElement.nativeElement, 'a');
expect(getDOM().getAttribute(native, 'href')).toEqual('/team/33/simple(aux:simple)');
router.navigateByUrl('/team/22/link(simple2)');
advance(fixture);
router.navigateByUrl('/team/22/link(simple2)');
advance(fixture);
expect(getDOM().getAttribute(native, "href")).toEqual("/team/33/simple(aux:simple2)");
})));
expect(getDOM().getAttribute(native, 'href'))
.toEqual('/team/33/simple(aux:simple2)');
})));
it("should support top-level link",
fakeAsync(inject([Router, TestComponentBuilder], (router: any /** TODO #9100 */, tcb: any /** TODO #9100 */) => {
let fixture = tcb.createFakeAsync(LinkCmp);
advance(fixture);
expect(fixture.debugElement.nativeElement).toHaveText('link');
})));
it('should support top-level link',
fakeAsync(inject(
[Router, TestComponentBuilder],
(router: any /** TODO #9100 */, tcb: any /** TODO #9100 */) => {
let fixture = tcb.createFakeAsync(LinkCmp);
advance(fixture);
expect(fixture.debugElement.nativeElement).toHaveText('link');
})));
it('should replace state when path is equal to current path',
fakeAsync(inject([Router, TestComponentBuilder, Location], (router: any /** TODO #9100 */, tcb: any /** TODO #9100 */, location: any /** TODO #9100 */) => {
let fixture = tcb.createFakeAsync(RootCmp);
fakeAsync(inject(
[Router, TestComponentBuilder, Location],
(router: any /** TODO #9100 */, tcb: any /** TODO #9100 */,
location: any /** TODO #9100 */) => {
let fixture = tcb.createFakeAsync(RootCmp);
router.navigateByUrl('/team/33/simple');
advance(fixture);
router.navigateByUrl('/team/33/simple');
advance(fixture);
router.navigateByUrl('/team/22/user/victor');
advance(fixture);
router.navigateByUrl('/team/22/user/victor');
advance(fixture);
router.navigateByUrl('/team/22/user/victor');
advance(fixture);
router.navigateByUrl('/team/22/user/victor');
advance(fixture);
location.back();
advance(fixture);
expect(location.path()).toEqual('/team/33/simple');
})));
location.back();
advance(fixture);
expect(location.path()).toEqual('/team/33/simple');
})));
}
});
}
@ -286,12 +309,18 @@ function compileRoot(tcb: TestComponentBuilder): Promise<ComponentFixture<any>>
@Component({selector: 'user-cmp', template: `hello {{user}}`})
class UserCmp implements OnActivate {
user: string;
routerOnActivate(s: RouteSegment, a?: any /** TODO #9100 */, b?: any /** TODO #9100 */, c?: any /** TODO #9100 */) { this.user = s.getParam('name'); }
routerOnActivate(
s: RouteSegment, a?: any /** TODO #9100 */, b?: any /** TODO #9100 */,
c?: any /** TODO #9100 */) {
this.user = s.getParam('name');
}
}
@Component({selector: 'cannot-deactivate', template: `cannotDeactivate`})
class CanDeactivateCmp implements CanDeactivate {
routerCanDeactivate(a?: any /** TODO #9100 */, b?: any /** TODO #9100 */): Promise<boolean> { return PromiseWrapper.resolve(false); }
routerCanDeactivate(a?: any /** TODO #9100 */, b?: any /** TODO #9100 */): Promise<boolean> {
return PromiseWrapper.resolve(false);
}
}
@Component({selector: 'simple-cmp', template: `simple`})
@ -321,7 +350,8 @@ class RelativeLinkCmp {
@Component({
selector: 'team-cmp',
template: `team {{id}} { <router-outlet></router-outlet>, aux: <router-outlet name="aux"></router-outlet> }`,
template:
`team {{id}} { <router-outlet></router-outlet>, aux: <router-outlet name="aux"></router-outlet> }`,
directives: [ROUTER_DIRECTIVES]
})
@Routes([
@ -334,7 +364,11 @@ class RelativeLinkCmp {
])
class TeamCmp implements OnActivate {
id: string;
routerOnActivate(s: RouteSegment, a?: any /** TODO #9100 */, b?: any /** TODO #9100 */, c?: any /** TODO #9100 */) { this.id = s.getParam('id'); }
routerOnActivate(
s: RouteSegment, a?: any /** TODO #9100 */, b?: any /** TODO #9100 */,
c?: any /** TODO #9100 */) {
this.id = s.getParam('id');
}
}
@Component({

165
modules/@angular/router/test/link_spec.ts
View File

@ -1,77 +1,65 @@
import {
AsyncTestCompleter,
beforeEach,
ddescribe,
xdescribe,
describe,
expect,
iit,
inject,
beforeEachProviders,
it,
xit
} from '@angular/core/testing/testing_internal';
import {AsyncTestCompleter, beforeEach, beforeEachProviders, ddescribe, describe, expect, iit, inject, it, xdescribe, xit} from '@angular/core/testing/testing_internal';
import {RouteSegment, UrlSegment, UrlTree, TreeNode, RouteTree} from '../src/segments';
import {link} from '../src/link';
import {DefaultRouterUrlSerializer} from '../src/router_url_serializer';
import {RouteSegment, RouteTree, TreeNode, UrlSegment, UrlTree} from '../src/segments';
export function main() {
describe('link', () => {
let parser = new DefaultRouterUrlSerializer();
it("should return the original tree when given an empty array", () => {
let p = parser.parse("/");
it('should return the original tree when given an empty array', () => {
let p = parser.parse('/');
let tree = s(p.root);
let t = link(tree.root, tree, p, []);
expect(t).toBe(p);
});
it("should navigate to the root", () => {
let p = parser.parse("/");
it('should navigate to the root', () => {
let p = parser.parse('/');
let tree = s(p.root);
let t = link(tree.root, tree, p, ["/"]);
expect(parser.serialize(t)).toEqual("");
let t = link(tree.root, tree, p, ['/']);
expect(parser.serialize(t)).toEqual('');
});
it("should support nested segments", () => {
let p = parser.parse("/a/b");
it('should support nested segments', () => {
let p = parser.parse('/a/b');
let tree = s(p.firstChild(p.root));
let t = link(tree.root, tree, p, ["/one", 11, "two", 22]);
expect(parser.serialize(t)).toEqual("/one/11/two/22");
let t = link(tree.root, tree, p, ['/one', 11, 'two', 22]);
expect(parser.serialize(t)).toEqual('/one/11/two/22');
});
it("should preserve siblings", () => {
let p = parser.parse("/a/11/b(c)");
it('should preserve siblings', () => {
let p = parser.parse('/a/11/b(c)');
let tree = s(p.root);
let t = link(tree.root, tree, p, ["/a", 11, 'd']);
expect(parser.serialize(t)).toEqual("/a/11/d(aux:c)");
let t = link(tree.root, tree, p, ['/a', 11, 'd']);
expect(parser.serialize(t)).toEqual('/a/11/d(aux:c)');
});
it('should update matrix parameters', () => {
let p = parser.parse("/a;aa=11");
let p = parser.parse('/a;aa=11');
let tree = s(p.root);
let t = link(tree.root, tree, p, ["/a", {aa: 22, bb: 33}]);
expect(parser.serialize(t)).toEqual("/a;aa=22;bb=33");
let t = link(tree.root, tree, p, ['/a', {aa: 22, bb: 33}]);
expect(parser.serialize(t)).toEqual('/a;aa=22;bb=33');
});
it('should create matrix parameters', () => {
let p = parser.parse("/a");
let p = parser.parse('/a');
let tree = s(p.root);
let t = link(tree.root, tree, p, ["/a", {aa: 22, bb: 33}]);
expect(parser.serialize(t)).toEqual("/a;aa=22;bb=33");
let t = link(tree.root, tree, p, ['/a', {aa: 22, bb: 33}]);
expect(parser.serialize(t)).toEqual('/a;aa=22;bb=33');
});
it('should create matrix parameters together with other segments', () => {
let p = parser.parse("/a");
let p = parser.parse('/a');
let tree = s(p.root);
let t = link(tree.root, tree, p, ["/a", "/b", {aa: 22, bb: 33}]);
expect(parser.serialize(t)).toEqual("/a/b;aa=22;bb=33");
let t = link(tree.root, tree, p, ['/a', '/b', {aa: 22, bb: 33}]);
expect(parser.serialize(t)).toEqual('/a/b;aa=22;bb=33');
});
describe("node reuse", () => {
describe('node reuse', () => {
it('should reuse nodes when path is the same', () => {
let p = parser.parse("/a/b");
let p = parser.parse('/a/b');
let tree = s(p.root);
let t = link(tree.root, tree, p, ['/a/c']);
@ -80,16 +68,16 @@ export function main() {
expect(t.firstChild(t.firstChild(t.root))).not.toBe(p.firstChild(p.firstChild(p.root)));
});
it("should create new node when params are the same", () => {
let p = parser.parse("/a;x=1");
it('should create new node when params are the same', () => {
let p = parser.parse('/a;x=1');
let tree = s(p.root);
let t = link(tree.root, tree, p, ['/a', {'x': 1}]);
expect(t.firstChild(t.root)).toBe(p.firstChild(p.root));
});
it("should create new node when params are different", () => {
let p = parser.parse("/a;x=1");
it('should create new node when params are different', () => {
let p = parser.parse('/a;x=1');
let tree = s(p.root);
let t = link(tree.root, tree, p, ['/a', {'x': 2}]);
@ -97,99 +85,100 @@ export function main() {
});
});
describe("relative navigation", () => {
it("should work", () => {
let p = parser.parse("/a(ap)/c(cp)");
describe('relative navigation', () => {
it('should work', () => {
let p = parser.parse('/a(ap)/c(cp)');
let c = p.firstChild(p.root);
let tree = s(c);
let t = link(tree.root, tree, p, ["c2"]);
expect(parser.serialize(t)).toEqual("/a(aux:ap)/c2(aux:cp)");
let t = link(tree.root, tree, p, ['c2']);
expect(parser.serialize(t)).toEqual('/a(aux:ap)/c2(aux:cp)');
});
it("should work when the first command starts with a ./", () => {
let p = parser.parse("/a(ap)/c(cp)");
it('should work when the first command starts with a ./', () => {
let p = parser.parse('/a(ap)/c(cp)');
let c = p.firstChild(p.root);
let tree = s(c);
let t = link(tree.root, tree, p, ["./c2"]);
expect(parser.serialize(t)).toEqual("/a(aux:ap)/c2(aux:cp)");
let t = link(tree.root, tree, p, ['./c2']);
expect(parser.serialize(t)).toEqual('/a(aux:ap)/c2(aux:cp)');
});
it("should work when the first command is ./)", () => {
let p = parser.parse("/a(ap)/c(cp)");
it('should work when the first command is ./)', () => {
let p = parser.parse('/a(ap)/c(cp)');
let c = p.firstChild(p.root);
let tree = s(c);
let t = link(tree.root, tree, p, ["./", "c2"]);
expect(parser.serialize(t)).toEqual("/a(aux:ap)/c2(aux:cp)");
let t = link(tree.root, tree, p, ['./', 'c2']);
expect(parser.serialize(t)).toEqual('/a(aux:ap)/c2(aux:cp)');
});
it("should work when given params", () => {
let p = parser.parse("/a(ap)/c(cp)");
it('should work when given params', () => {
let p = parser.parse('/a(ap)/c(cp)');
let c = p.firstChild(p.root);
let tree = s(c);
let t = link(tree.root, tree, p, [{'x': 99}]);
expect(parser.serialize(t)).toEqual("/a(aux:ap)/c;x=99(aux:cp)");
expect(parser.serialize(t)).toEqual('/a(aux:ap)/c;x=99(aux:cp)');
});
it("should support going to a parent", () => {
let p = parser.parse("/a(ap)/c(cp)");
it('should support going to a parent', () => {
let p = parser.parse('/a(ap)/c(cp)');
let a = p.firstChild(p.root);
let tree = s(a);
let t = link(tree.root, tree, p, ["../a2"]);
expect(parser.serialize(t)).toEqual("/a2(aux:ap)");
let t = link(tree.root, tree, p, ['../a2']);
expect(parser.serialize(t)).toEqual('/a2(aux:ap)');
});
it("should support going to a parent (nested case)", () => {
let p = parser.parse("/a/c");
it('should support going to a parent (nested case)', () => {
let p = parser.parse('/a/c');
let c = p.firstChild(p.firstChild(p.root));
let tree = s(c);
let t = link(tree.root, tree, p, ["../c2"]);
expect(parser.serialize(t)).toEqual("/a/c2");
let t = link(tree.root, tree, p, ['../c2']);
expect(parser.serialize(t)).toEqual('/a/c2');
});
it("should work when given ../", () => {
let p = parser.parse("/a/c");
it('should work when given ../', () => {
let p = parser.parse('/a/c');
let c = p.firstChild(p.firstChild(p.root));
let tree = s(c);
let t = link(tree.root, tree, p, ["../"]);
expect(parser.serialize(t)).toEqual("/a");
let t = link(tree.root, tree, p, ['../']);
expect(parser.serialize(t)).toEqual('/a');
});
it("should navigate to the root", () => {
let p = parser.parse("/a/c");
it('should navigate to the root', () => {
let p = parser.parse('/a/c');
let c = p.firstChild(p.root);
let tree = s(c);
let t = link(tree.root, tree, p, ["../"]);
expect(parser.serialize(t)).toEqual("");
let t = link(tree.root, tree, p, ['../']);
expect(parser.serialize(t)).toEqual('');
});
it("should support setting matrix params", () => {
let p = parser.parse("/a(ap)/c(cp)");
it('should support setting matrix params', () => {
let p = parser.parse('/a(ap)/c(cp)');
let c = p.firstChild(p.root);
let tree = s(c);
let t = link(tree.root, tree, p, ["../", {'x': 5}]);
expect(parser.serialize(t)).toEqual("/a;x=5(aux:ap)");
let t = link(tree.root, tree, p, ['../', {'x': 5}]);
expect(parser.serialize(t)).toEqual('/a;x=5(aux:ap)');
});
it("should throw when too many ..", () => {
let p = parser.parse("/a(ap)/c(cp)");
it('should throw when too many ..', () => {
let p = parser.parse('/a(ap)/c(cp)');
let c = p.firstChild(p.root);
let tree = s(c);
expect(() => link(tree.root, tree, p, ["../../"])).toThrowError("Invalid number of '../'");
expect(() => link(tree.root, tree, p, ['../../']))
.toThrowError('Invalid number of \'../\'');
});
it("should work when the provided segment doesn't have url segments", () => {
let p = parser.parse("/a(ap)/c(cp)");
it('should work when the provided segment doesn\'t have url segments', () => {
let p = parser.parse('/a(ap)/c(cp)');
let c = p.firstChild(p.root);
let child = new RouteSegment([], {'one': '1'}, null, null, null);
let root = new TreeNode<RouteSegment>(new RouteSegment([c], {}, null, null, null),
[new TreeNode<RouteSegment>(child, [])]);
let root = new TreeNode<RouteSegment>(
new RouteSegment([c], {}, null, null, null), [new TreeNode<RouteSegment>(child, [])]);
let tree = new RouteTree(root);
let t = link(child, tree, p, ["./c2"]);
expect(parser.serialize(t)).toEqual("/a(aux:ap)/c2(aux:cp)");
let t = link(child, tree, p, ['./c2']);
expect(parser.serialize(t)).toEqual('/a(aux:ap)/c2(aux:cp)');
});
});
});

288
modules/@angular/router/test/recognize_spec.ts
View File

@ -1,62 +1,53 @@
import {
AsyncTestCompleter,
beforeEach,
ddescribe,
xdescribe,
describe,
expect,
iit,
inject,
beforeEachProviders,
it,
xit
} from '@angular/core/testing/testing_internal';
import {Component, ComponentResolver, provide} from '@angular/core';
import {AsyncTestCompleter, beforeEach, beforeEachProviders, ddescribe, describe, expect, iit, inject, it, xdescribe, xit} from '@angular/core/testing/testing_internal';
import {Route, Routes} from '@angular/router';
import {recognize} from '../src/recognize';
import {Routes, Route} from '@angular/router';
import {provide, Component, ComponentResolver} from '@angular/core';
import {UrlSegment, RouteTree, UrlTree, createEmptyRouteTree} from '../src/segments';
import {DefaultRouterUrlSerializer} from '../src/router_url_serializer';
import {DEFAULT_OUTLET_NAME} from '../src/constants';
import {recognize} from '../src/recognize';
import {DefaultRouterUrlSerializer} from '../src/router_url_serializer';
import {RouteTree, UrlSegment, UrlTree, createEmptyRouteTree} from '../src/segments';
export function main() {
describe('recognize', () => {
let emptyRouteTree = createEmptyRouteTree(ComponentA);
it('should handle position args',
inject([AsyncTestCompleter, ComponentResolver], (async: AsyncTestCompleter, resolver: any /** TODO #9100 */) => {
recognize(resolver, ComponentA, tree("b/paramB/c/paramC/d"), emptyRouteTree)
.then(r => {
let a = r.root;
expect(stringifyUrl(a.urlSegments)).toEqual([""]);
expect(a.type).toBe(ComponentA);
inject(
[AsyncTestCompleter, ComponentResolver],
(async: AsyncTestCompleter, resolver: any /** TODO #9100 */) => {
recognize(resolver, ComponentA, tree('b/paramB/c/paramC/d'), emptyRouteTree)
.then(r => {
let a = r.root;
expect(stringifyUrl(a.urlSegments)).toEqual(['']);
expect(a.type).toBe(ComponentA);
let b = r.firstChild(r.root);
expect(stringifyUrl(b.urlSegments)).toEqual(["b", "paramB"]);
expect(b.type).toBe(ComponentB);
let b = r.firstChild(r.root);
expect(stringifyUrl(b.urlSegments)).toEqual(['b', 'paramB']);
expect(b.type).toBe(ComponentB);
let c = r.firstChild(r.firstChild(r.root));
expect(stringifyUrl(c.urlSegments)).toEqual(["c", "paramC"]);
expect(c.type).toBe(ComponentC);
let c = r.firstChild(r.firstChild(r.root));
expect(stringifyUrl(c.urlSegments)).toEqual(['c', 'paramC']);
expect(c.type).toBe(ComponentC);
let d = r.firstChild(r.firstChild(r.firstChild(r.root)));
expect(stringifyUrl(d.urlSegments)).toEqual(["d"]);
expect(d.type).toBe(ComponentD);
let d = r.firstChild(r.firstChild(r.firstChild(r.root)));
expect(stringifyUrl(d.urlSegments)).toEqual(['d']);
expect(d.type).toBe(ComponentD);
async.done();
});
}));
async.done();
});
}));
it('should support empty routes',
inject([AsyncTestCompleter, ComponentResolver], (async: AsyncTestCompleter, resolver: any /** TODO #9100 */) => {
recognize(resolver, ComponentA, tree("f"), emptyRouteTree)
.then(r => {
inject(
[AsyncTestCompleter, ComponentResolver],
(async: AsyncTestCompleter, resolver: any /** TODO #9100 */) => {
recognize(resolver, ComponentA, tree('f'), emptyRouteTree).then(r => {
let a = r.root;
expect(stringifyUrl(a.urlSegments)).toEqual([""]);
expect(stringifyUrl(a.urlSegments)).toEqual(['']);
expect(a.type).toBe(ComponentA);
let f = r.firstChild(r.root);
expect(stringifyUrl(f.urlSegments)).toEqual(["f"]);
expect(stringifyUrl(f.urlSegments)).toEqual(['f']);
expect(f.type).toBe(ComponentF);
let d = r.firstChild(r.firstChild(r.root));
@ -65,93 +56,104 @@ export function main() {
async.done();
});
}));
}));
it('should handle aux routes',
inject([AsyncTestCompleter, ComponentResolver], (async: AsyncTestCompleter, resolver: any /** TODO #9100 */) => {
recognize(resolver, ComponentA, tree("b/paramB(/d//right:d)"), emptyRouteTree)
.then(r => {
let c = r.children(r.root);
expect(stringifyUrl(c[0].urlSegments)).toEqual(["b", "paramB"]);
expect(c[0].outlet).toEqual(DEFAULT_OUTLET_NAME);
expect(c[0].type).toBe(ComponentB);
inject(
[AsyncTestCompleter, ComponentResolver],
(async: AsyncTestCompleter, resolver: any /** TODO #9100 */) => {
recognize(resolver, ComponentA, tree('b/paramB(/d//right:d)'), emptyRouteTree)
.then(r => {
let c = r.children(r.root);
expect(stringifyUrl(c[0].urlSegments)).toEqual(['b', 'paramB']);
expect(c[0].outlet).toEqual(DEFAULT_OUTLET_NAME);
expect(c[0].type).toBe(ComponentB);
expect(stringifyUrl(c[1].urlSegments)).toEqual(["d"]);
expect(c[1].outlet).toEqual("aux");
expect(c[1].type).toBe(ComponentD);
expect(stringifyUrl(c[1].urlSegments)).toEqual(['d']);
expect(c[1].outlet).toEqual('aux');
expect(c[1].type).toBe(ComponentD);
expect(stringifyUrl(c[2].urlSegments)).toEqual(["d"]);
expect(c[2].outlet).toEqual("right");
expect(c[2].type).toBe(ComponentD);
expect(stringifyUrl(c[2].urlSegments)).toEqual(['d']);
expect(c[2].outlet).toEqual('right');
expect(c[2].type).toBe(ComponentD);
async.done();
});
}));
async.done();
});
}));
it("should error when two segments with the same outlet name",
inject([AsyncTestCompleter, ComponentResolver], (async: AsyncTestCompleter, resolver: any /** TODO #9100 */) => {
recognize(resolver, ComponentA, tree("b/paramB(right:d//right:e)"), emptyRouteTree)
.catch(e => {
expect(e.message).toEqual(
"Two segments cannot have the same outlet name: 'right:d' and 'right:e'.");
async.done();
});
}));
it('should error when two segments with the same outlet name',
inject(
[AsyncTestCompleter, ComponentResolver],
(async: AsyncTestCompleter, resolver: any /** TODO #9100 */) => {
recognize(resolver, ComponentA, tree('b/paramB(right:d//right:e)'), emptyRouteTree)
.catch(e => {
expect(e.message).toEqual(
'Two segments cannot have the same outlet name: \'right:d\' and \'right:e\'.');
async.done();
});
}));
it('should handle nested aux routes',
inject([AsyncTestCompleter, ComponentResolver], (async: AsyncTestCompleter, resolver: any /** TODO #9100 */) => {
recognize(resolver, ComponentA, tree("b/paramB(/d(right:e))"), emptyRouteTree)
.then(r => {
let c = r.children(r.root);
expect(stringifyUrl(c[0].urlSegments)).toEqual(["b", "paramB"]);
expect(c[0].outlet).toEqual(DEFAULT_OUTLET_NAME);
expect(c[0].type).toBe(ComponentB);
inject(
[AsyncTestCompleter, ComponentResolver],
(async: AsyncTestCompleter, resolver: any /** TODO #9100 */) => {
recognize(resolver, ComponentA, tree('b/paramB(/d(right:e))'), emptyRouteTree)
.then(r => {
let c = r.children(r.root);
expect(stringifyUrl(c[0].urlSegments)).toEqual(['b', 'paramB']);
expect(c[0].outlet).toEqual(DEFAULT_OUTLET_NAME);
expect(c[0].type).toBe(ComponentB);
expect(stringifyUrl(c[1].urlSegments)).toEqual(["d"]);
expect(c[1].outlet).toEqual("aux");
expect(c[1].type).toBe(ComponentD);
expect(stringifyUrl(c[1].urlSegments)).toEqual(['d']);
expect(c[1].outlet).toEqual('aux');
expect(c[1].type).toBe(ComponentD);
expect(stringifyUrl(c[2].urlSegments)).toEqual(["e"]);
expect(c[2].outlet).toEqual("right");
expect(c[2].type).toBe(ComponentE);
expect(stringifyUrl(c[2].urlSegments)).toEqual(['e']);
expect(c[2].outlet).toEqual('right');
expect(c[2].type).toBe(ComponentE);
async.done();
});
}));
async.done();
});
}));
it('should handle non top-level aux routes',
inject([AsyncTestCompleter, ComponentResolver], (async: AsyncTestCompleter, resolver: any /** TODO #9100 */) => {
recognize(resolver, ComponentA, tree('b/paramB/d(e)'), emptyRouteTree)
.then(r => {
inject(
[AsyncTestCompleter, ComponentResolver],
(async: AsyncTestCompleter, resolver: any /** TODO #9100 */) => {
recognize(resolver, ComponentA, tree('b/paramB/d(e)'), emptyRouteTree).then(r => {
let c = r.children(r.firstChild(r.root));
expect(stringifyUrl(c[0].urlSegments)).toEqual(["d"]);
expect(stringifyUrl(c[0].urlSegments)).toEqual(['d']);
expect(c[0].outlet).toEqual(DEFAULT_OUTLET_NAME);
expect(c[0].type).toBe(ComponentD);
expect(stringifyUrl(c[1].urlSegments)).toEqual(["e"]);
expect(c[1].outlet).toEqual("aux");
expect(stringifyUrl(c[1].urlSegments)).toEqual(['e']);
expect(c[1].outlet).toEqual('aux');
expect(c[1].type).toBe(ComponentE);
async.done();
});
}));
}));
it('should handle matrix parameters',
inject([AsyncTestCompleter, ComponentResolver], (async: AsyncTestCompleter, resolver: any /** TODO #9100 */) => {
recognize(resolver, ComponentA, tree("b/paramB;b1=1;b2=2(/d;d1=1;d2=2)"), emptyRouteTree)
.then(r => {
let c = r.children(r.root);
expect(c[0].parameters).toEqual({'b': 'paramB', 'b1': '1', 'b2': '2'});
expect(c[1].parameters).toEqual({'d1': '1', 'd2': '2'});
inject(
[AsyncTestCompleter, ComponentResolver],
(async: AsyncTestCompleter, resolver: any /** TODO #9100 */) => {
recognize(
resolver, ComponentA, tree('b/paramB;b1=1;b2=2(/d;d1=1;d2=2)'), emptyRouteTree)
.then(r => {
let c = r.children(r.root);
expect(c[0].parameters).toEqual({'b': 'paramB', 'b1': '1', 'b2': '2'});
expect(c[1].parameters).toEqual({'d1': '1', 'd2': '2'});
async.done();
});
}));
async.done();
});
}));
it('should match a wildcard',
inject([AsyncTestCompleter, ComponentResolver], (async: AsyncTestCompleter, resolver: any /** TODO #9100 */) => {
recognize(resolver, ComponentG, tree("a;aa=1/b;bb=2"), emptyRouteTree)
.then(r => {
inject(
[AsyncTestCompleter, ComponentResolver],
(async: AsyncTestCompleter, resolver: any /** TODO #9100 */) => {
recognize(resolver, ComponentG, tree('a;aa=1/b;bb=2'), emptyRouteTree).then(r => {
let c = r.children(r.root);
expect(c.length).toEqual(1);
expect(stringifyUrl(c[0].urlSegments)).toEqual([]);
@ -159,51 +161,54 @@ export function main() {
async.done();
});
}));
}));
it('should error when no matching routes',
inject([AsyncTestCompleter, ComponentResolver], (async: AsyncTestCompleter, resolver: any /** TODO #9100 */) => {
recognize(resolver, ComponentA, tree("invalid"), emptyRouteTree)
.catch(e => {
expect(e.message).toContain("Cannot match any routes");
inject(
[AsyncTestCompleter, ComponentResolver],
(async: AsyncTestCompleter, resolver: any /** TODO #9100 */) => {
recognize(resolver, ComponentA, tree('invalid'), emptyRouteTree).catch(e => {
expect(e.message).toContain('Cannot match any routes');
async.done();
});
}));
}));
it('should handle no matching routes (too short)',
inject([AsyncTestCompleter, ComponentResolver], (async: AsyncTestCompleter, resolver: any /** TODO #9100 */) => {
recognize(resolver, ComponentA, tree("b"), emptyRouteTree)
.catch(e => {
expect(e.message).toContain("Cannot match any routes");
inject(
[AsyncTestCompleter, ComponentResolver],
(async: AsyncTestCompleter, resolver: any /** TODO #9100 */) => {
recognize(resolver, ComponentA, tree('b'), emptyRouteTree).catch(e => {
expect(e.message).toContain('Cannot match any routes');
async.done();
});
}));
}));
it("should error when a component doesn't have @Routes",
inject([AsyncTestCompleter, ComponentResolver], (async: AsyncTestCompleter, resolver: any /** TODO #9100 */) => {
recognize(resolver, ComponentA, tree("d/invalid"), emptyRouteTree)
.catch(e => {
expect(e.message)
.toEqual("Component 'ComponentD' does not have route configuration");
it('should error when a component doesn\'t have @Routes',
inject(
[AsyncTestCompleter, ComponentResolver],
(async: AsyncTestCompleter, resolver: any /** TODO #9100 */) => {
recognize(resolver, ComponentA, tree('d/invalid'), emptyRouteTree).catch(e => {
expect(e.message).toEqual(
'Component \'ComponentD\' does not have route configuration');
async.done();
});
}));
}));
it("should reuse existing segments",
inject([AsyncTestCompleter, ComponentResolver], (async: AsyncTestCompleter, resolver: any /** TODO #9100 */) => {
recognize(resolver, ComponentA, tree("/b/1/d"), emptyRouteTree)
.then(t1 => {
recognize(resolver, ComponentA, tree("/b/1/e"), t1)
.then(t2 => {
expect(t1.root).toBe(t2.root);
expect(t1.firstChild(t1.root)).toBe(t2.firstChild(t2.root));
expect(t1.firstChild(t1.firstChild(t1.root)))
.not.toBe(t2.firstChild(t2.firstChild(t2.root)));
it('should reuse existing segments',
inject(
[AsyncTestCompleter, ComponentResolver],
(async: AsyncTestCompleter, resolver: any /** TODO #9100 */) => {
recognize(resolver, ComponentA, tree('/b/1/d'), emptyRouteTree).then(t1 => {
recognize(resolver, ComponentA, tree('/b/1/e'), t1).then(t2 => {
expect(t1.root).toBe(t2.root);
expect(t1.firstChild(t1.root)).toBe(t2.firstChild(t2.root));
expect(t1.firstChild(t1.firstChild(t1.root)))
.not.toBe(t2.firstChild(t2.firstChild(t2.root)));
async.done();
});
async.done();
});
});
}));
}));
});
}
@ -224,36 +229,33 @@ class ComponentE {
}
@Component({selector: 'f', template: 't'})
@Routes([new Route({path: "/", component: ComponentD})])
@Routes([new Route({path: '/', component: ComponentD})])
class ComponentF {
}
@Component({selector: 'c', template: 't'})
@Routes([new Route({path: "d", component: ComponentD})])
@Routes([new Route({path: 'd', component: ComponentD})])
class ComponentC {
}
@Component({selector: 'b', template: 't'})
@Routes([
new Route({path: "d", component: ComponentD}),
new Route({path: "e", component: ComponentE}),
new Route({path: "c/:c", component: ComponentC})
new Route({path: 'd', component: ComponentD}), new Route({path: 'e', component: ComponentE}),
new Route({path: 'c/:c', component: ComponentC})
])
class ComponentB {
}
@Component({selector: 'g', template: 't'})
@Routes(
[new Route({path: "d", component: ComponentD}), new Route({path: "*", component: ComponentE})])
[new Route({path: 'd', component: ComponentD}), new Route({path: '*', component: ComponentE})])
class ComponentG {
}
@Component({selector: 'a', template: 't'})
@Routes([
new Route({path: "b/:b", component: ComponentB}),
new Route({path: "d", component: ComponentD}),
new Route({path: "e", component: ComponentE}),
new Route({path: "f", component: ComponentF})
new Route({path: 'b/:b', component: ComponentB}), new Route({path: 'd', component: ComponentD}),
new Route({path: 'e', component: ComponentE}), new Route({path: 'f', component: ComponentF})
])
class ComponentA {
}

88
modules/@angular/router/test/router_link_spec.ts
View File

@ -1,61 +1,45 @@
import {
AsyncTestCompleter,
beforeEach,
ddescribe,
xdescribe,
describe,
expect,
iit,
inject,
beforeEachProviders,
it,
xit
} from '@angular/core/testing/testing_internal';
import {provide, Component, ComponentResolver} from '@angular/core';
import {RouterLink} from '../src/directives/router_link';
import {
Router,
RouterOutletMap,
RouteSegment,
Route,
ROUTER_DIRECTIVES,
Routes,
RouterUrlSerializer,
DefaultRouterUrlSerializer,
OnActivate,
CanDeactivate
} from '@angular/router';
import {Location, LocationStrategy} from '@angular/common';
import {SpyLocation, MockLocationStrategy} from '@angular/common/testing';
import {MockLocationStrategy, SpyLocation} from '@angular/common/testing';
import {Component, ComponentResolver, provide} from '@angular/core';
import {AsyncTestCompleter, beforeEach, beforeEachProviders, ddescribe, describe, expect, iit, inject, it, xdescribe, xit} from '@angular/core/testing/testing_internal';
import {CanDeactivate, DefaultRouterUrlSerializer, OnActivate, ROUTER_DIRECTIVES, Route, RouteSegment, Router, RouterOutletMap, RouterUrlSerializer, Routes} from '@angular/router';
import {RouterLink} from '../src/directives/router_link';
export function main() {
describe('RouterLink', () => {
beforeEachProviders(() => [
{provide: RouterUrlSerializer, useClass: DefaultRouterUrlSerializer},
RouterOutletMap,
{provide: Location, useClass: SpyLocation},
{provide: LocationStrategy, useClass: MockLocationStrategy},
{
provide: Router,
useFactory: (resolver: any /** TODO #9100 */, urlParser: any /** TODO #9100 */, outletMap: any /** TODO #9100 */, location: any /** TODO #9100 */) => new Router(
"RootComponent", RootCmp, resolver, urlParser, outletMap, location),
deps: [ComponentResolver, RouterUrlSerializer, RouterOutletMap, Location]
}
]);
beforeEachProviders(
() =>
[{provide: RouterUrlSerializer, useClass: DefaultRouterUrlSerializer}, RouterOutletMap,
{provide: Location, useClass: SpyLocation},
{provide: LocationStrategy, useClass: MockLocationStrategy}, {
provide: Router,
useFactory:
(resolver: any /** TODO #9100 */, urlParser: any /** TODO #9100 */,
outletMap: any /** TODO #9100 */, location: any /** TODO #9100 */) =>
new Router(
'RootComponent', RootCmp, resolver, urlParser, outletMap, location),
deps: [ComponentResolver, RouterUrlSerializer, RouterOutletMap, Location]
}]);
describe("routerLink=", () => {
it("should accept an array of commands", inject([Router, LocationStrategy], (router: any /** TODO #9100 */, locationStrategy: any /** TODO #9100 */) => {
let link = new RouterLink(null, router, locationStrategy);
link.routerLink = ['/one', 11];
expect(link.href).toEqual("/one/11");
}));
describe('routerLink=', () => {
it('should accept an array of commands',
inject(
[Router, LocationStrategy],
(router: any /** TODO #9100 */, locationStrategy: any /** TODO #9100 */) => {
let link = new RouterLink(null, router, locationStrategy);
link.routerLink = ['/one', 11];
expect(link.href).toEqual('/one/11');
}));
it("should accept a single command", inject([Router, LocationStrategy], (router: any /** TODO #9100 */, locationStrategy: any /** TODO #9100 */) => {
let link = new RouterLink(null, router, locationStrategy);
link.routerLink = '/one/11';
expect(link.href).toEqual("/one/11");
}));
it('should accept a single command',
inject(
[Router, LocationStrategy],
(router: any /** TODO #9100 */, locationStrategy: any /** TODO #9100 */) => {
let link = new RouterLink(null, router, locationStrategy);
link.routerLink = '/one/11';
expect(link.href).toEqual('/one/11');
}));
});
});
}

94
modules/@angular/router/test/router_url_serializer_spec.ts
View File

@ -1,16 +1,4 @@
import {
AsyncTestCompleter,
beforeEach,
ddescribe,
xdescribe,
describe,
expect,
iit,
inject,
beforeEachProviders,
it,
xit
} from '@angular/core/testing/testing_internal';
import {AsyncTestCompleter, beforeEach, beforeEachProviders, ddescribe, describe, expect, iit, inject, it, xdescribe, xit} from '@angular/core/testing/testing_internal';
import {DefaultRouterUrlSerializer} from '../src/router_url_serializer';
import {UrlSegment} from '../src/segments';
@ -20,81 +8,81 @@ export function main() {
let url = new DefaultRouterUrlSerializer();
it('should parse the root url', () => {
let tree = url.parse("/");
expectSegment(tree.root, "");
expect(url.serialize(tree)).toEqual("");
let tree = url.parse('/');
expectSegment(tree.root, '');
expect(url.serialize(tree)).toEqual('');
});
it('should parse non-empty urls', () => {
let tree = url.parse("one/two");
expectSegment(tree.firstChild(tree.root), "one");
expectSegment(tree.firstChild(tree.firstChild(tree.root)), "two");
expect(url.serialize(tree)).toEqual("/one/two");
let tree = url.parse('one/two');
expectSegment(tree.firstChild(tree.root), 'one');
expectSegment(tree.firstChild(tree.firstChild(tree.root)), 'two');
expect(url.serialize(tree)).toEqual('/one/two');
});
it("should parse multiple aux routes", () => {
let tree = url.parse("/one/two(/three//right:four)/five");
it('should parse multiple aux routes', () => {
let tree = url.parse('/one/two(/three//right:four)/five');
let c = tree.children(tree.firstChild(tree.root));
expectSegment(c[0], "two");
expectSegment(c[1], "aux:three");
expectSegment(c[2], "right:four");
expectSegment(c[0], 'two');
expectSegment(c[1], 'aux:three');
expectSegment(c[2], 'right:four');
expectSegment(tree.firstChild(c[0]), "five");
expectSegment(tree.firstChild(c[0]), 'five');
expect(url.serialize(tree)).toEqual("/one/two(aux:three//right:four)/five");
expect(url.serialize(tree)).toEqual('/one/two(aux:three//right:four)/five');
});
it("should parse aux routes that have aux routes", () => {
let tree = url.parse("/one(/two(/three))");
it('should parse aux routes that have aux routes', () => {
let tree = url.parse('/one(/two(/three))');
let c = tree.children(tree.root);
expectSegment(c[0], "one");
expectSegment(c[1], "aux:two");
expectSegment(c[2], "aux:three");
expectSegment(c[0], 'one');
expectSegment(c[1], 'aux:two');
expectSegment(c[2], 'aux:three');
expect(url.serialize(tree)).toEqual("/one(aux:two//aux:three)");
expect(url.serialize(tree)).toEqual('/one(aux:two//aux:three)');
});
it("should parse aux routes that have children", () => {
let tree = url.parse("/one(/two/three)");
it('should parse aux routes that have children', () => {
let tree = url.parse('/one(/two/three)');
let c = tree.children(tree.root);
expectSegment(c[0], "one");
expectSegment(c[1], "aux:two");
expectSegment(tree.firstChild(c[1]), "three");
expectSegment(c[0], 'one');
expectSegment(c[1], 'aux:two');
expectSegment(tree.firstChild(c[1]), 'three');
expect(url.serialize(tree)).toEqual("/one(aux:two/three)");
expect(url.serialize(tree)).toEqual('/one(aux:two/three)');
});
it("should parse an empty aux route definition", () => {
let tree = url.parse("/one()");
it('should parse an empty aux route definition', () => {
let tree = url.parse('/one()');
let c = tree.children(tree.root);
expectSegment(c[0], "one");
expectSegment(c[0], 'one');
expect(tree.children(c[0]).length).toEqual(0);
expect(url.serialize(tree)).toEqual("/one");
expect(url.serialize(tree)).toEqual('/one');
});
it("should parse key-value matrix params", () => {
let tree = url.parse("/one;a=11a;b=11b(/two;c=22//right:three;d=33)");
it('should parse key-value matrix params', () => {
let tree = url.parse('/one;a=11a;b=11b(/two;c=22//right:three;d=33)');
let c = tree.children(tree.root);
expectSegment(c[0], "one;a=11a;b=11b");
expectSegment(c[1], "aux:two;c=22");
expectSegment(c[2], "right:three;d=33");
expectSegment(c[0], 'one;a=11a;b=11b');
expectSegment(c[1], 'aux:two;c=22');
expectSegment(c[2], 'right:three;d=33');
expect(url.serialize(tree)).toEqual("/one;a=11a;b=11b(aux:two;c=22//right:three;d=33)");
expect(url.serialize(tree)).toEqual('/one;a=11a;b=11b(aux:two;c=22//right:three;d=33)');
});
it("should parse key only matrix params", () => {
let tree = url.parse("/one;a");
it('should parse key only matrix params', () => {
let tree = url.parse('/one;a');
let c = tree.firstChild(tree.root);
expectSegment(c, "one;a=true");
expectSegment(c, 'one;a=true');
expect(url.serialize(tree)).toEqual("/one;a=true");
expect(url.serialize(tree)).toEqual('/one;a=true');
});
});
}

28
modules/@angular/router/test/tree_spec.ts
View File

@ -1,51 +1,39 @@
import {
AsyncTestCompleter,
beforeEach,
ddescribe,
xdescribe,
describe,
expect,
iit,
inject,
beforeEachProviders,
it,
xit
} from '@angular/core/testing/testing_internal';
import {AsyncTestCompleter, beforeEach, beforeEachProviders, ddescribe, describe, expect, iit, inject, it, xdescribe, xit} from '@angular/core/testing/testing_internal';
import {Tree, TreeNode} from '../src/segments';
export function main() {
describe('tree', () => {
it("should return the root of the tree", () => {
it('should return the root of the tree', () => {
let t = new Tree<any>(new TreeNode<number>(1, []));
expect(t.root).toEqual(1);
});
it("should return the parent of a node", () => {
it('should return the parent of a node', () => {
let t = new Tree<any>(new TreeNode<number>(1, [new TreeNode<number>(2, [])]));
expect(t.parent(1)).toEqual(null);
expect(t.parent(2)).toEqual(1);
});
it("should return the children of a node", () => {
it('should return the children of a node', () => {
let t = new Tree<any>(new TreeNode<number>(1, [new TreeNode<number>(2, [])]));
expect(t.children(1)).toEqual([2]);
expect(t.children(2)).toEqual([]);
});
it("should return the first child of a node", () => {
it('should return the first child of a node', () => {
let t = new Tree<any>(new TreeNode<number>(1, [new TreeNode<number>(2, [])]));
expect(t.firstChild(1)).toEqual(2);
expect(t.firstChild(2)).toEqual(null);
});
it("should return the path to the root", () => {
it('should return the path to the root', () => {
let t = new Tree<any>(new TreeNode<number>(1, [new TreeNode<number>(2, [])]));
expect(t.pathFromRoot(2)).toEqual([1, 2]);
});
describe("contains", () => {
it("should work", () => {
describe('contains', () => {
it('should work', () => {
let tree = new Tree<any>(
new TreeNode<number>(1, [new TreeNode<number>(2, []), new TreeNode<number>(3, [])]));
let subtree1 = new Tree<any>(new TreeNode<number>(1, []));