@japa/runner 3.0.0-6 → 3.0.0-8

package/build/chunk-7THDHQFT.js

@@ -0,0 +1,283 @@
+import {
+  BaseReporter
+} from "./chunk-MCOW34SG.js";
+
+// src/helpers.ts
+import useColors from "@poppinss/colors";
+var colors = useColors.ansi();
+var icons = process.platform === "win32" && !process.env.WT_SESSION ? {
+  tick: "\u221A",
+  cross: "\xD7",
+  bullet: "*",
+  nodejs: "\u2666",
+  pointer: ">",
+  info: "i",
+  warning: "\u203C",
+  squareSmallFilled: "[\u2588]"
+} : {
+  tick: "\u2714",
+  cross: "\u2716",
+  bullet: "\u25CF",
+  nodejs: "\u2B22",
+  pointer: "\u276F",
+  info: "\u2139",
+  warning: "\u26A0",
+  squareSmallFilled: "\u25FC"
+};
+
+// src/reporters/dot.ts
+var DotReporter = class extends BaseReporter {
+  /**
+   * When a test ended
+   */
+  onTestEnd(payload) {
+    let output = "";
+    if (payload.isTodo) {
+      output = colors.cyan(icons.info);
+    } else if (payload.hasError || payload.isFailing) {
+      output = payload.hasError ? colors.magenta(icons.squareSmallFilled) : colors.red(icons.cross);
+    } else if (payload.isSkipped) {
+      output = colors.yellow(icons.bullet);
+    } else {
+      output = colors.green(icons.tick);
+    }
+    process.stdout.write(`${output}`);
+  }
+  /**
+   * When test runner ended
+   */
+  async end() {
+    console.log("");
+    await this.printSummary(this.runner.getSummary());
+  }
+};
+
+// src/reporters/spec.ts
+import ms from "ms";
+import { relative } from "node:path";
+var SpecReporter = class extends BaseReporter {
+  /**
+   * Tracking if the first event we get is for a test without any parent group
+   * We need this to decide the display style for tests without groups.
+   */
+  #isFirstLoneTest = true;
+  /**
+   * Returns the icon for the test
+   */
+  #getTestIcon(payload) {
+    if (payload.isTodo) {
+      return colors.cyan(icons.info);
+    }
+    if (payload.isFailing) {
+      return payload.hasError ? colors.magenta(icons.squareSmallFilled) : colors.red(icons.cross);
+    }
+    if (payload.hasError) {
+      return colors.red(icons.cross);
+    }
+    if (payload.isSkipped) {
+      return colors.yellow(icons.bullet);
+    }
+    return colors.green(icons.tick);
+  }
+  /**
+   * Returns the test message
+   */
+  #getTestMessage(payload) {
+    const message = typeof payload.title === "string" ? payload.title : payload.title.expanded;
+    if (payload.isTodo) {
+      return colors.blue(message);
+    }
+    if (payload.isFailing) {
+      return payload.hasError ? colors.magenta(message) : colors.red(message);
+    }
+    if (payload.hasError) {
+      return colors.red(message);
+    }
+    if (payload.isSkipped) {
+      return colors.yellow(message);
+    }
+    return colors.grey(message);
+  }
+  /**
+   * Returns the subtext message for the test
+   */
+  #getSubText(payload) {
+    if (payload.isSkipped && payload.skipReason) {
+      return colors.yellow(payload.skipReason);
+    }
+    if (!payload.isFailing) {
+      return;
+    }
+    if (!payload.hasError) {
+      return colors.magenta(`Test marked with ".fails()" must finish with an error`);
+    }
+    if (payload.failReason) {
+      return colors.magenta(payload.failReason);
+    }
+    const testErrorMessage = payload.errors.find((error) => error.phase === "test");
+    if (testErrorMessage && testErrorMessage.error) {
+      return colors.magenta(testErrorMessage.error.message);
+    }
+  }
+  /**
+   * Returns the filename relative from the current working dir
+   */
+  #getRelativeFilename(fileName) {
+    return relative(process.cwd(), fileName);
+  }
+  /**
+   * Prints the test details
+   */
+  #printTest(payload) {
+    const icon = this.#getTestIcon(payload);
+    const message = this.#getTestMessage(payload);
+    const prefix = payload.isPinned ? colors.yellow("[PINNED] ") : "";
+    const indentation = this.currentFileName || this.currentGroupName ? "  " : "";
+    const duration = colors.dim(`(${ms(Number(payload.duration.toFixed(2)))})`);
+    const retries = payload.retryAttempt && payload.retryAttempt > 1 ? colors.dim(`(x${payload.retryAttempt}) `) : "";
+    let subText = this.#getSubText(payload);
+    subText = subText ? `
+${indentation}  ${subText}` : "";
+    console.log(`${indentation}${icon} ${prefix}${retries}${message} ${duration}${subText}`);
+  }
+  /**
+   * Prints the group name
+   */
+  #printGroup(payload) {
+    const title = this.currentSuiteName !== "default" ? `${this.currentSuiteName} / ${payload.title}` : payload.title;
+    const suffix = this.currentFileName ? colors.dim(` (${this.#getRelativeFilename(this.currentFileName)})`) : "";
+    console.log(`
+${title}${suffix}`);
+  }
+  onTestStart() {
+    if (this.currentFileName && this.#isFirstLoneTest) {
+      console.log(`
+${colors.dim(this.#getRelativeFilename(this.currentFileName))}`);
+    }
+    this.#isFirstLoneTest = false;
+  }
+  onTestEnd(payload) {
+    this.#printTest(payload);
+  }
+  onGroupStart(payload) {
+    this.#isFirstLoneTest = false;
+    this.#printGroup(payload);
+  }
+  onGroupEnd() {
+    this.#isFirstLoneTest = true;
+  }
+  async end() {
+    const summary = this.runner.getSummary();
+    await this.printSummary(summary);
+  }
+};
+
+// src/reporters/ndjson.ts
+import { relative as relative2 } from "node:path";
+import { serializeError } from "serialize-error";
+var NdJSONReporter = class extends BaseReporter {
+  /**
+   * Returns the filename relative from the current working dir
+   */
+  #getRelativeFilename(fileName) {
+    return relative2(process.cwd(), fileName);
+  }
+  /**
+   * Serialize errors to JSON
+   */
+  #serializeErrors(errors) {
+    return errors.map((error) => ({
+      phase: error.phase,
+      error: serializeError(error.error)
+    }));
+  }
+  onTestEnd(payload) {
+    console.log(
+      JSON.stringify({
+        event: "test:end",
+        filePath: this.currentFileName,
+        relativePath: this.currentFileName ? this.#getRelativeFilename(this.currentFileName) : void 0,
+        title: payload.title,
+        duration: payload.duration,
+        failReason: payload.failReason,
+        isFailing: payload.isFailing,
+        skipReason: payload.skipReason,
+        isSkipped: payload.isSkipped,
+        isTodo: payload.isTodo,
+        isPinned: payload.isPinned,
+        retryAttempt: payload.retryAttempt,
+        retries: payload.retries,
+        errors: this.#serializeErrors(payload.errors)
+      })
+    );
+  }
+  onGroupStart(payload) {
+    console.log(
+      JSON.stringify({
+        event: "group:start",
+        title: payload.title
+      })
+    );
+  }
+  onGroupEnd(payload) {
+    JSON.stringify({
+      event: "group:end",
+      title: payload.title,
+      errors: this.#serializeErrors(payload.errors)
+    });
+  }
+  onSuiteStart(payload) {
+    console.log(
+      JSON.stringify({
+        event: "suite:start",
+        ...payload
+      })
+    );
+  }
+  onSuiteEnd(payload) {
+    console.log(
+      JSON.stringify({
+        event: "suite:end",
+        ...payload
+      })
+    );
+  }
+  async end() {
+    const summary = this.runner.getSummary();
+    console.log(
+      JSON.stringify({
+        aggregates: summary.aggregates,
+        duration: summary.duration,
+        failedTestsTitles: summary.failedTestsTitles,
+        hasError: summary.hasError
+      })
+    );
+  }
+};
+
+// src/reporters/main.ts
+var spec = (options) => {
+  return {
+    name: "spec",
+    handler: (...args) => new SpecReporter(options).boot(...args)
+  };
+};
+var dot = (options) => {
+  return {
+    name: "dot",
+    handler: (...args) => new DotReporter(options).boot(...args)
+  };
+};
+var ndjson = (options) => {
+  return {
+    name: "ndjson",
+    handler: (...args) => new NdJSONReporter(options).boot(...args)
+  };
+};
+
+export {
+  colors,
+  spec,
+  dot,
+  ndjson
+};

package/build/chunk-HN4AVHWN.js

@@ -0,0 +1,17 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+
+export {
+  __reExport
+};

package/build/chunk-MCOW34SG.js

@@ -0,0 +1,269 @@
+// modules/core/main.ts
+import {
+  Emitter,
+  Refiner,
+  Test as BaseTest,
+  Suite as BaseSuite,
+  Group as BaseGroup,
+  Runner as BaseRunner,
+  TestContext as BaseTestContext
+} from "@japa/core";
+import { inspect } from "node:util";
+import { AssertionError } from "node:assert";
+
+// modules/core/reporters/base.ts
+import ms from "ms";
+import colors from "@poppinss/colors";
+import { ErrorsPrinter } from "@japa/errors-printer";
+var ansi = colors.ansi();
+var BaseReporter = class {
+  #options;
+  runner;
+  /**
+   * Path to the file for which the tests are getting executed
+   */
+  currentFileName;
+  /**
+   * Suite for which the tests are getting executed
+   */
+  currentSuiteName;
+  /**
+   * Group for which the tests are getting executed
+   */
+  currentGroupName;
+  constructor(options = {}) {
+    this.#options = Object.assign({ stackLinesCount: 2 }, options);
+  }
+  /**
+   * Pretty prints the aggregates
+   */
+  #printAggregates(summary) {
+    const tests = [];
+    if (summary.aggregates.passed) {
+      tests.push(ansi.green(`${summary.aggregates.passed} passed`));
+    }
+    if (summary.aggregates.failed) {
+      tests.push(ansi.red(`${summary.aggregates.failed} failed`));
+    }
+    if (summary.aggregates.todo) {
+      tests.push(ansi.cyan(`${summary.aggregates.todo} todo`));
+    }
+    if (summary.aggregates.skipped) {
+      tests.push(ansi.yellow(`${summary.aggregates.skipped} skipped`));
+    }
+    if (summary.aggregates.regression) {
+      tests.push(ansi.magenta(`${summary.aggregates.regression} regression`));
+    }
+    this.runner.summaryBuilder.use(() => {
+      return [
+        {
+          key: ansi.dim("Tests"),
+          value: `${tests.join(", ")} ${ansi.dim(`(${summary.aggregates.total})`)}`
+        },
+        {
+          key: ansi.dim("Time"),
+          value: ansi.dim(ms(summary.duration))
+        }
+      ];
+    });
+    console.log(this.runner.summaryBuilder.build().join("\n"));
+  }
+  /**
+   * Aggregates errors tree to a flat array
+   */
+  #aggregateErrors(summary) {
+    const errorsList = [];
+    summary.failureTree.forEach((suite) => {
+      suite.errors.forEach((error) => errorsList.push({ title: suite.name, ...error }));
+      suite.children.forEach((testOrGroup) => {
+        if (testOrGroup.type === "test") {
+          testOrGroup.errors.forEach((error) => {
+            errorsList.push({ title: `${suite.name} / ${testOrGroup.title}`, ...error });
+          });
+          return;
+        }
+        testOrGroup.errors.forEach((error) => {
+          errorsList.push({ title: testOrGroup.name, ...error });
+        });
+        testOrGroup.children.forEach((test) => {
+          test.errors.forEach((error) => {
+            errorsList.push({ title: `${testOrGroup.name} / ${test.title}`, ...error });
+          });
+        });
+      });
+    });
+    return errorsList;
+  }
+  /**
+   * Pretty print errors
+   */
+  async #printErrors(summary) {
+    if (!summary.failureTree.length) {
+      return;
+    }
+    const errorPrinter = new ErrorsPrinter({
+      stackLinesCount: this.#options.stackLinesCount,
+      framesMaxLimit: this.#options.framesMaxLimit
+    });
+    errorPrinter.printSectionHeader("ERRORS");
+    await errorPrinter.printErrors(this.#aggregateErrors(summary));
+  }
+  /**
+   * Handlers to capture events
+   */
+  onTestStart(_) {
+  }
+  onTestEnd(_) {
+  }
+  onGroupStart(_) {
+  }
+  onGroupEnd(_) {
+  }
+  onSuiteStart(_) {
+  }
+  onSuiteEnd(_) {
+  }
+  async start(_) {
+  }
+  async end(_) {
+  }
+  /**
+   * Print tests summary
+   */
+  async printSummary(summary) {
+    await this.#printErrors(summary);
+    console.log("");
+    if (summary.aggregates.total === 0 && !summary.hasError) {
+      console.log(ansi.bgYellow().black(" NO TESTS EXECUTED "));
+      return;
+    }
+    if (summary.hasError) {
+      console.log(ansi.bgRed().black(" FAILED "));
+    } else {
+      console.log(ansi.bgGreen().black(" PASSED "));
+    }
+    console.log("");
+    this.#printAggregates(summary);
+  }
+  /**
+   * Invoked by the tests runner when tests are about to start
+   */
+  boot(runner, emitter) {
+    this.runner = runner;
+    emitter.on("test:start", (payload) => {
+      this.currentFileName = payload.meta.fileName;
+      this.onTestStart(payload);
+    });
+    emitter.on("test:end", (payload) => {
+      this.onTestEnd(payload);
+    });
+    emitter.on("group:start", (payload) => {
+      this.currentGroupName = payload.title;
+      this.currentFileName = payload.meta.fileName;
+      this.onGroupStart(payload);
+    });
+    emitter.on("group:end", (payload) => {
+      this.currentGroupName = void 0;
+      this.onGroupEnd(payload);
+    });
+    emitter.on("suite:start", (payload) => {
+      this.currentSuiteName = payload.name;
+      this.onSuiteStart(payload);
+    });
+    emitter.on("suite:end", (payload) => {
+      this.currentSuiteName = void 0;
+      this.onSuiteEnd(payload);
+    });
+    emitter.on("runner:start", async (payload) => {
+      await this.start(payload);
+    });
+    emitter.on("runner:end", async (payload) => {
+      await this.end(payload);
+    });
+  }
+};
+
+// modules/core/main.ts
+var TestContext = class extends BaseTestContext {
+  constructor(test) {
+    super();
+    this.test = test;
+    this.cleanup = (cleanupCallback) => {
+      test.cleanup(cleanupCallback);
+    };
+  }
+};
+var Test = class extends BaseTest {
+  /**
+   * @inheritdoc
+   */
+  static executedCallbacks = [];
+  /**
+   * @inheritdoc
+   */
+  static executingCallbacks = [];
+  /**
+   * Assert the test callback throws an exception when a certain
+   * error message and optionally is an instance of a given
+   * Error class.
+   */
+  throws(message, errorConstructor) {
+    const errorInPoint = new AssertionError({});
+    const existingExecutor = this.options.executor;
+    if (!existingExecutor) {
+      throw new Error('Cannot use "test.throws" method without a test callback');
+    }
+    this.options.executor = async (...args) => {
+      let raisedException;
+      try {
+        await existingExecutor(...args);
+      } catch (error) {
+        raisedException = error;
+      }
+      if (!raisedException) {
+        errorInPoint.message = "Expected test to throw an exception";
+        throw errorInPoint;
+      }
+      if (errorConstructor && !(raisedException instanceof errorConstructor)) {
+        errorInPoint.message = `Expected test to throw "${inspect(errorConstructor)}"`;
+        throw errorInPoint;
+      }
+      const exceptionMessage = raisedException.message;
+      if (!exceptionMessage || typeof exceptionMessage !== "string") {
+        errorInPoint.message = "Expected test to throw an exception with message property";
+        throw errorInPoint;
+      }
+      if (typeof message === "string") {
+        if (exceptionMessage !== message) {
+          errorInPoint.message = `Expected test to throw "${message}". Instead received "${raisedException.message}"`;
+          errorInPoint.actual = raisedException.message;
+          errorInPoint.expected = message;
+          throw errorInPoint;
+        }
+        return;
+      }
+      if (!message.test(exceptionMessage)) {
+        errorInPoint.message = `Expected test error to match "${message}" regular expression`;
+        throw errorInPoint;
+      }
+    };
+    return this;
+  }
+};
+var Group = class extends BaseGroup {
+};
+var Suite = class extends BaseSuite {
+};
+var Runner = class extends BaseRunner {
+};
+
+export {
+  BaseReporter,
+  Emitter,
+  Refiner,
+  TestContext,
+  Test,
+  Group,
+  Suite,
+  Runner
+};