codeceptjs 4.0.0-beta.2 → 4.0.0-beta.21

package/lib/codecept.js

@@ -1,228 +1,328 @@
-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);
+import { existsSync, readFileSync } from 'fs'
+import { globSync } from 'glob'
+import shuffle from 'lodash.shuffle'
+import fsPath from 'path'
+import { resolve } from 'path'
+import { fileURLToPath, pathToFileURL } from 'url'
+import { dirname } from 'path'
+import { createRequire } from 'module'
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = dirname(__filename)
+
+import Helper from '@codeceptjs/helper'
+import container from './container.js'
+import Config from './config.js'
+import event from './event.js'
+import runHook from './hooks.js'
+import ActorFactory from './actor.js'
+import output from './output.js'
+import { emptyFolder } from './utils.js'
+import { initCodeceptGlobals } from './globals.js'
+import { validateTypeScriptSetup } from './utils/loaderCheck.js'
+import recorder from './recorder.js'
+
+import storeListener from './listener/store.js'
+import stepsListener from './listener/steps.js'
+import configListener from './listener/config.js'
+import resultListener from './listener/result.js'
+import helpersListener from './listener/helpers.js'
+import globalTimeoutListener from './listener/globalTimeout.js'
+import globalRetryListener from './listener/globalRetry.js'
+import exitListener from './listener/exit.js'
+import emptyRunListener from './listener/emptyRun.js'
 
 /**
- * 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.config = Config.create(config)
+    this.opts = opts
+    this.testFiles = new Array(0)
+    this.requiringModules = 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);
-    });
+  async requireModules(requiringModules) {
+    if (requiringModules) {
+      for (const requiredModule of requiringModules) {
+        let modulePath = requiredModule
+        const isLocalFile = existsSync(modulePath) || existsSync(`${modulePath}.js`)
+        if (isLocalFile) {
+          modulePath = resolve(modulePath)
+          // For ESM, ensure .js extension for local files
+          if (!modulePath.endsWith('.js') && !modulePath.endsWith('.mjs') && !modulePath.endsWith('.cjs')) {
+            if (existsSync(`${modulePath}.js`)) {
+              modulePath = `${modulePath}.js`
+            }
+          }
+        } else {
+          // For npm packages, resolve from the user's directory
+          // This ensures packages like tsx are found in user's node_modules
+          const userDir = global.codecept_dir || process.cwd()
+          
+          try {
+            // Use createRequire to resolve from user's directory
+            const userRequire = createRequire(pathToFileURL(resolve(userDir, 'package.json')).href)
+            const resolvedPath = userRequire.resolve(requiredModule)
+            modulePath = pathToFileURL(resolvedPath).href
+          } catch (resolveError) {
+            // If resolution fails, try direct import (will check from CodeceptJS node_modules)
+            // This is the fallback for globally installed packages
+            modulePath = requiredModule
+          }
+        }
+        // Use dynamic import for ESM
+        await import(modulePath)
+      }
+    }
   }
 
   /**
-   * Initializes CodeceptJS in a specific directory.
-   * @param {string} dir - Directory path.
+   * Initialize CodeceptJS at specific dir.
+   * Loads config, requires factory methods
+   *
+   * @param {string} dir
    */
-  init(dir) {
-    this.initGlobals(dir);
-    container.create(this.config, this.opts);
-    this.runHooks();
+  async init(dir) {
+    await this.initGlobals(dir)
+    // Require modules before initializing
+    await this.requireModules(this.requiringModules)
+    // initializing listeners
+    await container.create(this.config, this.opts)
+    // Store container globally for easy access
+    global.container = container
+    await 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);
-
-    if (this.config.emptyOutputFolder) emptyFolder(global.output_dir);
-
-    if (!this.config.noGlobals) {
-      this.initGlobalHelpers();
-    }
+  async initGlobals(dir) {
+    await initCodeceptGlobals(dir, this.config, container)
   }
 
   /**
-   * Initializes global helpers and other CodeceptJS features.
+   * Executes hooks.
    */
-  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;
-  }
+  async runHooks() {
+    // default hooks - dynamic imports for ESM
+    const listenerModules = [
+      './listener/store.js',
+      './listener/steps.js',
+      './listener/config.js',
+      './listener/result.js',
+      './listener/helpers.js',
+      './listener/globalTimeout.js',
+      './listener/globalRetry.js',
+      './listener/retryEnhancer.js',
+      './listener/exit.js',
+      './listener/emptyRun.js',
+    ]
 
-  /**
-   * Runs all hooks, including custom and default.
-   */
-  runHooks() {
-    const listeners = [
-      listener,
-      listenerArtifacts,
-      listenerConfig,
-      listenerHelpers,
-      listenerRetry,
-      listenerTimeout,
-      listenerExit,
-    ];
-
-    listeners.forEach(runHook);
-
-    // Run custom hooks
-    this.config.hooks.forEach(runHook);
+    for (const modulePath of listenerModules) {
+      const module = await import(modulePath)
+      runHook(module.default || module)
+    }
+
+    // custom hooks (previous iteration of plugins)
+    this.config.hooks.forEach(hook => runHook(hook))
   }
 
   /**
-   * Executes the bootstrap process.
+   * Executes bootstrap.
+   *
+   * @returns {Promise<void>}
    */
   async bootstrap() {
-    return runHook(this.config.bootstrap, 'bootstrap');
+    return runHook(this.config.bootstrap, 'bootstrap')
   }
 
   /**
-   * Executes the teardown process.
+   * Executes teardown.
+   *
+   * @returns {Promise<void>}
    */
   async teardown() {
-    return runHook(this.config.teardown, '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 };
+    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);
+    let patterns = [pattern]
+    if (!pattern) {
+      patterns = []
 
-          if (!this.testFiles.includes(resolvedFile)) {
-            this.testFiles.push(resolvedFile);
-          }
+      // 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)
         }
-      });
-    });
+      }
+
+      if (this.config.gherkin && 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)
+        }
+      }
+    }
+
+    for (pattern of patterns) {
+      if (pattern) {
+        globSync(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 (this.opts.shuffle) {
+      this.testFiles = shuffle(this.testFiles)
+    }
+
+    if (this.opts.shard) {
+      this.testFiles = this._applySharding(this.testFiles, this.opts.shard)
+    }
   }
 
   /**
-   * Gets test patterns based on config and options.
-   * @param {string} [pattern] - Test pattern to match.
-   * @returns {string[]} - Array of test patterns.
+   * Apply sharding to test files based on shard configuration
+   *
+   * @param {Array<string>} testFiles - Array of test file paths
+   * @param {string} shardConfig - Shard configuration in format "index/total" (e.g., "1/4")
+   * @returns {Array<string>} - Filtered array of test files for this shard
    */
-  getTestPatterns(pattern) {
-    if (pattern) return [pattern];
+  _applySharding(testFiles, shardConfig) {
+    const shardMatch = shardConfig.match(/^(\d+)\/(\d+)$/)
+    if (!shardMatch) {
+      throw new Error('Invalid shard format. Expected format: "index/total" (e.g., "1/4")')
+    }
+
+    const shardIndex = parseInt(shardMatch[1], 10)
+    const shardTotal = parseInt(shardMatch[2], 10)
 
-    const patterns = [];
-    const { tests, gherkin } = this.config;
+    if (shardTotal < 1) {
+      throw new Error('Shard total must be at least 1')
+    }
 
-    if (tests && !this.opts.features) {
-      patterns.push(...(Array.isArray(tests) ? tests : [tests]));
+    if (shardIndex < 1 || shardIndex > shardTotal) {
+      throw new Error(`Shard index ${shardIndex} must be between 1 and ${shardTotal}`)
     }
 
-    if (gherkin?.features && !this.opts.tests) {
-      patterns.push(...(Array.isArray(gherkin.features) ? gherkin.features : [gherkin.features]));
+    if (testFiles.length === 0) {
+      return testFiles
     }
 
-    return patterns;
+    // Calculate which tests belong to this shard
+    const shardSize = Math.ceil(testFiles.length / shardTotal)
+    const startIndex = (shardIndex - 1) * shardSize
+    const endIndex = Math.min(startIndex + shardSize, testFiles.length)
+
+    return testFiles.slice(startIndex, endIndex)
   }
 
   /**
-   * 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;
+    await container.started()
 
-    if (test) {
-      const testPath = isAbsolute(test) ? test : join(global.codecept_dir, test);
-      mocha.files = mocha.files.filter((t) => resolve(t) === resolve(testPath));
+    // Check TypeScript loader configuration before running tests
+    const tsValidation = validateTypeScriptSetup(this.testFiles, this.requiringModules || [])
+    if (tsValidation.hasError) {
+      output.error(tsValidation.message)
+      process.exit(1)
+    }
+
+    // Ensure translations are loaded for Gherkin features
+    try {
+      const { loadTranslations } = await import('./mocha/gherkin.js')
+      await loadTranslations()
+    } catch (e) {
+      // Ignore if gherkin module not available
     }
 
     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)
+        }
+        const testBasename = fsPath.basename(test, '.js')
+        const testFeatureBasename = fsPath.basename(test, '.feature')
+        mocha.files = mocha.files.filter(t => {
+          return fsPath.basename(t, '.js') === testBasename || fsPath.basename(t, '.feature') === testFeatureBasename || t === test
+        })
+      }
+
+      const done = async (failures) => {
+        event.emit(event.all.result, container.result())
+        event.emit(event.all.after, this)
+        // Wait for any recorder tasks added by event.all.after handlers
+        await recorder.promise()
+        // Set exit code based on test failures
+        if (failures) {
+          process.exitCode = 1
+        }
+        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);
+        event.emit(event.all.before, this)
+        mocha.run(async (failures) => await done(failures))
+      } 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;
+  /**
+   * Returns the version string of CodeceptJS.
+   *
+   * @returns {string} The version string.
+   */
+  static version() {
+    return JSON.parse(readFileSync(`${__dirname}/../package.json`, 'utf8')).version
+  }
 }
+
+export default Codecept

package/lib/colorUtils.js

@@ -144,14 +144,14 @@ function convertColorNameToHex(color) {
     whitesmoke: '#f5f5f5',
     yellow: '#ffff00',
     yellowgreen: '#9acd32',
-  };
+  }
 
-  const cColor = `${color}`.toLowerCase();
+  const cColor = `${color}`.toLowerCase()
   if (typeof colors[cColor] !== 'undefined') {
-    return colors[cColor];
+    return colors[cColor]
   }
 
-  return color;
+  return color
 }
 
 /**
@@ -160,23 +160,23 @@ function convertColorNameToHex(color) {
  */
 function convertHexColorToRgba(hex) {
   // Expand shorthand form (e.g. "#03F") to full form (e.g. "#0033FF")
-  const shorthandRegex = /^#([a-f\d])([a-f\d])([a-f\d])$/i;
+  const shorthandRegex = /^#([a-f\d])([a-f\d])([a-f\d])$/i
   const hexFull = `${hex}`.replace(shorthandRegex, (m, r, g, b) => {
-    return r + r + g + g + b + b;
-  });
+    return r + r + g + g + b + b
+  })
 
-  const result = /^#([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hexFull);
+  const result = /^#([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hexFull)
   if (!result) {
     // Return untouched if not a hex code
-    return hex;
+    return hex
   }
 
-  const r = parseInt(result[1], 16);
-  const g = parseInt(result[2], 16);
-  const b = parseInt(result[3], 16);
-  const a = 1;
+  const r = parseInt(result[1], 16)
+  const g = parseInt(result[2], 16)
+  const b = parseInt(result[3], 16)
+  const a = 1
 
-  return `rgba(${r}, ${g}, ${b}, ${a})`;
+  return `rgba(${r}, ${g}, ${b}, ${a})`
 }
 
 /**
@@ -189,30 +189,30 @@ function convertHexColorToRgba(hex) {
  *
  * @param {string} color Color as a string, i.e. rgb(85,0,0)
  */
-export function convertColorToRGBA(color) {
-  const cstr = `${color}`.toLowerCase().trim() || '';
+function convertColorToRGBA(color) {
+  const cstr = `${color}`.toLowerCase().trim() || ''
 
   if (!/^rgba?\(.+?\)$/.test(cstr)) {
     // Convert both color names and hex colors to rgba
-    const hexColor = convertColorNameToHex(color);
-    return convertHexColorToRgba(hexColor);
+    const hexColor = convertColorNameToHex(color)
+    return convertHexColorToRgba(hexColor)
   }
 
   // Convert rgb to rgba
-  const channels = cstr.match(/([\-0-9.]+)/g) || [];
+  const channels = cstr.match(/([\-0-9.]+)/g) || []
 
   switch (channels.length) {
     case 3:
       // Convert rgb to rgba
-      return `rgba(${channels.join(', ')}, 1)`;
+      return `rgba(${channels.join(', ')}, 1)`
 
     case 4:
       // Format rgba
-      return `rgba(${channels.join(', ')})`;
+      return `rgba(${channels.join(', ')})`
 
     default:
       // Unexpected color format. Leave it untouched (let the user handle it)
-      return color;
+      return color
   }
 }
 
@@ -221,35 +221,33 @@ export function convertColorToRGBA(color) {
  *
  * @param {string} prop CSS Property name
  */
-export function isColorProperty(prop) {
-  return [
-    'color',
-    'background',
-    'backgroundColor',
-    'background-color',
-    'borderColor',
-    'border-color',
-    'borderBottomColor',
-    'border-bottom-color',
-    'borderLeftColor',
-    'border-left-color',
-    'borderRightColor',
-    'borderTopColor',
-    'caretColor',
-    'columnRuleColor',
-    'outlineColor',
-    'textDecorationColor',
-    'border-right-color',
-    'border-top-color',
-    'caret-color',
-    'column-rule-color',
-    'outline-color',
-    'text-decoration-color',
-  ].indexOf(prop) > -1;
+function isColorProperty(prop) {
+  return (
+    [
+      'color',
+      'background',
+      'backgroundColor',
+      'background-color',
+      'borderColor',
+      'border-color',
+      'borderBottomColor',
+      'border-bottom-color',
+      'borderLeftColor',
+      'border-left-color',
+      'borderRightColor',
+      'borderTopColor',
+      'caretColor',
+      'columnRuleColor',
+      'outlineColor',
+      'textDecorationColor',
+      'border-right-color',
+      'border-top-color',
+      'caret-color',
+      'column-rule-color',
+      'outline-color',
+      'text-decoration-color',
+    ].indexOf(prop) > -1
+  )
 }
 
-export default {
-  isColorProperty,
-  convertColorToRGBA,
-  convertColorNameToHex,
-};
+export { isColorProperty, convertColorToRGBA, convertColorNameToHex }