codeceptjs 4.0.0-beta.1 → 4.0.0-beta.10.esm-aria

package/lib/rerun.js

@@ -1,80 +1,125 @@
-import fsPath from 'path';
-import container from './container.js';
-import * as event from './event.js';
-import BaseCodecept from './codecept.js';
-import * as output from './output.js';
+import fsPath from 'path'
+import container from './container.js'
+import event from './event.js'
+import BaseCodecept from './codecept.js'
+import output from './output.js'
+import { createRequire } from 'module'
+
+const require = createRequire(import.meta.url)
 
 class CodeceptRerunner extends BaseCodecept {
-  runOnce(test) {
-    return new Promise((resolve, reject) => {
-      // @ts-ignore
-      container.createMocha();
-      const mocha = container.mocha();
-      this.testFiles.forEach((file) => {
-        // delete require.cache[file];
-      });
-      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);
-      }
+  async runOnce(test) {
+    await container.started()
+
+    // 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(async (resolve, reject) => {
       try {
-        mocha.run((failures) => {
-          if (failures === 0) {
-            resolve();
+        // Create a fresh Mocha instance for each run
+        // @ts-ignore
+        container.createMocha()
+        const mocha = container.mocha()
+
+        let filesToRun = this.testFiles
+        if (test) {
+          if (!fsPath.isAbsolute(test)) {
+            test = fsPath.join(global.codecept_dir, test)
+          }
+          filesToRun = this.testFiles.filter(t => fsPath.basename(t, '.js') === test || t === test)
+        }
+
+        // Clear any existing tests/suites
+        mocha.suite.suites = []
+        mocha.suite.tests = []
+
+        // Manually load each test file by importing it
+        for (const file of filesToRun) {
+          try {
+            // Clear CommonJS cache if available (for mixed environments)
+            try {
+              delete require.cache[file]
+            } catch (e) {
+              // ESM modules don't have require.cache, ignore
+            }
+
+            // Force reload the module by using a cache-busting query parameter
+            const fileUrl = `${fsPath.resolve(file)}?t=${Date.now()}`
+            await import(fileUrl)
+          } catch (e) {
+            console.error(`Error loading test file ${file}:`, e)
+          }
+        }
+
+        const done = () => {
+          event.emit(event.all.result, container.result())
+          event.emit(event.all.after, this)
+
+          // Check if there were any failures
+          if (container.result().hasFailed) {
+            reject(new Error('Test run failed'))
           } else {
-            reject(new Error(`${failures} tests fail`));
+            resolve(undefined)
           }
-        });
+        }
+
+        event.emit(event.all.before, this)
+        mocha.run(() => done())
       } catch (e) {
-        reject(e);
+        output.error(e.stack)
+        reject(e)
       }
-    });
+    })
   }
 
   async runTests(test) {
-    const configRerun = this.config.rerun || {};
-    const minSuccess = configRerun.minSuccess || 1;
-    const maxReruns = configRerun.maxReruns || 1;
+    const configRerun = this.config.rerun || {}
+    const minSuccess = configRerun.minSuccess || 1
+    const maxReruns = configRerun.maxReruns || 1
     if (minSuccess > maxReruns) {
-      process.exitCode = 1;
-      throw new Error(`run-rerun Configuration Error: minSuccess must be less than maxReruns. Current values: minSuccess=${minSuccess} maxReruns=${maxReruns}`);
+      process.exitCode = 1
+      throw new Error(`run-rerun Configuration Error: minSuccess must be less than maxReruns. Current values: minSuccess=${minSuccess} maxReruns=${maxReruns}`)
     }
     if (maxReruns === 1) {
-      await this.runOnce(test);
-      return;
+      await this.runOnce(test)
+      return
     }
-    let successCounter = 0;
-    let rerunsCounter = 0;
+    let successCounter = 0
+    let rerunsCounter = 0
     while (rerunsCounter < maxReruns && successCounter < minSuccess) {
-      rerunsCounter++;
+      container.result().reset() // reset result
+      rerunsCounter++
       try {
-        await this.runOnce(test);
-        successCounter++;
-        output.output.success(`\nProcess run ${rerunsCounter} of max ${maxReruns}, success runs ${successCounter}/${minSuccess}\n`);
+        await this.runOnce(test)
+        successCounter++
+        output.success(`\nProcess run ${rerunsCounter} of max ${maxReruns}, success runs ${successCounter}/${minSuccess}\n`)
       } catch (e) {
-        output.output.error(`\nFail run ${rerunsCounter} of max ${maxReruns}, success runs ${successCounter}/${minSuccess} \n`);
-        console.error(e);
+        output.error(`\nFail run ${rerunsCounter} of max ${maxReruns}, success runs ${successCounter}/${minSuccess} \n`)
+        console.error(e)
       }
     }
     if (successCounter < minSuccess) {
-      throw new Error(`Flaky tests detected! ${successCounter} success runs achieved instead of ${minSuccess} success runs expected`);
+      throw new Error(`Flaky tests detected! ${successCounter} success runs achieved instead of ${minSuccess} success runs expected`)
     }
   }
 
   async run(test) {
-    event.emit(event.all.before, this);
+    event.emit(event.all.before, this)
     try {
-      await this.runTests(test);
+      await this.runTests(test)
     } catch (e) {
-      output.output.error(e.stack);
+      output.error(e.stack)
+      throw e
     } finally {
-      event.emit(event.all.result, this);
-      event.emit(event.all.after, this);
+      event.emit(event.all.result, this)
+      event.emit(event.all.after, this)
     }
   }
 }
 
-export default CodeceptRerunner;
+export default CodeceptRerunner

package/lib/result.js

@@ -0,0 +1,238 @@
+import fs from 'fs'
+import path from 'path'
+import { serializeTest } from './mocha/test.js'
+
+/**
+ * @typedef {Object} Stats Statistics for a test result.
+ * @property {number} passes Number of passed tests.
+ * @property {number} failures Number of failed tests.
+ * @property {number} tests Total number of tests.
+ * @property {number} pending Number of pending tests.
+ * @property {number} failedHooks Number of failed hooks.
+ * @property {Date} start Start time of the test run.
+ * @property {Date} end End time of the test run.
+ * @property {number} duration Duration of the test run, in milliseconds.
+ */
+
+/**
+ * Result of a test run. Will be emitted for example in "event.all.result" events.
+ */
+class Result {
+  constructor() {
+    this._startTime = new Date()
+    this._endTime = null
+
+    this.reset()
+    this.start()
+  }
+
+  /**
+   * Resets all collected stats, tests, and failure reports.
+   */
+  reset() {
+    this._stats = {
+      passes: 0,
+      failures: 0,
+      tests: 0,
+      pending: 0,
+      failedHooks: 0,
+      start: null,
+      end: null,
+      duration: 0,
+    }
+
+    /**
+     * @type {CodeceptJS.Test[]}
+     * @private
+     */
+    this._tests = []
+
+    /**
+     * @type {string[][]}
+     * @private
+     */
+    this._failures = []
+  }
+
+  /**
+   * Sets the start time to the current time.
+   */
+  start() {
+    this._startTime = new Date()
+  }
+
+  /**
+   * Sets the end time to the current time.
+   */
+  finish() {
+    this._endTime = new Date()
+  }
+
+  /**
+   * Whether this result contains any failed tests.
+   *
+   * @type {boolean}
+   * @readonly
+   */
+  get hasFailed() {
+    return this._stats.failures > 0
+  }
+
+  /**
+   * All collected tests.
+   *
+   * @type {CodeceptJS.Test[]}
+   * @readonly
+   */
+  get tests() {
+    return this._tests
+  }
+
+  /**
+   * The failure reports (array of strings per failed test).
+   *
+   * @type {string[][]}
+   * @readonly
+   */
+  get failures() {
+    return this._failures.filter(f => f && (!Array.isArray(f) || f.length > 0))
+  }
+
+  /**
+   * The test statistics.
+   *
+   * @type {Stats}
+   * @readonly
+   */
+  get stats() {
+    return this._stats
+  }
+
+  /**
+   * The start time of the test run.
+   *
+   * @type {Date}
+   * @readonly
+   */
+  get startTime() {
+    return this._startTime
+  }
+
+  /**
+   * Adds a test to this result.
+   *
+   * @param {CodeceptJS.Test} test
+   */
+  addTest(test) {
+    const existingTestIndex = this._tests.findIndex(t => !!t.uid && t.uid === test.uid)
+    if (existingTestIndex >= 0) {
+      this._tests[existingTestIndex] = test
+      return
+    }
+
+    this._tests.push(test)
+  }
+
+  /**
+   * Adds failure reports to this result.
+   *
+   * @param {string[][]} newFailures
+   */
+  addFailures(newFailures) {
+    this._failures.push(...newFailures)
+  }
+
+  /**
+   * Whether this result contains any failed tests.
+   *
+   * @type {boolean}
+   * @readonly
+   */
+  get hasFailures() {
+    return this.stats.failures > 0
+  }
+
+  /**
+   * The duration of the test run, in milliseconds.
+   *
+   * @type {number}
+   * @readonly
+   */
+  get duration() {
+    return this._endTime ? +this._endTime - +this._startTime : 0
+  }
+
+  /**
+   * All failed tests.
+   *
+   * @type {CodeceptJS.Test[]}
+   * readonly
+   */
+  get failedTests() {
+    return this._tests.filter(test => test.state === 'failed')
+  }
+
+  /**
+   * All passed tests.
+   *
+   * @type {CodeceptJS.Test[]}
+   * @readonly
+   */
+  get passedTests() {
+    return this._tests.filter(test => test.state === 'passed')
+  }
+
+  /**
+   * All skipped tests.
+   *
+   * @type {CodeceptJS.Test[]}
+   * @readonly
+   */
+  get skippedTests() {
+    return this._tests.filter(test => test.state === 'skipped' || test.state === 'pending')
+  }
+
+  /**
+   * @returns {object} The JSON representation of this result.
+   */
+  simplify() {
+    return {
+      hasFailed: this.hasFailed,
+      stats: this.stats,
+      duration: this.duration,
+      tests: this._tests.map(test => serializeTest(test)),
+      failures: this._failures,
+    }
+  }
+
+  /**
+   * Saves this result to a JSON file.
+   *
+   * @param {string} [fileName] Path to the JSON file, relative to `output_dir`. Defaults to "result.json".
+   */
+  save(fileName) {
+    if (!fileName) fileName = 'result.json'
+    fs.writeFileSync(path.join(global.output_dir, fileName), JSON.stringify(this.simplify(), null, 2))
+  }
+
+  /**
+   * Adds stats to this result.
+   *
+   * @param {Partial<Stats>} [newStats]
+   */
+  addStats(newStats = {}) {
+    this._stats.passes += newStats.passes || 0
+    this._stats.failures += newStats.failures || 0
+    this._stats.tests += newStats.tests || 0
+    this._stats.pending += newStats.pending || 0
+    this._stats.failedHooks += newStats.failedHooks || 0
+
+    // do not override start time
+    this._stats.start = this._stats.start || newStats.start
+
+    this._stats.end = newStats.end || this._stats.end
+    this._stats.duration = newStats.duration
+  }
+}
+
+export default Result

package/lib/retryCoordinator.js

@@ -0,0 +1,207 @@
+import output from './output.js'
+
+/**
+ * Retry Coordinator - Central coordination for all retry mechanisms
+ *
+ * This module provides:
+ * 1. Priority-based retry coordination
+ * 2. Unified configuration validation
+ * 3. Consolidated retry reporting
+ * 4. Conflict detection and resolution
+ */
+
+/**
+ * Priority levels for retry mechanisms (higher number = higher priority)
+ */
+const RETRY_PRIORITIES = {
+  MANUAL_STEP: 100, // I.retry() or step.retry() - highest priority
+  STEP_PLUGIN: 50, // retryFailedStep plugin
+  SCENARIO_CONFIG: 30, // Global scenario retry config
+  FEATURE_CONFIG: 20, // Global feature retry config
+  HOOK_CONFIG: 10, // Hook retry config - lowest priority
+}
+
+/**
+ * Retry mechanism types
+ */
+const RETRY_TYPES = {
+  MANUAL_STEP: 'manual-step',
+  STEP_PLUGIN: 'step-plugin',
+  SCENARIO: 'scenario',
+  FEATURE: 'feature',
+  HOOK: 'hook',
+}
+
+/**
+ * Global retry coordination state
+ */
+let retryState = {
+  activeTest: null,
+  activeSuite: null,
+  retryHistory: [],
+  conflicts: [],
+}
+
+/**
+ * Registers a retry mechanism for coordination
+ * @param {string} type - Type of retry mechanism
+ * @param {Object} config - Retry configuration
+ * @param {Object} target - Target object (test, suite, etc.)
+ * @param {number} priority - Priority level
+ */
+function registerRetry(type, config, target, priority = 0) {
+  const retryInfo = {
+    type,
+    config,
+    target,
+    priority,
+    timestamp: Date.now(),
+  }
+
+  // Detect conflicts
+  const existingRetries = retryState.retryHistory.filter(r => r.target === target && r.type !== type && r.priority !== priority)
+
+  if (existingRetries.length > 0) {
+    const conflict = {
+      newRetry: retryInfo,
+      existingRetries: existingRetries,
+      resolved: false,
+    }
+    retryState.conflicts.push(conflict)
+    handleRetryConflict(conflict)
+  }
+
+  retryState.retryHistory.push(retryInfo)
+
+  output.log(`[Retry Coordinator] Registered ${type} retry (priority: ${priority})`)
+}
+
+/**
+ * Handles conflicts between retry mechanisms
+ * @param {Object} conflict - Conflict information
+ */
+function handleRetryConflict(conflict) {
+  const { newRetry, existingRetries } = conflict
+
+  // Find highest priority retry
+  const allRetries = [newRetry, ...existingRetries]
+  const highestPriority = Math.max(...allRetries.map(r => r.priority))
+  const winningRetry = allRetries.find(r => r.priority === highestPriority)
+
+  // Log the conflict resolution
+  output.log(`[Retry Coordinator] Conflict detected:`)
+  allRetries.forEach(retry => {
+    const status = retry === winningRetry ? 'ACTIVE' : 'DEFERRED'
+    output.log(`  - ${retry.type} (priority: ${retry.priority}) [${status}]`)
+  })
+
+  conflict.resolved = true
+  conflict.winner = winningRetry
+}
+
+/**
+ * Gets the effective retry configuration for a target
+ * @param {Object} target - Target object (test, suite, etc.)
+ * @returns {Object} Effective retry configuration
+ */
+function getEffectiveRetryConfig(target) {
+  const targetRetries = retryState.retryHistory.filter(r => r.target === target)
+
+  if (targetRetries.length === 0) {
+    return { type: 'none', retries: 0 }
+  }
+
+  // Find highest priority retry
+  const highestPriority = Math.max(...targetRetries.map(r => r.priority))
+  const effectiveRetry = targetRetries.find(r => r.priority === highestPriority)
+
+  return {
+    type: effectiveRetry.type,
+    retries: effectiveRetry.config.retries || effectiveRetry.config,
+    config: effectiveRetry.config,
+  }
+}
+
+/**
+ * Generates a retry summary report
+ * @returns {Object} Retry summary
+ */
+function generateRetrySummary() {
+  const summary = {
+    totalRetryMechanisms: retryState.retryHistory.length,
+    conflicts: retryState.conflicts.length,
+    byType: {},
+    recommendations: [],
+  }
+
+  // Count by type
+  retryState.retryHistory.forEach(retry => {
+    summary.byType[retry.type] = (summary.byType[retry.type] || 0) + 1
+  })
+
+  // Generate recommendations
+  if (summary.conflicts > 0) {
+    summary.recommendations.push('Consider consolidating retry configurations to avoid conflicts')
+  }
+
+  if (summary.byType[RETRY_TYPES.STEP_PLUGIN] && summary.byType[RETRY_TYPES.SCENARIO]) {
+    summary.recommendations.push('Step-level and scenario-level retries are both active - consider using only one approach')
+  }
+
+  return summary
+}
+
+/**
+ * Resets the retry coordination state (useful for testing)
+ */
+function reset() {
+  retryState = {
+    activeTest: null,
+    activeSuite: null,
+    retryHistory: [],
+    conflicts: [],
+  }
+}
+
+/**
+ * Validates retry configuration for common issues
+ * @param {Object} config - Configuration object
+ * @returns {Array} Array of validation warnings
+ */
+function validateConfig(config) {
+  const warnings = []
+
+  if (!config) return warnings
+
+  // Check for potential configuration conflicts
+  if (config.retry && config.plugins && config.plugins.retryFailedStep) {
+    const globalRetries = typeof config.retry === 'number' ? config.retry : config.retry.Scenario || config.retry.Feature
+    const stepRetries = config.plugins.retryFailedStep.retries || 3
+
+    if (globalRetries && stepRetries) {
+      warnings.push(`Both global retries (${globalRetries}) and step retries (${stepRetries}) are configured - total executions could be ${globalRetries * (stepRetries + 1)}`)
+    }
+  }
+
+  // Check for excessive retry counts
+  if (config.retry) {
+    const retryValues = typeof config.retry === 'number' ? [config.retry] : Object.values(config.retry)
+    const maxRetries = Math.max(...retryValues.filter(v => typeof v === 'number'))
+
+    if (maxRetries > 5) {
+      warnings.push(`High retry count detected (${maxRetries}) - consider investigating test stability instead`)
+    }
+  }
+
+  return warnings
+}
+
+export {
+  RETRY_PRIORITIES,
+  RETRY_TYPES,
+  registerRetry,
+  getEffectiveRetryConfig,
+  generateRetrySummary,
+  validateConfig,
+  reset,
+}

package/lib/secret.js

@@ -1,21 +1,20 @@
-/* eslint-disable max-classes-per-file */
-import { deepClone } from './utils.js';
+import { deepClone } from './utils.js'
 
-const maskedString = '*****';
+const maskedString = '*****'
 
 /** @param {string} secret */
-export default class Secret {
+class Secret {
   constructor(secret) {
-    this._secret = secret;
+    this._secret = secret
   }
 
   /** @returns {string} */
   toString() {
-    return this._secret;
+    return this._secret
   }
 
   getMasked() {
-    return maskedString;
+    return maskedString
   }
 
   /**
@@ -24,11 +23,11 @@ export default class Secret {
    */
   static secret(secret) {
     if (typeof secret === 'object') {
-      const fields = Array.from(arguments);
-      fields.shift();
-      return secretObject(secret, fields);
+      const fields = Array.from(arguments)
+      fields.shift()
+      return secretObject(secret, fields)
     }
-    return new Secret(secret);
+    return new Secret(secret)
   }
 }
 
@@ -37,14 +36,17 @@ function secretObject(obj, fieldsToHide = []) {
     get(obj, prop) {
       if (prop === 'toString') {
         return function () {
-          const maskedObject = deepClone(obj);
-          fieldsToHide.forEach(f => maskedObject[f] = maskedString);
-          return JSON.stringify(maskedObject);
-        };
+          const maskedObject = deepClone(obj)
+          fieldsToHide.forEach(f => (maskedObject[f] = maskedString))
+          return JSON.stringify(maskedObject)
+        }
       }
-      return fieldsToHide.includes(prop) ? new Secret(obj[prop]) : obj[prop];
+      return fieldsToHide.includes(prop) ? new Secret(obj[prop]) : obj[prop]
     },
-  };
+  }
 
-  return new Proxy(obj, handler);
+  return new Proxy(obj, handler)
 }
+
+export default Secret
+export const secret = Secret.secret