codeceptjs 4.0.0-beta.1 → 4.0.0-beta.3

package/lib/codecept.js

@@ -1,228 +1,215 @@
-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);
+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');
 
 /**
- * CodeceptJS runner class.
+ * CodeceptJS runner
  */
-export default class Codecept {
+class Codecept {
   /**
-   * Initializes CodeceptJS runner with config and options.
-   * @param {Object} config - Configuration object.
-   * @param {Object} opts - Options.
+   * Create CodeceptJS runner.
+   * Config and options should be passed
+   *
+   * @param {*} config
+   * @param {*} opts
    */
   constructor(config, opts) {
     this.config = Config.create(config);
     this.opts = opts;
-    this.testFiles = [];
-    this.requireModules(config?.require);
+    this.testFiles = new Array(0);
+    this.requireModules(config.require);
   }
 
   /**
-   * Requires necessary modules before running CodeceptJS.
-   * @param {string[]} requiringModules - List of modules to require.
+   * Require modules before codeceptjs running
+   *
+   * @param {string[]} requiringModules
    */
   requireModules(requiringModules) {
-    requiringModules?.forEach((requiredModule) => {
-      const isLocalFile = existsSync(requiredModule) || existsSync(`${requiredModule}.js`);
-      const modulePath = isLocalFile ? resolve(requiredModule) : requiredModule;
-      require(modulePath);
-    });
+    if (requiringModules) {
+      requiringModules.forEach((requiredModule) => {
+        const isLocalFile = existsSync(requiredModule) || existsSync(`${requiredModule}.js`);
+        if (isLocalFile) {
+          requiredModule = resolve(requiredModule);
+        }
+        require(requiredModule);
+      });
+    }
   }
 
   /**
-   * Initializes CodeceptJS in a specific directory.
-   * @param {string} dir - Directory path.
+   * Initialize CodeceptJS at specific directory.
+   * If async initialization is required, pass callback as second parameter.
+   *
+   * @param {string} dir
    */
   init(dir) {
     this.initGlobals(dir);
+    // initializing listeners
     container.create(this.config, this.opts);
     this.runHooks();
   }
 
   /**
-   * Initializes global variables.
-   * @param {string} dir - Directory path.
+   * Creates global variables
+   *
+   * @param {string} dir
    */
   initGlobals(dir) {
     global.codecept_dir = dir;
-    global.output_dir = resolve(dir, this.config.output);
+    global.output_dir = fsPath.resolve(dir, this.config.output);
 
     if (this.config.emptyOutputFolder) emptyFolder(global.output_dir);
 
     if (!this.config.noGlobals) {
-      this.initGlobalHelpers();
+      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;
     }
   }
 
   /**
-   * 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.
+   * Executes hooks.
    */
   runHooks() {
-    const listeners = [
-      listener,
-      listenerArtifacts,
-      listenerConfig,
-      listenerHelpers,
-      listenerRetry,
-      listenerTimeout,
-      listenerExit,
-    ];
-
-    listeners.forEach(runHook);
-
-    // Run custom hooks
-    this.config.hooks.forEach(runHook);
+    // 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));
   }
 
   /**
-   * Executes the bootstrap process.
+   * Executes bootstrap.
+   *
    */
   async bootstrap() {
     return runHook(this.config.bootstrap, 'bootstrap');
   }
 
   /**
-   * Executes the teardown process.
+   * Executes teardown.
+
    */
   async teardown() {
     return runHook(this.config.teardown, 'teardown');
   }
 
   /**
-   * Loads test files based on the given pattern or config.
-   * @param {string} [pattern] - Optional pattern for loading tests.
+   * Loads tests by pattern or by config.tests
+   *
+   * @param {string} [pattern]
    */
   loadTests(pattern) {
-    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);
-          }
+    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);
         }
-      });
-    });
-  }
-
-  /**
-   * 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]));
+      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);
+        }
+      }
     }
 
-    if (gherkin?.features && !this.opts.tests) {
-      patterns.push(...(Array.isArray(gherkin.features) ? gherkin.features : [gherkin.features]));
+    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));
+        }
+      });
     }
-
-    return patterns;
   }
 
   /**
-   * Runs tests either specific to a file or all loaded tests.
-   * @param {string} [test] - Test file to run.
+   * Run a specific test or all loaded tests.
+   *
+   * @param {string} [test]
    * @returns {Promise<void>}
    */
   async run(test) {
-    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) => {
+      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();
+      };
+
       try {
         event.emit(event.all.before, this);
-        mocha.run(() => {
-          event.emit(event.all.result, this);
-          event.emit(event.all.after, this);
-          resolve();
-        });
-      } catch (error) {
-        output.output.error(error.stack);
-        reject(error);
+        mocha.run(() => done());
+      } catch (e) {
+        output.error(e.stack);
+        reject(e);
       }
     });
   }
-}
 
-/**
- * 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;
+  static version() {
+    return JSON.parse(readFileSync(`${__dirname}/../package.json`, 'utf8')).version;
+  }
 }
+
+module.exports = Codecept;

package/lib/colorUtils.js

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

package/lib/command/configMigrate.js

@@ -1,70 +1,76 @@
-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 colors = require('chalk')
+const fs = require('fs')
+const inquirer = require('inquirer')
+const mkdirp = require('mkdirp')
+const path = require('path')
+const util = require('util')
 
-export default function (initPath) {
-  const testsPath = getTestRoot(initPath);
+const { print, success, error } = require('../output')
+const { fileExists } = require('../utils')
+const { getTestRoot } = require('./utils')
 
-  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();
+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()
 
   if (!path) {
-    outputLib.print('No config file is specified.');
-    outputLib.print(`Test root is assumed to be ${colors.yellow.bold(testsPath)}`);
-    outputLib.print('----------------------------------');
+    print('No config file is specified.')
+    print(`Test root is assumed to be ${colors.yellow.bold(testsPath)}`)
+    print('----------------------------------')
   } else {
-    outputLib.print(`Migrating ${colors.magenta.bold('.js')} config to ${colors.bold(testsPath)}`);
+    print(`Migrating ${colors.magenta.bold('.js')} config to ${colors.bold(testsPath)}`)
   }
 
   if (!fileExists(testsPath)) {
-    outputLib.print(`Directory ${testsPath} does not exist, creating...`);
-    mkdirp.sync(testsPath);
+    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)) {
-    outputLib.output.output.error(`Config is already created at ${configFile}`);
-    return;
+    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');
-        outputLib.output.success(`Config is successfully migrated at ${configFile}`);
+        const finish = () => {
+          fs.writeFileSync(configFile, `exports.config = ${util.inspect(config, false, 4, false)}`, 'utf-8')
+          success(`Config is successfully migrated at ${configFile}`)
 
-        if (result.delete) {
-          if (fileExists(jsonConfigFile)) {
-            fs.unlinkSync(jsonConfigFile);
-            outputLib.output.success('JSON config file is deleted!');
+          if (result.delete) {
+            if (fileExists(jsonConfigFile)) {
+              fs.unlinkSync(jsonConfigFile)
+              success('JSON config file is deleted!')
+            }
           }
         }
-      };
-      finish();
-    }
-  });
+        finish()
+      }
+    })
 }