Jasmine ES6 promises

it-promise.js

// Quick and dirty ES6 promise testing (because I couldn't find any better)
// MIT License

function makeResolvedPromise(value) {
  return new Promise(function(success) {
    success(value);
  });
}

function makeRejectedPromise(errorValue) {
  return new Promise(function(success, error) {
    error(errorValue);
  });
}

function ensureReturnsPromise(callback) {
  return function() {
    try {
      var ret = callback.call(this);
      if (ret && ret.then) {
        return ret;
      } else {
        return makeResolvedPromise(ret);
      }
    } catch (error) {
      return makeRejectedPromise(error);
    }
  }
}

function itpBase(jasmineItFunction, description) {
  var dependency, testCase;
  if (arguments.length == 3) {
    dependency = function() {};
    testCase = arguments[2];
  } else {
    dependency = arguments[2];
    testCase = arguments[3];
  }

  dependency = ensureReturnsPromise(dependency);
  testCase = ensureReturnsPromise(testCase);

  var testCaseWithDependencies = function() {
    var self = this;
    return dependency.call(self).then(function() {
      return testCase.call(self);
    }, function(error) {
      console.log("Failed due to rejected dependency.");
      return makeRejectedPromise(error);
    });
  }

  jasmineItFunction(description, function(done) {
    var testPromise = testCaseWithDependencies.call(this);
    testPromise.then(function() {
      // Test promise fulfilled
      done();
    }, function(error) {
      // Test promise rejected
      expect("promise").toBe("fulfilled");
      console.log(error);
      done();
    });
  });

  return testCaseWithDependencies;
}

function makeRealArray(pseudoArray) {
  return Array.prototype.slice.call(pseudoArray);
}

function itP() {
  var args = makeRealArray(arguments);
  return itpBase.apply(undefined, [it].concat(args));
}

it-promise.spec.js

// Quick and dirty ES6 promise testing (because I couldn't find any better)
// MIT License

describe("ensureReturnsPromise", function() {
  it("turns nothing into fulfilled promise", function() {
    var testResolve = ensureReturnsPromise(function() {});

    var returnedPromise = testResolve();
    expect(returnedPromise.then).not.toBe(undefined);

    returnedPromise.then(function(value) {
      expect(value).toBe(undefined);
      done();
    }, function(error) {
      expect("promise").toBe("resolved");
      done();
    });
  });

  it("turns non-thenables into fulfilled promises", function() {
    var testResolve = ensureReturnsPromise(function() {
      return "Hi";
    });

    var returnedPromise = testResolve();
    expect(returnedPromise.then).not.toBe(undefined);

    returnedPromise.then(function(value) {
      expect(value).toEqual("Hi");
      done();
    }, function(error) {
      expect("promise").toBe("resolved");
      done();
    });
  });

  it("turns exceptions into rejected promises", function() {
    var testResolve = ensureReturnsPromise(function() {
      throw new Error("synchronous foo error");
    });

    var returnedPromise = testResolve();
    expect(returnedPromise.then).not.toBe(undefined);

    returnedPromise.then(function() {
      expect("promise").toBe("rejected");
      done();
    }, function(error) {
      expect(error.message).toEqual("synchronous foo error");
      done();
    });
  });

  it("passes through fulfilled promises", function() {
    var resolvedPromise = makeResolvedPromise("Hi")

    var testResolve = ensureReturnsPromise(function() {
      return resolvedPromise;
    });

    var returnedPromise = testResolve();
    expect(returnedPromise).toBe(resolvedPromise);

    returnedPromise.then(function(value) {
      expect(value).toEqual("Hi");
      done();
    }, function(error) {
      expect("promise").toBe("resolved");
      done();
    });
  });

  it("passes through rejected promises", function() {
    var rejectedPromise = makeRejectedPromise(new Error("foo error"))

    var testReject = ensureReturnsPromise(function() {
      return rejectedPromise;
    });

    var returnedPromise = testReject();
    expect(returnedPromise).toBe(rejectedPromise);

    returnedPromise.then(function() {
      expect("promise").toBe("rejected");
      done();
    }, function(error) {
      expect(error.message).toEqual("foo error");
      done();
    });
  });
});

describe("itP promises", function() {
  beforeEach(function() {
    this.testChainLevel = 0;
  });

  itP("pass successful synchronous tests", function() {
    expect(true).toEqual(true);
  });

  var successfulTest = itP("pass when return a fulfilled promise", function() {
    expect(this.testChainLevel).toEqual(0);
    this.testChainLevel++;
    return makeResolvedPromise(12);
  });

  var successfulTest2 = itP("supports dependencies", successfulTest,
  function() {
    expect(this.testChainLevel).toEqual(1);
    this.testChainLevel++;
    return makeResolvedPromise();
  });

  itP("supports nested dependencies", successfulTest2, function() {
    expect(this.testChainLevel).toEqual(2);
    return makeResolvedPromise();
  });

  // Expected failures
  return;
  itP("fail unsuccessful synchronous tests", function() {
    expect(true).toEqual(false);
  });

  itP("fail when return a rejected promise", function() {
    return makeRejectedPromise(new Error("foo error"));
  });

  var rejectedTest = itP("fail when an exception is throw", function() {
    throw new Error("foo error");
  });

  itP("fail if dependencies fail", rejectedTest, function() {
    expect("this code").toBe("never executed");
  });
});