gecko/addon-sdk/source/test/test-promise.js

/* vim:set ts=2 sw=2 sts=2 expandtab */
/*jshint asi: true undef: true es5: true node: true devel: true
         forin: true */
/*global define: true */

'use strict';

var core = require('sdk/core/promise'),
    defer = core.defer, resolve = core.resolve, reject = core.reject, all = core.all,
    promised = core.promised;

var { setTimeout } = require('sdk/timers');

exports['test all observers are notified'] = function(assert, done) {
  var expected = 'Taram pam param!'
  var deferred = defer()
  var pending = 10, i = 0

  function resolved(value) {
    assert.equal(value, expected, 'value resolved as expected: #' + pending)
    if (!--pending) done()
  }

  while (i++ < pending) deferred.promise.then(resolved)

  deferred.resolve(expected)
}

exports['test exceptions dont stop notifications'] = function(assert, done) {
  var threw = false, boom = Error('Boom!')
  var deferred = defer()

  var promise2 = deferred.promise.then(function() {
    threw = true
    throw boom
  })

  deferred.promise.then(function() {
    assert.ok(threw, 'observer is called even though previos one threw')
    promise2.then(function() {
      assert.fail('should not resolve')
    }, function(reason) {
      assert.equal(reason, boom, 'rejects to thrown error')
      done()
    })
  })

  deferred.resolve('go!')
}

exports['test subsequent resolves are ignored'] = function(assert, done) {
  var deferred = defer()
  deferred.resolve(1)
  deferred.resolve(2)
  deferred.reject(3)

  deferred.promise.then(function(actual) {
    assert.equal(actual, 1, 'resolves to first value')
  }, function() {
    assert.fail('must not reject')
  })
  deferred.promise.then(function(actual) {
    assert.equal(actual, 1, 'subsequent resolutions are ignored')
    done()
  }, function() {
    assert.fail('must not reject')
  })
}

exports['test subsequent rejections are ignored'] = function(assert, done) {
  var deferred = defer()
  deferred.reject(1)
  deferred.resolve(2)
  deferred.reject(3)

  deferred.promise.then(function(actual) {
    assert.fail('must not resolve')
  }, function(actual) {
    assert.equal(actual, 1, 'must reject to first')
  })
  deferred.promise.then(function(actual) {
    assert.fail('must not resolve')
  }, function(actual) {
    assert.equal(actual, 1, 'must reject to first')
    done()
  })
}

exports['test error recovery'] = function(assert, done) {
  var boom = Error('Boom!')
  var deferred = defer()

  deferred.promise.then(function() {
    assert.fail('rejected promise should not resolve')
  }, function(reason) {
    assert.equal(reason, boom, 'rejection reason delivered')
    return 'recovery'
  }).then(function(value) {
    assert.equal(value, 'recovery', 'error handled by a handler')
    done()
  })

  deferred.reject(boom)
}


exports['test error recovery with promise'] = function(assert, done) {
  var deferred = defer()

  deferred.promise.then(function() {
    assert.fail('must reject')
  }, function(actual) {
    assert.equal(actual, 'reason', 'rejected')
    var deferred = defer()
    deferred.resolve('recovery')
    return deferred.promise
  }).then(function(actual) {
    assert.equal(actual, 'recovery', 'recorvered via promise')
    var deferred = defer()
    deferred.reject('error')
    return deferred.promise
  }).then(null, function(actual) {
    assert.equal(actual, 'error', 'rejected via promise')
    var deferred = defer()
    deferred.reject('end')
    return deferred.promise
  }).then(null, function(actual) {
    assert.equal(actual, 'end', 'rejeced via promise')
    done()
  })

  deferred.reject('reason')
}

exports['test propagation'] = function(assert, done) {
  var d1 = defer(), d2 = defer(), d3 = defer()

  d1.promise.then(function(actual) {
    assert.equal(actual, 'expected', 'resolves to expected value')
    done()
  })

  d1.resolve(d2.promise)
  d2.resolve(d3.promise)
  d3.resolve('expected')
}

exports['test chaining'] = function(assert, done) {
  var boom = Error('boom'), brax = Error('braxXXx')
  var deferred = defer()

  deferred.promise.then().then().then(function(actual) {
    assert.equal(actual, 2, 'value propagates unchanged')
    return actual + 2
  }).then(null, function(reason) {
    assert.fail('should not reject')
  }).then(function(actual) {
    assert.equal(actual, 4, 'value propagates through if not handled')
    throw boom
  }).then(function(actual) {
    assert.fail('exception must reject promise')
  }).then().then(null, function(actual) {
    assert.equal(actual, boom, 'reason propagates unchanged')
    throw brax
  }).then().then(null, function(actual) {
    assert.equal(actual, brax, 'reason changed becase of exception')
    return 'recovery'
  }).then(function(actual) {
    assert.equal(actual, 'recovery', 'recovered from error')
    done()
  })

  deferred.resolve(2)
}


exports['test reject'] = function(assert, done) {
  var expected = Error('boom')

  reject(expected).then(function() {
    assert.fail('should reject')
  }, function(actual) {
    assert.equal(actual, expected, 'rejected with expected reason')
  }).then(function() {
    done()
  })
}

exports['test resolve to rejected'] = function(assert, done) {
  var expected = Error('boom')
  var deferred = defer()

  deferred.promise.then(function() {
    assert.fail('should reject')
  }, function(actual) {
    assert.equal(actual, expected, 'rejected with expected failure')
  }).then(function() {
    done()
  })

  deferred.resolve(reject(expected))
}

exports['test resolve'] = function(assert, done) {
  var expected = 'value'
  resolve(expected).then(function(actual) {
    assert.equal(actual, expected, 'resolved as expected')
  }).then(function() {
    done()
  })
}

exports['test resolve with prototype'] = function(assert, done) {
  var seventy = resolve(70, {
    subtract: function subtract(y) {
      return this.then(function(x) { return x - y })
    }
  })

  seventy.subtract(17).then(function(actual) {
    assert.equal(actual, 70 - 17, 'resolves to expected')
    done()
  })
}

exports['test promised with normal args'] = function(assert, done) {
  var sum = promised(function(x, y) { return x + y })

  sum(7, 8).then(function(actual) {
    assert.equal(actual, 7 + 8, 'resolves as expected')
    done()
  })
}

exports['test promised with promise args'] = function(assert, done) {
  var sum = promised(function(x, y) { return x + y })
  var deferred = defer()

  sum(11, deferred.promise).then(function(actual) {
    assert.equal(actual, 11 + 24, 'resolved as expected')
    done()
  })

  deferred.resolve(24)
}

exports['test promised with prototype'] = function(assert, done) {
  var deferred = defer()
  var numeric = {}
  numeric.subtract = promised(function(y) { return this - y }, numeric)

  var sum = promised(function(x, y) { return x + y }, numeric)

  sum(7, 70).
    subtract(14).
    subtract(deferred.promise).
    subtract(5).
    then(function(actual) {
      assert.equal(actual, 7 + 70 - 14 - 23 - 5, 'resolved as expected')
      done()
    })

  deferred.resolve(23)
}

exports['test promised error handleing'] = function(assert, done) {
  var expected = Error('boom')
  var f = promised(function() {
    throw expected
  })

  f().then(function() {
    assert.fail('should reject')
  }, function(actual) {
    assert.equal(actual, expected, 'rejected as expected')
    done()
  })
}

exports['test return promise form promised'] = function(assert, done) {
  var f = promised(function() {
    return resolve(17)
  })

  f().then(function(actual) {
    assert.equal(actual, 17, 'resolves to a promise resolution')
    done()
  })
}

exports['test promised returning failure'] = function(assert, done) {
  var expected = Error('boom')
  var f = promised(function() {
    return reject(expected)
  })

  f().then(function() {
    assert.fail('must reject')
  }, function(actual) {
    assert.equal(actual, expected, 'rejects with expected reason')
    done()
  })
}

exports['test promised are greedy'] = function(assert, done) {
  var runs = 0
  var f = promised(function() { ++runs })
  var promise = f()
  assert.equal(runs, 1, 'promised runs task right away')
  done()
}

exports['test arrays should not flatten'] = function(assert, done) {
  var a = defer()
  var b = defer()

  var combine = promised(function(str, arr) {
    assert.equal(str, 'Hello', 'Array was not flattened')
    assert.deepEqual(arr, [ 'my', 'friend' ])
  })

  combine(a.promise, b.promise).then(done)


  a.resolve('Hello')
  b.resolve([ 'my', 'friend' ])
}

exports['test `all` for all promises'] = function (assert, done) {
  all([
    resolve(5), resolve(7), resolve(10)
  ]).then(function (val) {
    assert.equal(
      val[0] === 5 &&
      val[1] === 7 &&
      val[2] === 10
    , true, 'return value contains resolved promises values');
    done();
  }, function () {
    assert.fail('should not call reject function');
  });
};

exports['test `all` aborts upon first reject'] = function (assert, done) {
  all([
    resolve(5), reject('error'), delayedResolve()
  ]).then(function (val) {
    assert.fail('Successful resolve function should not be called');
  }, function (reason) {
    assert.equal(reason, 'error', 'should reject the `all` promise');
    done();
  });

  function delayedResolve () {
    var deferred = defer();
    setTimeout(deferred.resolve, 50);
    return deferred.promise;
  }
};

exports['test `all` with array containing non-promise'] = function (assert, done) {
  all([
    resolve(5), resolve(10), 925
  ]).then(function (val) {
    assert.equal(val[2], 925, 'non-promises should pass-through value');
    done();
  }, function () {
    assert.fail('should not be rejected');
  });
};

exports['test `all` should resolve with an empty array'] = function (assert, done) {
  all([]).then(function (val) {
    assert.equal(Array.isArray(val), true, 'should return array in resolved');
    assert.equal(val.length, 0, 'array should be empty in resolved');
    done();
  }, function () {
    assert.fail('should not be rejected');
  });
};

exports['test `all` with multiple rejected'] = function (assert, done) {
  all([
    reject('error1'), reject('error2'), reject('error3')
  ]).then(function (value) {
    assert.fail('should not be successful');
  }, function (reason) {
    assert.equal(reason, 'error1', 'should reject on first promise reject');
    done();
  });
};

require("test").run(exports)