hamjest 3.7.3 → 4.0.1

package/test/node/matchers/IsFulfilledSpec.js

@@ -2,7 +2,6 @@
 
 const _ = require('lodash');
 const assert = require('assert');
-const Bluebird = require('bluebird');
 
 const __ = require('../../..');
 
@@ -20,7 +19,7 @@ describe('IsFulfilled', () => {
 			});
 
 			it('should return a promise', () => {
-				const aFulfilledPromise = Bluebird.resolve('a value');
+				const aFulfilledPromise = Promise.resolve('a value');
 
 				const result = sut.matches(aFulfilledPromise);
 
@@ -29,7 +28,7 @@ describe('IsFulfilled', () => {
 			});
 
 			it('should match fulfilled promises', () => {
-				const aFulfilledPromise = Bluebird.resolve('a value');
+				const aFulfilledPromise = Promise.resolve('a value');
 
 				return sut.matches(aFulfilledPromise).then((value) => {
 					assert.ok(value);
@@ -37,7 +36,7 @@ describe('IsFulfilled', () => {
 			});
 
 			it('should not match rejected promises', () => {
-				const aRejectedPromise = Bluebird.reject(new Error('rejected for a reason'));
+				const aRejectedPromise = Promise.reject(new Error('rejected for a reason'));
 
 				return sut.matches(aRejectedPromise).then((value) => {
 					assert.equal(value, false);
@@ -46,14 +45,14 @@ describe('IsFulfilled', () => {
 
 			it('should wait for pending promises', (done) => {
 				let resolveFn;
-				const deferred = new Bluebird((resolve) => {
+				const deferred = new Promise((resolve) => {
 					resolveFn = resolve;
 				});
 
 				sut.matches(deferred).then((value) => {
 					assert.ok(value);
 				})
-				.nodeify(done);
+				.then(done, done);
 
 				resolveFn();
 			});
@@ -74,7 +73,7 @@ describe('IsFulfilled', () => {
 			});
 
 			it('should return a promise', () => {
-				const aFulfilledPromise = Bluebird.resolve('a value');
+				const aFulfilledPromise = Promise.resolve('a value');
 
 				const result = sut.matches(aFulfilledPromise);
 
@@ -83,7 +82,7 @@ describe('IsFulfilled', () => {
 			});
 
 			it('should match fulfilled promise with equivalent value', () => {
-				const aFulfilledPromise = Bluebird.resolve('a value');
+				const aFulfilledPromise = Promise.resolve('a value');
 
 				return sut.matches(aFulfilledPromise).then((value) => {
 					assert.ok(value);
@@ -91,7 +90,7 @@ describe('IsFulfilled', () => {
 			});
 
 			it('should not match fulfilled promise with different value', () => {
-				const aFulfilledPromise = Bluebird.resolve('another value');
+				const aFulfilledPromise = Promise.resolve('another value');
 
 				return sut.matches(aFulfilledPromise).then((value) => {
 					assert.equal(value, false);
@@ -99,7 +98,7 @@ describe('IsFulfilled', () => {
 			});
 
 			it('should not match rejected promise', () => {
-				const aRejectedPromise = Bluebird.reject(new Error('a value'));
+				const aRejectedPromise = Promise.reject(new Error('a value'));
 
 				return sut.matches(aRejectedPromise).then((value) => {
 					assert.equal(value, false);
@@ -108,14 +107,14 @@ describe('IsFulfilled', () => {
 
 			it('should wait for pending promises', (done) => {
 				let resolveFn;
-				const deferred = new Bluebird((resolve) => {
+				const deferred = new Promise((resolve) => {
 					resolveFn = resolve;
 				});
 
 				sut.matches(deferred).then((value) => {
 					assert.ok(value);
 				})
-				.nodeify(done);
+				.then(done, done);
 
 				resolveFn('a value');
 			});
@@ -134,7 +133,7 @@ describe('IsFulfilled', () => {
 				});
 
 				it('should contain mismatched value', () => {
-					const actual = Bluebird.resolve('another value');
+					const actual = Promise.resolve('another value');
 
 					return sut.describeMismatch(actual, description).then(() => {
 						__.assertThat(description.get(), __.equalTo('fulfillment value: was "another value"'));
@@ -142,7 +141,7 @@ describe('IsFulfilled', () => {
 				});
 
 				it('should contain rejected reason', () => {
-					const actual = Bluebird.reject(new Error('for a reason'));
+					const actual = Promise.reject(new Error('for a reason'));
 
 					return sut.describeMismatch(actual, description).then(() => {
 						__.assertThat(description.get(), __.allOf(__.containsString('was'), __.containsString('rejected'), __.containsString('"for a reason"')));
@@ -158,7 +157,7 @@ describe('IsFulfilled', () => {
 			});
 
 			it('should match fulfilled promise with matching values', () => {
-				const aFulfilledPromise = Bluebird.resolve('expected value');
+				const aFulfilledPromise = Promise.resolve('expected value');
 
 				return sut.matches(aFulfilledPromise).then((value) => {
 					assert.ok(value);
@@ -166,7 +165,7 @@ describe('IsFulfilled', () => {
 			});
 
 			it('should not match fulfilled promise with nonmatching value', () => {
-				const aFulfilledPromise = Bluebird.resolve('another value');
+				const aFulfilledPromise = Promise.resolve('another value');
 
 				return sut.matches(aFulfilledPromise).then((value) => {
 					assert.equal(value, false);
@@ -174,7 +173,7 @@ describe('IsFulfilled', () => {
 			});
 
 			it('should not match rejected promise', () => {
-				const aRejectedPromise = Bluebird.reject(new Error('rejected for expected reason'));
+				const aRejectedPromise = Promise.reject(new Error('rejected for expected reason'));
 
 				return sut.matches(aRejectedPromise).then((value) => {
 					assert.equal(value, false);
@@ -183,14 +182,14 @@ describe('IsFulfilled', () => {
 
 			it('should wait for pending promises', (done) => {
 				let resolveFn;
-				const deferred = new Bluebird((resolve) => {
+				const deferred = new Promise((resolve) => {
 					resolveFn = resolve;
 				});
 
 				sut.matches(deferred).then((value) => {
 					assert.ok(value);
 				})
-				.nodeify(done);
+				.then(done, done);
 
 				resolveFn('expected value');
 			});
@@ -209,7 +208,7 @@ describe('IsFulfilled', () => {
 				});
 
 				it('should contain mismatched value', () => {
-					const actual = Bluebird.resolve('another value');
+					const actual = Promise.resolve('another value');
 
 					return sut.describeMismatch(actual, description).then(() => {
 						__.assertThat(description.get(), __.equalTo('fulfillment value: was "another value"'));
@@ -222,7 +221,7 @@ describe('IsFulfilled', () => {
 						other: 'property'
 					}));
 
-					const actual = Bluebird.resolve({expected: 'another value', other: 'property'});
+					const actual = Promise.resolve({expected: 'another value', other: 'property'});
 
 					return sut.describeMismatch(actual, description).then(() => {
 						__.assertThat(description.get(), __.equalTo('fulfillment value: expected was "another value"'));
@@ -230,7 +229,7 @@ describe('IsFulfilled', () => {
 				});
 
 				it('should contain rejected reason', () => {
-					const actual = Bluebird.reject(new Error('for a reason'));
+					const actual = Promise.reject(new Error('for a reason'));
 
 					return sut.describeMismatch(actual, description).then(() => {
 						__.assertThat(description.get(), __.allOf(__.containsString('was'), __.containsString('rejected'), __.containsString('"for a reason"')));
@@ -246,8 +245,8 @@ describe('IsFulfilled', () => {
 			});
 
 			it('should match fulfilled promise with matching values', () => {
-				const aFulfilledPromise = Bluebird.resolve([
-					Bluebird.resolve('expected')
+				const aFulfilledPromise = Promise.resolve([
+					Promise.resolve('expected')
 				]);
 
 				return sut.matches(aFulfilledPromise).then((value) => {
@@ -256,8 +255,8 @@ describe('IsFulfilled', () => {
 			});
 
 			it('should not match fulfilled promise with nonmatching value', () => {
-				const aFulfilledPromise = Bluebird.resolve([
-					Bluebird.resolve('another value')
+				const aFulfilledPromise = Promise.resolve([
+					Promise.resolve('another value')
 				]);
 
 				return sut.matches(aFulfilledPromise).then((value) => {
@@ -267,15 +266,15 @@ describe('IsFulfilled', () => {
 
 			it('should wait for pending promises', (done) => {
 				let resolveFn;
-				const deferred = new Bluebird((resolve) => {
+				const deferred = new Promise((resolve) => {
 					resolveFn = resolve;
 				});
-				const aFulfilledPromiseContainingAPendingPromise = Bluebird.resolve([deferred]);
+				const aFulfilledPromiseContainingAPendingPromise = Promise.resolve([deferred]);
 
 				sut.matches(aFulfilledPromiseContainingAPendingPromise).then((value) => {
 					assert.ok(value);
 				})
-				.nodeify(done);
+				.then(done, done);
 
 				resolveFn('expected');
 			});
@@ -295,7 +294,7 @@ describe('IsFulfilled', () => {
 
 				it('should contain mismatch description', () => {
 
-					const actual = Bluebird.resolve([Bluebird.resolve('another value')]);
+					const actual = Promise.resolve([Promise.resolve('another value')]);
 
 					return sut.describeMismatch(actual, description).then(() => {
 						__.assertThat(description.get(), __.equalTo('fulfillment value: item 0: fulfillment value: was "another value"\n'));

package/test/node/matchers/IsPromiseSpec.js

@@ -1,7 +1,6 @@
 'use strict';
 
 const assert = require('assert');
-const Bluebird = require('bluebird');
 
 const __ = require('../../..');
 
@@ -15,20 +14,20 @@ describe('IsPromise', () => {
 			});
 
 			it('should match fulfilled promises', () => {
-				const aFulfilledPromise = Bluebird.resolve('a value');
+				const aFulfilledPromise = Promise.resolve('a value');
 
 				assert.ok(sut.matches(aFulfilledPromise));
 			});
 
 			it('should match rejected promises', () => {
-				const aRejectedPromise = Bluebird.reject(new Error('rejected for a reason'));
+				const aRejectedPromise = Promise.reject(new Error('rejected for a reason'));
 				aRejectedPromise.catch(() => null);
 
 				assert.ok(sut.matches(aRejectedPromise));
 			});
 
 			it('should match pending promises', () => {
-				const aPendingPromise = new Bluebird(() => {});
+				const aPendingPromise = new Promise(() => {});
 
 				assert.ok(sut.matches(aPendingPromise));
 			});

package/test/node/matchers/IsRejectedSpec.js

@@ -2,7 +2,6 @@
 
 const _ = require('lodash');
 const assert = require('assert');
-const Bluebird = require('bluebird');
 
 const __ = require('../../..');
 
@@ -20,7 +19,7 @@ describe('IsRejected', () => {
 			});
 
 			it('should return a promise', () => {
-				const aFulfilledPromise = Bluebird.resolve('a value');
+				const aFulfilledPromise = Promise.resolve('a value');
 
 				const result = sut.matches(aFulfilledPromise);
 
@@ -29,7 +28,7 @@ describe('IsRejected', () => {
 			});
 
 			it('should not match fulfilled promises', () => {
-				const aFulfilledPromise = Bluebird.resolve('a value');
+				const aFulfilledPromise = Promise.resolve('a value');
 
 				return sut.matches(aFulfilledPromise).then((value) => {
 					assert.equal(value, false);
@@ -37,7 +36,7 @@ describe('IsRejected', () => {
 			});
 
 			it('should match rejected promises', () => {
-				const aRejectedPromise = Bluebird.reject(new Error('rejected for a reason'));
+				const aRejectedPromise = Promise.reject(new Error('rejected for a reason'));
 
 				return sut.matches(aRejectedPromise).then((value) => {
 					assert.ok(value);
@@ -46,14 +45,14 @@ describe('IsRejected', () => {
 
 			it('should wait for pending promises', (done) => {
 				let rejectFn;
-				const deferred = new Bluebird((__resolve, reject) => {
+				const deferred = new Promise((__resolve, reject) => {
 					rejectFn = reject;
 				});
 
 				sut.matches(deferred).then((value) => {
 					assert.ok(value);
 				})
-				.nodeify(done);
+				.then(done, done);
 
 				rejectFn(new Error());
 			});
@@ -74,7 +73,7 @@ describe('IsRejected', () => {
 			});
 
 			it('should return a promise', () => {
-				const aFulfilledPromise = Bluebird.resolve('a value');
+				const aFulfilledPromise = Promise.resolve('a value');
 
 				const result = sut.matches(aFulfilledPromise);
 
@@ -83,7 +82,7 @@ describe('IsRejected', () => {
 			});
 
 			it('should not match fulfilled promise with matching value', () => {
-				const aFulfilledPromise = Bluebird.resolve(new Error('a reason'));
+				const aFulfilledPromise = Promise.resolve(new Error('a reason'));
 
 				return sut.matches(aFulfilledPromise).then((value) => {
 					assert.equal(value, false);
@@ -91,7 +90,7 @@ describe('IsRejected', () => {
 			});
 
 			it('should match rejected promise with same reason', () => {
-				const aRejectedPromise = Bluebird.reject(new Error('a reason'));
+				const aRejectedPromise = Promise.reject(new Error('a reason'));
 
 				return sut.matches(aRejectedPromise).then((value) => {
 					assert.ok(value);
@@ -99,7 +98,7 @@ describe('IsRejected', () => {
 			});
 
 			it('should not match rejected promise with different reason', () => {
-				const aRejectedPromise = Bluebird.reject(new Error('another reason'));
+				const aRejectedPromise = Promise.reject(new Error('another reason'));
 				aRejectedPromise.catch(() => null);
 
 				return sut.matches(aRejectedPromise).then((value) => {
@@ -109,14 +108,14 @@ describe('IsRejected', () => {
 
 			it('should wait for pending promises', (done) => {
 				let rejectFn;
-				const deferred = new Bluebird((__resolve, reject) => {
+				const deferred = new Promise((__resolve, reject) => {
 					rejectFn = reject;
 				});
 
 				sut.matches(deferred).then((value) => {
 					assert.ok(value);
 				})
-				.nodeify(done);
+				.then(done, done);
 
 				rejectFn(new Error('a reason'));
 			});
@@ -135,7 +134,7 @@ describe('IsRejected', () => {
 				});
 
 				it('should contain fulfilled value', () => {
-					const actual = Bluebird.resolve('a value');
+					const actual = Promise.resolve('a value');
 
 					return sut.describeMismatch(actual, description).then(() => {
 						__.assertThat(description.get(), __.allOf(__.containsString('was'), __.containsString('fulfilled'), __.containsString('"a value"')));
@@ -143,7 +142,7 @@ describe('IsRejected', () => {
 				});
 
 				it('should contain mismatched reason', () => {
-					const actual = Bluebird.reject(new Error('another reason'));
+					const actual = Promise.reject(new Error('another reason'));
 
 					return sut.describeMismatch(actual, description).then(() => {
 						__.assertThat(description.get(), __.equalTo('rejection value message was "another reason"'));
@@ -159,7 +158,7 @@ describe('IsRejected', () => {
 			});
 
 			it('should return a promise', () => {
-				const aFulfilledPromise = Bluebird.resolve('a value');
+				const aFulfilledPromise = Promise.resolve('a value');
 
 				const result = sut.matches(aFulfilledPromise);
 
@@ -168,7 +167,7 @@ describe('IsRejected', () => {
 			});
 
 			it('should not match fulfilled promise with matching value', () => {
-				const aFulfilledPromise = Bluebird.resolve(new Error('expected value'));
+				const aFulfilledPromise = Promise.resolve(new Error('expected value'));
 
 				return sut.matches(aFulfilledPromise).then((value) => {
 					assert.equal(value, false);
@@ -176,7 +175,7 @@ describe('IsRejected', () => {
 			});
 
 			it('should match rejected promises with matching reason', () => {
-				const aRejectedPromise = Bluebird.reject(new Error('rejected for expected reason'));
+				const aRejectedPromise = Promise.reject(new Error('rejected for expected reason'));
 
 				return sut.matches(aRejectedPromise).then((value) => {
 					assert.ok(value);
@@ -184,7 +183,7 @@ describe('IsRejected', () => {
 			});
 
 			it('should not match rejected promises with different reason', () => {
-				const aRejectedPromise = Bluebird.reject(new Error('rejected for a reason'));
+				const aRejectedPromise = Promise.reject(new Error('rejected for a reason'));
 
 				return sut.matches(aRejectedPromise).then((value) => {
 					assert.equal(value, false);
@@ -193,14 +192,14 @@ describe('IsRejected', () => {
 
 			it('should wait for pending promises', (done) => {
 				let rejectFn;
-				const deferred = new Bluebird((__resolve, reject) => {
+				const deferred = new Promise((__resolve, reject) => {
 					rejectFn = reject;
 				});
 
 				sut.matches(deferred).then((value) => {
 					assert.ok(value);
 				})
-				.nodeify(done);
+				.then(done, done);
 
 				rejectFn(new Error('expected reason'));
 			});
@@ -220,7 +219,7 @@ describe('IsRejected', () => {
 				});
 
 				it('should contain fulfilled value', () => {
-					const actual = Bluebird.resolve('a value');
+					const actual = Promise.resolve('a value');
 
 					return sut.describeMismatch(actual, description).then(() => {
 						__.assertThat(description.get(), __.allOf(__.containsString('was'), __.containsString('fulfilled'), __.containsString('"a value"')));
@@ -228,7 +227,7 @@ describe('IsRejected', () => {
 				});
 
 				it('should contain mismatched description', () => {
-					const actual = Bluebird.reject(new Error('another reason'));
+					const actual = Promise.reject(new Error('another reason'));
 
 					return sut.describeMismatch(actual, description).then(() => {
 						__.assertThat(description.get(), __.equalTo('rejection value message was "another reason"'));

package/test/node/promiseThatSpec.js

@@ -2,7 +2,6 @@
 
 const _ = require('lodash');
 const AssertionError = require('assertion-error');
-const Bluebird = require('bluebird');
 
 const __ = require('../..');
 const TestMatcher = require('./TestMatcher');
@@ -16,113 +15,80 @@ describe('promiseThat', () => {
 		__.assertThat(result, __.is(__.promise()));
 	});
 
-	it('should pass given value to matcher', (done) => {
+	it('should pass given value to matcher', async () => {
 		let passedValue;
 
-		__.promiseThat('a value', new TestMatcher((value) => {
+		await __.promiseThat('a value', new TestMatcher((value) => {
 			passedValue = value;
 			return true;
-		})).done(
-			() => {
-				__.assertThat(passedValue, __.is('a value'));
-				done();
-			},
-			() => {
-				throw new Error('Should not be rejected');
-			}
-		);
+		}));
+		__.assertThat(passedValue, __.is('a value'));
 	});
 
-	it('should fulfill promise if matcher matches', (done) => {
+	it('should fulfill promise if matcher matches', async () => {
 		const input = 'expected value';
 
-		__.promiseThat(input, __.is('expected value')).done(
-			() => {
-				done();
-			},
-			() => {
-				throw new Error('Should not be rejected');
-			}
-		);
+		await __.promiseThat(input, __.is('expected value'));
 	});
 
-	it('should resolve if matcher returns promise resolving to true', (done) => {
+	it('should resolve if matcher returns promise resolving to true', async () => {
 
-		__.promiseThat('a value', new TestMatcher(() => {
-			return Bluebird.resolve(true);
-		})).done(
-			() => {
-				done();
-			},
-			() => {
-				throw new Error('Should not be rejected');
-			}
-		);
+		await __.promiseThat('a value', new TestMatcher(() => {
+			return Promise.resolve(true);
+		}));
 	});
 
-	it('should reject promise with AssertionError if matcher resolves to false', (done) => {
+	it('should reject promise with AssertionError if matcher resolves to false', async () => {
 
-		__.promiseThat('a value', new TestMatcher(() => {
-			return Bluebird.resolve(false);
-		})).done(
-			() => {
-				throw new Error('Should not be fulfilled');
-			},
-			(reason) => {
-				__.assertThat(reason, __.instanceOf(AssertionError));
-				done();
-			}
-		);
+		try {
+			await __.promiseThat('a value', new TestMatcher(() => Promise.resolve(false)));
+			throw new Error('Should not be fulfilled');
+		} catch (e) {
+			__.assertThat(e, __.instanceOf(AssertionError));
+		}
 	});
 
 	it('should defer result until matcher promise resolves', (done) => {
 		let resolveFn;
-		const deferred = new Bluebird((resolve) => {
+		const deferred = new Promise((resolve) => {
 			resolveFn = resolve;
 		});
 
 		__.promiseThat('a value', new TestMatcher(() => {
 			return deferred;
 		}))
-		.nodeify(done);
+		.then(done, done);
 
 		resolveFn(true);
 	});
 
-	it('should allow a message as first parameter', () => {
+	it('should allow a message as first parameter', async () => {
 		const message = 'Some explanation';
 
-		return __.promiseThat(message, 'different value', __.is('expected value')).then(
-			() => {
-				throw new Error('Should not be fulfilled');
-			},
-			(reason) => {
-				__.assertThat(reason, __.instanceOf(AssertionError));
-				__.assertThat(reason.message, __.containsString(message));
-			}
-		);
+		try {
+			await __.promiseThat(message, 'different value', __.is('expected value'));
+			throw new Error('Should not be fulfilled');
+		} catch (e) {
+			__.assertThat(e, __.instanceOf(AssertionError));
+			__.assertThat(e.message, __.containsString(message));
+		}
 	});
 
-	it('should forward rejection if matcher returns rejecting promise', () => {
+	it('should forward rejection if matcher returns rejecting promise', async () => {
 		const rejectionValue = new Error('some reason');
-		const rejectingMatcher = new TestMatcher(() => {
-			return Bluebird.reject(rejectionValue);
-		});
-
-		return __.promiseThat('a value', rejectingMatcher)
-			.then(
-				() => {
-					throw new Error('Should not be fulfilled');
-				},
-				(reason) => {
-					__.assertThat(reason, __.is(rejectionValue));
-				}
-			);
+		const rejectingMatcher = new TestMatcher(() => Promise.reject(rejectionValue));
+
+		try {
+			await __.promiseThat('a value', rejectingMatcher);
+			throw new Error('Should not be fulfilled');
+		} catch (e) {
+			__.assertThat(e, __.is(rejectionValue));
+		}
 	});
 
 	it('should allow matchers to describe mismatch asynchronously', (done) => {
 		let resolveFn;
-		const deferred = new Bluebird((resolve) => {
+		const deferred = new Promise((resolve) => {
 			resolveFn = resolve;
 		});
 		const matcher = _.create(new __.Matcher(), {
@@ -148,31 +114,28 @@ describe('promiseThat', () => {
 				__.assertThat(reason.message, __.containsString('Deferred mismatch description'));
 			}
 		)
-		.nodeify(done);
+		.then(done, done);
 
 		resolveFn();
 	});
 
-	it('should pass diff representations to AssertionError', (done) => {
+	it('should pass diff representations to AssertionError', async () => {
 		const testMatcher = new TestMatcher(() => { return false; });
 		testMatcher.getExpectedForDiff = () => {
 			return 'expected for diff';
 		};
 		testMatcher.formatActualForDiff = function (actual) {
-			return Bluebird.resolve('actual for diff: ' + actual);
+			return Promise.resolve('actual for diff: ' + actual);
 		};
 
-		__.promiseThat('actual value', testMatcher).done(
-			() => {
-				throw new Error('Should not be fulfilled');
-			},
-			(reason) => {
-				__.assertThat(reason, __.hasProperties({
-					expected: 'expected for diff',
-					actual: 'actual for diff: actual value'
-				}));
-				done();
-			}
-		);
+		try {
+			await __.promiseThat('actual value', testMatcher);
+			throw new Error('Should not be fulfilled');
+		} catch (e) {
+			__.assertThat(e, __.hasProperties({
+				expected: 'expected for diff',
+				actual: 'actual for diff: actual value'
+			}));
+		}
 	});
 });