@japa/runner 3.0.0-8 → 3.0.0

package/build/src/exceptions_manager.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.
+ */
+import { ErrorsPrinter } from '@japa/errors-printer';
+/**
+ * Handles uncaught exceptions and prints them to the
+ * console
+ */
+export class ExceptionsManager {
+    #exceptionsBuffer = [];
+    #rejectionsBuffer = [];
+    #state = 'watching';
+    #errorsPrinter = new ErrorsPrinter({ stackLinesCount: 2, framesMaxLimit: 4 });
+    hasErrors = false;
+    /**
+     * Monitors unhandled exceptions and rejections. The exceptions
+     * are stacked in a buffer, so that we do not clutter the
+     * tests output and once the tests are over, we will
+     * print them to the console.
+     *
+     * In case the tests are completed, we will print errors as they
+     * happen.
+     */
+    monitor() {
+        process.on('uncaughtException', async (error) => {
+            this.hasErrors = true;
+            if (this.#state === 'watching') {
+                this.#exceptionsBuffer.push(error);
+            }
+            else {
+                this.#errorsPrinter.printSectionBorder('[Unhandled Error]');
+                await this.#errorsPrinter.printError(error);
+                process.exitCode = 1;
+            }
+        });
+        process.on('unhandledRejection', async (error) => {
+            this.hasErrors = true;
+            if (this.#state === 'watching') {
+                this.#rejectionsBuffer.push(error);
+            }
+            else {
+                this.#errorsPrinter.printSectionBorder('[Unhandled Rejection]');
+                await this.#errorsPrinter.printError(error);
+                process.exitCode = 1;
+            }
+        });
+    }
+    async flow() {
+        if (this.#state === 'flowing') {
+            return;
+        }
+        this.#state = 'flowing';
+        /**
+         * Print exceptions
+         */
+        if (this.#exceptionsBuffer.length) {
+            let exceptionsCount = this.#exceptionsBuffer.length;
+            let exceptionsIndex = this.#exceptionsBuffer.length;
+            this.#errorsPrinter.printSectionHeader('Unhandled Errors');
+            for (let exception of this.#exceptionsBuffer) {
+                await this.#errorsPrinter.printError(exception);
+                this.#errorsPrinter.printSectionBorder(`[${++exceptionsIndex}/${exceptionsCount}]`);
+            }
+            this.#exceptionsBuffer = [];
+        }
+        /**
+         * Print rejections
+         */
+        if (this.#rejectionsBuffer.length) {
+            let rejectionsCount = this.#exceptionsBuffer.length;
+            let rejectionsIndex = this.#exceptionsBuffer.length;
+            this.#errorsPrinter.printSectionBorder('Unhandled Rejections');
+            for (let rejection of this.#rejectionsBuffer) {
+                await this.#errorsPrinter.printError(rejection);
+                this.#errorsPrinter.printSectionBorder(`[${++rejectionsIndex}/${rejectionsCount}]`);
+            }
+            this.#rejectionsBuffer = [];
+        }
+    }
+}

package/build/src/files_manager.d.ts

@@ -0,0 +1,18 @@
+/// <reference types="node" resolution-mode="require"/>
+import type { TestFiles } from './types.js';
+/**
+ * Files manager exposes the API to collect, filter and import test
+ * files based upon the config
+ */
+export declare class FilesManager {
+    /**
+     * Returns a collection of files from the user defined
+     * glob or the implementation function
+     */
+    getFiles(cwd: string, files: TestFiles): Promise<URL[]>;
+    /**
+     * Applies file name filter on a collection of file
+     * URLs
+     */
+    grep(files: URL[], filters: string[]): URL[];
+}

package/build/src/files_manager.js

@@ -0,0 +1,57 @@
+/*
+ * @japa/runner
+ *
+ * (c) Japa
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+import slash from 'slash';
+import fastGlob from 'fast-glob';
+import { pathToFileURL } from 'node:url';
+/**
+ * The expression to remove file extension and optionally
+ * .spec|.test from the test file name
+ */
+const FILE_SUFFIX_EXPRESSION = /(\.spec|\.test)?\.[js|ts|jsx|tsx|mjs|mts|cjs|cts]+$/;
+/**
+ * Files manager exposes the API to collect, filter and import test
+ * files based upon the config
+ */
+export class FilesManager {
+    /**
+     * Returns a collection of files from the user defined
+     * glob or the implementation function
+     */
+    async getFiles(cwd, files) {
+        if (Array.isArray(files) || typeof files === 'string') {
+            const testFiles = await fastGlob(files, {
+                absolute: true,
+                onlyFiles: true,
+                cwd: cwd,
+            });
+            return testFiles.map((file) => pathToFileURL(file));
+        }
+        return await files();
+    }
+    /**
+     * Applies file name filter on a collection of file
+     * URLs
+     */
+    grep(files, filters) {
+        return files.filter((file) => {
+            const filename = slash(file.pathname);
+            const filenameWithoutTestSuffix = filename.replace(FILE_SUFFIX_EXPRESSION, '');
+            return !!filters.find((filter) => {
+                if (filename.endsWith(filter)) {
+                    return true;
+                }
+                const filterSegments = filter.split('/').reverse();
+                const fileSegments = filenameWithoutTestSuffix.split('/').reverse();
+                return filterSegments.every((segment, index) => {
+                    return fileSegments[index] && (segment === '*' || fileSegments[index].endsWith(segment));
+                });
+            });
+        });
+    }
+}

package/build/src/helpers.d.ts

@@ -0,0 +1,15 @@
+import { Colors } from '@poppinss/colors/types';
+export declare const colors: Colors;
+/**
+ * A collection of platform specific icons
+ */
+export declare const icons: {
+    tick: string;
+    cross: string;
+    bullet: string;
+    nodejs: string;
+    pointer: string;
+    info: string;
+    warning: string;
+    squareSmallFilled: string;
+};

package/build/src/helpers.js

@@ -0,0 +1,34 @@
+/*
+ * @japa/runner
+ *
+ * (c) Japa
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+import useColors from '@poppinss/colors';
+export const colors = useColors.ansi();
+/**
+ * A collection of platform specific icons
+ */
+export const icons = process.platform === 'win32' && !process.env.WT_SESSION
+    ? {
+        tick: '√',
+        cross: '×',
+        bullet: '*',
+        nodejs: '♦',
+        pointer: '>',
+        info: 'i',
+        warning: '‼',
+        squareSmallFilled: '[█]',
+    }
+    : {
+        tick: '✔',
+        cross: '✖',
+        bullet: '●',
+        nodejs: '⬢',
+        pointer: '❯',
+        info: 'ℹ',
+        warning: '⚠',
+        squareSmallFilled: '◼',
+    };

package/build/src/hooks.d.ts

@@ -0,0 +1,20 @@
+import { Runner } from '../modules/core/main.js';
+import type { NormalizedConfig } from './types.js';
+/**
+ * Exposes API for working with global hooks
+ */
+export declare class GlobalHooks {
+    #private;
+    /**
+     * Apply hooks from the config
+     */
+    apply(config: NormalizedConfig): void;
+    /**
+     * Perform setup
+     */
+    setup(runner: Runner): Promise<void>;
+    /**
+     * Perform cleanup
+     */
+    teardown(error: Error | null, runner: Runner): Promise<void>;
+}

package/build/src/hooks.js

@@ -0,0 +1,46 @@
+/*
+ * @japa/runner
+ *
+ * (c) Japa
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+import Hooks from '@poppinss/hooks';
+/**
+ * Exposes API for working with global hooks
+ */
+export class GlobalHooks {
+    #hooks = new Hooks();
+    #setupRunner;
+    #teardownRunner;
+    /**
+     * Apply hooks from the config
+     */
+    apply(config) {
+        config.setup.forEach((hook) => this.#hooks.add('setup', hook));
+        config.teardown.forEach((hook) => this.#hooks.add('teardown', hook));
+    }
+    /**
+     * Perform setup
+     */
+    async setup(runner) {
+        this.#setupRunner = this.#hooks.runner('setup');
+        this.#teardownRunner = this.#hooks.runner('teardown');
+        await this.#setupRunner.run(runner);
+    }
+    /**
+     * Perform cleanup
+     */
+    async teardown(error, runner) {
+        if (this.#setupRunner) {
+            await this.#setupRunner.cleanup(error, runner);
+        }
+        if (this.#teardownRunner) {
+            if (!error) {
+                await this.#teardownRunner.run(runner);
+            }
+            await this.#teardownRunner.cleanup(error, runner);
+        }
+    }
+}

package/build/src/planner.d.ts

@@ -0,0 +1,25 @@
+/// <reference types="node" resolution-mode="require"/>
+import type { NamedReporterContract, NormalizedConfig, TestSuite } from './types.js';
+/**
+ * The tests planner is used to plan the tests by doing all
+ * the heavy lifting of executing plugins, registering
+ * reporters, filtering tests and so on.
+ */
+export declare class Planner {
+    #private;
+    constructor(config: NormalizedConfig);
+    /**
+     * Creates a plan for running the tests
+     */
+    plan(): Promise<{
+        reporters: NamedReporterContract[];
+        suites: (TestSuite & {
+            filesURLs: URL[];
+        })[];
+        refinerFilters: {
+            layer: "tags" | "tests" | "groups";
+            filters: string[];
+        }[];
+        config: NormalizedConfig;
+    }>;
+}

package/build/src/planner.js

@@ -0,0 +1,98 @@
+/*
+ * @japa/runner
+ *
+ * (c) Japa
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+import validator from './validator.js';
+import { FilesManager } from './files_manager.js';
+/**
+ * The tests planner is used to plan the tests by doing all
+ * the heavy lifting of executing plugins, registering
+ * reporters, filtering tests and so on.
+ */
+export class Planner {
+    #config;
+    #fileManager = new FilesManager();
+    constructor(config) {
+        validator.validateActivatedReporters(config);
+        validator.validateSuitesFilter(config);
+        validator.validateSuitesForUniqueness(config);
+        this.#config = config;
+    }
+    /**
+     * Returns a list of reporters based upon the activated
+     * reporters list.
+     */
+    #getActivatedReporters() {
+        return this.#config.reporters.activated.map((activated) => {
+            return this.#config.reporters.list.find(({ name }) => activated === name);
+        });
+    }
+    /**
+     * A generic method to collect files from the user defined
+     * files glob and apply the files filter
+     */
+    async #collectFiles(files) {
+        let filesURLs = await this.#fileManager.getFiles(this.#config.cwd, files);
+        if (this.#config.filters.files && this.#config.filters.files.length) {
+            filesURLs = this.#fileManager.grep(filesURLs, this.#config.filters.files);
+        }
+        return filesURLs;
+    }
+    /**
+     * Returns a collection of suites and their associated
+     * test files by applying all the filters
+     */
+    async #getSuites() {
+        let suites = [];
+        let suitesFilters = this.#config.filters.suites || [];
+        if ('files' in this.#config) {
+            suites.push({
+                name: 'default',
+                files: this.#config.files,
+                timeout: this.#config.timeout,
+                retries: this.#config.retries,
+                filesURLs: await this.#collectFiles(this.#config.files),
+            });
+        }
+        if ('suites' in this.#config) {
+            for (let suite of this.#config.suites) {
+                if (!suitesFilters.length || suitesFilters.includes(suite.name)) {
+                    suites.push({
+                        ...suite,
+                        filesURLs: await this.#collectFiles(suite.files),
+                    });
+                }
+            }
+        }
+        return suites;
+    }
+    /**
+     * Returns a list of filters to the passed to the refiner
+     */
+    #getRefinerFilters() {
+        return Object.keys(this.#config.filters).reduce((result, layer) => {
+            if (layer === 'tests' || layer === 'tags' || layer === 'groups') {
+                result.push({ layer, filters: this.#config.filters[layer] });
+            }
+            return result;
+        }, []);
+    }
+    /**
+     * Creates a plan for running the tests
+     */
+    async plan() {
+        const suites = await this.#getSuites();
+        const reporters = this.#getActivatedReporters();
+        const refinerFilters = this.#getRefinerFilters();
+        return {
+            reporters,
+            suites,
+            refinerFilters,
+            config: this.#config,
+        };
+    }
+}

package/build/src/plugins/retry.d.ts

@@ -0,0 +1,20 @@
+import type { PluginFn } from '../types.js';
+/**
+ * Returns an object with the title of the tests failed during
+ * the last run.
+ */
+export declare function getFailedTests(): Promise<{
+    tests?: string[];
+}>;
+/**
+ * Writes failing tests to the cache directory
+ */
+export declare function cacheFailedTests(tests: string[]): Promise<void>;
+/**
+ * Clears the cache dir
+ */
+export declare function clearCache(): Promise<void>;
+/**
+ * Exposes the API to run failing tests using the "failed" CLI flag.
+ */
+export declare const retryPlugin: PluginFn;

package/build/src/plugins/retry.js

@@ -0,0 +1,66 @@
+/*
+ * @japa/runner
+ *
+ * (c) Japa
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+import { join } from 'node:path';
+import findCacheDirectory from 'find-cache-dir';
+import { mkdir, readFile, unlink, writeFile } from 'node:fs/promises';
+import { colors } from '../helpers.js';
+/**
+ * Paths to the cache directory and the summary file
+ */
+const CACHE_DIR = findCacheDirectory({ name: '@japa/runner' });
+const SUMMARY_FILE = CACHE_DIR ? join(CACHE_DIR, 'summary.json') : undefined;
+/**
+ * Returns an object with the title of the tests failed during
+ * the last run.
+ */
+export async function getFailedTests() {
+    try {
+        const summary = await readFile(SUMMARY_FILE, 'utf-8');
+        return JSON.parse(summary);
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            return {};
+        }
+        throw new Error('Unable to read failed tests cache file', { cause: error });
+    }
+}
+/**
+ * Writes failing tests to the cache directory
+ */
+export async function cacheFailedTests(tests) {
+    await mkdir(CACHE_DIR, { recursive: true });
+    await writeFile(SUMMARY_FILE, JSON.stringify({ tests: tests }));
+}
+/**
+ * Clears the cache dir
+ */
+export async function clearCache() {
+    await unlink(SUMMARY_FILE);
+}
+/**
+ * Exposes the API to run failing tests using the "failed" CLI flag.
+ */
+export const retryPlugin = async function retry({ config, cliArgs }) {
+    if (!SUMMARY_FILE) {
+        return;
+    }
+    config.teardown.push(async (runner) => {
+        const summary = runner.getSummary();
+        await cacheFailedTests(summary.failedTestsTitles);
+    });
+    if (cliArgs.failed) {
+        const { tests } = await getFailedTests();
+        if (!tests || !tests.length) {
+            console.log(colors.bgYellow().black(' No failing tests found. Running all the tests '));
+            return;
+        }
+        config.filters.tests = tests;
+    }
+};

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

@@ -0,0 +1,15 @@
+import type { TestEndNode } from '../../modules/core/types.js';
+import { BaseReporter } from '../../modules/core/reporters/base.js';
+/**
+ * Minimal reporter that prints each test as an icon.
+ */
+export declare class DotReporter extends BaseReporter {
+    /**
+     * When a test ended
+     */
+    protected onTestEnd(payload: TestEndNode): void;
+    /**
+     * When test runner ended
+     */
+    protected end(): Promise<void>;
+}

package/build/src/reporters/dot.js

@@ -0,0 +1,41 @@
+/*
+ * @japa/runner
+ *
+ * (c) Japa
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+import { colors, icons } from '../helpers.js';
+import { BaseReporter } from '../../modules/core/reporters/base.js';
+/**
+ * Minimal reporter that prints each test as an icon.
+ */
+export class DotReporter 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());
+    }
+}

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

@@ -1,18 +1,13 @@
-import { B as BaseReporterOptions } from '../../main-63126780.js';
-import { NamedReporterContract } from '@japa/core/types';
-import '@japa/core';
-
+import type { BaseReporterOptions, NamedReporterContract } from '../types.js';
 /**
  * Create an instance of the spec reporter
  */
-declare const spec: (options?: BaseReporterOptions) => NamedReporterContract;
+export declare const spec: (options?: BaseReporterOptions) => NamedReporterContract;
 /**
  * Create an instance of the dot reporter
  */
-declare const dot: (options?: BaseReporterOptions) => NamedReporterContract;
+export declare const dot: (options?: BaseReporterOptions) => NamedReporterContract;
 /**
  * Create an instance of the ndjson reporter
  */
-declare const ndjson: (options?: BaseReporterOptions) => NamedReporterContract;
-
-export { dot, ndjson, spec };
+export declare const ndjson: (options?: BaseReporterOptions) => NamedReporterContract;

package/build/src/reporters/main.js

@@ -1,12 +1,38 @@
-import {
-  dot,
-  ndjson,
-  spec
-} from "../../chunk-7THDHQFT.js";
-import "../../chunk-MCOW34SG.js";
-import "../../chunk-HN4AVHWN.js";
-export {
-  dot,
-  ndjson,
-  spec
+/*
+ * @japa/runner
+ *
+ * (c) Japa
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+import { DotReporter } from './dot.js';
+import { SpecReporter } from './spec.js';
+import { NdJSONReporter } from './ndjson.js';
+/**
+ * Create an instance of the spec reporter
+ */
+export const spec = (options) => {
+    return {
+        name: 'spec',
+        handler: (...args) => new SpecReporter(options).boot(...args),
+    };
+};
+/**
+ * Create an instance of the dot reporter
+ */
+export const dot = (options) => {
+    return {
+        name: 'dot',
+        handler: (...args) => new DotReporter(options).boot(...args),
+    };
+};
+/**
+ * Create an instance of the ndjson reporter
+ */
+export const ndjson = (options) => {
+    return {
+        name: 'ndjson',
+        handler: (...args) => new NdJSONReporter(options).boot(...args),
+    };
 };

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

@@ -0,0 +1,15 @@
+import { BaseReporter } from '../../modules/core/main.js';
+import type { TestEndNode, SuiteEndNode, GroupEndNode, SuiteStartNode, GroupStartNode } from '../../modules/core/types.js';
+/**
+ * Prints tests progress as JSON. Each event is emitted
+ * independently
+ */
+export declare class NdJSONReporter extends BaseReporter {
+    #private;
+    protected onTestEnd(payload: TestEndNode): void;
+    protected onGroupStart(payload: GroupStartNode): void;
+    protected onGroupEnd(payload: GroupEndNode): void;
+    protected onSuiteStart(payload: SuiteStartNode): void;
+    protected onSuiteEnd(payload: SuiteEndNode): void;
+    protected end(): Promise<void>;
+}