@japa/runner 3.0.0-8 → 3.0.0-9

package/build/src/reporters/ndjson.js

@@ -0,0 +1,86 @@
+/*
+ * @japa/runner
+ *
+ * (c) Japa
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+import { relative } from 'node:path';
+import { serializeError } from 'serialize-error';
+import { BaseReporter } from '../../modules/core/main.js';
+/**
+ * Prints tests progress as JSON. Each event is emitted
+ * independently
+ */
+export class NdJSONReporter extends BaseReporter {
+    /**
+     * Returns the filename relative from the current working dir
+     */
+    #getRelativeFilename(fileName) {
+        return relative(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)
+                : undefined,
+            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,
+        }));
+    }
+}

package/build/src/reporters/spec.d.ts

@@ -0,0 +1,13 @@
+import { BaseReporter } from '../../modules/core/main.js';
+import { GroupStartNode, TestEndNode } from '../../modules/core/types.js';
+/**
+ * Pretty prints the tests on the console
+ */
+export declare class SpecReporter extends BaseReporter {
+    #private;
+    protected onTestStart(): void;
+    protected onTestEnd(payload: TestEndNode): void;
+    protected onGroupStart(payload: GroupStartNode): void;
+    protected onGroupEnd(): void;
+    protected end(): Promise<void>;
+}

package/build/src/reporters/spec.js

@@ -0,0 +1,152 @@
+/*
+ * @japa/runner
+ *
+ * (c) Japa
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+import ms from 'ms';
+import { relative } from 'node:path';
+import { colors, icons } from '../helpers.js';
+import { BaseReporter } from '../../modules/core/main.js';
+/**
+ * Pretty prints the tests on the console
+ */
+export class SpecReporter 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 ? `\n${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(`\n${title}${suffix}`);
+    }
+    onTestStart() {
+        /**
+         * Display the filename when
+         *
+         * - The filename exists
+         * - The test is not under a group
+         * - Test is first in a sequence
+         */
+        if (this.currentFileName && this.#isFirstLoneTest) {
+            console.log(`\n${colors.dim(this.#getRelativeFilename(this.currentFileName))}`);
+        }
+        this.#isFirstLoneTest = false;
+    }
+    onTestEnd(payload) {
+        this.#printTest(payload);
+    }
+    onGroupStart(payload) {
+        /**
+         * When a group starts, we mark the upcoming test as NOT a
+         * lone test
+         */
+        this.#isFirstLoneTest = false;
+        this.#printGroup(payload);
+    }
+    onGroupEnd() {
+        /**
+         * When the group ends we assume that the next test can
+         * be out of the group, hence a lone test.
+         *
+         * If this assumption is false, then the `onGroupStart` method
+         * will toggle the boolean
+         */
+        this.#isFirstLoneTest = true;
+    }
+    async end() {
+        const summary = this.runner.getSummary();
+        await this.printSummary(summary);
+    }
+}

package/build/src/types.d.ts

@@ -1,31 +1,29 @@
-import { HookHandler } from '@poppinss/hooks/types';
-import { R as Runner, S as Suite } from '../main-63126780.js';
-export { B as BaseReporterOptions } from '../main-63126780.js';
-import { FilteringOptions, NamedReporterContract } from '@japa/core/types';
-export * from '@japa/core/types';
-import { Emitter, Refiner } from '@japa/core';
-
+/// <reference types="node" resolution-mode="require"/>
+import type { HookHandler } from '@poppinss/hooks/types';
+import type { Emitter, Refiner, Runner, Suite } from '../modules/core/main.js';
+import type { FilteringOptions, NamedReporterContract } from '../modules/core/types.js';
+export * from '../modules/core/types.js';
 /**
  * Global setup hook
  */
-type SetupHookState = [[runner: Runner], [error: Error | null, runner: Runner]];
-type SetupHookHandler = HookHandler<SetupHookState[0], SetupHookState[1]>;
+export type SetupHookState = [[runner: Runner], [error: Error | null, runner: Runner]];
+export type SetupHookHandler = HookHandler<SetupHookState[0], SetupHookState[1]>;
 /**
  * Global teardown hook
  */
-type TeardownHookState = [[runner: Runner], [error: Error | null, runner: Runner]];
-type TeardownHookHandler = HookHandler<TeardownHookState[0], TeardownHookState[1]>;
+export type TeardownHookState = [[runner: Runner], [error: Error | null, runner: Runner]];
+export type TeardownHookHandler = HookHandler<TeardownHookState[0], TeardownHookState[1]>;
 /**
  * Global set of available hooks
  */
-type HooksEvents = {
+export type HooksEvents = {
     setup: SetupHookState;
     teardown: TeardownHookState;
 };
 /**
  * Parsed command-line arguments
  */
-type CLIArgs = {
+export type CLIArgs = {
     _?: string[];
     tags?: string | string[];
     files?: string | string[];
@@ -42,7 +40,7 @@ type CLIArgs = {
 /**
  * Set of filters you can apply to run only specific tests
  */
-type Filters = FilteringOptions & {
+export type Filters = FilteringOptions & {
     files?: string[];
     suites?: string[];
 };
@@ -50,7 +48,7 @@ type Filters = FilteringOptions & {
  * Plugin function receives an instance of the runner,
  * emitter, config and the hooks
  */
-type PluginFn = (japa: {
+export type PluginFn = (japa: {
     config: NormalizedConfig;
     cliArgs: CLIArgs;
     runner: Runner;
@@ -59,7 +57,7 @@ type PluginFn = (japa: {
 /**
  * Base configuration options
  */
-type BaseConfig = {
+export type BaseConfig = {
     /**
      * Current working directory. It is required to search for
      * the test files
@@ -122,11 +120,11 @@ type BaseConfig = {
  * A collection of test files defined as a glob or a callback
  * function that returns an array of URLs
  */
-type TestFiles = string | string[] | (() => URL[] | Promise<URL[]>);
+export type TestFiles = string | string[] | (() => URL[] | Promise<URL[]>);
 /**
  * A test suite to register tests under a named suite
  */
-type TestSuite = {
+export type TestSuite = {
     /**
      * A unique name for the suite
      */
@@ -153,7 +151,7 @@ type TestSuite = {
 /**
  * BaseConfig after normalized by the config manager
  */
-type NormalizedBaseConfig = Required<Omit<BaseConfig, 'reporters'>> & {
+export type NormalizedBaseConfig = Required<Omit<BaseConfig, 'reporters'>> & {
     reporters: {
         activated: string[];
         list: NamedReporterContract[];
@@ -162,7 +160,7 @@ type NormalizedBaseConfig = Required<Omit<BaseConfig, 'reporters'>> & {
 /**
  * Configuration options
  */
-type Config = BaseConfig & ({
+export type Config = BaseConfig & ({
     files: TestFiles;
 } | {
     suites: TestSuite[];
@@ -170,10 +168,8 @@ type Config = BaseConfig & ({
 /**
  * Config after normalized by the config manager
  */
-type NormalizedConfig = NormalizedBaseConfig & ({
+export type NormalizedConfig = NormalizedBaseConfig & ({
     files: TestFiles;
 } | {
     suites: Required<TestSuite>[];
 });
-
-export { BaseConfig, CLIArgs, Config, Filters, HooksEvents, NormalizedBaseConfig, NormalizedConfig, PluginFn, SetupHookHandler, SetupHookState, TeardownHookHandler, TeardownHookState, TestFiles, TestSuite };

package/build/src/types.js

@@ -1,14 +1,9 @@
-import {
-  __reExport
-} from "../chunk-HN4AVHWN.js";
-
-// src/types.ts
-var types_exports2 = {};
-
-// modules/core/types.ts
-var types_exports = {};
-__reExport(types_exports, types_star);
-import * as types_star from "@japa/core/types";
-
-// src/types.ts
-__reExport(types_exports2, types_exports);
+/*
+ * @japa/runner
+ *
+ * (c) Japa
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+export * from '../modules/core/types.js';

package/build/src/validator.d.ts

@@ -0,0 +1,30 @@
+import { NormalizedConfig } from './types.js';
+/**
+ * Validator encapsulates the validations to perform before running
+ * the tests
+ */
+declare class Validator {
+    /**
+     * Ensures the japa is configured. Otherwise raises an exception
+     */
+    ensureIsConfigured(config: NormalizedConfig | undefined): void;
+    /**
+     * Ensures the japa is in planning phase
+     */
+    ensureIsInPlanningPhase(phase: 'idle' | 'planning' | 'executing'): void;
+    /**
+     * Ensures the suites filter uses a subset of the user configured suites.
+     */
+    validateSuitesFilter(config: NormalizedConfig): void;
+    /**
+     * Ensure there are unique suites
+     */
+    validateSuitesForUniqueness(config: NormalizedConfig): void;
+    /**
+     * Ensure the activated reporters are in the list of defined
+     * reporters
+     */
+    validateActivatedReporters(config: NormalizedConfig): void;
+}
+declare const _default: Validator;
+export default _default;

package/build/src/validator.js

@@ -0,0 +1,85 @@
+/*
+ * @japa/runner
+ *
+ * (c) Japa
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+/**
+ * Validator encapsulates the validations to perform before running
+ * the tests
+ */
+class Validator {
+    /**
+     * Ensures the japa is configured. Otherwise raises an exception
+     */
+    ensureIsConfigured(config) {
+        if (!config) {
+            throw new Error(`Cannot run tests. Make sure to call "configure" method before the "run" method`);
+        }
+    }
+    /**
+     * Ensures the japa is in planning phase
+     */
+    ensureIsInPlanningPhase(phase) {
+        if (phase !== 'planning') {
+            throw new Error(`Cannot import japa test file directly. It must be imported by calling the "japa.run" method`);
+        }
+    }
+    /**
+     * Ensures the suites filter uses a subset of the user configured suites.
+     */
+    validateSuitesFilter(config) {
+        /**
+         * Do not perform any validation if no filters are applied
+         * in the first place
+         */
+        if (!config.filters.suites || !config.filters.suites.length) {
+            return;
+        }
+        /**
+         * Notify user they have applied the suites filter but forgot to define
+         * suites
+         */
+        if (!('suites' in config) || !config.suites.length) {
+            throw new Error(`Cannot apply suites filter. You have not configured any test suites`);
+        }
+        const suites = config.suites.map(({ name }) => name);
+        /**
+         * Find unknown suites and report the error
+         */
+        const unknownSuites = config.filters.suites.filter((suite) => !suites.includes(suite));
+        if (unknownSuites.length) {
+            throw new Error(`Cannot apply suites filter. "${unknownSuites[0]}" suite is not configured`);
+        }
+    }
+    /**
+     * Ensure there are unique suites
+     */
+    validateSuitesForUniqueness(config) {
+        if (!('suites' in config)) {
+            return;
+        }
+        const suites = new Set();
+        config.suites.forEach(({ name }) => {
+            if (suites.has(name)) {
+                throw new Error(`Duplicate suite "${name}"`);
+            }
+            suites.add(name);
+        });
+        suites.clear();
+    }
+    /**
+     * Ensure the activated reporters are in the list of defined
+     * reporters
+     */
+    validateActivatedReporters(config) {
+        const reportersList = config.reporters.list.map(({ name }) => name);
+        const unknownReporters = config.reporters.activated.filter((name) => !reportersList.includes(name));
+        if (unknownReporters.length) {
+            throw new Error(`Invalid reporter "${unknownReporters[0]}". Make sure to register it first inside the "reporters.list" array`);
+        }
+    }
+}
+export default new Validator();

package/build/tests/base_reporter.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/build/tests/base_reporter.spec.js

@@ -0,0 +1,111 @@
+/*
+ * @japa/runner
+ *
+ * (c) Japa
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+import { test } from 'node:test';
+import chaiSubset from 'chai-subset';
+import { assert, default as chai } from 'chai';
+chai.use(chaiSubset);
+import { wrapAssertions } from '../tests_helpers/main.js';
+import { Test, Suite, Group, Runner, Refiner, Emitter, TestContext, BaseReporter, } from '../modules/core/main.js';
+test.describe('Base reporter', () => {
+    test('extend base reporter to create a custom reporter', async () => {
+        const stack = [];
+        class MyReporter extends BaseReporter {
+            async start() {
+                stack.push('reporter started');
+            }
+        }
+        const emitter = new Emitter();
+        const runner = new Runner(emitter);
+        runner.registerReporter((r, e) => new MyReporter({}).boot(r, e));
+        await runner.start();
+        await wrapAssertions(() => {
+            assert.deepEqual(stack, ['reporter started']);
+        });
+    });
+    test('invoke handlers when suite, groups and tests are executed', async () => {
+        const stack = [];
+        let summary;
+        class MyReporter extends BaseReporter {
+            async start() {
+                stack.push('reporter started');
+            }
+            async end() {
+                summary = this.runner.getSummary();
+                stack.push('reporter ended');
+            }
+            onTestStart(t) {
+                assert.equal(t.title.expanded, '2 + 2');
+                assert.equal(this.currentSuiteName, 'unit');
+                assert.equal(this.currentGroupName, 'default');
+                stack.push('test started');
+            }
+            onTestEnd(t) {
+                assert.equal(t.title.expanded, '2 + 2');
+                assert.isFalse(t.hasError);
+                stack.push('test ended');
+            }
+            onGroupStart(g) {
+                assert.equal(g.title, 'default');
+                assert.equal(this.currentSuiteName, 'unit');
+                stack.push('group started');
+            }
+            onGroupEnd(g) {
+                assert.equal(g.title, 'default');
+                assert.isFalse(g.hasError);
+                stack.push('group ended');
+            }
+            onSuiteStart(s) {
+                assert.equal(s.name, 'unit');
+                stack.push('suite started');
+            }
+            onSuiteEnd(s) {
+                assert.equal(s.name, 'unit');
+                stack.push('suite ended');
+            }
+        }
+        const emitter = new Emitter();
+        const runner = new Runner(emitter);
+        const refiner = new Refiner();
+        const suite = new Suite('unit', emitter, refiner);
+        const group = new Group('default', emitter, refiner);
+        const t = new Test('2 + 2', (_t) => new TestContext(_t), emitter, refiner, group);
+        group.add(t);
+        suite.add(group);
+        runner.add(suite);
+        runner.registerReporter((r, e) => new MyReporter({}).boot(r, e));
+        await runner.start();
+        await runner.exec();
+        await runner.end();
+        await wrapAssertions(() => {
+            assert.deepEqual(stack, [
+                'reporter started',
+                'suite started',
+                'group started',
+                'test started',
+                'test ended',
+                'group ended',
+                'suite ended',
+                'reporter ended',
+            ]);
+            assert.containSubset(summary, {
+                aggregates: {
+                    total: 1,
+                    failed: 0,
+                    passed: 0,
+                    regression: 0,
+                    skipped: 0,
+                    todo: 1,
+                },
+                hasError: false,
+                failureTree: [],
+                failedTestsTitles: [],
+            });
+        });
+    });
+});

package/build/tests/cli_parser.spec.d.ts

@@ -0,0 +1 @@
+export {};