fix(facade): Make PromiseWrapper#all semantics equivalent

The semantics between ES6 `Promise#all` and Dart's `Future#wait` are different for values that are not `Promise`/`Future`s. In ES6, non-`Promise` values are immediately completed to their current value. In Dart, non-`Future` values cause an error. Updated Dart's `PromiseWrapper#all` implementation to conform to the ES6 spec.

Author: Tim Blasi

modules/angular2/src/facade/async.dart

@@ -9,9 +9,12 @@ class PromiseWrapper {
  static Future reject(obj, stackTrace) => new Future.error(obj,
  stackTrace != null ? stackTrace : obj is Error ? obj.stackTrace : null);
 
- static Future<List> all(List<Future> promises) => Future.wait(promises);
+ static Future<List> all(List<dynamic> promises) {
+ return Future
+ .wait(promises.map((p) => p is Future ? p : new Future.value(p)));
+ }
 
- static Future then(Future promise, success(value), Function onError) {
+ static Future then(Future promise, success(value), [Function onError]) {
  if (success == null) return promise.catchError(onError);
  return promise.then(success, onError: onError);
  }

modules/angular2/src/facade/async.ts

@@ -18,13 +18,13 @@ export class PromiseWrapper {
  return promise.catch(onError);
  }
 
- static all(promises: List<Promise<any>>): Promise<any> {
+ static all(promises: List<any>): Promise<any> {
  if (promises.length == 0) return Promise.resolve([]);
  return Promise.all(promises);
  }
 
  static then<T>(promise: Promise<T>, success: (value: any) => T | Thenable<T>,
- rejection: (error: any, stack?: any) => T | Thenable<T>): Promise<T> {
+ rejection?: (error: any, stack?: any) => T | Thenable<T>): Promise<T> {
  return promise.then(success, rejection);
  }
 

modules/angular2/test/facade/async_spec.ts

@@ -14,6 +14,7 @@ import {
 } from 'angular2/test_lib';
 
 import {ObservableWrapper, EventEmitter, PromiseWrapper} from 'angular2/src/facade/async';
+import {ListWrapper} from 'angular2/src/facade/collection';
 
 export function main() {
  describe('EventEmitter', () => {
@@ -62,4 +63,45 @@ export function main() {
  // should call dispose on the subscription on throw
  // should call dispose on the subscription on return
  });
-}
+
+ // See ECMAScript 6 Spec 25.4.4.1
+ describe("PromiseWrapper", () => {
+ describe("#all", () => {
+ it("should combine lists of Promises", inject([AsyncTestCompleter], (async) => {
+ var one = PromiseWrapper.completer();
+ var two = PromiseWrapper.completer();
+
+ var all = PromiseWrapper.all([one.promise, two.promise]);
+ var allCalled = false;
+
+ PromiseWrapper.then(one.promise, (_) => {
+ expect(allCalled).toBe(false);
+ two.resolve('two');
+ });
+
+ PromiseWrapper.then(all, (_) => {
+ allCalled = true;
+ async.done();
+ });
+
+ one.resolve('one');
+ }));
+
+ ListWrapper.forEach([null, true, false, 10, 'thing', {}, []], (abruptCompletion) => {
+ it(`should treat "${abruptCompletion}" as an "abrupt completion"`,
+ inject([AsyncTestCompleter], (async) => {
+ var one = PromiseWrapper.completer();
+
+ var all = PromiseWrapper.all([one.promise, abruptCompletion]);
+
+ PromiseWrapper.then(all, (val) => {
+ expect(val[1]).toEqual(abruptCompletion);
+ async.done();
+ });
+
+ one.resolve('one');
+ }));
+ });
+ });
+ });
+}