@adonisjs/assembler 5.4.2 → 5.5.2-0

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,8 @@
+export declare type JapaFlags = Partial<{
+    '_': string[];
+    '--tags': string[];
+    '--ignore-tags': string[];
+    '--files': string[];
+    '--timeout': number;
+    '--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,317 @@
+"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);
+            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);
+            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);
+            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,66 @@
+"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];
+            if (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/build/templates/test-entrypoint.txt

@@ -0,0 +1,45 @@
+/*
+|--------------------------------------------------------------------------
+| Tests
+|--------------------------------------------------------------------------
+|
+| The contents in this file boots the AdonisJS application and configures
+| the Japa tests runner.
+|
+| For the most part you will never edit this file. The configuration
+| for the tests can be controlled via ".adonisrc.json" and
+| "tests/bootstrap.ts" files.
+|
+*/
+
+process.env.NODE_ENV = 'testing'
+
+import 'reflect-metadata'
+import sourceMapSupport from 'source-map-support'
+import { Ignitor } from '@adonisjs/core/build/standalone'
+import { configure, processCliArgs, run, RunnerHooksHandler } from '@japa/runner'
+
+sourceMapSupport.install({ handleUncaughtExceptions: false })
+
+const kernel = new Ignitor(__dirname).kernel('test')
+
+kernel
+  .boot()
+  .then(() => import('./tests/bootstrap'))
+  .then(({ runnerHooks, ...config }) => {
+    const app: RunnerHooksHandler[] = [() => kernel.start()]
+
+    configure({
+      ...kernel.application.rcFile.tests,
+      ...processCliArgs(process.argv.slice(2)),
+      ...config,
+      ...{
+        importer: (filePath) => import(filePath),
+        setup: app.concat(runnerHooks.setup),
+        teardown: runnerHooks.teardown,
+      },
+      cwd: kernel.application.appRoot
+    })
+
+    run()
+  })

package/build/templates/test.txt

@@ -0,0 +1,5 @@
+import { test } from '@japa/runner'
+
+test.group('{{ name }}', () => {
+  // Write your test here
+})

package/build/templates/tests-contract.txt

@@ -0,0 +1,18 @@
+/**
+ * Contract source: https://github.com/adonisjs/core/blob/master/templates/contracts/tests.txt
+ *
+ * Feel free to let us know via PR, if you find something broken in this contract
+ * file.
+ */
+
+import '@japa/runner'
+
+declare module '@japa/runner' {
+  interface TestContext {
+    // Extend context
+  }
+
+  interface Test<DataSet> {
+    // Extend test
+  }
+}