Pull async matchers out to their own functions

- Makes AsyncExpectation closer to Expectation

spec/core/matchers/async/toBeRejectedSpec.js

@@ -0,0 +1,23 @@
+describe('toBeRejected', function() {
+  it('passes if the actual is rejected', function() {
+    jasmine.getEnv().requirePromises();
+
+    var matcher = jasmineUnderTest.asyncMatchers.toBeRejected(jasmineUnderTest.matchersUtil),
+      actual = Promise.reject('AsyncExpectationSpec rejection');
+
+    return matcher.compare(actual).then(function(result) {
+      expect(result).toEqual(jasmine.objectContaining({pass: true}));
+    });
+  });
+
+  it('fails if the actual is resolved', function() {
+    jasmine.getEnv().requirePromises();
+
+    var matcher = jasmineUnderTest.asyncMatchers.toBeRejected(jasmineUnderTest.matchersUtil),
+      actual = Promise.resolve();
+
+    return matcher.compare(actual).then(function(result) {
+      expect(result).toEqual(jasmine.objectContaining({pass: false}));
+    });
+  });
+});

spec/core/matchers/async/toBeRejectedWithSpec.js

@@ -0,0 +1,63 @@
+describe('#toBeRejectedWith', function () {
+  it('should return true if the promise is rejected with the expected value', function () {
+    jasmine.getEnv().requirePromises();
+
+    var matcher = jasmineUnderTest.asyncMatchers.toBeRejectedWith(jasmineUnderTest.matchersUtil),
+      actual = Promise.reject({error: 'PEBCAK'});
+
+    return matcher.compare(actual, {error: 'PEBCAK'}).then(function (result) {
+      expect(result).toEqual(jasmine.objectContaining({ pass: true }));
+    });
+  });
+
+  it('should fail if the promise resolves', function () {
+    jasmine.getEnv().requirePromises();
+
+    var matcher = jasmineUnderTest.asyncMatchers.toBeRejectedWith(jasmineUnderTest.matchersUtil),
+      actual = Promise.resolve();
+
+    return matcher.compare(actual, '').then(function (result) {
+      expect(result).toEqual(jasmine.objectContaining({ pass: false }));
+    });
+  });
+
+  it('should fail if the promise is rejected with a different value', function () {
+    jasmine.getEnv().requirePromises();
+
+    var matcher = jasmineUnderTest.asyncMatchers.toBeRejectedWith(jasmineUnderTest.matchersUtil),
+      actual = Promise.reject('A Bad Apple');
+
+    return matcher.compare(actual, 'Some Cool Thing').then(function (result) {
+      expect(result).toEqual(jasmine.objectContaining({
+        pass: false,
+        message: "Expected a promise to be rejected with 'Some Cool Thing' but it was rejected with 'A Bad Apple'.",
+      }));
+    });
+  });
+
+  it('should build its error correctly when negated', function () {
+    jasmine.getEnv().requirePromises();
+
+    var matcher = jasmineUnderTest.asyncMatchers.toBeRejectedWith(jasmineUnderTest.matchersUtil),
+      actual = Promise.reject(true);
+
+    return matcher.compare(actual, true).then(function (result) {
+      expect(result).toEqual(jasmine.objectContaining({
+        pass: true,
+        message: 'Expected a promise not to be rejected with true.'
+      }));
+    });
+  });
+
+  it('should support custom equality testers', function () {
+    jasmine.getEnv().requirePromises();
+
+    var customEqualityTesters = [function() { return true; }],
+      matcher = jasmineUnderTest.asyncMatchers.toBeRejectedWith(jasmineUnderTest.matchersUtil, customEqualityTesters),
+      actual = Promise.reject('actual');
+
+    return matcher.compare(actual, 'expected').then(function(result) {
+      expect(result).toEqual(jasmine.objectContaining({pass: true}));
+    });
+  });
+});

spec/core/matchers/async/toBeResolvedSpec.js

@@ -0,0 +1,23 @@
+describe('toBeResolved', function() {
+  it('passes if the actual is resolved', function() {
+    jasmine.getEnv().requirePromises();
+
+    var matcher = jasmineUnderTest.asyncMatchers.toBeResolved(jasmineUnderTest.matchersUtil),
+      actual = Promise.resolve();
+
+    return matcher.compare(actual).then(function(result) {
+      expect(result).toEqual(jasmine.objectContaining({pass: true}));
+    });
+  });
+
+  it('fails if the actual is rejected', function() {
+    jasmine.getEnv().requirePromises();
+
+    var matcher = jasmineUnderTest.asyncMatchers.toBeResolved(jasmineUnderTest.matchersUtil),
+      actual = Promise.reject('AsyncExpectationSpec rejection');
+
+    return matcher.compare(actual).then(function(result) {
+      expect(result).toEqual(jasmine.objectContaining({pass: false}));
+    });
+  });
+});

spec/core/matchers/async/toBeResolvedToSpec.js

@@ -0,0 +1,66 @@
+describe('#toBeResolvedTo', function() {
+  it('passes if the promise is resolved to the expected value', function() {
+    jasmine.getEnv().requirePromises();
+
+    var matcher = jasmineUnderTest.asyncMatchers.toBeResolvedTo(jasmineUnderTest.matchersUtil),
+      actual = Promise.resolve({foo: 42});
+
+    return matcher.compare(actual, {foo: 42}).then(function(result) {
+      expect(result).toEqual(jasmine.objectContaining({pass: true}));
+    });
+  });
+
+  it('fails if the promise is rejected', function() {
+    jasmine.getEnv().requirePromises();
+
+    var matcher = jasmineUnderTest.asyncMatchers.toBeResolvedTo(jasmineUnderTest.matchersUtil),
+      actual = Promise.reject('AsyncExpectationSpec error');
+
+    return matcher.compare(actual, '').then(function(result) {
+      expect(result).toEqual(jasmine.objectContaining({
+        pass: false,
+        message: "Expected a promise to be resolved to '' but it was rejected.",
+      }));
+    });
+  });
+
+  it('fails if the promise is resolved to a different value', function() {
+    jasmine.getEnv().requirePromises();
+
+    var matcher = jasmineUnderTest.asyncMatchers.toBeResolvedTo(jasmineUnderTest.matchersUtil),
+      actual = Promise.resolve({foo: 17});
+
+    return matcher.compare(actual, {foo: 42}).then(function(result) {
+      expect(result).toEqual(jasmine.objectContaining({
+        pass: false,
+        message: 'Expected a promise to be resolved to Object({ foo: 42 }) but it was resolved to Object({ foo: 17 }).',
+      }));
+    });
+  });
+
+  it('builds its message correctly when negated', function() {
+    jasmine.getEnv().requirePromises();
+
+    var matcher = jasmineUnderTest.asyncMatchers.toBeResolvedTo(jasmineUnderTest.matchersUtil),
+      actual = Promise.resolve(true);
+
+    return matcher.compare(actual, true).then(function(result) {
+      expect(result).toEqual(jasmine.objectContaining({
+        pass: true,
+        message: 'Expected a promise not to be resolved to true.'
+      }));
+    });
+  });
+
+  it('supports custom equality testers', function() {
+    jasmine.getEnv().requirePromises();
+
+    var customEqualityTesters = [function() { return true; }],
+      matcher = jasmineUnderTest.asyncMatchers.toBeResolvedTo(jasmineUnderTest.matchersUtil, customEqualityTesters),
+      actual = Promise.resolve('actual');
+
+    return matcher.compare(actual, 'expected').then(function(result) {
+      expect(result).toEqual(jasmine.objectContaining({pass: true}));
+    });
+  });
+});