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

feat(router): change recognize to return a router state candidate

Browse Source
This commit is contained in:
vsavkin
2016-06-01 13:29:52 -07:00
parent 46911117f1
commit 63c194b71f
2 changed files with 81 additions and 120 deletions
Download Patch File Download Diff File Expand all files Collapse all files

120
modules/@angular/router/test/recognize.spec.ts
View File

@ -1,18 +1,16 @@
import {DefaultUrlSerializer} from '../src/url_serializer';
import {UrlTree} from '../src/url_tree';
import {Params, PRIMARY_OUTLET} from '../src/shared';
import {createEmptyState, ActivatedRoute} from '../src/router_state';
import {ActivatedRouteCandidate} from '../src/router_state';
import {recognize} from '../src/recognize';
describe('recognize', () => {
const empty = () => createEmptyState(RootComponent);
it('should work', (done) => {
recognize([
recognize(RootComponent, [
{
path: 'a', component: ComponentA
}
], tree("a"), empty()).forEach(s => {
], tree("a")).forEach(s => {
checkActivatedRoute(s.root, "", {}, RootComponent);
checkActivatedRoute(s.firstChild(s.root), "a", {}, ComponentA);
done();
@ -20,40 +18,25 @@ describe('recognize', () => {
});
it('should handle position args', () => {
recognize([
recognize(RootComponent, [
{
path: 'a/:id', component: ComponentA, children: [
{ path: 'b/:id', component: ComponentB}
]
}
], tree("a/paramA/b/paramB"), empty()).forEach(s => {
], tree("a/paramA/b/paramB")).forEach(s => {
checkActivatedRoute(s.root, "", {}, RootComponent);
checkActivatedRoute(s.firstChild(s.root), "a/paramA", {id: 'paramA'}, ComponentA);
checkActivatedRoute(s.firstChild(<any>s.firstChild(s.root)), "b/paramB", {id: 'paramB'}, ComponentB);
});
});
it('should reuse activated routes', () => {
const config = [{path: 'a/:id', component: ComponentA}];
recognize(config, tree("a/paramA"), empty()).forEach(s => {
const n1 = s.firstChild(s.root);
const recorded = [];
n1!.params.forEach(r => recorded.push(r));
recognize(config, tree("a/paramB"), s).forEach(s2 => {
const n2 = s2.firstChild(s2.root);
expect(n1).toBe(n2);
expect(recorded).toEqual([{id: 'paramA'}, {id: 'paramB'}]);
});
});
});
it('should support secondary routes', () => {
recognize([
recognize(RootComponent, [
{ path: 'a', component: ComponentA },
{ path: 'b', component: ComponentB, outlet: 'left' },
{ path: 'c', component: ComponentC, outlet: 'right' }
], tree("a(left:b//right:c)"), empty()).forEach(s => {
], tree("a(left:b//right:c)")).forEach(s => {
const c = s.children(s.root);
checkActivatedRoute(c[0], "a", {}, ComponentA);
checkActivatedRoute(c[1], "b", {}, ComponentB, 'left');
@ -62,11 +45,11 @@ describe('recognize', () => {
});
it('should use outlet name when matching secondary routes', () => {
recognize([
recognize(RootComponent, [
{ path: 'a', component: ComponentA },
{ path: 'b', component: ComponentB, outlet: 'left' },
{ path: 'b', component: ComponentC, outlet: 'right' }
], tree("a(right:b)"), empty()).forEach(s => {
], tree("a(right:b)")).forEach(s => {
const c = s.children(s.root);
checkActivatedRoute(c[0], "a", {}, ComponentA);
checkActivatedRoute(c[1], "b", {}, ComponentC, 'right');
@ -74,11 +57,11 @@ describe('recognize', () => {
});
it('should handle nested secondary routes', () => {
recognize([
recognize(RootComponent, [
{ path: 'a', component: ComponentA },
{ path: 'b', component: ComponentB, outlet: 'left' },
{ path: 'c', component: ComponentC, outlet: 'right' }
], tree("a(left:b(right:c))"), empty()).forEach(s => {
], tree("a(left:b(right:c))")).forEach(s => {
const c = s.children(s.root);
checkActivatedRoute(c[0], "a", {}, ComponentA);
checkActivatedRoute(c[1], "b", {}, ComponentB, 'left');
@ -87,27 +70,40 @@ describe('recognize', () => {
});
it('should handle non top-level secondary routes', () => {
recognize([
recognize(RootComponent, [
{ path: 'a', component: ComponentA, children: [
{ path: 'b', component: ComponentB },
{ path: 'c', component: ComponentC, outlet: 'left' }
] },
], tree("a/b(left:c))"), empty()).forEach(s => {
], tree("a/b(left:c))")).forEach(s => {
const c = s.children(<any>s.firstChild(s.root));
checkActivatedRoute(c[0], "b", {}, ComponentB, PRIMARY_OUTLET);
checkActivatedRoute(c[1], "c", {}, ComponentC, 'left');
});
});
it('should sort routes by outlet name', () => {
recognize(RootComponent, [
{ path: 'a', component: ComponentA },
{ path: 'c', component: ComponentC, outlet: 'c' },
{ path: 'b', component: ComponentB, outlet: 'b' }
], tree("a(c:c//b:b)")).forEach(s => {
const c = s.children(s.root);
checkActivatedRoute(c[0], "a", {}, ComponentA);
checkActivatedRoute(c[1], "b", {}, ComponentB, 'b');
checkActivatedRoute(c[2], "c", {}, ComponentC, 'c');
});
});
it('should support matrix parameters', () => {
recognize([
recognize(RootComponent, [
{
path: 'a', component: ComponentA, children: [
{ path: 'b', component: ComponentB },
{ path: 'c', component: ComponentC, outlet: 'left' }
]
}
], tree("a;a1=11;a2=22/b;b1=111;b2=222(left:c;c1=1111;c2=2222)"), empty()).forEach(s => {
], tree("a;a1=11;a2=22/b;b1=111;b2=222(left:c;c1=1111;c2=2222)")).forEach(s => {
checkActivatedRoute(s.firstChild(s.root), "a", {a1: '11', a2: '22'}, ComponentA);
const c = s.children(<any>s.firstChild(s.root));
checkActivatedRoute(c[0], "b", {b1: '111', b2: '222'}, ComponentB);
@ -117,15 +113,15 @@ describe('recognize', () => {
describe("index", () => {
it("should support index routes", () => {
recognize([
recognize(RootComponent, [
{index: true, component: ComponentA}
], tree(""), empty()).forEach(s => {
], tree("")).forEach(s => {
checkActivatedRoute(s.firstChild(s.root), "a", {}, ComponentA);
});
});
it("should support index routes with children", () => {
recognize([
recognize(RootComponent, [
{
index: true, component: ComponentA, children: [
{ index: true, component: ComponentB, children: [
@ -134,7 +130,7 @@ describe('recognize', () => {
}
]
}
], tree("c/10"), empty()).forEach(s => {
], tree("c/10")).forEach(s => {
checkActivatedRoute(s.firstChild(s.root), "", {}, ComponentA);
checkActivatedRoute(s.firstChild(<any>s.firstChild(s.root)), "", {}, ComponentB);
checkActivatedRoute(
@ -145,9 +141,9 @@ describe('recognize', () => {
describe("wildcards", () => {
it("should support simple wildcards", () => {
recognize([
recognize(RootComponent, [
{path: '**', component: ComponentA}
], tree("a/b/c/d;a1=11"), empty()).forEach(s => {
], tree("a/b/c/d;a1=11")).forEach(s => {
checkActivatedRoute(s.firstChild(s.root), "a/b/c/d", {a1:'11'}, ComponentA);
});
});
@ -156,16 +152,8 @@ describe('recognize', () => {
describe("query parameters", () => {
it("should support query params", () => {
const config = [{path: 'a', component: ComponentA}];
recognize(config, tree("a?q=11"), empty()).forEach(s => {
const q1 = s.queryParams;
const recorded = [];
q1!.forEach(r => recorded.push(r));
recognize(config, tree("a?q=22"), s).forEach(s2 => {
const q2 = s2.queryParams;
expect(q1).toBe(q2);
expect(recorded).toEqual([{q: '11'}, {q: '22'}]);
});
recognize(RootComponent, config, tree("a?q=11")).forEach(s => {
expect(s.queryParams).toEqual({q: '11'});
});
});
});
@ -173,62 +161,48 @@ describe('recognize', () => {
describe("fragment", () => {
it("should support fragment", () => {
const config = [{path: 'a', component: ComponentA}];
recognize(config, tree("a#f1"), empty()).forEach(s => {
const f1 = s.fragment;
const recorded = [];
f1!.forEach(r => recorded.push(r));
recognize(config, tree("a#f2"), s).forEach(s2 => {
const f2 = s2.fragment;
expect(f1).toBe(f2);
expect(recorded).toEqual(["f1", "f2"]);
});
recognize(RootComponent, config, tree("a#f1")).forEach(s => {
expect(s.fragment).toEqual("f1");
});
});
});
describe("error handling", () => {
it('should error when two routes with the same outlet name got matched', () => {
recognize([
recognize(RootComponent, [
{ path: 'a', component: ComponentA },
{ path: 'b', component: ComponentB, outlet: 'aux' },
{ path: 'c', component: ComponentC, outlet: 'aux' }
], tree("a(aux:b//aux:c)"), empty()).subscribe(null, s => {
], tree("a(aux:b//aux:c)")).subscribe(null, s => {
expect(s.toString()).toContain("Two segments cannot have the same outlet name: 'aux:b' and 'aux:c'.");
});
});
it("should error when no matching routes", () => {
recognize([
recognize(RootComponent, [
{ path: 'a', component: ComponentA }
], tree("invalid"), empty()).subscribe(null, s => {
], tree("invalid")).subscribe(null, s => {
expect(s.toString()).toContain("Cannot match any routes");
});
});
it("should error when no matching routes (too short)", () => {
recognize([
recognize(RootComponent, [
{ path: 'a/:id', component: ComponentA }
], tree("a"), empty()).subscribe(null, s => {
], tree("a")).subscribe(null, s => {
expect(s.toString()).toContain("Cannot match any routes");
});
});
});
});
function checkActivatedRoute(actual: ActivatedRoute | null, url: string, params: Params, cmp: Function, outlet: string = PRIMARY_OUTLET):void {
function checkActivatedRoute(actual: ActivatedRouteCandidate | null, url: string, params: Params, cmp: Function, outlet: string = PRIMARY_OUTLET):void {
if (actual === null) {
expect(actual).toBeDefined();
} else {
let actualUrl;
actual.urlSegments.forEach(segments => actualUrl = segments.map(s => s.path).join("/"));
expect(actualUrl).toEqual(url);
let actualParams;
actual.params.forEach(s => actualParams = s);
expect(actualParams).toEqual(params);
expect(actual.urlSegments.map(s => s.path).join("/")).toEqual(url);
expect(actual.params).toEqual(params);
expect(actual.component).toBe(cmp);
expect(actual.outlet).toEqual(outlet);
}
}