@japa/runner 3.0.0-7 → 3.0.0-8

package/build/factories/main.js

@@ -1,13 +1,209 @@
-/*
- * @japa/runner
- *
- * (c) Japa
- *
- * For the full copyright and license information, please view the LICENSE
- * file that was distributed with this source code.
- */
-import { RunnerFactory } from './runner.js';
-/**
- * Create an instance of the runner factory
- */
-export const runner = () => new RunnerFactory();
+import {
+  CliParser,
+  ConfigManager,
+  GlobalHooks,
+  Planner,
+  createTest,
+  createTestGroup
+} from "../chunk-W5IABAQU.js";
+import "../chunk-7THDHQFT.js";
+import {
+  Emitter,
+  Runner,
+  Suite
+} from "../chunk-MCOW34SG.js";
+import "../chunk-HN4AVHWN.js";
+
+// factories/runner.ts
+import { fileURLToPath } from "node:url";
+var RunnerFactory = class {
+  #emitter = new Emitter();
+  #config;
+  #cliArgs;
+  #file = fileURLToPath(import.meta.url);
+  get #refiner() {
+    return this.#config.refiner;
+  }
+  /**
+   * Registers plugins
+   */
+  async #registerPlugins(runner2) {
+    for (let plugin of this.#config.plugins) {
+      await plugin({
+        config: this.#config,
+        runner: runner2,
+        emitter: this.#emitter,
+        cliArgs: this.#cliArgs
+      });
+    }
+  }
+  /**
+   * Configure runner
+   */
+  configure(config, argv) {
+    this.#cliArgs = new CliParser().parse(argv || []);
+    this.#config = new ConfigManager(config, this.#cliArgs).hydrate();
+    return this;
+  }
+  /**
+   * Define a custom emitter instance to use
+   */
+  useEmitter(emitter) {
+    this.#emitter = emitter;
+    return this;
+  }
+  /**
+   * Run a test using the runner
+   */
+  async runTest(title, callback) {
+    return this.runSuites((emitter, refiner, file) => {
+      const defaultSuite = new Suite("default", emitter, refiner);
+      createTest(title, emitter, refiner, {
+        suite: defaultSuite,
+        file
+      }).run(callback);
+      return [defaultSuite];
+    });
+  }
+  /**
+   * Run dummy tests. You might use
+   */
+  async runSuites(suites) {
+    const runner2 = new Runner(this.#emitter);
+    await this.#registerPlugins(runner2);
+    const { config, reporters, refinerFilters } = await new Planner(this.#config).plan();
+    const globalHooks = new GlobalHooks();
+    globalHooks.apply(config);
+    reporters.forEach((reporter) => {
+      runner2.registerReporter(reporter);
+    });
+    refinerFilters.forEach((filter) => {
+      config.refiner.add(filter.layer, filter.filters);
+    });
+    suites(this.#emitter, this.#refiner, this.#file).forEach((suite) => runner2.add(suite));
+    await globalHooks.setup(runner2);
+    await runner2.start();
+    await runner2.exec();
+    await runner2.end();
+    await globalHooks.teardown(null, runner2);
+    return runner2.getSummary();
+  }
+};
+
+// factories/create_diverse_tests.ts
+import assert from "node:assert";
+function createUnitTestsSuite(emitter, refiner, file) {
+  const suite = new Suite("unit", emitter, refiner);
+  const group = createTestGroup("Maths#add", emitter, refiner, {
+    suite,
+    file
+  });
+  createTest("A top level test inside a suite", emitter, refiner, {
+    suite,
+    file
+  }).run(() => {
+  });
+  createTest("add two numbers", emitter, refiner, { group, file }).run(() => {
+    assert.equal(2 + 2, 4);
+  });
+  createTest("add three numbers", emitter, refiner, {
+    group,
+    file
+  }).run(() => {
+    assert.equal(2 + 2 + 2, 6);
+  });
+  createTest("add group of numbers", emitter, refiner, { group, file });
+  createTest("use math.js lib", emitter, refiner, { group, file }).skip(
+    true,
+    "Library work pending"
+  );
+  createTest("add multiple numbers", emitter, refiner, {
+    file,
+    group
+  }).run(() => {
+    assert.equal(2 + 2 + 2 + 2, 6);
+  });
+  createTest("add floating numbers", emitter, refiner, { group, file }).run(() => {
+    assert.equal(2 + 2.2 + 2.1, 6);
+  }).fails("Have to add support for floating numbers");
+  createTest("A test with an error that is not an AssertionError", emitter, refiner, {
+    group,
+    file
+  }).run(() => {
+    throw new Error("This is an error");
+  });
+  return suite;
+}
+function createFunctionalTestsSuite(emitter, refiner, file) {
+  const suite = new Suite("functional", emitter, refiner);
+  const group = createTestGroup("Users/store", emitter, refiner, {
+    suite,
+    file
+  });
+  createTest("Validate user data", emitter, refiner, {
+    group,
+    file
+  }).run(() => {
+  });
+  createTest("Disallow duplicate emails", emitter, refiner, {
+    group,
+    file
+  }).run(() => {
+  });
+  createTest("Disallow duplicate emails across tenants", emitter, refiner, {
+    group,
+    file
+  }).run(() => {
+    const users = ["", ""];
+    assert.equal(users.length, 1);
+  });
+  createTest("Normalize email before persisting it", emitter, refiner, {
+    group,
+    file
+  }).skip(true, "Have to build a normalizer");
+  createTest("Send email verification mail", emitter, refiner, {
+    group,
+    file
+  });
+  const usersListGroup = createTestGroup("Users/list", emitter, refiner, {
+    suite,
+    file
+  });
+  usersListGroup.setup(() => {
+    throw new Error("Unable to cleanup database");
+  });
+  createTest("A test that will never because the group hooks fails", emitter, refiner, {
+    group: usersListGroup
+  });
+  createTest("A top level test inside functional suite", emitter, refiner, {
+    suite,
+    file
+  }).run(() => {
+  });
+  return suite;
+}
+function createDiverseTests(emitter, refiner, file) {
+  return [
+    createUnitTestsSuite(emitter, refiner, file),
+    createFunctionalTestsSuite(emitter, refiner, file)
+  ];
+}
+
+// factories/main.ts
+var runner = () => new RunnerFactory();
+var syncReporter = {
+  name: "sync",
+  handler(r, emitter) {
+    emitter.on("runner:end", function() {
+      const summary = r.getSummary();
+      if (summary.hasError) {
+        throw summary.failureTree[0].children[0].errors[0].error;
+      }
+    });
+  }
+};
+export {
+  createDiverseTests,
+  runner,
+  syncReporter
+};

package/build/index.d.ts

@@ -1,23 +1,26 @@
-import type { TestExecutor } from '@japa/core/types';
-import type { Config } from './src/types.js';
-import { Group, Test, TestContext } from './modules/core/main.js';
+import { TestExecutor } from '@japa/core/types';
+import { Config } from './src/types.js';
+import { T as TestContext, a as Test, G as Group } from './main-63126780.js';
+import '@poppinss/hooks/types';
+import '@japa/core';
+
 /**
  * Create a Japa test. Defining a test without the callback
  * will create a todo test.
  */
-export declare function test(title: string, callback?: TestExecutor<TestContext, undefined>): Test<undefined>;
-export declare namespace test {
+declare function test(title: string, callback?: TestExecutor<TestContext, undefined>): Test<undefined>;
+declare namespace test {
     var group: (title: string, callback: (group: Group) => void) => void;
 }
 /**
  * Get the test of currently running test
  */
-export declare function getActiveTest(): Test<any> | undefined;
+declare function getActiveTest(): Test<any> | undefined;
 /**
  * Make Japa process command line arguments. Later the parsed output
  * will be used by Japa to compute the configuration
  */
-export declare function processCLIArgs(argv: string[]): void;
+declare function processCLIArgs(argv: string[]): void;
 /**
  * Configure the tests runner with inline configuration. You must
  * call configure method before the run method.
@@ -25,9 +28,11 @@ export declare function processCLIArgs(argv: string[]): void;
  * Do note: The CLI flags will overwrite the options provided
  * to the configure method.
  */
-export declare function configure(options: Config): void;
+declare function configure(options: Config): void;
 /**
  * Execute Japa tests. Calling this function will import the test
  * files behind the scenes
  */
-export declare function run(): Promise<void>;
+declare function run(): Promise<void>;
+
+export { configure, getActiveTest, processCLIArgs, run, test };