angular-cn/packages/zone.js/test/common/Promise.spec.ts

/**
 * @license
 * Copyright Google LLC All Rights Reserved.
 *
 * Use of this source code is governed by an MIT-style license that can be
 * found in the LICENSE file at https://angular.io/license
 */

import {isNode, zoneSymbol} from '../../lib/common/utils';
import {ifEnvSupports} from '../test-util';

declare const global: any;

class MicroTaskQueueZoneSpec implements ZoneSpec {
  name: string = 'MicroTaskQueue';
  queue: MicroTask[] = [];
  properties = {queue: this.queue, flush: this.flush.bind(this)};

  flush() {
    while (this.queue.length) {
      const task = this.queue.shift();
      task!.invoke();
    }
  }

  onScheduleTask(delegate: ZoneDelegate, currentZone: Zone, targetZone: Zone, task: Task): any {
    this.queue.push(task as MicroTask);
  }
}

function flushMicrotasks() {
  Zone.current.get('flush')();
}

class TestRejection {
  prop1?: string;
  prop2?: string;
}

describe(
    'Promise', ifEnvSupports('Promise', function() {
      if (!global.Promise) return;
      let log: string[];
      let queueZone: Zone;
      let testZone: Zone;
      let pZone: Zone;

      beforeEach(() => {
        testZone = Zone.current.fork({name: 'TestZone'});

        pZone = Zone.current.fork({
          name: 'promise-zone',
          onScheduleTask:
              (parentZoneDelegate: ZoneDelegate, currentZone: Zone, targetZone: Zone, task: Task):
                  any => {
                    log.push('scheduleTask');
                    parentZoneDelegate.scheduleTask(targetZone, task);
                  }
        });

        queueZone = Zone.current.fork(new MicroTaskQueueZoneSpec());

        log = [];
      });

      xit('should allow set es6 Promise after load ZoneAwarePromise', (done) => {
        const ES6Promise = require('es6-promise').Promise;
        const NativePromise = global[zoneSymbol('Promise')];

        try {
          global['Promise'] = ES6Promise;
          Zone.assertZonePatched();
          expect(global[zoneSymbol('Promise')]).toBe(ES6Promise);
          const promise = Promise.resolve(0);
          console.log('promise', promise);
          promise
              .then(value => {
                expect(value).toBe(0);
                done();
              })
              .catch(error => {
                fail(error);
              });
        } finally {
          global['Promise'] = NativePromise;
          Zone.assertZonePatched();
          expect(global[zoneSymbol('Promise')]).toBe(NativePromise);
        }
      });

      it('should pretend to be a native code', () => {
        expect(String(Promise).indexOf('[native code]') >= 0).toBe(true);
      });

      it('should use native toString for promise instance', () => {
        expect(Object.prototype.toString.call(Promise.resolve())).toEqual('[object Promise]');
      });

      it('should make sure that new Promise is instance of Promise', () => {
        expect(Promise.resolve(123) instanceof Promise).toBe(true);
        expect(new Promise(() => null) instanceof Promise).toBe(true);
      });

      xit('should ensure that Promise this is instanceof Promise', () => {
        expect(() => {
          Promise.call({} as any, () => null);
        }).toThrowError('Must be an instanceof Promise.');
      });

      it('should allow subclassing without Symbol.species', () => {
        class MyPromise extends Promise<any> {
          constructor(fn: any) {
            super(fn);
          }
        }
        expect(new MyPromise(() => {}).then(() => null) instanceof MyPromise).toBe(true);
      });

      it('should allow subclassing with Symbol.species', () => {
        class MyPromise extends Promise<any> {
          constructor(fn: any) {
            super(fn);
          }

          static get[Symbol.species]() {
            return MyPromise;
          }
        }
        expect(new MyPromise(() => {}).then(() => null) instanceof MyPromise).toBe(true);
      });

      it('Symbol.species should return ZoneAwarePromise', () => {
        const empty = function() {};
        const promise = Promise.resolve(1);
        const FakePromise =
            ((promise.constructor = {} as any) as any)[Symbol.species] = function(exec: any) {
              exec(empty, empty);
            };
        expect(promise.then(empty) instanceof FakePromise).toBe(true);
      });

      it('should intercept scheduling of resolution and then', (done) => {
        pZone.run(() => {
          let p: Promise<any> = new Promise(function(resolve, reject) {
            expect(resolve('RValue')).toBe(undefined);
          });
          expect(log).toEqual([]);
          expect(p instanceof Promise).toBe(true);
          p = p.then((v) => {
            log.push(v);
            expect(v).toBe('RValue');
            expect(log).toEqual(['scheduleTask', 'RValue']);
            return 'second value';
          });
          expect(p instanceof Promise).toBe(true);
          expect(log).toEqual(['scheduleTask']);
          p = p.then((v) => {
            log.push(v);
            expect(log).toEqual(['scheduleTask', 'RValue', 'scheduleTask', 'second value']);
            done();
          });
          expect(p instanceof Promise).toBe(true);
          expect(log).toEqual(['scheduleTask']);
        });
      });

      it('should allow sync resolution of promises', () => {
        queueZone.run(() => {
          const flush = Zone.current.get('flush');
          const queue = Zone.current.get('queue');
          const p = new Promise<string>(function(resolve, reject) {
                      resolve('RValue');
                    })
                        .then((v: string) => {
                          log.push(v);
                          return 'second value';
                        })
                        .then((v: string) => {
                          log.push(v);
                        });
          expect(queue.length).toEqual(1);
          expect(log).toEqual([]);
          flush();
          expect(log).toEqual(['RValue', 'second value']);
        });
      });

      it('should allow sync resolution of promises returning promises', () => {
        queueZone.run(() => {
          const flush = Zone.current.get('flush');
          const queue = Zone.current.get('queue');
          const p = new Promise<string>(function(resolve, reject) {
                      resolve(Promise.resolve('RValue'));
                    })
                        .then((v: string) => {
                          log.push(v);
                          return Promise.resolve('second value');
                        })
                        .then((v: string) => {
                          log.push(v);
                        });
          expect(queue.length).toEqual(1);
          expect(log).toEqual([]);
          flush();
          expect(log).toEqual(['RValue', 'second value']);
        });
      });

      describe('Promise API', function() {
        it('should work with .then', function(done) {
          let resolve: Function|null = null;

          testZone.run(function() {
            new Promise(function(resolveFn) {
              resolve = resolveFn;
            }).then(function() {
              expect(Zone.current).toBe(testZone);
              done();
            });
          });

          resolve!();
        });

        it('should work with .catch', function(done) {
          let reject: (() => void)|null = null;

          testZone.run(function() {
            new Promise(function(resolveFn, rejectFn) {
              reject = rejectFn;
            })['catch'](function() {
              expect(Zone.current).toBe(testZone);
              done();
            });
          });


          expect(reject!()).toBe(undefined);
        });

        it('should work with .finally with resolved promise', function(done) {
          let resolve: Function|null = null;

          testZone.run(function() {
            (new Promise(function(resolveFn) {
               resolve = resolveFn;
             }) as any)
                .finally(function() {
                  expect(arguments.length).toBe(0);
                  expect(Zone.current).toBe(testZone);
                  done();
                });
          });

          resolve!('value');
        });

        it('should work with .finally with rejected promise', function(done) {
          let reject: Function|null = null;

          testZone.run(function() {
            (new Promise(function(_, rejectFn) {
               reject = rejectFn;
             }) as any)
                .finally(function() {
                  expect(arguments.length).toBe(0);
                  expect(Zone.current).toBe(testZone);
                  done();
                });
          });

          reject!('error');
        });

        it('should work with Promise.resolve', () => {
          queueZone.run(() => {
            let value: any = null;
            Promise.resolve('resolveValue').then((v) => value = v);
            expect(Zone.current.get('queue').length).toEqual(1);
            flushMicrotasks();
            expect(value).toEqual('resolveValue');
          });
        });

        it('should work with Promise.reject', () => {
          queueZone.run(() => {
            let value: any = null;
            Promise.reject('rejectReason')['catch']((v) => value = v);
            expect(Zone.current.get('queue').length).toEqual(1);
            flushMicrotasks();
            expect(value).toEqual('rejectReason');
          });
        });

        describe('reject', () => {
          it('should reject promise', () => {
            queueZone.run(() => {
              let value: any = null;
              Promise.reject('rejectReason')['catch']((v) => value = v);
              flushMicrotasks();
              expect(value).toEqual('rejectReason');
            });
          });

          it('should re-reject promise', () => {
            queueZone.run(() => {
              let value: any = null;
              Promise.reject('rejectReason')['catch']((v) => {
                throw v;
              })['catch']((v) => value = v);
              flushMicrotasks();
              expect(value).toEqual('rejectReason');
            });
          });

          it('should reject and recover promise', () => {
            queueZone.run(() => {
              let value: any = null;
              Promise.reject('rejectReason')['catch']((v) => v).then((v) => value = v);
              flushMicrotasks();
              expect(value).toEqual('rejectReason');
            });
          });

          it('should reject if chained promise does not catch promise', () => {
            queueZone.run(() => {
              let value: any = null;
              Promise.reject('rejectReason')
                  .then((v) => fail('should not get here'))
                  .then(null, (v) => value = v);
              flushMicrotasks();
              expect(value).toEqual('rejectReason');
            });
          });

          it('should output error to console if ignoreConsoleErrorUncaughtError is false',
             (done) => {
               Zone.current.fork({name: 'promise-error'}).run(() => {
                 (Zone as any)[Zone.__symbol__('ignoreConsoleErrorUncaughtError')] = false;
                 const originalConsoleError = console.error;
                 console.error = jasmine.createSpy('consoleErr');
                 const p = new Promise((resolve, reject) => {
                   throw new Error('promise error');
                 });
                 setTimeout(() => {
                   expect(console.error).toHaveBeenCalled();
                   console.error = originalConsoleError;
                   done();
                 }, 10);
               });
             });

          it('should not output error to console if ignoreConsoleErrorUncaughtError is true',
             (done) => {
               Zone.current.fork({name: 'promise-error'}).run(() => {
                 (Zone as any)[Zone.__symbol__('ignoreConsoleErrorUncaughtError')] = true;
                 const originalConsoleError = console.error;
                 console.error = jasmine.createSpy('consoleErr');
                 const p = new Promise((resolve, reject) => {
                   throw new Error('promise error');
                 });
                 setTimeout(() => {
                   expect(console.error).not.toHaveBeenCalled();
                   console.error = originalConsoleError;
                   (Zone as any)[Zone.__symbol__('ignoreConsoleErrorUncaughtError')] = false;
                   done();
                 }, 10);
               });
             });

          it('should notify Zone.onHandleError if no one catches promise', (done) => {
            let promiseError: Error|null = null;
            let zone: Zone|null = null;
            let task: Task|null = null;
            let error: Error|null = null;
            queueZone
                .fork({
                  name: 'promise-error',
                  onHandleError: (delegate: ZoneDelegate, current: Zone, target: Zone, error: any):
                      boolean => {
                        promiseError = error;
                        delegate.handleError(target, error);
                        return false;
                      }
                })
                .run(() => {
                  zone = Zone.current;
                  task = Zone.currentTask;
                  error = new Error('rejectedErrorShouldBeHandled');
                  try {
                    // throw so that the stack trace is captured
                    throw error;
                  } catch (e) {
                  }
                  Promise.reject(error);
                  expect(promiseError).toBe(null);
                });
            setTimeout((): any => null);
            setTimeout(() => {
              expect(promiseError!.message)
                  .toBe(
                      'Uncaught (in promise): ' + error +
                      (error!.stack ? '\n' + error!.stack : ''));
              expect((promiseError as any)['rejection']).toBe(error);
              expect((promiseError as any)['zone']).toBe(zone);
              expect((promiseError as any)['task']).toBe(task);
              done();
            });
          });

          it('should print readable information when throw a not error object', (done) => {
            let promiseError: Error|null = null;
            let zone: Zone|null = null;
            let task: Task|null = null;
            let rejectObj: TestRejection;
            queueZone
                .fork({
                  name: 'promise-error',
                  onHandleError: (delegate: ZoneDelegate, current: Zone, target: Zone, error: any):
                      boolean => {
                        promiseError = error;
                        delegate.handleError(target, error);
                        return false;
                      }
                })
                .run(() => {
                  zone = Zone.current;
                  task = Zone.currentTask;
                  rejectObj = new TestRejection();
                  rejectObj.prop1 = 'value1';
                  rejectObj.prop2 = 'value2';
                  Promise.reject(rejectObj);
                  expect(promiseError).toBe(null);
                });
            setTimeout((): any => null);
            setTimeout(() => {
              expect(promiseError!.message)
                  .toMatch(/Uncaught \(in promise\):.*: {"prop1":"value1","prop2":"value2"}/);
              done();
            });
          });
        });

        describe('Promise.race', () => {
          it('should reject the value', () => {
            queueZone.run(() => {
              let value: any = null;
              (Promise as any).race([
                Promise.reject('rejection1'), 'v1'
              ])['catch']((v: any) => value = v);
              // expect(Zone.current.get('queue').length).toEqual(2);
              flushMicrotasks();
              expect(value).toEqual('rejection1');
            });
          });

          it('should resolve the value', () => {
            queueZone.run(() => {
              let value: any = null;
              (Promise as any)
                  .race([Promise.resolve('resolution'), 'v1'])
                  .then((v: any) => value = v);
              // expect(Zone.current.get('queue').length).toEqual(2);
              flushMicrotasks();
              expect(value).toEqual('resolution');
            });
          });
        });

        describe('Promise.all', () => {
          it('should reject the value', () => {
            queueZone.run(() => {
              let value: any = null;
              Promise.all([Promise.reject('rejection'), 'v1'])['catch']((v: any) => value = v);
              // expect(Zone.current.get('queue').length).toEqual(2);
              flushMicrotasks();
              expect(value).toEqual('rejection');
            });
          });

          it('should resolve the value', () => {
            queueZone.run(() => {
              let value: any = null;
              Promise.all([Promise.resolve('resolution'), 'v1']).then((v: any) => value = v);
              // expect(Zone.current.get('queue').length).toEqual(2);
              flushMicrotasks();
              expect(value).toEqual(['resolution', 'v1']);
            });
          });

          it('should resolve with the sync then operation', () => {
            queueZone.run(() => {
              let value: any = null;
              const p1 = {
                then: function(thenCallback: Function) {
                  return thenCallback('p1');
                }
              };
              const p2 = {
                then: function(thenCallback: Function) {
                  return thenCallback('p2');
                }
              };
              Promise.all([p1, 'v1', p2]).then((v: any) => value = v);
              // expect(Zone.current.get('queue').length).toEqual(2);
              flushMicrotasks();
              expect(value).toEqual(['p1', 'v1', 'p2']);
            });
          });

          it('should resolve generators',
             ifEnvSupports(
                 () => {
                   return isNode;
                 },
                 () => {
                   const generators: any = function*() {
                     yield Promise.resolve(1);
                     yield Promise.resolve(2);
                     return;
                   };
                   queueZone.run(() => {
                     let value: any = null;
                     Promise.all(generators()).then(val => {
                       value = val;
                     });
                     // expect(Zone.current.get('queue').length).toEqual(2);
                     flushMicrotasks();
                     expect(value).toEqual([1, 2]);
                   });
                 }));
        });
      });

      describe('Promise subclasses', function() {
        class MyPromise<T> {
          private _promise: Promise<any>;
          constructor(init: any) {
            this._promise = new Promise(init);
          }

          catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>)|
                                 undefined|null): Promise<T|TResult> {
            return this._promise.catch.call(this._promise, onrejected);
          };

          then<TResult1 = T, TResult2 = never>(
              onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>)|undefined|null,
              onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>)|undefined|
              null): Promise<any> {
            return this._promise.then.call(this._promise, onfulfilled, onrejected);
          };
        }

        const setPrototypeOf = (Object as any).setPrototypeOf || function(obj: any, proto: any) {
          obj.__proto__ = proto;
          return obj;
        };

        setPrototypeOf(MyPromise.prototype, Promise.prototype);

        it('should reject if the Promise subclass rejects', function() {
          const myPromise = new MyPromise(function(resolve: any, reject: any): void {
            reject('foo');
          });

          return Promise.resolve()
              .then(function() {
                return myPromise;
              })
              .then(
                  function() {
                    throw new Error('Unexpected resolution');
                  },
                  function(result) {
                    expect(result).toBe('foo');
                  });
        });

        function testPromiseSubClass(done?: Function) {
          const myPromise = new MyPromise(function(resolve: any, reject: Function) {
            resolve('foo');
          });

          return Promise.resolve()
              .then(function() {
                return myPromise;
              })
              .then(function(result) {
                expect(result).toBe('foo');
                done && done();
              });
        }

        it('should resolve if the Promise subclass resolves', jasmine ? function(done) {
          testPromiseSubClass(done);
        } : function() {
          testPromiseSubClass();
        });
      });

      describe('Promise.allSettled', () => {
        const yes = function makeFulfilledResult(value: any) {
          return {status: 'fulfilled', value: value};
        };
        const no = function makeRejectedResult(reason: any) {
          return {status: 'rejected', reason: reason};
        };
        const a = {};
        const b = {};
        const c = {};
        const allSettled = (Promise as any).allSettled;
        it('no promise values', (done: DoneFn) => {
          allSettled([a, b, c]).then((results: any[]) => {
            expect(results).toEqual([yes(a), yes(b), yes(c)]);
            done();
          });
        });
        it('all fulfilled', (done: DoneFn) => {
          allSettled([
            Promise.resolve(a), Promise.resolve(b), Promise.resolve(c)
          ]).then((results: any[]) => {
            expect(results).toEqual([yes(a), yes(b), yes(c)]);
            done();
          });
        });
        it('all rejected', (done: DoneFn) => {
          allSettled([
            Promise.reject(a), Promise.reject(b), Promise.reject(c)
          ]).then((results: any[]) => {
            expect(results).toEqual([no(a), no(b), no(c)]);
            done();
          });
        });
        it('mixed', (done: DoneFn) => {
          allSettled([a, Promise.resolve(b), Promise.reject(c)]).then((results: any[]) => {
            expect(results).toEqual([yes(a), yes(b), no(c)]);
            done();
          });
        });
        it('mixed should in zone', (done: DoneFn) => {
          const zone = Zone.current.fork({name: 'settled'});
          const bPromise = Promise.resolve(b);
          const cPromise = Promise.reject(c);
          zone.run(() => {
            allSettled([a, bPromise, cPromise]).then((results: any[]) => {
              expect(results).toEqual([yes(a), yes(b), no(c)]);
              expect(Zone.current.name).toEqual(zone.name);
              done();
            });
          });
        });
        it('poisoned .then', (done: DoneFn) => {
          const promise = new Promise(function() {});
          promise.then = function() {
            throw new EvalError();
          };
          allSettled([promise]).then(
              () => {
                fail('should not reach here');
              },
              (reason: any) => {
                expect(reason instanceof EvalError).toBe(true);
                done();
              });
        });
        const Subclass = (function() {
          try {
            // eslint-disable-next-line no-new-func
            return Function(
                'class Subclass extends Promise { constructor(...args) { super(...args); this.thenArgs = []; } then(...args) { Subclass.thenArgs.push(args); this.thenArgs.push(args); return super.then(...args); } } Subclass.thenArgs = []; return Subclass;')();
          } catch (e) { /**/
          }

          return false;
        }());

        describe('inheritance', () => {
          it('preserves correct subclass', () => {
            const promise = allSettled.call(Subclass, [1]);
            expect(promise instanceof Subclass).toBe(true);
            expect(promise.constructor).toEqual(Subclass);
          });

          it('invoke the subclass', () => {
            Subclass.thenArgs.length = 0;

            const original = Subclass.resolve();
            expect(Subclass.thenArgs.length).toBe(0);
            expect(original.thenArgs.length).toBe(0);

            allSettled.call(Subclass, [original]);

            expect(original.thenArgs.length).toBe(1);
            expect(Subclass.thenArgs.length).toBe(1);
          });
        });
      });
    }));