Make t.throws() and t.notThrows() accept async function as parameter.

Refs: #1371

Author: oantoro

index.js.flow

@@ -55,13 +55,13 @@ type AssertContext = {
 	deepEqual<U>(value: U, expected: U, message?: string): void;
 	// Assert that value is not deep equal to expected.
 	notDeepEqual<U>(value: U, expected: U, message?: string): void;
-	// Assert that function throws an error or promise rejects.
+	// Assert that the promise rejects, or the function throws or returns a rejected promise.
 	// @param error Can be a constructor, regex, error message or validation function.
 	throws: {
 		(value: PromiseLike<mixed>, error?: ErrorValidator, message?: string): Promise<any>;
 		(value: () => mixed, error?: ErrorValidator, message?: string): any;
 	};
-	// Assert that function doesn't throw an error or promise resolves.
+	// Assert that the promise resolves, or the function doesn't throws or returns a resolved promise.
 	notThrows: {
 		(value: PromiseLike<mixed>, message?: string): Promise<void>;
 		(value: () => mixed, message?: string): void;

lib/assert.js

@@ -198,13 +198,14 @@ function wrapAssertions(callbacks) {
 				coreAssertThrowsErrorArg = err;
 			}
 
+			let maybePromise;
 			const test = (fn, stack) => {
 				let actual;
 				let threw = false;
 				try {
 					coreAssert.throws(() => {
 						try {
-							fn();
+							maybePromise = fn();
 						} catch (err) {
 							actual = err;
 							threw = true;
@@ -224,7 +225,7 @@ function wrapAssertions(callbacks) {
 				}
 			};
 
-			if (promise) {
+			const handlePromise = promise => {
 				// Record stack before it gets lost in the promise chain.
 				const stack = getStack();
 				const intermediate = promise.then(value => {
@@ -238,13 +239,25 @@ function wrapAssertions(callbacks) {
 				pending(this, intermediate);
 				// Don't reject the returned promise, even if the assertion fails.
 				return intermediate.catch(noop);
+			};
+
+			if (promise) {
+				return handlePromise(promise);
 			}
 
 			try {
 				const retval = test(fn);
 				pass(this);
 				return retval;
 			} catch (err) {
+				if (maybePromise) {
+					if (isPromise(maybePromise)) {
+						return handlePromise(maybePromise);
+					}
+					if (isObservable(maybePromise)) {
+						return handlePromise(observableToPromise(maybePromise));
+					}
+				}
 				fail(this, err);
 			}
 		},
@@ -265,9 +278,12 @@ function wrapAssertions(callbacks) {
 				return;
 			}
 
+			let maybePromise;
 			const test = (fn, stack) => {
 				try {
-					coreAssert.doesNotThrow(fn);
+					coreAssert.doesNotThrow(() => {
+						maybePromise = fn();
+					});
 				} catch (err) {
 					throw new AssertionError({
 						assertion: 'notThrows',
@@ -278,17 +294,29 @@ function wrapAssertions(callbacks) {
 				}
 			};
 
-			if (promise) {
+			const handlePromise = promise => {
 				// Record stack before it gets lost in the promise chain.
 				const stack = getStack();
 				const intermediate = promise.then(noop, reason => test(makeRethrow(reason), stack));
 				pending(this, intermediate);
 				// Don't reject the returned promise, even if the assertion fails.
 				return intermediate.catch(noop);
+			};
+
+			if (promise) {
+				return handlePromise(promise);
 			}
 
 			try {
 				test(fn);
+				if (maybePromise) {
+					if (isPromise(maybePromise)) {
+						return handlePromise(maybePromise);
+					}
+					if (isObservable(maybePromise)) {
+						return handlePromise(observableToPromise(maybePromise));
+					}
+				}
 				pass(this);
 			} catch (err) {
 				fail(this, err);

readme.md

@@ -913,7 +913,7 @@ Assert that `value` is not deeply equal to `expected`. The inverse of `.deepEqua
 
 ### `.throws(function|promise, [error, [message]])`
 
-Assert that `function` throws an error, or `promise` rejects with an error.
+Assert that `function` throws an error, `promise` rejects with an error, or `function` returns a rejected `promise`.
 
 `error` can be an error constructor, error message, regex matched against the error message, or validation function.
 
@@ -952,9 +952,21 @@ test('rejects', async t => {
 });
 ```
 
+When testing an `async function` you must also wait for the assertion to complete:
+
+```js
+test('throws', async t => {
+	const error = await t.throws(async () => {
+		throw new TypeError('🦄');
+	}, TypeError);
+
+	t.is(error.message, '🦄');
+});
+```
+
 ### `.notThrows(function|promise, [message])`
 
-Assert that `function` does not throw an error or that `promise` does not reject with an error.
+Assert that `function` does not throw an error, `promise` does not reject with an error, or `function` returns a promise that does not reject with an error.
 
 Like the `.throws()` assertion, when testing a promise you must wait for the assertion to complete:
 

test/assert.js

@@ -6,6 +6,7 @@ const stripAnsi = require('strip-ansi');
 const React = require('react');
 const renderer = require('react-test-renderer');
 const test = require('tap').test;
+const Observable = require('zen-observable');
 const assert = require('../lib/assert');
 const snapshotManager = require('../lib/snapshot-manager');
 const Test = require('../lib/test');
@@ -655,7 +656,11 @@ test('.throws()', t => {
 		});
 	});
 
-	t.end();
+	return eventuallyFailsWith(t, assertions.throws(() => Promise.resolve('foo')), {
+		assertion: 'throws',
+		message: 'Expected promise to be rejected, but it was resolved instead',
+		values: [{label: 'Resolved with:', formatted: /'foo'/}]
+	});
 });
 
 test('.throws() returns the thrown error', t => {
@@ -678,6 +683,28 @@ test('.throws() returns the rejection reason of promise', t => {
 	});
 });
 
+test('.throws() returns the rejection reason of a promise returned by the function', t => {
+	const expected = new Error();
+
+	return assertions.throws(() => {
+		return Promise.reject(expected);
+	}).then(actual => {
+		t.is(actual, expected);
+		t.end();
+	});
+});
+
+test('.throws() returns the error of an observable returned by the function', t => {
+	const expected = new Error();
+
+	return assertions.throws(() => {
+		return new Observable(observer => observer.error(expected));
+	}).then(actual => {
+		t.is(actual, expected);
+		t.end();
+	});
+});
+
 test('.throws() fails if passed a bad value', t => {
 	failsWith(t, () => {
 		assertions.throws('not a function');
@@ -723,7 +750,13 @@ test('.notThrows()', t => {
 		values: [{label: 'Threw:', formatted: /foo/}]
 	});
 
-	t.end();
+	return eventuallyFailsWith(t, assertions.notThrows(() => {
+		return Promise.reject(new Error('foo'));
+	}), {
+		assertion: 'notThrows',
+		message: '',
+		values: [{label: 'Threw:', formatted: /foo/}]
+	});
 });
 
 test('.notThrows() returns undefined for a fulfilled promise', t => {
@@ -732,6 +765,22 @@ test('.notThrows() returns undefined for a fulfilled promise', t => {
 	});
 });
 
+test('.notThrows() returns undefined for a fulfilled promise returned by the function', t => {
+	return assertions.notThrows(() => {
+		return Promise.resolve(Symbol(''));
+	}).then(actual => {
+		t.is(actual, undefined);
+	});
+});
+
+test('.notThrows() returns undefined for an observable returned by the function', t => {
+	return assertions.notThrows(() => {
+		return Observable.of(Symbol(''));
+	}).then(actual => {
+		t.is(actual, undefined);
+	});
+});
+
 test('.notThrows() fails if passed a bad value', t => {
 	failsWith(t, () => {
 		assertions.notThrows('not a function');

types/base.d.ts

@@ -67,11 +67,13 @@ export interface AssertContext {
  	 * @param error Can be a constructor, regex, error message or validation function.
  	 */
 	throws(value: PromiseLike<any>, error?: ErrorValidator, message?: string): Promise<any>;
+	throws(value: () => PromiseLike<any>, error?: ErrorValidator, message?: string): Promise<any>;
 	throws(value: () => void, error?: ErrorValidator, message?: string): any;
 	/**
 	 * Assert that function doesn't throw an error or promise resolves.
 	 */
 	notThrows(value: PromiseLike<any>, message?: string): Promise<void>;
+	notThrows(value: () => PromiseLike<any>, message?: string): Promise<void>;
 	notThrows(value: () => void, message?: string): void;
 	/**
 	 * Assert that contents matches regex.