6ddfff5cd5
This is a big change. @matsko also deserves much of the credit for the implementation.
Previously, `ComponentInstruction`s held all the state for async components.
Now, we introduce several subclasses for `Instruction` to describe each type of navigation.
BREAKING CHANGE:
Redirects now use the Link DSL syntax. Before:
```
@RouteConfig([
{ path: '/foo', redirectTo: '/bar' },
{ path: '/bar', component: BarCmp }
])
```
After:
```
@RouteConfig([
{ path: '/foo', redirectTo: ['Bar'] },
{ path: '/bar', component: BarCmp, name: 'Bar' }
])
```
BREAKING CHANGE:
This also introduces `useAsDefault` in the RouteConfig, which makes cases like lazy-loading
and encapsulating large routes with sub-routes easier.
Previously, you could use `redirectTo` like this to expand a URL like `/tab` to `/tab/posts`:
@RouteConfig([
{ path: '/tab', redirectTo: '/tab/users' }
{ path: '/tab', component: TabsCmp, name: 'Tab' }
])
AppCmp { ... }
Now the recommended way to handle this is case is to use `useAsDefault` like so:
```
@RouteConfig([
{ path: '/tab', component: TabsCmp, name: 'Tab' }
])
AppCmp { ... }
@RouteConfig([
{ path: '/posts', component: PostsCmp, useAsDefault: true, name: 'Posts' },
{ path: '/users', component: UsersCmp, name: 'Users' }
])
TabsCmp { ... }
```
In the above example, you can write just `['/Tab']` and the route `Users` is automatically selected as a child route.
Closes #4728
Closes #4228
Closes #4170
Closes #4490
Closes #4694
Closes #5200
Closes #5475
95 lines
3.8 KiB
TypeScript
95 lines
3.8 KiB
TypeScript
import {
|
|
AsyncTestCompleter,
|
|
describe,
|
|
it,
|
|
iit,
|
|
ddescribe,
|
|
expect,
|
|
inject,
|
|
beforeEach,
|
|
SpyObject
|
|
} from 'angular2/testing_internal';
|
|
|
|
import {PathRecognizer} from 'angular2/src/router/path_recognizer';
|
|
import {parser, Url, RootUrl} from 'angular2/src/router/url_parser';
|
|
|
|
export function main() {
|
|
describe('PathRecognizer', () => {
|
|
|
|
it('should throw when given an invalid path', () => {
|
|
expect(() => new PathRecognizer('/hi#'))
|
|
.toThrowError(`Path "/hi#" should not include "#". Use "HashLocationStrategy" instead.`);
|
|
expect(() => new PathRecognizer('hi?'))
|
|
.toThrowError(`Path "hi?" contains "?" which is not allowed in a route config.`);
|
|
expect(() => new PathRecognizer('hi;'))
|
|
.toThrowError(`Path "hi;" contains ";" which is not allowed in a route config.`);
|
|
expect(() => new PathRecognizer('hi='))
|
|
.toThrowError(`Path "hi=" contains "=" which is not allowed in a route config.`);
|
|
expect(() => new PathRecognizer('hi('))
|
|
.toThrowError(`Path "hi(" contains "(" which is not allowed in a route config.`);
|
|
expect(() => new PathRecognizer('hi)'))
|
|
.toThrowError(`Path "hi)" contains ")" which is not allowed in a route config.`);
|
|
expect(() => new PathRecognizer('hi//there'))
|
|
.toThrowError(`Path "hi//there" contains "//" which is not allowed in a route config.`);
|
|
});
|
|
|
|
describe('querystring params', () => {
|
|
it('should parse querystring params so long as the recognizer is a root', () => {
|
|
var rec = new PathRecognizer('/hello/there');
|
|
var url = parser.parse('/hello/there?name=igor');
|
|
var match = rec.recognize(url);
|
|
expect(match['allParams']).toEqual({'name': 'igor'});
|
|
});
|
|
|
|
it('should return a combined map of parameters with the param expected in the URL path',
|
|
() => {
|
|
var rec = new PathRecognizer('/hello/:name');
|
|
var url = parser.parse('/hello/paul?topic=success');
|
|
var match = rec.recognize(url);
|
|
expect(match['allParams']).toEqual({'name': 'paul', 'topic': 'success'});
|
|
});
|
|
});
|
|
|
|
describe('matrix params', () => {
|
|
it('should be parsed along with dynamic paths', () => {
|
|
var rec = new PathRecognizer('/hello/:id');
|
|
var url = new Url('hello', new Url('matias', null, null, {'key': 'value'}));
|
|
var match = rec.recognize(url);
|
|
expect(match['allParams']).toEqual({'id': 'matias', 'key': 'value'});
|
|
});
|
|
|
|
it('should be parsed on a static path', () => {
|
|
var rec = new PathRecognizer('/person');
|
|
var url = new Url('person', null, null, {'name': 'dave'});
|
|
var match = rec.recognize(url);
|
|
expect(match['allParams']).toEqual({'name': 'dave'});
|
|
});
|
|
|
|
it('should be ignored on a wildcard segment', () => {
|
|
var rec = new PathRecognizer('/wild/*everything');
|
|
var url = parser.parse('/wild/super;variable=value');
|
|
var match = rec.recognize(url);
|
|
expect(match['allParams']).toEqual({'everything': 'super;variable=value'});
|
|
});
|
|
|
|
it('should set matrix param values to true when no value is present', () => {
|
|
var rec = new PathRecognizer('/path');
|
|
var url = new Url('path', null, null, {'one': true, 'two': true, 'three': '3'});
|
|
var match = rec.recognize(url);
|
|
expect(match['allParams']).toEqual({'one': true, 'two': true, 'three': '3'});
|
|
});
|
|
|
|
it('should be parsed on the final segment of the path', () => {
|
|
var rec = new PathRecognizer('/one/two/three');
|
|
|
|
var three = new Url('three', null, null, {'c': '3'});
|
|
var two = new Url('two', three, null, {'b': '2'});
|
|
var one = new Url('one', two, null, {'a': '1'});
|
|
|
|
var match = rec.recognize(one);
|
|
expect(match['allParams']).toEqual({'c': '3'});
|
|
});
|
|
});
|
|
});
|
|
}
|