fixup! Support expectation object in t.throws()

Author: novemberborn

index.d.ts

@@ -5,10 +5,10 @@ export interface ObservableLike {
 export type Constructor = (new (...args: Array<any>) => any);
 
 export type ThrowsExpectation = {
+	instanceOf?: Constructor;
 	is?: Error;
 	message?: string | RegExp;
 	name?: string;
-	of?: Constructor;
 };
 
 export type ThrowsErrorValidator = Constructor | RegExp | string | ThrowsExpectation;

index.js.flow

@@ -10,10 +10,10 @@ export interface ObservableLike {
 export type Constructor = Class<{constructor(...args: Array<any>): any}>;
 
 export type ThrowsExpectation = {
+	instanceOf?: Constructor;
 	is?: Error;
 	message?: string | RegExp;
 	name?: string;
-	of?: Constructor;
 };
 
 export type ThrowsErrorValidator = Constructor | RegExp | string | ThrowsExpectation;

lib/assert.js

@@ -171,23 +171,23 @@ function wrapAssertions(callbacks) {
 			}
 
 			if (typeof expected === 'function') {
-				expected = {of: expected};
+				expected = {instanceOf: expected};
 			} else if (typeof expected === 'string' || expected instanceof RegExp) {
 				expected = {message: expected};
 			} else if (arguments.length === 1 || expected === null) {
 				expected = {};
-			} else if (typeof expected !== 'object' || Array.isArray(expected)) {
+			} else if (typeof expected !== 'object' || Array.isArray(expected) || Object.keys(expected).length === 0) {
 				fail(this, new AssertionError({
 					assertion: 'throws',
 					message: 'The second argument to `t.throws()` must be a function, string, regular expression, expectation object or `null`',
 					values: [formatWithLabel('Called with:', expected)]
 				}));
 				return;
 			} else {
-				if (hasOwnProperty(expected, 'of') && typeof expected.of !== 'function') {
+				if (hasOwnProperty(expected, 'instanceOf') && typeof expected.instanceOf !== 'function') {
 					fail(this, new AssertionError({
 						assertion: 'throws',
-						message: 'The `of` property of the second argument to `t.throws()` must be a function',
+						message: 'The `instanceOf` property of the second argument to `t.throws()` must be a function',
 						values: [formatWithLabel('Called with:', expected)]
 					}));
 					return;
@@ -213,10 +213,10 @@ function wrapAssertions(callbacks) {
 
 				for (const key of Object.keys(expected)) {
 					switch (key) {
+						case 'instanceOf':
 						case 'is':
 						case 'message':
 						case 'name':
-						case 'of':
 							continue;
 						default:
 							fail(this, new AssertionError({
@@ -253,14 +253,14 @@ function wrapAssertions(callbacks) {
 					});
 				}
 
-				if (expected.of && !(actual instanceof expected.of)) {
+				if (expected.instanceOf && !(actual instanceof expected.instanceOf)) {
 					throw new AssertionError({
 						assertion: 'throws',
 						message,
 						stack,
 						values: [
 							formatWithLabel(`${prefix} unexpected exception:`, actual),
-							formatWithLabel('Expected instance of:', expected.of)
+							formatWithLabel('Expected instance of:', expected.instanceOf)
 						]
 					});
 				}

readme.md

@@ -918,12 +918,12 @@ The thrown value *must* be an error. It is returned so you can run more assertio
 
 `expected` can be a constructor, in which case the thrown error must be an instance of the constructor. It can be a string, which is compared against the thrown error's message, or a regular expression which is matched against this message. You can also specify a matcher object with one or more of the following properties:
 
+* `instanceOf`: a constructor, the thrown error must be an instance of
 * `is`: the thrown error must be strictly equal to `expected.is`
 * `message`: either a string, which is compared against the thrown error's message, or a regular expression, which is matched against this message
 * `name`: the expected `.name` value of the thrown error
-* `of`: a constructor, the thrown error must be an instance of
 
-`expected` does not need to be specified. If you don't need it but do want to set an assertion message you have to specify `null` or the empty object `{}`.
+`expected` does not need to be specified. If you don't need it but do want to set an assertion message you have to specify `null`.
 
 Example:
 
@@ -964,7 +964,7 @@ When testing an asynchronous function you must also wait for the assertion to co
 test('throws', async t => {
 	await t.throws(async () => {
 		throw new TypeError('🦄');
-	}, {of: TypeError, message: '🦄'});
+	}, {instanceOf: TypeError, message: '🦄'});
 });
 ```
 

test/assert.js

@@ -965,6 +965,14 @@ test('.throws() fails if passed a bad expectation', t => {
 		values: [{label: 'Called with:', formatted: /true/}]
 	});
 
+	failsWith(t, () => {
+		assertions.throws(() => {}, {});
+	}, {
+		assertion: 'throws',
+		message: 'The second argument to `t.throws()` must be a function, string, regular expression, expectation object or `null`',
+		values: [{label: 'Called with:', formatted: /\{\}/}]
+	});
+
 	failsWith(t, () => {
 		assertions.throws(() => {}, []);
 	}, {
@@ -974,11 +982,11 @@ test('.throws() fails if passed a bad expectation', t => {
 	});
 
 	failsWith(t, () => {
-		assertions.throws(() => {}, {of: null});
+		assertions.throws(() => {}, {instanceOf: null});
 	}, {
 		assertion: 'throws',
-		message: 'The `of` property of the second argument to `t.throws()` must be a function',
-		values: [{label: 'Called with:', formatted: /of: null/}]
+		message: 'The `instanceOf` property of the second argument to `t.throws()` must be a function',
+		values: [{label: 'Called with:', formatted: /instanceOf: null/}]
 	});
 
 	failsWith(t, () => {