123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227
// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.// Copyright 2019 Allain Lalonde. All rights reserved. ISC License.
import type { AnyConstructor, Matcher, MatcherContext } from "./_types.ts";import { AssertionError } from "../assert/assertion_error.ts";import {  toBe,  toBeCloseTo,  toBeDefined,  toBeFalsy,  toBeGreaterThan,  toBeGreaterThanOrEqual,  toBeInstanceOf,  toBeLessThan,  toBeLessThanOrEqual,  toBeNaN,  toBeNull,  toBeTruthy,  toBeUndefined,  toContain,  toContainEqual,  toEqual,  toHaveBeenCalled,  toHaveBeenCalledTimes,  toHaveBeenCalledWith,  toHaveBeenLastCalledWith,  toHaveBeenNthCalledWith,  toHaveLastReturnedWith,  toHaveLength,  toHaveNthReturnedWith,  toHaveProperty,  toHaveReturned,  toHaveReturnedTimes,  toHaveReturnedWith,  toMatch,  toMatchObject,  toStrictEqual,  toThrow,} from "./_matchers.ts";export interface Expected {  lastCalledWith(...expected: unknown[]): void;  lastReturnedWith(expected: unknown): void;  nthCalledWith(nth: number, ...expected: unknown[]): void;  nthReturnedWith(nth: number, expected: unknown): void;  toBeCalled(): void;  toBeCalledTimes(expected: number): void;  toBeCalledWith(...expected: unknown[]): void;  toBeCloseTo(candidate: number, tolerance?: number): void;  toBeDefined(): void;  toBeFalsy(): void;  toBeGreaterThan(expected: number): void;  toBeGreaterThanOrEqual(expected: number): void;  toBeInstanceOf<T extends AnyConstructor>(expected: T): void;  toBeLessThan(expected: number): void;  toBeLessThanOrEqual(expected: number): void;  toBeNaN(): void;  toBeNull(): void;  toBeTruthy(): void;  toBeUndefined(): void;  toBe(expected: unknown): void;  toContainEqual(expected: unknown): void;  toContain(expected: unknown): void;  toEqual(expected: unknown): void;  toHaveBeenCalledTimes(expected: number): void;  toHaveBeenCalledWith(...expected: unknown[]): void;  toHaveBeenCalled(): void;  toHaveBeenLastCalledWith(...expected: unknown[]): void;  toHaveBeenNthCalledWith(nth: number, ...expected: unknown[]): void;  toHaveLength(expected: number): void;  toHaveLastReturnedWith(expected: unknown): void;  toHaveNthReturnedWith(nth: number, expected: unknown): void;  toHaveProperty(propName: string | string[], value?: unknown): void;  toHaveReturnedTimes(expected: number): void;  toHaveReturnedWith(expected: unknown): void;  toHaveReturned(): void;  toMatch(expected: RegExp): void;  toMatchObject(expected: Record<PropertyKey, unknown>): void;  toReturn(): void;  toReturnTimes(expected: number): void;  toReturnWith(expected: unknown): void;  toStrictEqual(candidate: unknown): void;  // deno-lint-ignore no-explicit-any  toThrow<E extends Error = Error>(expected?: new (...args: any[]) => E): void;  not: Expected;  resolves: Async<Expected>;  rejects: Async<Expected>;}
type MatcherKey = keyof Omit<Expected, "not" | "resolves" | "rejects">;
const matchers: Record<MatcherKey, Matcher> = {  lastCalledWith: toHaveBeenLastCalledWith,  lastReturnedWith: toHaveLastReturnedWith,  nthCalledWith: toHaveBeenNthCalledWith,  nthReturnedWith: toHaveNthReturnedWith,  toBeCalled: toHaveBeenCalled,  toBeCalledTimes: toHaveBeenCalledTimes,  toBeCalledWith: toHaveBeenCalledWith,  toBeCloseTo,  toBeDefined,  toBeFalsy,  toBeGreaterThanOrEqual,  toBeGreaterThan,  toBeInstanceOf,  toBeLessThanOrEqual,  toBeLessThan,  toBeNaN,  toBeNull,  toBeTruthy,  toBeUndefined,  toBe,  toContainEqual,  toContain,  toEqual,  toHaveBeenCalledTimes,  toHaveBeenCalledWith,  toHaveBeenCalled,  toHaveBeenLastCalledWith,  toHaveBeenNthCalledWith,  toHaveLength,  toHaveLastReturnedWith,  toHaveNthReturnedWith,  toHaveProperty,  toHaveReturnedTimes,  toHaveReturnedWith,  toHaveReturned,  toMatchObject,  toMatch,  toReturn: toHaveReturned,  toReturnTimes: toHaveReturnedTimes,  toReturnWith: toHaveReturnedWith,  toStrictEqual,  toThrow,};
export function expect(value: unknown, customMessage?: string): Expected {  let isNot = false;  let isPromised = false;  const self: Expected = new Proxy<Expected>(    <Expected> {},    {      get(_, name) {        if (name === "not") {          isNot = !isNot;          return self;        }
        if (name === "resolves") {          if (!isPromiseLike(value)) {            throw new AssertionError("expected value must be Promiselike");          }
          isPromised = true;          return self;        }
        if (name === "rejects") {          if (!isPromiseLike(value)) {            throw new AssertionError("expected value must be a PromiseLike");          }
          value = value.then(            (value) => {              throw new AssertionError(                `Promise did not reject. resolved to ${value}`,              );            },            (err) => err,          );          isPromised = true;          return self;        }
        const matcher: Matcher = matchers[name as MatcherKey];        if (!matcher) {          throw new TypeError(            typeof name === "string"              ? `matcher not found: ${name}`              : "matcher not found",          );        }
        return (...args: unknown[]) => {          function applyMatcher(value: unknown, args: unknown[]) {            const context: MatcherContext = {              value,              isNot: false,              customMessage,            };            if (isNot) {              context.isNot = true;            }            matcher(context, ...args);          }
          return isPromised            ? (value as Promise<unknown>).then((value: unknown) =>              applyMatcher(value, args)            )            : applyMatcher(value, args);        };      },    },  );
  return self;}
// a helper type to match any function. Used so that we only convert functions// to return a promise and not properties.type Fn = (...args: unknown[]) => unknown;
// converts all the methods in an interface to be async functionsexport type Async<T> = {  [K in keyof T]: T[K] extends Fn    ? (...args: Parameters<T[K]>) => Promise<ReturnType<T[K]>>    : T[K];};
function isPromiseLike(value: unknown): value is PromiseLike<unknown> {  if (value == null) {    return false;  } else {    return typeof ((value as Record<string, unknown>).then) === "function";  }}