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

Refs: #1371

Author: oantoro

index.js.flow

@@ -56,12 +56,14 @@ type AssertContext = {
 	// 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.
+	// If the given function returns a Promise, then the Promise will be evaluated instead.
 	// @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.
+	// If the given function returns a Promise, then the Promise will be evaluated instead.
 	notThrows: {
 		(value: PromiseLike<mixed>, message?: string): Promise<void>;
 		(value: () => mixed, message?: string): void;

lib/assert.js

@@ -182,13 +182,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;
@@ -208,7 +209,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 => {
@@ -222,13 +223,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);
 			}
 		},
@@ -249,9 +262,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',
@@ -262,17 +278,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

@@ -948,7 +948,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.
 
@@ -979,6 +979,16 @@ test('rejects', async t => {
 });
 ```
 
+```js
+test('throws', async t => {
+	const error = await t.throws(async () => {
+		throw new TypeError('🦄');
+	}, TypeError);
+
+	t.is(error.message, '🦄');
+});
+```
+
 When testing a promise you must wait for the assertion to complete:
 
 ```js
@@ -987,9 +997,19 @@ test('rejects', async t => {
 });
 ```
 
+When testing an `async function` you must also wait for the assertion to complete:
+
+```js
+test('rejects', async t => {
+	await t.throws(async () => {
+		throw new TypeError('🦄');
+	});
+});
+```
+
 ### `.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 or that `promise` does not reject with an error. When you pass a `function` that returns a `promise` as parameter, the returned promise will be evaluated instead.
 
 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');
@@ -678,6 +679,28 @@ test('.throws() returns the rejection reason of promise', t => {
 	});
 });
 
+test('.throws() returns the rejection reason of function that return rejected `Promise`', t => {
+	const expected = new Error();
+
+	return assertions.throws(() => {
+		return Promise.reject(expected);
+	}).then(actual => {
+		t.is(actual, expected);
+		t.end();
+	});
+});
+
+test('.throws() throws exception from `Observable`', 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');
@@ -732,6 +755,22 @@ test('.notThrows() returns undefined for a fulfilled promise', t => {
 	});
 });
 
+test('.notThrows() returns undefined for a function that return fulfilled promise', t => {
+	return assertions.notThrows(() => {
+		return Promise.resolve(Symbol(''));
+	}).then(actual => {
+		t.is(actual, undefined);
+	});
+});
+
+test('.notThrows() returns undefined for a function that return `Observable`', 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.