chore(di): moved tests to typescript

modules/angular2/test/di/async_spec.ts

@@ -0,0 +1,178 @@
+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]);
+
+           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]);
+
+           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();
+      });
+    });
+  });
+}