@adonisjs/assembler 5.4.2 → 5.5.0-0

package/build/ace-manifest.json

@@ -353,6 +353,80 @@
         }
       ]
     },
+    "test": {
+      "settings": {
+        "stayAlive": true
+      },
+      "commandPath": "./commands/Test",
+      "commandName": "test",
+      "description": "Run AdonisJS tests",
+      "args": [],
+      "aliases": [],
+      "flags": [
+        {
+          "name": "watch",
+          "propertyName": "watch",
+          "type": "boolean",
+          "description": "Watch for file changes and re-run tests on file change",
+          "alias": "w"
+        },
+        {
+          "name": "poll",
+          "propertyName": "poll",
+          "type": "boolean",
+          "description": "Detect file changes by polling files instead of listening to filesystem events",
+          "alias": "p"
+        },
+        {
+          "name": "node-args",
+          "propertyName": "nodeArgs",
+          "type": "array",
+          "description": "CLI options to pass to the node command line"
+        },
+        {
+          "name": "tags",
+          "propertyName": "tags",
+          "type": "array",
+          "description": "Run tests for only specified tags"
+        },
+        {
+          "name": "ignore-tags",
+          "propertyName": "ignoreTags",
+          "type": "array",
+          "description": "Run all the tests except the tests using specified tags"
+        },
+        {
+          "name": "timeout",
+          "propertyName": "timeout",
+          "type": "number",
+          "description": "Define timeout for tests"
+        },
+        {
+          "name": "suites",
+          "propertyName": "suites",
+          "type": "array",
+          "description": "Run tests for only the specified suites"
+        },
+        {
+          "name": "groups",
+          "propertyName": "groups",
+          "type": "array",
+          "description": "Run tests for only the specified groups"
+        },
+        {
+          "name": "tests",
+          "propertyName": "tests",
+          "type": "array",
+          "description": "Run tests with the specified titles"
+        },
+        {
+          "name": "force-exit",
+          "propertyName": "forceExit",
+          "type": "boolean",
+          "description": "Force exit the tests runner process"
+        }
+      ]
+    },
     "type-check": {
       "settings": {},
       "commandPath": "./commands/TypeCheck",

package/build/commands/Test.d.ts

@@ -0,0 +1,35 @@
+import { BaseCommand } from '@adonisjs/core/build/standalone';
+/**
+ * Run tests
+ */
+export default class Test extends BaseCommand {
+    static commandName: string;
+    static description: string;
+    static settings: {
+        stayAlive: boolean;
+    };
+    /**
+     * Allows watching for file changes
+     */
+    watch: boolean;
+    /**
+     * Detect changes by polling files
+     */
+    poll: boolean;
+    /**
+     * Arguments to pass to the `node` binary
+     */
+    nodeArgs: string[];
+    tags: string[];
+    ignoreTags: string[];
+    timeout: number;
+    suites: string[];
+    groups: string[];
+    tests: string[];
+    forceExit: boolean;
+    /**
+     * Convert command flags to test filters
+     */
+    private getTestFilters;
+    run(): Promise<void>;
+}

package/build/commands/Test.js

@@ -0,0 +1,150 @@
+"use strict";
+/*
+ * @adonisjs/assembler
+ *
+ * (c) Harminder Virk <virk@adonisjs.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const standalone_1 = require("@adonisjs/core/build/standalone");
+/**
+ * Run tests
+ */
+class Test extends standalone_1.BaseCommand {
+    constructor() {
+        super(...arguments);
+        /**
+         * Arguments to pass to the `node` binary
+         */
+        this.nodeArgs = [];
+    }
+    /**
+     * Convert command flags to test filters
+     */
+    getTestFilters() {
+        const filters = {};
+        if (this.forceExit) {
+            filters['--force-exit'] = true;
+        }
+        if (this.timeout !== undefined) {
+            filters['--timeout'] = this.timeout;
+        }
+        if (this.tests) {
+            filters['--tests'] = this.tests;
+        }
+        if (this.groups) {
+            filters['--groups'] = this.groups;
+        }
+        if (this.suites) {
+            filters['--suites'] = this.suites;
+        }
+        if (this.tags) {
+            filters['--tags'] = this.tags;
+        }
+        if (this.ignoreTags) {
+            filters['--ignore-tags'] = this.ignoreTags;
+        }
+        return filters;
+    }
+    async run() {
+        const { TestsServer } = await Promise.resolve().then(() => __importStar(require('../src/Test')));
+        try {
+            if (this.watch) {
+                await new TestsServer(this.application.appRoot, this.getTestFilters(), this.nodeArgs, this.logger).watch();
+            }
+            else {
+                await new TestsServer(this.application.appRoot, this.getTestFilters(), this.nodeArgs, this.logger).run();
+            }
+        }
+        catch (error) {
+            this.exitCode = 1;
+            this.logger.fatal(error);
+        }
+    }
+}
+Test.commandName = 'test';
+Test.description = 'Run AdonisJS tests';
+Test.settings = {
+    stayAlive: true,
+};
+__decorate([
+    standalone_1.flags.boolean({
+        description: 'Watch for file changes and re-run tests on file change',
+        alias: 'w',
+    }),
+    __metadata("design:type", Boolean)
+], Test.prototype, "watch", void 0);
+__decorate([
+    standalone_1.flags.boolean({
+        description: 'Detect file changes by polling files instead of listening to filesystem events',
+        alias: 'p',
+    }),
+    __metadata("design:type", Boolean)
+], Test.prototype, "poll", void 0);
+__decorate([
+    standalone_1.flags.array({ description: 'CLI options to pass to the node command line' }),
+    __metadata("design:type", Array)
+], Test.prototype, "nodeArgs", void 0);
+__decorate([
+    standalone_1.flags.array({ description: 'Run tests for only specified tags' }),
+    __metadata("design:type", Array)
+], Test.prototype, "tags", void 0);
+__decorate([
+    standalone_1.flags.array({ description: 'Run all the tests except the tests using specified tags' }),
+    __metadata("design:type", Array)
+], Test.prototype, "ignoreTags", void 0);
+__decorate([
+    standalone_1.flags.number({ description: 'Define timeout for tests' }),
+    __metadata("design:type", Number)
+], Test.prototype, "timeout", void 0);
+__decorate([
+    standalone_1.flags.array({ description: 'Run tests for only the specified suites' }),
+    __metadata("design:type", Array)
+], Test.prototype, "suites", void 0);
+__decorate([
+    standalone_1.flags.array({ description: 'Run tests for only the specified groups' }),
+    __metadata("design:type", Array)
+], Test.prototype, "groups", void 0);
+__decorate([
+    standalone_1.flags.array({ description: 'Run tests with the specified titles' }),
+    __metadata("design:type", Array)
+], Test.prototype, "tests", void 0);
+__decorate([
+    standalone_1.flags.boolean({ description: 'Force exit the tests runner process' }),
+    __metadata("design:type", Boolean)
+], Test.prototype, "forceExit", void 0);
+exports.default = Test;

package/build/config/paths.d.ts

@@ -3,4 +3,5 @@ export declare const DEFAULT_BUILD_DIR = "build";
 export declare const RCFILE_NAME = ".adonisrc.json";
 export declare const ENV_FILES: string[];
 export declare const SERVER_ENTRY_FILE = "server.ts";
+export declare const TESTS_ENTRY_FILE = "tests.ts";
 export declare const TSCONFIG_FILE_NAME = "tsconfig.json";

package/build/config/paths.js

@@ -8,10 +8,11 @@
  * file that was distributed with this source code.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TSCONFIG_FILE_NAME = exports.SERVER_ENTRY_FILE = exports.ENV_FILES = exports.RCFILE_NAME = exports.DEFAULT_BUILD_DIR = exports.ACE_FILE_NAME = void 0;
+exports.TSCONFIG_FILE_NAME = exports.TESTS_ENTRY_FILE = exports.SERVER_ENTRY_FILE = exports.ENV_FILES = exports.RCFILE_NAME = exports.DEFAULT_BUILD_DIR = exports.ACE_FILE_NAME = void 0;
 exports.ACE_FILE_NAME = 'ace';
 exports.DEFAULT_BUILD_DIR = 'build';
 exports.RCFILE_NAME = '.adonisrc.json';
 exports.ENV_FILES = ['.env', '.env.testing'];
 exports.SERVER_ENTRY_FILE = 'server.ts';
+exports.TESTS_ENTRY_FILE = 'tests.ts';
 exports.TSCONFIG_FILE_NAME = 'tsconfig.json';

package/build/src/Contracts/index.d.ts

@@ -0,0 +1,10 @@
+export declare type JapaFlags = Partial<{
+    '--tests': string[];
+    '--tags': string[];
+    '--groups': string[];
+    '--ignore-tags': string[];
+    '--files': string[];
+    '--timeout': number;
+    '--suites': string[];
+    '--force-exit': boolean;
+}>;

package/build/src/Contracts/index.js

@@ -0,0 +1,10 @@
+"use strict";
+/*
+ * @adonisjs/assembler
+ *
+ * (c) Harminder Virk <virk@adonisjs.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/src/RcFile/index.d.ts

@@ -18,6 +18,10 @@ export declare class RcFile {
      * A matcher to know if a file is part of the meta files globs
      */
     isMetaFile: (filePath: string) => boolean;
+    /**
+     * A matcher to know if file is a test file or not
+     */
+    isTestsFile: (filePath: string) => boolean;
     /**
      * A matcher to know if a file is part of the restart server files globs
      */
@@ -47,6 +51,10 @@ export declare class RcFile {
      * to be copied
      */
     getMetaFilesGlob(): string[];
+    /**
+     * Returns an array of globs for the test files
+     */
+    getTestsFileGlob(): string[];
     /**
      * Reloads the rcfile.json
      */
@@ -59,5 +67,6 @@ export declare class RcFile {
         reload: boolean;
         rcFile: boolean;
         metaFile: boolean;
+        testFile: boolean;
     };
 }

package/build/src/RcFile/index.js

@@ -39,6 +39,10 @@ class RcFile {
          * A matcher to know if a file is part of the meta files globs
          */
         this.isMetaFile = (0, picomatch_1.default)(this.getMetaFilesGlob());
+        /**
+         * A matcher to know if file is a test file or not
+         */
+        this.isTestsFile = (0, picomatch_1.default)(this.getTestsFileGlob());
         /**
          * A matcher to know if a file is part of the restart server files globs
          */
@@ -90,6 +94,17 @@ class RcFile {
             .map(({ pattern }) => pattern)
             .concat([paths_1.ACE_FILE_NAME]);
     }
+    /**
+     * Returns an array of globs for the test files
+     */
+    getTestsFileGlob() {
+        return this.application.rcFile.tests.suites.reduce((result, suite) => {
+            if (suite.files) {
+                result = result.concat(suite.files);
+            }
+            return result;
+        }, []);
+    }
     /**
      * Reloads the rcfile.json
      */
@@ -109,6 +124,7 @@ class RcFile {
                 reload: true,
                 rcFile: true,
                 metaFile: true,
+                testFile: false,
             };
         }
         /**
@@ -119,6 +135,7 @@ class RcFile {
                 reload: true,
                 rcFile: false,
                 metaFile: true,
+                testFile: false,
             };
         }
         /**
@@ -129,6 +146,18 @@ class RcFile {
                 reload: false,
                 rcFile: false,
                 metaFile: true,
+                testFile: false,
+            };
+        }
+        /**
+         * File is part of one of the tests suite
+         */
+        if (this.isTestsFile(filePath)) {
+            return {
+                reload: false,
+                rcFile: false,
+                metaFile: false,
+                testFile: true,
             };
         }
         /**
@@ -138,6 +167,7 @@ class RcFile {
             reload: false,
             rcFile: false,
             metaFile: false,
+            testFile: false,
         };
     }
 }

package/build/src/Test/index.d.ts

@@ -0,0 +1,66 @@
+import { logger as uiLogger } from '@poppinss/cliui';
+import { JapaFlags } from '../Contracts';
+/**
+ * Exposes the API to watch project for compilition changes and
+ * run/re-run tests
+ */
+export declare class TestsServer {
+    private appRoot;
+    private filters;
+    private nodeArgs;
+    private logger;
+    /**
+     * A boolean to know if we are watching for filesystem
+     */
+    private watchingFileSystem;
+    /**
+     * Boolean to hold the current state of tests. This is avoid
+     * re-running the tests when one run is in progress
+     */
+    private busy;
+    /**
+     * Reference to the typescript compiler
+     */
+    private ts;
+    /**
+     * Reference to the RCFile
+     */
+    private rcFile;
+    /**
+     * Manifest instance to generate ace manifest file
+     */
+    private manifest;
+    /**
+     * Require-ts watch helpers
+     */
+    private watchHelpers;
+    /**
+     * A method to know if the file is part of the selected suites
+     * or not
+     */
+    private isTestSuiteFile;
+    /**
+     * Find if the test file part of the applied file filters
+     */
+    private isTestFile;
+    constructor(appRoot: string, filters: JapaFlags, nodeArgs?: string[], logger?: typeof uiLogger);
+    /**
+     * Returns the glob paths for test suites. Returns all if no
+     * filter is applied. Otherwise only the filtered suites
+     * are picked.
+     */
+    private getFilesForSelectedSuites;
+    /**
+     * Kill current process
+     */
+    private kill;
+    /**
+     * Run tests. Use [[watch]] to also watch for file
+     * changes
+     */
+    run(filePath?: string): Promise<void>;
+    /**
+     * Build and watch for file changes
+     */
+    watch(poll?: boolean): Promise<void>;
+}

package/build/src/Test/index.js

@@ -0,0 +1,323 @@
+"use strict";
+/*
+ * @adonisjs/assembler
+ *
+ * (c) Harminder Virk <virk@adonisjs.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TestsServer = void 0;
+const path_1 = require("path");
+const picomatch_1 = __importDefault(require("picomatch"));
+const cliui_1 = require("@poppinss/cliui");
+const require_ts_1 = require("@adonisjs/require-ts");
+const Ts_1 = require("../Ts");
+const RcFile_1 = require("../RcFile");
+const Manifest_1 = require("../Manifest");
+const process_1 = require("./process");
+const paths_1 = require("../../config/paths");
+/**
+ * Exposes the API to watch project for compilition changes and
+ * run/re-run tests
+ */
+class TestsServer {
+    constructor(appRoot, filters, nodeArgs = [], logger = cliui_1.logger) {
+        this.appRoot = appRoot;
+        this.filters = filters;
+        this.nodeArgs = nodeArgs;
+        this.logger = logger;
+        /**
+         * A boolean to know if we are watching for filesystem
+         */
+        this.watchingFileSystem = false;
+        /**
+         * Boolean to hold the current state of tests. This is avoid
+         * re-running the tests when one run is in progress
+         */
+        this.busy = false;
+        /**
+         * Reference to the typescript compiler
+         */
+        this.ts = new Ts_1.Ts(this.appRoot, this.logger);
+        /**
+         * Reference to the RCFile
+         */
+        this.rcFile = new RcFile_1.RcFile(this.appRoot);
+        /**
+         * Manifest instance to generate ace manifest file
+         */
+        this.manifest = new Manifest_1.Manifest(this.appRoot, this.logger);
+        /**
+         * Require-ts watch helpers
+         */
+        this.watchHelpers = (0, require_ts_1.getWatcherHelpers)(this.appRoot);
+        /**
+         * A method to know if the file is part of the selected suites
+         * or not
+         */
+        this.isTestSuiteFile = (0, picomatch_1.default)(this.getFilesForSelectedSuites());
+        /**
+         * Find if the test file part of the applied file filters
+         */
+        this.isTestFile = (filePath) => {
+            if (!this.filters['--files']) {
+                return true;
+            }
+            const fileName = filePath.replace((0, path_1.extname)(filePath), '');
+            return !!this.filters['--files'].find((filter) => {
+                if (filePath.endsWith(filter)) {
+                    return true;
+                }
+                return fileName.endsWith(filter) || fileName.endsWith(`${filter}.spec`);
+            });
+        };
+    }
+    /**
+     * Returns the glob paths for test suites. Returns all if no
+     * filter is applied. Otherwise only the filtered suites
+     * are picked.
+     */
+    getFilesForSelectedSuites() {
+        return this.rcFile.application.rcFile.tests.suites.reduce((result, suite) => {
+            if (!suite.files) {
+                return result;
+            }
+            if (!this.filters['--suites'] || this.filters['--suites'].includes(suite.name)) {
+                result = result.concat(suite.files);
+            }
+            return result;
+        }, []);
+    }
+    /**
+     * Kill current process
+     */
+    kill() {
+        process.exit();
+    }
+    /**
+     * Run tests. Use [[watch]] to also watch for file
+     * changes
+     */
+    async run(filePath) {
+        if (this.busy) {
+            return;
+        }
+        const filters = { ...this.filters };
+        /**
+         * Overwrite files filter when a specific file path
+         * is mentioned
+         */
+        if (filePath) {
+            filters['--files'] = [filePath];
+        }
+        this.busy = true;
+        const { hasErrors } = await new process_1.TestProcess(paths_1.TESTS_ENTRY_FILE, this.appRoot, filters, this.nodeArgs, this.logger, {}).run();
+        this.busy = false;
+        if (!this.watchingFileSystem) {
+            if (hasErrors) {
+                process.exitCode = 1;
+            }
+            this.kill();
+        }
+    }
+    /**
+     * Build and watch for file changes
+     */
+    async watch(poll = false) {
+        this.watchingFileSystem = true;
+        /**
+         * Clear require-ts cache
+         */
+        this.watchHelpers.clear();
+        /**
+         * Run tests
+         */
+        await this.run();
+        /**
+         * Parse config to find the files excluded inside
+         * tsconfig file
+         */
+        const config = this.ts.parseConfig();
+        if (!config) {
+            this.logger.warning('Cannot start watcher because of errors in the tsconfig file');
+            return;
+        }
+        /**
+         * Stick file watcher
+         */
+        const watcher = this.ts.tsCompiler.watcher(config, 'raw');
+        /**
+         * Watcher is ready after first compile
+         */
+        watcher.on('watcher:ready', () => {
+            this.logger.info('watching file system for changes');
+        });
+        /**
+         * Source file removed
+         */
+        watcher.on('source:unlink', async ({ absPath, relativePath }) => {
+            this.watchHelpers.clear(absPath);
+            if (this.busy) {
+                return;
+            }
+            this.logger.action('delete').succeeded(relativePath);
+            /**
+             * Generate manifest when filePath is a commands path
+             */
+            if (this.rcFile.isCommandsPath(relativePath)) {
+                this.manifest.generate();
+            }
+            /**
+             * Run all tests when any of the source, except the
+             * test file changes
+             */
+            if (!this.rcFile.isTestsFile(relativePath)) {
+                await this.run();
+            }
+        });
+        /**
+         * Source file added
+         */
+        watcher.on('source:add', async ({ absPath, relativePath }) => {
+            this.watchHelpers.clear(absPath);
+            if (this.busy) {
+                return;
+            }
+            this.logger.action('add').succeeded(relativePath);
+            /**
+             * Run all tests when any of the source, except the
+             * test file changes
+             */
+            if (!this.rcFile.isTestsFile(relativePath)) {
+                await this.run();
+                return;
+            }
+            /**
+             * Run only the changed file if it part of the test
+             * suites (respecting filters)
+             */
+            if (this.isTestSuiteFile(relativePath) && this.isTestFile(relativePath)) {
+                await this.run(relativePath);
+            }
+        });
+        /**
+         * Source file changed
+         */
+        watcher.on('source:change', async ({ absPath, relativePath }) => {
+            this.watchHelpers.clear(absPath);
+            if (this.busy) {
+                return;
+            }
+            this.logger.action('update').succeeded(relativePath);
+            /**
+             * Generate manifest when filePath is a commands path
+             */
+            if (this.rcFile.isCommandsPath(relativePath)) {
+                this.manifest.generate();
+            }
+            /**
+             * Run all tests when any of the source, except the
+             * test file changes
+             */
+            if (!this.rcFile.isTestsFile(relativePath)) {
+                await this.run();
+                return;
+            }
+            /**
+             * Run only the changed file if it part of the test
+             * suites (respecting filters)
+             */
+            if (this.isTestSuiteFile(relativePath) && this.isTestFile(relativePath)) {
+                await this.run(relativePath);
+            }
+        });
+        /**
+         * New file added
+         */
+        watcher.on('add', async ({ relativePath }) => {
+            if (this.busy) {
+                return;
+            }
+            if (paths_1.ENV_FILES.includes(relativePath)) {
+                this.logger.action('create').succeeded(relativePath);
+                await this.run();
+                return;
+            }
+            const metaData = this.rcFile.getMetaData(relativePath);
+            if (!metaData.metaFile) {
+                return;
+            }
+            this.logger.action('create').succeeded(relativePath);
+            if (metaData.reload) {
+                await this.run();
+            }
+        });
+        /**
+         * File changed
+         */
+        watcher.on('change', async ({ relativePath }) => {
+            if (this.busy) {
+                return;
+            }
+            if (paths_1.ENV_FILES.includes(relativePath)) {
+                this.logger.action('update').succeeded(relativePath);
+                await this.run();
+                return;
+            }
+            const metaData = this.rcFile.getMetaData(relativePath);
+            if (!metaData.metaFile) {
+                return;
+            }
+            this.logger.action('update').succeeded(relativePath);
+            if (metaData.reload || metaData.rcFile) {
+                await this.run();
+            }
+        });
+        /**
+         * File removed
+         */
+        watcher.on('unlink', async ({ relativePath }) => {
+            if (this.busy) {
+                return;
+            }
+            if (paths_1.ENV_FILES.includes(relativePath)) {
+                this.logger.action('delete').succeeded(relativePath);
+                await this.run();
+                return;
+            }
+            const metaData = this.rcFile.getMetaData(relativePath);
+            if (!metaData.metaFile) {
+                return;
+            }
+            if (metaData.rcFile) {
+                this.logger.info('cannot continue after deletion of .adonisrc.json file');
+                watcher.chokidar.close();
+                this.kill();
+                return;
+            }
+            this.logger.action('delete').succeeded(relativePath);
+            if (metaData.reload) {
+                await this.run();
+            }
+        });
+        /**
+         * Start the watcher
+         */
+        watcher.watch(['.'], {
+            usePolling: poll,
+        });
+        /**
+         * Kill when watcher recieves an error
+         */
+        watcher.chokidar.on('error', (error) => {
+            this.logger.fatal(error);
+            this.kill();
+        });
+    }
+}
+exports.TestsServer = TestsServer;

package/build/src/Test/process.d.ts

@@ -0,0 +1,22 @@
+import { logger as uiLogger } from '@poppinss/cliui';
+import { JapaFlags } from '../Contracts';
+/**
+ * Exposes the API to run tests as a child process.
+ */
+export declare class TestProcess {
+    private sourceFile;
+    private projectRoot;
+    private filters;
+    private logger;
+    private env;
+    private nodeArgs;
+    constructor(sourceFile: string, projectRoot: string, filters: JapaFlags, nodeArgs: string[] | undefined, logger: typeof uiLogger, env?: {
+        [key: string]: string;
+    });
+    /**
+     * Start the HTTP server as a child process.
+     */
+    run(): Promise<{
+        hasErrors: boolean;
+    }>;
+}

package/build/src/Test/process.js

@@ -0,0 +1,64 @@
+"use strict";
+/*
+ * @adonisjs/assembler
+ *
+ * (c) Harminder Virk <virk@adonisjs.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TestProcess = void 0;
+const execa_1 = __importDefault(require("execa"));
+/**
+ * Exposes the API to run tests as a child process.
+ */
+class TestProcess {
+    constructor(sourceFile, projectRoot, filters, nodeArgs = [], logger, env = {}) {
+        this.sourceFile = sourceFile;
+        this.projectRoot = projectRoot;
+        this.filters = filters;
+        this.logger = logger;
+        this.env = env;
+        this.nodeArgs = nodeArgs.reduce((result, arg) => {
+            result = result.concat(arg.split(' '));
+            return result;
+        }, []);
+    }
+    /**
+     * Start the HTTP server as a child process.
+     */
+    async run() {
+        this.logger.info('running tests...');
+        const filters = Object.keys(this.filters).reduce((result, filter) => {
+            const value = this.filters[filter];
+            result.push(filter);
+            if (Array.isArray(value)) {
+                result.push(...value);
+            }
+            else {
+                result.push(value);
+            }
+            return result;
+        }, []);
+        try {
+            await execa_1.default.node(this.sourceFile, filters, {
+                stdio: 'inherit',
+                cwd: this.projectRoot,
+                env: {
+                    FORCE_COLOR: 'true',
+                    ...this.env,
+                },
+                nodeOptions: ['-r', '@adonisjs/assembler/build/register'].concat(this.nodeArgs),
+            });
+            return { hasErrors: false };
+        }
+        catch {
+            return { hasErrors: true };
+        }
+    }
+}
+exports.TestProcess = TestProcess;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adonisjs/assembler",
-  "version": "5.4.2",
+  "version": "5.5.0-0",
   "description": "Core commands to compiler and build AdonisJs project",
   "main": "build/ace-manifest.json",
   "files": [
@@ -111,7 +111,7 @@
   },
   "publishConfig": {
     "access": "public",
-    "tag": "latest"
+    "tag": "next"
   },
   "mrmConfig": {
     "core": true,