Allow throws to accept a fn/Promise that throws anything

.xo-config.cjs

@@ -89,5 +89,13 @@ module.exports = {
 				'unicorn/error-message': 'off',
 			},
 		},
+		{
+			files: 'test-tap/assert.js',
+			rules: {
+				'prefer-promise-reject-errors': 'off',
+				'no-throw-literal': 'off',
+			},
+		},
+
 	],
 };

lib/assert.js

@@ -137,13 +137,22 @@ function validateExpectations(assertion, expectations, numberArgs) { // eslint-d
 			});
 		}
 
+		if (Object.hasOwn(expectations, 'any') && typeof expectations.any !== 'boolean') {
+			throw new AssertionError({
+				assertion,
+				message: `The \`any\` property of the second argument to \`t.${assertion}()\` must be a bool`,
+				values: [formatWithLabel('Called with:', expectations)],
+			});
+		}
+
 		for (const key of Object.keys(expectations)) {
 			switch (key) {
 				case 'instanceOf':
 				case 'is':
 				case 'message':
 				case 'name':
-				case 'code': {
+				case 'code':
+				case 'any': {
 					continue;
 				}
 
@@ -164,7 +173,8 @@ function validateExpectations(assertion, expectations, numberArgs) { // eslint-d
 // Note: this function *must* throw exceptions, since it can be used
 // as part of a pending assertion for promises.
 function assertExpectations({assertion, actual, expectations, message, prefix, savedError}) {
-	if (!isNativeError(actual)) {
+	const allowThrowAnything = Object.hasOwn(expectations, 'any') && expectations.any;
+	if (!isNativeError(actual) && !allowThrowAnything) {
 		throw new AssertionError({
 			assertion,
 			message,

test-tap/assert.js

@@ -838,6 +838,11 @@ test('.throws()', gather(t => {
 		throw new Error('foo');
 	}));
 
+	// Passes when string is thrown, only when any is set to true.
+	passes(t, () => assertions.throws(() => {
+		throw 'foo';
+	}, {any: true}));
+
 	// Passes because the correct error is thrown.
 	passes(t, () => {
 		const error = new Error('foo');
@@ -1040,9 +1045,19 @@ test('.throwsAsync()', gather(t => {
 		values: [{label: 'Returned promise resolved with:', formatted: /'foo'/}],
 	});
 
+	// Fails because the function returned a promise that rejected, but not with an error.
+	throwsAsyncFails(t, () => assertions.throwsAsync(() => Promise.reject('foo')), {
+		assertion: 'throwsAsync',
+		message: '',
+		values: [{label: 'Returned promise rejected with exception that is not an error:', formatted: /'foo'/}],
+	});
+
 	// Passes because the promise was rejected with an error.
 	throwsAsyncPasses(t, () => assertions.throwsAsync(Promise.reject(new Error())));
 
+	// Passes because the promise was rejected with an with an non-error exception, & set `any` to true in expectation.
+	throwsAsyncPasses(t, () => assertions.throwsAsync(Promise.reject('foo'), {any: true}));
+
 	// Passes because the function returned a promise rejected with an error.
 	throwsAsyncPasses(t, () => assertions.throwsAsync(() => Promise.reject(new Error())));