angular-cn/modules/angular2/test/di/async_spec.ts

177 lines
6.2 KiB
TypeScript
Raw Normal View History

2015-05-22 18:39:28 -04:00
import {
AsyncTestCompleter,
beforeEach,
ddescribe,
describe,
expect,
iit,
inject,
it,
xit,
} from 'angular2/test_lib';
import {Injector, bind, Key} from 'angular2/di';
import {Inject, InjectPromise, Injectable} from 'angular2/src/di/decorators';
import {Promise, PromiseWrapper} from 'angular2/src/facade/async';
import {stringify} from 'angular2/src/facade/lang';
class UserList {}
function fetchUsers() {
return PromiseWrapper.resolve(new UserList());
}
class SynchronousUserList {}
@Injectable()
class UserController {
list: UserList;
constructor(list: UserList) { this.list = list; }
}
@Injectable()
class AsyncUserController {
userList;
constructor(@InjectPromise(UserList) userList) { this.userList = userList; }
}
export function main() {
describe("async injection", function() {
describe("asyncGet", function() {
it('should return a promise', function() {
var injector = Injector.resolveAndCreate([bind(UserList).toAsyncFactory(fetchUsers)]);
var p = injector.asyncGet(UserList);
expect(p).toBePromise();
});
it('should return a promise when the binding is sync', function() {
var injector = Injector.resolveAndCreate([SynchronousUserList]);
var p = injector.asyncGet(SynchronousUserList);
expect(p).toBePromise();
});
it("should return a promise when the binding is sync (from cache)", function() {
var injector = Injector.resolveAndCreate([UserList]);
expect(injector.get(UserList)).toBeAnInstanceOf(UserList);
expect(injector.asyncGet(UserList)).toBePromise();
});
it('should return the injector', inject([AsyncTestCompleter], (async) => {
var injector = Injector.resolveAndCreate([]);
var p = injector.asyncGet(Injector);
p.then(function(injector) {
expect(injector).toBe(injector);
async.done();
});
}));
it('should return a promise when instantiating a sync binding ' +
'with an async dependency',
inject([AsyncTestCompleter], (async) => {
var injector = Injector.resolveAndCreate(
[bind(UserList).toAsyncFactory(fetchUsers), UserController]);
2015-05-22 18:39:28 -04:00
injector.asyncGet(UserController)
.then(function(userController) {
expect(userController).toBeAnInstanceOf(UserController);
expect(userController.list).toBeAnInstanceOf(UserList);
async.done();
});
}));
it("should create only one instance (async + async)",
inject([AsyncTestCompleter], (async) => {
var injector = Injector.resolveAndCreate([bind(UserList).toAsyncFactory(fetchUsers)]);
var ul1 = injector.asyncGet(UserList);
var ul2 = injector.asyncGet(UserList);
PromiseWrapper.all([ul1, ul2])
.then(function(uls) {
expect(uls[0]).toBe(uls[1]);
async.done();
});
}));
it("should create only one instance (sync + async)", inject([AsyncTestCompleter], (async) => {
var injector = Injector.resolveAndCreate([UserList]);
var promise = injector.asyncGet(UserList);
var ul = injector.get(UserList);
expect(promise).toBePromise();
expect(ul).toBeAnInstanceOf(UserList);
promise.then(function(ful) {
expect(ful).toBe(ul);
async.done();
});
}));
it('should show the full path when error happens in a constructor',
inject([AsyncTestCompleter], (async) => {
var injector = Injector.resolveAndCreate([
UserController,
bind(UserList).toAsyncFactory(function() { throw "Broken UserList"; })
]);
var promise = injector.asyncGet(UserController);
PromiseWrapper.then(promise, null, function(e) {
expect(e.message).toContain(
`Error during instantiation of UserList! (${stringify(UserController)} -> UserList)`);
async.done();
});
}));
});
describe("get", function() {
it('should throw when instantiating an async binding', function() {
var injector = Injector.resolveAndCreate([bind(UserList).toAsyncFactory(fetchUsers)]);
expect(() => injector.get(UserList))
.toThrowError(
'Cannot instantiate UserList synchronously. It is provided as a promise!');
});
it('should throw when instantiating a sync binding with an async dependency', function() {
var injector =
Injector.resolveAndCreate([bind(UserList).toAsyncFactory(fetchUsers), UserController]);
expect(() => injector.get(UserController))
.toThrowError(new RegExp(
'Cannot instantiate UserList synchronously. It is provided as a promise!'));
});
it('should not throw when instantiating a sync binding with a resolved async dependency',
inject([AsyncTestCompleter], (async) => {
var injector = Injector.resolveAndCreate(
[bind(UserList).toAsyncFactory(fetchUsers), UserController]);
2015-05-22 18:39:28 -04:00
injector.asyncGet(UserList).then((_) => {
expect(() => { injector.get(UserController); }).not.toThrow();
async.done();
});
}));
it('should resolve synchronously when an async dependency requested as a promise',
function() {
var injector = Injector.resolveAndCreate(
[bind(UserList).toAsyncFactory(fetchUsers), AsyncUserController]);
var controller = injector.get(AsyncUserController);
expect(controller).toBeAnInstanceOf(AsyncUserController);
expect(controller.userList).toBePromise();
});
it('should wrap sync dependencies into promises if required', function() {
var injector = Injector.resolveAndCreate(
[bind(UserList).toFactory(() => new UserList()), AsyncUserController]);
var controller = injector.get(AsyncUserController);
expect(controller).toBeAnInstanceOf(AsyncUserController);
expect(controller.userList).toBePromise();
});
});
});
}