@japa/runner 3.0.0-0 → 3.0.0-1

package/build/factories/main.d.ts

@@ -0,0 +1,3 @@
+import { RunnerFactory } from './runner.js';
+export declare const runner: () => RunnerFactory;
+//# sourceMappingURL=main.d.ts.map

package/build/factories/main.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../../factories/main.ts"],"names":[],"mappings":"AASA,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAK3C,eAAO,MAAM,MAAM,qBAA4B,CAAA"}

package/build/factories/main.js

@@ -0,0 +1,2 @@
+import { RunnerFactory } from './runner.js';
+export const runner = () => new RunnerFactory();

package/build/factories/runner.d.ts

@@ -0,0 +1,10 @@
+import { Config } from '../src/types.js';
+import { Suite, Emitter } from '../modules/core/main.js';
+export declare class RunnerFactory {
+    #private;
+    configure(config: Config, argv?: string[]): this;
+    withSuites(suites: Suite[]): this;
+    useEmitter(emitter: Emitter): this;
+    run(): Promise<import("@japa/core/types").RunnerSummary>;
+}
+//# sourceMappingURL=runner.d.ts.map

package/build/factories/runner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runner.d.ts","sourceRoot":"","sources":["../../factories/runner.ts"],"names":[],"mappings":"AAeA,OAAO,EAAW,MAAM,EAAE,MAAM,iBAAiB,CAAA;AAGjD,OAAO,EAAS,KAAK,EAAU,OAAO,EAAE,MAAM,yBAAyB,CAAA;AAOvE,qBAAa,aAAa;;IAmJxB,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,EAAE;IAUzC,UAAU,CAAC,MAAM,EAAE,KAAK,EAAE;IAQ1B,UAAU,CAAC,OAAO,EAAE,OAAO;IAQrB,GAAG;CAoCV"}

package/build/factories/runner.js

@@ -0,0 +1,155 @@
+import assert from 'node:assert';
+import { fileURLToPath } from 'node:url';
+import { Planner } from '../src/planner.js';
+import { GlobalHooks } from '../src/hooks.js';
+import { CliParser } from '../src/cli_parser.js';
+import { ConfigManager } from '../src/config_manager.js';
+import { createTest, createTestGroup } from '../src/create_test.js';
+import { Suite, Runner, Emitter } from '../modules/core/main.js';
+export class RunnerFactory {
+    #emitter = new Emitter();
+    #config;
+    #cliArgs;
+    #suites;
+    #file = fileURLToPath(import.meta.url);
+    get #refiner() {
+        return this.#config.refiner;
+    }
+    #createSuites() {
+        return [
+            new Suite('unit', this.#emitter, this.#refiner),
+            new Suite('functional', this.#emitter, this.#refiner),
+        ];
+    }
+    #createAdditionTests(group) {
+        createTest('add two numbers', this.#emitter, this.#refiner, { group, file: this.#file }).run(() => {
+            assert.equal(2 + 2, 4);
+        });
+        createTest('add three numbers', this.#emitter, this.#refiner, {
+            group,
+            file: this.#file,
+        }).run(() => {
+            assert.equal(2 + 2 + 2, 6);
+        });
+        createTest('add group of numbers', this.#emitter, this.#refiner, { group, file: this.#file });
+        createTest('use math.js lib', this.#emitter, this.#refiner, { group, file: this.#file }).skip(true, 'Library work pending');
+        createTest('add multiple numbers', this.#emitter, this.#refiner, {
+            file: this.#file,
+            group,
+        }).run(() => {
+            assert.equal(2 + 2 + 2 + 2, 6);
+        });
+        createTest('add floating numbers', this.#emitter, this.#refiner, { group, file: this.#file })
+            .run(() => {
+            assert.equal(2 + 2.2 + 2.1, 6);
+        })
+            .fails('Have to add support for floating numbers');
+    }
+    #createUserStoreTests(group) {
+        createTest('Validate user data', this.#emitter, this.#refiner, {
+            group,
+            file: this.#file,
+        }).run(() => { });
+        createTest('Disallow duplicate emails', this.#emitter, this.#refiner, {
+            group,
+            file: this.#file,
+        }).run(() => { });
+        createTest('Disallow duplicate emails across tenants', this.#emitter, this.#refiner, {
+            group,
+            file: this.#file,
+        }).run(() => {
+            const users = ['', ''];
+            assert.equal(users.length, 1);
+        });
+        createTest('Normalize email before persisting it', this.#emitter, this.#refiner, {
+            group,
+            file: this.#file,
+        }).skip(true, 'Have to build a normalizer');
+        createTest('Send email verification mail', this.#emitter, this.#refiner, {
+            group,
+            file: this.#file,
+        });
+    }
+    #createUnitTests(suite) {
+        const additionGroup = createTestGroup('Maths#add', this.#emitter, this.#refiner, {
+            suite,
+            file: this.#file,
+        });
+        this.#createAdditionTests(additionGroup);
+        createTest('A top level test inside a suite', this.#emitter, this.#refiner, {
+            suite,
+            file: this.#file,
+        }).run(() => { });
+    }
+    #createFunctionalTests(suite) {
+        const usersStoreGroup = createTestGroup('Users/store', this.#emitter, this.#refiner, {
+            suite,
+            file: this.#file,
+        });
+        this.#createUserStoreTests(usersStoreGroup);
+        const usersListGroup = createTestGroup('Users/list', this.#emitter, this.#refiner, {
+            suite,
+            file: this.#file,
+        });
+        usersListGroup.setup(() => {
+            throw new Error('Unable to cleanup database');
+        });
+        createTest('A test that will never because the group hooks fails', this.#emitter, this.#refiner, { group: usersListGroup });
+        createTest('A top level test inside functional suite', this.#emitter, this.#refiner, {
+            suite,
+            file: this.#file,
+        }).run(() => { });
+    }
+    async #registerPlugins(runner) {
+        for (let plugin of this.#config.plugins) {
+            await plugin({
+                config: this.#config,
+                runner,
+                emitter: this.#emitter,
+                cliArgs: this.#cliArgs,
+            });
+        }
+    }
+    configure(config, argv) {
+        this.#cliArgs = new CliParser().parse(argv || []);
+        this.#config = new ConfigManager(config, this.#cliArgs).hydrate();
+        return this;
+    }
+    withSuites(suites) {
+        this.#suites = suites;
+        return this;
+    }
+    useEmitter(emitter) {
+        this.#emitter = emitter;
+        return this;
+    }
+    async run() {
+        const runner = new Runner(this.#emitter);
+        await this.#registerPlugins(runner);
+        const { config, reporters, refinerFilters } = await new Planner(this.#config).plan();
+        const globalHooks = new GlobalHooks();
+        globalHooks.apply(config);
+        reporters.forEach((reporter) => {
+            runner.registerReporter(reporter);
+        });
+        refinerFilters.forEach((filter) => {
+            config.refiner.add(filter.layer, filter.filters);
+        });
+        if (this.#suites) {
+            this.#suites.forEach((suite) => runner.add(suite));
+        }
+        else {
+            const [unit, functional] = this.#createSuites();
+            this.#createUnitTests(unit);
+            runner.add(unit);
+            this.#createFunctionalTests(functional);
+            runner.add(functional);
+        }
+        await globalHooks.setup(runner);
+        await runner.start();
+        await runner.exec();
+        await runner.end();
+        await globalHooks.teardown(null, runner);
+        return runner.getSummary();
+    }
+}

package/build/modules/core/main.d.ts

@@ -0,0 +1,29 @@
+import { Emitter, Refiner, Test as BaseTest, Suite as BaseSuite, Group as BaseGroup, Runner as BaseRunner, TestContext as BaseTestContext } from '@japa/core';
+import { BaseReporter } from './reporters/base.js';
+import type { DataSetNode, TestHooksCleanupHandler } from './types.js';
+declare module '@japa/core' {
+    interface Test<Context extends Record<any, any>, TestData extends DataSetNode = undefined> {
+        throws(message: string | RegExp, errorConstructor?: any): this;
+    }
+    interface TestContext {
+        cleanup: (cleanupCallback: TestHooksCleanupHandler<TestContext>) => void;
+    }
+}
+export { Emitter, Refiner, BaseReporter };
+export declare class TestContext extends BaseTestContext {
+    test: Test;
+    cleanup: (cleanupCallback: TestHooksCleanupHandler<TestContext>) => void;
+    constructor(test: Test);
+}
+export declare class Test<TestData extends DataSetNode = undefined> extends BaseTest<TestContext, TestData> {
+    static executedCallbacks: never[];
+    static executingCallbacks: never[];
+    throws(message: string | RegExp, errorConstructor?: any): this;
+}
+export declare class Group extends BaseGroup<TestContext> {
+}
+export declare class Suite extends BaseSuite<TestContext> {
+}
+export declare class Runner extends BaseRunner<TestContext> {
+}
+//# sourceMappingURL=main.d.ts.map

package/build/modules/core/main.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../../../modules/core/main.ts"],"names":[],"mappings":"AASA,OAAO,EACL,OAAO,EACP,OAAO,EACP,IAAI,IAAI,QAAQ,EAChB,KAAK,IAAI,SAAS,EAClB,KAAK,IAAI,SAAS,EAClB,MAAM,IAAI,UAAU,EACpB,WAAW,IAAI,eAAe,EAC/B,MAAM,YAAY,CAAA;AAGnB,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAA;AAClD,OAAO,KAAK,EAAE,WAAW,EAAE,uBAAuB,EAAE,MAAM,YAAY,CAAA;AAEtE,OAAO,QAAQ,YAAY,CAAC;IAC1B,UAAU,IAAI,CAAC,OAAO,SAAS,MAAM,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,QAAQ,SAAS,WAAW,GAAG,SAAS;QACvF,MAAM,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,gBAAgB,CAAC,EAAE,GAAG,GAAG,IAAI,CAAA;KAC/D;IACD,UAAU,WAAW;QACnB,OAAO,EAAE,CAAC,eAAe,EAAE,uBAAuB,CAAC,WAAW,CAAC,KAAK,IAAI,CAAA;KACzE;CACF;AAED,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,YAAY,EAAE,CAAA;AAKzC,qBAAa,WAAY,SAAQ,eAAe;IAO3B,IAAI,EAAE,IAAI;IAFrB,OAAO,EAAE,CAAC,eAAe,EAAE,uBAAuB,CAAC,WAAW,CAAC,KAAK,IAAI,CAAA;gBAE7D,IAAI,EAAE,IAAI;CAM9B;AAMD,qBAAa,IAAI,CAAC,QAAQ,SAAS,WAAW,GAAG,SAAS,CAAE,SAAQ,QAAQ,CAC1E,WAAW,EACX,QAAQ,CACT;IAIC,MAAM,CAAC,iBAAiB,UAAK;IAK7B,MAAM,CAAC,kBAAkB,UAAK;IAO9B,MAAM,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,gBAAgB,CAAC,EAAE,GAAG;CAgExD;AAMD,qBAAa,KAAM,SAAQ,SAAS,CAAC,WAAW,CAAC;CAAG;AAOpD,qBAAa,KAAM,SAAQ,SAAS,CAAC,WAAW,CAAC;CAAG;AAKpD,qBAAa,MAAO,SAAQ,UAAU,CAAC,WAAW,CAAC;CAAG"}

package/build/modules/core/main.js

@@ -0,0 +1,68 @@
+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';
+import { BaseReporter } from './reporters/base.js';
+export { Emitter, Refiner, BaseReporter };
+export class TestContext extends BaseTestContext {
+    test;
+    constructor(test) {
+        super();
+        this.test = test;
+        this.cleanup = (cleanupCallback) => {
+            test.cleanup(cleanupCallback);
+        };
+    }
+}
+export class Test extends BaseTest {
+    static executedCallbacks = [];
+    static executingCallbacks = [];
+    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;
+    }
+}
+export class Group extends BaseGroup {
+}
+export class Suite extends BaseSuite {
+}
+export class Runner extends BaseRunner {
+}

package/build/modules/core/reporters/base.d.ts

@@ -0,0 +1,21 @@
+import type { TestEndNode, SuiteEndNode, GroupEndNode, TestStartNode, RunnerSummary, RunnerEndNode, GroupStartNode, SuiteStartNode, RunnerStartNode, BaseReporterOptions } from '../types.js';
+import { Emitter, Runner } from '../main.js';
+export declare abstract class BaseReporter {
+    #private;
+    runner?: Runner;
+    currentFileName?: string;
+    currentSuiteName?: string;
+    currentGroupName?: string;
+    constructor(options?: BaseReporterOptions);
+    protected onTestStart(_: TestStartNode): void;
+    protected onTestEnd(_: TestEndNode): void;
+    protected onGroupStart(_: GroupStartNode): void;
+    protected onGroupEnd(_: GroupEndNode): void;
+    protected onSuiteStart(_: SuiteStartNode): void;
+    protected onSuiteEnd(_: SuiteEndNode): void;
+    protected start(_: RunnerStartNode): Promise<void>;
+    protected end(_: RunnerEndNode): Promise<void>;
+    protected printSummary(summary: RunnerSummary): Promise<void>;
+    boot(runner: Runner, emitter: Emitter): void;
+}
+//# sourceMappingURL=base.d.ts.map

package/build/modules/core/reporters/base.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base.d.ts","sourceRoot":"","sources":["../../../../modules/core/reporters/base.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EACV,WAAW,EACX,YAAY,EACZ,YAAY,EACZ,aAAa,EACb,aAAa,EACb,aAAa,EACb,cAAc,EACd,cAAc,EACd,eAAe,EACf,mBAAmB,EACpB,MAAM,aAAa,CAAA;AACpB,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,YAAY,CAAA;AAO5C,8BAAsB,YAAY;;IAEhC,MAAM,CAAC,EAAE,MAAM,CAAA;IAKf,eAAe,CAAC,EAAE,MAAM,CAAA;IAKxB,gBAAgB,CAAC,EAAE,MAAM,CAAA;IAKzB,gBAAgB,CAAC,EAAE,MAAM,CAAA;gBAEb,OAAO,GAAE,mBAAwB;IAsG7C,SAAS,CAAC,WAAW,CAAC,CAAC,EAAE,aAAa,GAAG,IAAI;IAC7C,SAAS,CAAC,SAAS,CAAC,CAAC,EAAE,WAAW;IAElC,SAAS,CAAC,YAAY,CAAC,CAAC,EAAE,cAAc;IACxC,SAAS,CAAC,UAAU,CAAC,CAAC,EAAE,YAAY;IAEpC,SAAS,CAAC,YAAY,CAAC,CAAC,EAAE,cAAc;IACxC,SAAS,CAAC,UAAU,CAAC,CAAC,EAAE,YAAY;cAEpB,KAAK,CAAC,CAAC,EAAE,eAAe;cACxB,GAAG,CAAC,CAAC,EAAE,aAAa;cAKpB,YAAY,CAAC,OAAO,EAAE,aAAa;IAqBnD,IAAI,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO;CAyCtC"}

package/build/modules/core/reporters/base.js

@@ -0,0 +1,136 @@
+import ms from 'ms';
+import colors from '@poppinss/colors';
+import { ErrorsPrinter } from '@japa/errors-printer';
+const ansi = colors.ansi();
+export class BaseReporter {
+    #options;
+    runner;
+    currentFileName;
+    currentSuiteName;
+    currentGroupName;
+    constructor(options = {}) {
+        this.#options = Object.assign({ stackLinesCount: 2 }, options);
+    }
+    #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'));
+    }
+    #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;
+    }
+    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));
+    }
+    onTestStart(_) { }
+    onTestEnd(_) { }
+    onGroupStart(_) { }
+    onGroupEnd(_) { }
+    onSuiteStart(_) { }
+    onSuiteEnd(_) { }
+    async start(_) { }
+    async end(_) { }
+    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);
+    }
+    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 = undefined;
+            this.onGroupEnd(payload);
+        });
+        emitter.on('suite:start', (payload) => {
+            this.currentSuiteName = payload.name;
+            this.onSuiteStart(payload);
+        });
+        emitter.on('suite:end', (payload) => {
+            this.currentSuiteName = undefined;
+            this.onSuiteEnd(payload);
+        });
+        emitter.on('runner:start', async (payload) => {
+            await this.start(payload);
+        });
+        emitter.on('runner:end', async (payload) => {
+            await this.end(payload);
+        });
+    }
+}

package/build/modules/core/types.d.ts

@@ -0,0 +1,6 @@
+export * from '@japa/core/types';
+export type BaseReporterOptions = {
+    stackLinesCount?: number;
+    framesMaxLimit?: number;
+};
+//# sourceMappingURL=types.d.ts.map

package/build/modules/core/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../modules/core/types.ts"],"names":[],"mappings":"AASA,cAAc,kBAAkB,CAAA;AAEhC,MAAM,MAAM,mBAAmB,GAAG;IAChC,eAAe,CAAC,EAAE,MAAM,CAAA;IACxB,cAAc,CAAC,EAAE,MAAM,CAAA;CACxB,CAAA"}

package/build/modules/core/types.js

@@ -0,0 +1 @@
+export * from '@japa/core/types';

package/package.json

@@ -1,10 +1,12 @@
 {
   "name": "@japa/runner",
-  "version": "3.0.0-0",
+  "version": "3.0.0-1",
   "description": "Runner for Japa testing framework",
   "main": "build/index.js",
   "type": "module",
   "files": [
+    "build/factories",
+    "build/modules",
     "build/src",
     "build/index.d.ts",
     "build/index.js"