123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212
// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
export interface Chalk {  green(text: string): string;  red(text: string): string;  gray(text: string): string;}
export interface NodeProcess {  stdout: {    write(text: string): void;  };  exit(code: number): number;}
export interface RunTestDefinitionsOptions {  chalk: Chalk;  process: NodeProcess;  /** The file the tests are running in. */  origin: string;}
export interface TestDefinition {  name: string;  fn: (context: TestContext) => Promise<void> | void;  ignore?: boolean;}
export interface TestContext {  name: string;  parent: TestContext | undefined;  origin: string;  err: any;  children: TestContext[];  hasFailingChild: boolean;  getOutput(): string;  step(    nameOrDefinition: string | TestDefinition,    fn?: (context: TestContext) => void | Promise<void>,  ): Promise<boolean>;  status: "ok" | "fail" | "pending" | "ignored";}
export async function runTestDefinitions(  testDefinitions: TestDefinition[],  options: RunTestDefinitionsOptions,) {  const testFailures = [];  for (const definition of testDefinitions) {    options.process.stdout.write("test " + definition.name + " ...");    if (definition.ignore) {      options.process.stdout.write(` ${options.chalk.gray("ignored")}\n`);      continue;    }    const context = getTestContext(definition, undefined);    let pass = false;    try {      await definition.fn(context);      if (context.hasFailingChild) {        testFailures.push({          name: definition.name,          err: new Error("Had failing test step."),        });      } else {        pass = true;      }    } catch (err) {      testFailures.push({ name: definition.name, err });    }    const testStepOutput = context.getOutput();    if (testStepOutput.length > 0) {      options.process.stdout.write(testStepOutput);    } else {      options.process.stdout.write(" ");    }    options.process.stdout.write(getStatusText(pass ? "ok" : "fail"));    options.process.stdout.write("\n");  }
  if (testFailures.length > 0) {    options.process.stdout.write("\nFAILURES");    for (const failure of testFailures) {      options.process.stdout.write("\n\n");      options.process.stdout.write(failure.name + "\n");      options.process.stdout.write(        indentText((failure.err?.stack ?? failure.err).toString(), 1),      );    }    options.process.exit(1);  }
  function getTestContext(    definition: TestDefinition,    parent: TestContext | undefined,  ): TestContext {    return {      name: definition.name,      parent,      origin: options.origin,      /** @type {any} */      err: undefined,      status: "ok",      children: [],      get hasFailingChild() {        return this.children.some((c) =>          c.status === "fail" || c.status === "pending"        );      },      getOutput() {        let output = "";        if (this.parent) {          output += "test " + this.name + " ...";        }        if (this.children.length > 0) {          output += "\n" + this.children.map((c) =>            indentText(c.getOutput(), 1)          ).join("\n") + "\n";        } else if (!this.err) {          output += " ";        }        if (this.parent && this.err) {          output += "\n";        }        if (this.err) {          output += indentText((this.err.stack ?? this.err).toString(), 1);          if (this.parent) {            output += "\n";          }        }        if (this.parent) {          output += getStatusText(this.status);        }        return output;      },      async step(nameOrTestDefinition, fn) {        const definition = getDefinition();
        const context = getTestContext(definition, this);        context.status = "pending";        this.children.push(context);
        if (definition.ignore) {          context.status = "ignored";          return false;        }
        try {          await definition.fn(context);          context.status = "ok";          if (context.hasFailingChild) {            context.status = "fail";            return false;          }          return true;        } catch (err) {          context.status = "fail";          context.err = err;          return false;        }
        /** @returns {TestDefinition} */        function getDefinition() {          if (typeof nameOrTestDefinition === "string") {            if (!(fn instanceof Function)) {              throw new TypeError("Expected function for second argument.");            }            return {              name: nameOrTestDefinition,              fn,            };          } else if (typeof nameOrTestDefinition === "object") {            return nameOrTestDefinition;          } else {            throw new TypeError(              "Expected a test definition or name and function.",            );          }        }      },    };  }
  function getStatusText(status: TestContext["status"]) {    switch (status) {      case "ok":        return options.chalk.green(status);      case "fail":      case "pending":        return options.chalk.red(status);      case "ignored":        return options.chalk.gray(status);      default: {        const _assertNever: never = status;        return status;      }    }  }
  function indentText(text: string, indentLevel: number) {    if (text === undefined) {      text = "[undefined]";    } else if (text === null) {      text = "[null]";    } else {      text = text.toString();    }    return text.split(/\r?\n/)      .map((line) => "  ".repeat(indentLevel) + line)      .join("\n");  }}