codeceptjs 3.6.6 → 4.0.0-beta.1

package/lib/codecept.js

@@ -1,215 +1,228 @@
-const { existsSync, readFileSync } = require('fs');
-const glob = require('glob');
-const fsPath = require('path');
-const { resolve } = require('path');
-
-const container = require('./container');
-const Config = require('./config');
-const event = require('./event');
-const runHook = require('./hooks');
-const output = require('./output');
-const { emptyFolder } = require('./utils');
+import { existsSync, readFileSync } from 'fs';
+import glob from 'glob';
+import { resolve, dirname, isAbsolute, join } from 'path';
+import { fileURLToPath } from 'url';
+import { createRequire } from 'node:module';
+import container from './container.js';
+import Config from './config.js';
+import * as event from './event.js';
+import runHook from './hooks.js';
+import * as output from './output.js';
+import { emptyFolder } from './utils.js';
+import * as index from './index.js';
+
+// Helpers and features
+import * as actor from './actor.js';
+import pause from './pause.js';
+import within from './within.js';
+import session from './session.js';
+import data from './data/table.js';
+import Locator from './locator.js';
+import secret from './secret.js';
+import * as stepDefinitions from './interfaces/bdd.js';
+
+// Listeners
+import listener from './listener/steps.js';
+import listenerArtifacts from './listener/artifacts.js';
+import listenerConfig from './listener/config.js';
+import listenerHelpers from './listener/helpers.js';
+import listenerRetry from './listener/retry.js';
+import listenerTimeout from './listener/timeout.js';
+import listenerExit from './listener/exit.js';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const require = createRequire(import.meta.url);
 
 /**
- * CodeceptJS runner
+ * CodeceptJS runner class.
  */
-class Codecept {
+export default class Codecept {
   /**
-   * Create CodeceptJS runner.
-   * Config and options should be passed
-   *
-   * @param {*} config
-   * @param {*} opts
+   * Initializes CodeceptJS runner with config and options.
+   * @param {Object} config - Configuration object.
+   * @param {Object} opts - Options.
    */
   constructor(config, opts) {
     this.config = Config.create(config);
     this.opts = opts;
-    this.testFiles = new Array(0);
-    this.requireModules(config.require);
+    this.testFiles = [];
+    this.requireModules(config?.require);
   }
 
   /**
-   * Require modules before codeceptjs running
-   *
-   * @param {string[]} requiringModules
+   * Requires necessary modules before running CodeceptJS.
+   * @param {string[]} requiringModules - List of modules to require.
    */
   requireModules(requiringModules) {
-    if (requiringModules) {
-      requiringModules.forEach((requiredModule) => {
-        const isLocalFile = existsSync(requiredModule) || existsSync(`${requiredModule}.js`);
-        if (isLocalFile) {
-          requiredModule = resolve(requiredModule);
-        }
-        require(requiredModule);
-      });
-    }
+    requiringModules?.forEach((requiredModule) => {
+      const isLocalFile = existsSync(requiredModule) || existsSync(`${requiredModule}.js`);
+      const modulePath = isLocalFile ? resolve(requiredModule) : requiredModule;
+      require(modulePath);
+    });
   }
 
   /**
-   * Initialize CodeceptJS at specific directory.
-   * If async initialization is required, pass callback as second parameter.
-   *
-   * @param {string} dir
+   * Initializes CodeceptJS in a specific directory.
+   * @param {string} dir - Directory path.
    */
   init(dir) {
     this.initGlobals(dir);
-    // initializing listeners
     container.create(this.config, this.opts);
     this.runHooks();
   }
 
   /**
-   * Creates global variables
-   *
-   * @param {string} dir
+   * Initializes global variables.
+   * @param {string} dir - Directory path.
    */
   initGlobals(dir) {
     global.codecept_dir = dir;
-    global.output_dir = fsPath.resolve(dir, this.config.output);
+    global.output_dir = resolve(dir, this.config.output);
 
     if (this.config.emptyOutputFolder) emptyFolder(global.output_dir);
 
     if (!this.config.noGlobals) {
-      global.Helper = global.codecept_helper = require('@codeceptjs/helper');
-      global.actor = global.codecept_actor = require('./actor');
-      global.pause = require('./pause');
-      global.within = require('./within');
-      global.session = require('./session');
-      global.DataTable = require('./data/table');
-      global.locate = locator => require('./locator').build(locator);
-      global.inject = container.support;
-      global.share = container.share;
-      global.secret = require('./secret').secret;
-      global.codecept_debug = output.debug;
-      global.codeceptjs = require('./index'); // load all objects
-
-      // BDD
-      const stepDefinitions = require('./interfaces/bdd');
-      global.Given = stepDefinitions.Given;
-      global.When = stepDefinitions.When;
-      global.Then = stepDefinitions.Then;
-      global.DefineParameterType = stepDefinitions.defineParameterType;
-
-      // debug mode
-      global.debugMode = false;
+      this.initGlobalHelpers();
     }
   }
 
   /**
-   * Executes hooks.
+   * Initializes global helpers and other CodeceptJS features.
+   */
+  initGlobalHelpers() {
+    global.Helper = global.codecept_helper = index.generated;
+    global.actor = global.codecept_actor = actor;
+    global.pause = pause;
+    global.within = within;
+    global.session = session;
+    global.DataTable = data;
+    global.locate = (locator) => new Locator(locator);
+    global.inject = container.support;
+    global.share = container.share;
+    global.secret = secret;
+    global.codecept_debug = output.debug;
+    global.codeceptjs = index;
+
+    // BDD
+    global.Given = stepDefinitions.Given;
+    global.When = stepDefinitions.When;
+    global.Then = stepDefinitions.Then;
+    global.DefineParameterType = stepDefinitions.defineParameterType;
+    global.debugMode = false;
+  }
+
+  /**
+   * Runs all hooks, including custom and default.
    */
   runHooks() {
-    // default hooks
-    runHook(require('./listener/steps'));
-    runHook(require('./listener/artifacts'));
-    runHook(require('./listener/config'));
-    runHook(require('./listener/helpers'));
-    runHook(require('./listener/retry'));
-    runHook(require('./listener/timeout'));
-    runHook(require('./listener/exit'));
-
-    // custom hooks (previous iteration of plugins)
-    this.config.hooks.forEach(hook => runHook(hook));
+    const listeners = [
+      listener,
+      listenerArtifacts,
+      listenerConfig,
+      listenerHelpers,
+      listenerRetry,
+      listenerTimeout,
+      listenerExit,
+    ];
+
+    listeners.forEach(runHook);
+
+    // Run custom hooks
+    this.config.hooks.forEach(runHook);
   }
 
   /**
-   * Executes bootstrap.
-   *
+   * Executes the bootstrap process.
    */
   async bootstrap() {
     return runHook(this.config.bootstrap, 'bootstrap');
   }
 
   /**
-   * Executes teardown.
-
+   * Executes the teardown process.
    */
   async teardown() {
     return runHook(this.config.teardown, 'teardown');
   }
 
   /**
-   * Loads tests by pattern or by config.tests
-   *
-   * @param {string} [pattern]
+   * Loads test files based on the given pattern or config.
+   * @param {string} [pattern] - Optional pattern for loading tests.
    */
   loadTests(pattern) {
-    const options = {
-      cwd: global.codecept_dir,
-    };
-
-    let patterns = [pattern];
-    if (!pattern) {
-      patterns = [];
-
-      // If the user wants to test a specific set of test files as an array or string.
-      if (this.config.tests && !this.opts.features) {
-        if (Array.isArray(this.config.tests)) {
-          patterns.push(...this.config.tests);
-        } else {
-          patterns.push(this.config.tests);
+    const patterns = this.getTestPatterns(pattern);
+    const options = { cwd: global.codecept_dir };
+
+    patterns.forEach((p) => {
+      glob.sync(p, options).forEach((file) => {
+        if (!file.includes('node_modules')) {
+          const fullPath = isAbsolute(file) ? file : join(global.codecept_dir, file);
+          const resolvedFile = resolve(fullPath);
+
+          if (!this.testFiles.includes(resolvedFile)) {
+            this.testFiles.push(resolvedFile);
+          }
         }
-      }
+      });
+    });
+  }
 
-      if (this.config.gherkin.features && !this.opts.tests) {
-        if (Array.isArray(this.config.gherkin.features)) {
-          this.config.gherkin.features.forEach(feature => {
-            patterns.push(feature);
-          });
-        } else {
-          patterns.push(this.config.gherkin.features);
-        }
-      }
+  /**
+   * Gets test patterns based on config and options.
+   * @param {string} [pattern] - Test pattern to match.
+   * @returns {string[]} - Array of test patterns.
+   */
+  getTestPatterns(pattern) {
+    if (pattern) return [pattern];
+
+    const patterns = [];
+    const { tests, gherkin } = this.config;
+
+    if (tests && !this.opts.features) {
+      patterns.push(...(Array.isArray(tests) ? tests : [tests]));
     }
 
-    for (pattern of patterns) {
-      glob.sync(pattern, options).forEach((file) => {
-        if (file.includes('node_modules')) return;
-        if (!fsPath.isAbsolute(file)) {
-          file = fsPath.join(global.codecept_dir, file);
-        }
-        if (!this.testFiles.includes(fsPath.resolve(file))) {
-          this.testFiles.push(fsPath.resolve(file));
-        }
-      });
+    if (gherkin?.features && !this.opts.tests) {
+      patterns.push(...(Array.isArray(gherkin.features) ? gherkin.features : [gherkin.features]));
     }
+
+    return patterns;
   }
 
   /**
-   * Run a specific test or all loaded tests.
-   *
-   * @param {string} [test]
+   * Runs tests either specific to a file or all loaded tests.
+   * @param {string} [test] - Test file to run.
    * @returns {Promise<void>}
    */
   async run(test) {
-    return new Promise((resolve, reject) => {
-      const mocha = container.mocha();
-      mocha.files = this.testFiles;
-      if (test) {
-        if (!fsPath.isAbsolute(test)) {
-          test = fsPath.join(global.codecept_dir, test);
-        }
-        mocha.files = mocha.files.filter(t => fsPath.basename(t, '.js') === test || t === test);
-      }
-      const done = () => {
-        event.emit(event.all.result, this);
-        event.emit(event.all.after, this);
-        resolve();
-      };
+    const mocha = container.mocha();
+    mocha.files = this.testFiles;
 
+    if (test) {
+      const testPath = isAbsolute(test) ? test : join(global.codecept_dir, test);
+      mocha.files = mocha.files.filter((t) => resolve(t) === resolve(testPath));
+    }
+
+    return new Promise((resolve, reject) => {
       try {
         event.emit(event.all.before, this);
-        mocha.run(() => done());
-      } catch (e) {
-        output.error(e.stack);
-        reject(e);
+        mocha.run(() => {
+          event.emit(event.all.result, this);
+          event.emit(event.all.after, this);
+          resolve();
+        });
+      } catch (error) {
+        output.output.error(error.stack);
+        reject(error);
       }
     });
   }
-
-  static version() {
-    return JSON.parse(readFileSync(`${__dirname}/../package.json`, 'utf8')).version;
-  }
 }
 
-module.exports = Codecept;
+/**
+ * Retrieves the version from package.json.
+ * @returns {string} - The version of the package.
+ */
+export function version() {
+  return JSON.parse(readFileSync(resolve(__dirname, '../package.json'), 'utf8')).version;
+}

package/lib/colorUtils.js

@@ -189,7 +189,7 @@ function convertHexColorToRgba(hex) {
  *
  * @param {string} color Color as a string, i.e. rgb(85,0,0)
  */
-function convertColorToRGBA(color) {
+export function convertColorToRGBA(color) {
   const cstr = `${color}`.toLowerCase().trim() || '';
 
   if (!/^rgba?\(.+?\)$/.test(cstr)) {
@@ -221,7 +221,7 @@ function convertColorToRGBA(color) {
  *
  * @param {string} prop CSS Property name
  */
-function isColorProperty(prop) {
+export function isColorProperty(prop) {
   return [
     'color',
     'background',
@@ -248,7 +248,7 @@ function isColorProperty(prop) {
   ].indexOf(prop) > -1;
 }
 
-module.exports = {
+export default {
   isColorProperty,
   convertColorToRGBA,
   convertColorNameToHex,

package/lib/command/configMigrate.js

@@ -1,76 +1,70 @@
-const colors = require('chalk')
-const fs = require('fs')
-const inquirer = require('inquirer')
-const mkdirp = require('mkdirp')
-const path = require('path')
-const util = require('util')
+import colors from 'chalk';
+import fs from 'fs';
+import inquirer from 'inquirer';
+import mkdirp from 'mkdirp';
+import path from 'path';
+import util from 'util';
+import * as outputLib from '../output.js';
+import { fileExists } from '../utils.js';
+import { getTestRoot } from './utils.js';
 
-const { print, success, error } = require('../output')
-const { fileExists } = require('../utils')
-const { getTestRoot } = require('./utils')
+export default function (initPath) {
+  const testsPath = getTestRoot(initPath);
 
-module.exports = function (initPath) {
-  const testsPath = getTestRoot(initPath)
-
-  print()
-  print(`  Welcome to ${colors.magenta.bold('CodeceptJS')} configuration migration tool`)
-  print(
-    `  It will help you switch from ${colors.cyan.bold('.json')} to ${colors.magenta.bold('.js')} config format at ease`,
-  )
-  print()
+  outputLib.print();
+  outputLib.print(`  Welcome to ${colors.magenta.bold('CodeceptJS')} configuration migration tool`);
+  outputLib.print(`  It will help you switch from ${colors.cyan.bold('.json')} to ${colors.magenta.bold('.js')} config format at ease`);
+  outputLib.print();
 
   if (!path) {
-    print('No config file is specified.')
-    print(`Test root is assumed to be ${colors.yellow.bold(testsPath)}`)
-    print('----------------------------------')
+    outputLib.print('No config file is specified.');
+    outputLib.print(`Test root is assumed to be ${colors.yellow.bold(testsPath)}`);
+    outputLib.print('----------------------------------');
   } else {
-    print(`Migrating ${colors.magenta.bold('.js')} config to ${colors.bold(testsPath)}`)
+    outputLib.print(`Migrating ${colors.magenta.bold('.js')} config to ${colors.bold(testsPath)}`);
   }
 
   if (!fileExists(testsPath)) {
-    print(`Directory ${testsPath} does not exist, creating...`)
-    mkdirp.sync(testsPath)
+    outputLib.print(`Directory ${testsPath} does not exist, creating...`);
+    mkdirp.sync(testsPath);
   }
 
-  const configFile = path.join(testsPath, 'codecept.conf.js')
+  const configFile = path.join(testsPath, 'codecept.conf.js');
   if (fileExists(configFile)) {
-    error(`Config is already created at ${configFile}`)
-    return
+    outputLib.output.output.error(`Config is already created at ${configFile}`);
+    return;
   }
 
-  inquirer
-    .prompt([
-      {
-        name: 'configFile',
-        type: 'confirm',
-        message: `Would you like to switch from ${colors.cyan.bold('.json')} to ${colors.magenta.bold('.js')} config format?`,
-        default: true,
-      },
-      {
-        name: 'delete',
-        type: 'confirm',
-        message: `Would you like to delete ${colors.cyan.bold('.json')} config format afterwards?`,
-        default: true,
-      },
-    ])
-    .then((result) => {
-      if (result.configFile) {
-        const jsonConfigFile = path.join(testsPath, 'codecept.js')
-        const config = JSON.parse(fs.readFileSync(jsonConfigFile, 'utf8'))
-        config.name = testsPath.split(path.sep).pop()
+  inquirer.prompt([{
+    name: 'configFile',
+    type: 'confirm',
+    message: `Would you like to switch from ${colors.cyan.bold('.json')} to ${colors.magenta.bold('.js')} config format?`,
+    default: true,
+  },
+  {
+    name: 'delete',
+    type: 'confirm',
+    message: `Would you like to delete ${colors.cyan.bold('.json')} config format afterwards?`,
+    default: true,
+  },
+  ]).then((result) => {
+    if (result.configFile) {
+      const jsonConfigFile = path.join(testsPath, 'codecept.js');
+      const config = JSON.parse(fs.readFileSync(jsonConfigFile, 'utf8'));
+      config.name = testsPath.split(path.sep).pop();
 
-        const finish = () => {
-          fs.writeFileSync(configFile, `exports.config = ${util.inspect(config, false, 4, false)}`, 'utf-8')
-          success(`Config is successfully migrated at ${configFile}`)
+      const finish = () => {
+        fs.writeFileSync(configFile, `exports.config = ${util.inspect(config, false, 4, false)}`, 'utf-8');
+        outputLib.output.success(`Config is successfully migrated at ${configFile}`);
 
-          if (result.delete) {
-            if (fileExists(jsonConfigFile)) {
-              fs.unlinkSync(jsonConfigFile)
-              success('JSON config file is deleted!')
-            }
+        if (result.delete) {
+          if (fileExists(jsonConfigFile)) {
+            fs.unlinkSync(jsonConfigFile);
+            outputLib.output.success('JSON config file is deleted!');
           }
         }
-        finish()
-      }
-    })
+      };
+      finish();
+    }
+  });
 }