mirror of
https://github.com/denoland/std.git
synced 2024-11-22 04:59:05 +00:00
c46143f0ac
* chore: update copyright year * fix --------- Co-authored-by: Asher Gomez <ashersaupingomez@gmail.com>
107 lines
3.1 KiB
TypeScript
107 lines
3.1 KiB
TypeScript
// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
|
|
import { AssertionError } from "./assertion_error.ts";
|
|
import { assertIsError } from "./assert_is_error.ts";
|
|
|
|
/**
|
|
* Executes a function which returns a promise, expecting it to reject.
|
|
*
|
|
* @example
|
|
* ```ts
|
|
* import { assertRejects } from "https://deno.land/std@$STD_VERSION/assert/assert_rejects.ts";
|
|
*
|
|
* await assertRejects(async () => Promise.reject(new Error())); // Doesn't throw
|
|
* await assertRejects(async () => console.log("Hello world")); // Throws
|
|
* ```
|
|
*/
|
|
export function assertRejects(
|
|
fn: () => PromiseLike<unknown>,
|
|
msg?: string,
|
|
): Promise<unknown>;
|
|
/**
|
|
* Executes a function which returns a promise, expecting it to reject.
|
|
* If it does not, then it throws. An error class and a string that should be
|
|
* included in the error message can also be asserted.
|
|
*
|
|
* @example
|
|
* ```ts
|
|
* import { assertRejects } from "https://deno.land/std@$STD_VERSION/assert/assert_rejects.ts";
|
|
*
|
|
* await assertRejects(async () => Promise.reject(new Error()), Error); // Doesn't throw
|
|
* await assertRejects(async () => Promise.reject(new Error()), SyntaxError); // Throws
|
|
* ```
|
|
*/
|
|
export function assertRejects<E extends Error = Error>(
|
|
fn: () => PromiseLike<unknown>,
|
|
// deno-lint-ignore no-explicit-any
|
|
ErrorClass: new (...args: any[]) => E,
|
|
msgIncludes?: string,
|
|
msg?: string,
|
|
): Promise<E>;
|
|
export async function assertRejects<E extends Error = Error>(
|
|
fn: () => PromiseLike<unknown>,
|
|
errorClassOrMsg?:
|
|
// deno-lint-ignore no-explicit-any
|
|
| (new (...args: any[]) => E)
|
|
| string,
|
|
msgIncludesOrMsg?: string,
|
|
msg?: string,
|
|
): Promise<E | Error | unknown> {
|
|
// deno-lint-ignore no-explicit-any
|
|
let ErrorClass: (new (...args: any[]) => E) | undefined = undefined;
|
|
let msgIncludes: string | undefined = undefined;
|
|
let err;
|
|
|
|
if (typeof errorClassOrMsg !== "string") {
|
|
if (
|
|
errorClassOrMsg === undefined ||
|
|
errorClassOrMsg.prototype instanceof Error ||
|
|
errorClassOrMsg.prototype === Error.prototype
|
|
) {
|
|
// deno-lint-ignore no-explicit-any
|
|
ErrorClass = errorClassOrMsg as new (...args: any[]) => E;
|
|
msgIncludes = msgIncludesOrMsg;
|
|
}
|
|
} else {
|
|
msg = errorClassOrMsg;
|
|
}
|
|
let doesThrow = false;
|
|
let isPromiseReturned = false;
|
|
const msgSuffix = msg ? `: ${msg}` : ".";
|
|
try {
|
|
const possiblePromise = fn();
|
|
if (
|
|
possiblePromise &&
|
|
typeof possiblePromise === "object" &&
|
|
typeof possiblePromise.then === "function"
|
|
) {
|
|
isPromiseReturned = true;
|
|
await possiblePromise;
|
|
}
|
|
} catch (error) {
|
|
if (!isPromiseReturned) {
|
|
throw new AssertionError(
|
|
`Function throws when expected to reject${msgSuffix}`,
|
|
);
|
|
}
|
|
if (ErrorClass) {
|
|
if (error instanceof Error === false) {
|
|
throw new AssertionError(`A non-Error object was rejected${msgSuffix}`);
|
|
}
|
|
assertIsError(
|
|
error,
|
|
ErrorClass,
|
|
msgIncludes,
|
|
msg,
|
|
);
|
|
}
|
|
err = error;
|
|
doesThrow = true;
|
|
}
|
|
if (!doesThrow) {
|
|
throw new AssertionError(
|
|
`Expected function to reject${msgSuffix}`,
|
|
);
|
|
}
|
|
return err;
|
|
}
|