angular-cn/packages/zone.js/test/promise/promise.finally.spec.js

'use strict';

var assert = require('assert');
var adapter = require('./promise-adapter');
var P = global[Zone.__symbol__('Promise')];

var someRejectionReason = {message: 'some rejection reason'};
var anotherReason = {message: 'another rejection reason'};
process.on('unhandledRejection', function(reason, promise) {
  console.log('unhandledRejection', reason);
});

describe('mocha promise sanity check', () => {
  it('passes with a resolved promise', () => {
    return P.resolve(3);
  });

  it('passes with a rejected then resolved promise', () => {
    return P.reject(someRejectionReason).catch(x => 'this should be resolved');
  });

  var ifPromiseIt = P === Promise ? it : it.skip;
  ifPromiseIt('is the native Promise', () => {
    assert.equal(P, Promise);
  });
});

describe('onFinally', () => {
  describe('no callback', () => {
    specify('from resolved', (done) => {
      adapter.resolved(3)
          .then((x) => {
            assert.strictEqual(x, 3);
            return x;
          })
          .finally()
          .then(
              function onFulfilled(x) {
                assert.strictEqual(x, 3);
                done();
              },
              function onRejected() {
                done(new Error('should not be called'));
              });
    });

    specify('from rejected', (done) => {
      adapter.rejected(someRejectionReason)
          .catch((e) => {
            assert.strictEqual(e, someRejectionReason);
            throw e;
          })
          .finally()
          .then(
              function onFulfilled() {
                done(new Error('should not be called'));
              },
              function onRejected(reason) {
                assert.strictEqual(reason, someRejectionReason);
                done();
              });
    });
  });

  describe('throws an exception', () => {
    specify('from resolved', (done) => {
      adapter.resolved(3)
          .then((x) => {
            assert.strictEqual(x, 3);
            return x;
          })
          .finally(function onFinally() {
            assert(arguments.length === 0);
            throw someRejectionReason;
          })
          .then(
              function onFulfilled() {
                done(new Error('should not be called'));
              },
              function onRejected(reason) {
                assert.strictEqual(reason, someRejectionReason);
                done();
              });
    });

    specify('from rejected', (done) => {
      adapter.rejected(anotherReason)
          .finally(function onFinally() {
            assert(arguments.length === 0);
            throw someRejectionReason;
          })
          .then(
              function onFulfilled() {
                done(new Error('should not be called'));
              },
              function onRejected(reason) {
                assert.strictEqual(reason, someRejectionReason);
                done();
              });
    });
  });

  describe('returns a non-promise', () => {
    specify('from resolved', (done) => {
      adapter.resolved(3)
          .then((x) => {
            assert.strictEqual(x, 3);
            return x;
          })
          .finally(function onFinally() {
            assert(arguments.length === 0);
            return 4;
          })
          .then(
              function onFulfilled(x) {
                assert.strictEqual(x, 3);
                done();
              },
              function onRejected() {
                done(new Error('should not be called'));
              });
    });

    specify('from rejected', (done) => {
      adapter.rejected(anotherReason)
          .catch((e) => {
            assert.strictEqual(e, anotherReason);
            throw e;
          })
          .finally(function onFinally() {
            assert(arguments.length === 0);
            throw someRejectionReason;
          })
          .then(
              function onFulfilled() {
                done(new Error('should not be called'));
              },
              function onRejected(e) {
                assert.strictEqual(e, someRejectionReason);
                done();
              });
    });
  });

  describe('returns a pending-forever promise', () => {
    specify('from resolved', (done) => {
      var timeout;
      adapter.resolved(3)
          .then((x) => {
            assert.strictEqual(x, 3);
            return x;
          })
          .finally(function onFinally() {
            assert(arguments.length === 0);
            timeout = setTimeout(done, 0.1e3);
            return new P(() => {});  // forever pending
          })
          .then(
              function onFulfilled(x) {
                clearTimeout(timeout);
                done(new Error('should not be called'));
              },
              function onRejected() {
                clearTimeout(timeout);
                done(new Error('should not be called'));
              });
    });

    specify('from rejected', (done) => {
      var timeout;
      adapter.rejected(someRejectionReason)
          .catch((e) => {
            assert.strictEqual(e, someRejectionReason);
            throw e;
          })
          .finally(function onFinally() {
            assert(arguments.length === 0);
            timeout = setTimeout(done, 0.1e3);
            return new P(() => {});  // forever pending
          })
          .then(
              function onFulfilled(x) {
                clearTimeout(timeout);
                done(new Error('should not be called'));
              },
              function onRejected() {
                clearTimeout(timeout);
                done(new Error('should not be called'));
              });
    });
  });

  describe('returns an immediately-fulfilled promise', () => {
    specify('from resolved', (done) => {
      adapter.resolved(3)
          .then((x) => {
            assert.strictEqual(x, 3);
            return x;
          })
          .finally(function onFinally() {
            assert(arguments.length === 0);
            return adapter.resolved(4);
          })
          .then(
              function onFulfilled(x) {
                assert.strictEqual(x, 3);
                done();
              },
              function onRejected() {
                done(new Error('should not be called'));
              });
    });

    specify('from rejected', (done) => {
      adapter.rejected(someRejectionReason)
          .catch((e) => {
            assert.strictEqual(e, someRejectionReason);
            throw e;
          })
          .finally(function onFinally() {
            assert(arguments.length === 0);
            return adapter.resolved(4);
          })
          .then(
              function onFulfilled() {
                done(new Error('should not be called'));
              },
              function onRejected(e) {
                assert.strictEqual(e, someRejectionReason);
                done();
              });
    });
  });

  describe('returns an immediately-rejected promise', () => {
    specify('from resolved ', (done) => {
      adapter.resolved(3)
          .then((x) => {
            assert.strictEqual(x, 3);
            return x;
          })
          .finally(function onFinally() {
            assert(arguments.length === 0);
            return adapter.rejected(4);
          })
          .then(
              function onFulfilled(x) {
                done(new Error('should not be called'));
              },
              function onRejected(e) {
                assert.strictEqual(e, 4);
                done();
              });
    });

    specify('from rejected', (done) => {
      const newReason = {};
      adapter.rejected(someRejectionReason)
          .catch((e) => {
            assert.strictEqual(e, someRejectionReason);
            throw e;
          })
          .finally(function onFinally() {
            assert(arguments.length === 0);
            return adapter.rejected(newReason);
          })
          .then(
              function onFulfilled(x) {
                done(new Error('should not be called'));
              },
              function onRejected(e) {
                assert.strictEqual(e, newReason);
                done();
              });
    });
  });

  describe('returns a fulfilled-after-a-second promise', () => {
    specify('from resolved', (done) => {
      var timeout;
      adapter.resolved(3)
          .then((x) => {
            assert.strictEqual(x, 3);
            return x;
          })
          .finally(function onFinally() {
            assert(arguments.length === 0);
            timeout = setTimeout(done, 1.5e3);
            return new P((resolve) => {
              setTimeout(() => resolve(4), 1e3);
            });
          })
          .then(
              function onFulfilled(x) {
                clearTimeout(timeout);
                assert.strictEqual(x, 3);
                done();
              },
              function onRejected() {
                clearTimeout(timeout);
                done(new Error('should not be called'));
              });
    });

    specify('from rejected', (done) => {
      var timeout;
      adapter.rejected(3)
          .catch((e) => {
            assert.strictEqual(e, 3);
            throw e;
          })
          .finally(function onFinally() {
            assert(arguments.length === 0);
            timeout = setTimeout(done, 1.5e3);
            return new P((resolve) => {
              setTimeout(() => resolve(4), 1e3);
            });
          })
          .then(
              function onFulfilled() {
                clearTimeout(timeout);
                done(new Error('should not be called'));
              },
              function onRejected(e) {
                clearTimeout(timeout);
                assert.strictEqual(e, 3);
                done();
              });
    });
  });

  describe('returns a rejected-after-a-second promise', () => {
    specify('from resolved', (done) => {
      var timeout;
      adapter.resolved(3)
          .then((x) => {
            assert.strictEqual(x, 3);
            return x;
          })
          .finally(function onFinally() {
            assert(arguments.length === 0);
            timeout = setTimeout(done, 1.5e3);
            return new P((resolve, reject) => {
              setTimeout(() => reject(4), 1e3);
            });
          })
          .then(
              function onFulfilled() {
                clearTimeout(timeout);
                done(new Error('should not be called'));
              },
              function onRejected(e) {
                clearTimeout(timeout);
                assert.strictEqual(e, 4);
                done();
              });
    });

    specify('from rejected', (done) => {
      var timeout;
      adapter.rejected(someRejectionReason)
          .catch((e) => {
            assert.strictEqual(e, someRejectionReason);
            throw e;
          })
          .finally(function onFinally() {
            assert(arguments.length === 0);
            timeout = setTimeout(done, 1.5e3);
            return new P((resolve, reject) => {
              setTimeout(() => reject(anotherReason), 1e3);
            });
          })
          .then(
              function onFulfilled() {
                clearTimeout(timeout);
                done(new Error('should not be called'));
              },
              function onRejected(e) {
                clearTimeout(timeout);
                assert.strictEqual(e, anotherReason);
                done();
              });
    });
  });

  specify('has the correct property descriptor', () => {
    var descriptor = Object.getOwnPropertyDescriptor(Promise.prototype, 'finally');

    assert.strictEqual(descriptor.writable, true);
    assert.strictEqual(descriptor.configurable, true);
  });
});