codeceptjs 4.0.0-beta.3 → 4.0.0-beta.5

package/lib/assert/include.js

@@ -10,7 +10,7 @@ class InclusionAssertion extends Assertion {
     params.jar = params.jar || 'string'
     const comparator = function (needle, haystack) {
       if (Array.isArray(haystack)) {
-        return haystack.filter((part) => part.indexOf(needle) >= 0).length > 0
+        return haystack.filter(part => part.indexOf(needle) >= 0).length > 0
       }
       return haystack.indexOf(needle) >= 0
     }
@@ -28,9 +28,7 @@ class InclusionAssertion extends Assertion {
       this.params.haystack = this.params.haystack.join('\n___(next element)___\n')
     }
     err.cliMessage = function () {
-      const msg = this.template
-        .replace('{{jar}}', output.colors.bold('{{jar}}'))
-        .replace('{{needle}}', output.colors.bold('{{needle}}'))
+      const msg = this.template.replace('{{jar}}', output.colors.bold('{{jar}}')).replace('{{needle}}', output.colors.bold('{{needle}}'))
       return template(msg, this.params)
     }
     return err
@@ -66,11 +64,11 @@ class InclusionAssertion extends Assertion {
 
 module.exports = {
   Assertion: InclusionAssertion,
-  includes: (needleType) => {
+  includes: needleType => {
     needleType = needleType || 'string'
     return new InclusionAssertion({ jar: needleType })
   },
-  fileIncludes: (file) => new InclusionAssertion({ file, jar: 'file {{file}}' }),
+  fileIncludes: file => new InclusionAssertion({ file, jar: 'file {{file}}' }),
 }
 
 function escapeRegExp(str) {

package/lib/assert/throws.js

@@ -11,10 +11,8 @@ function errorThrown(actual, expected) {
     throw new Error(`Expected error to be thrown with message ${expected} while '${msg}' caught`)
   }
   if (typeof expected === 'object') {
-    if (actual.constructor.name !== expected.constructor.name)
-      throw new Error(`Expected ${expected} error to be thrown but ${actual} was caught`)
-    if (expected.message && expected.message !== msg)
-      throw new Error(`Expected error to be thrown with message ${expected.message} while '${msg}' caught`)
+    if (actual.constructor.name !== expected.constructor.name) throw new Error(`Expected ${expected} error to be thrown but ${actual} was caught`)
+    if (expected.message && expected.message !== msg) throw new Error(`Expected error to be thrown with message ${expected.message} while '${msg}' caught`)
   }
   return null
 }

package/lib/assert/truth.js

@@ -5,9 +5,9 @@ const output = require('../output')
 
 class TruthAssertion extends Assertion {
   constructor(params) {
-    super((value) => {
+    super(value => {
       if (Array.isArray(value)) {
-        return value.filter((val) => !!val).length > 0
+        return value.filter(val => !!val).length > 0
       }
       return !!value
     }, params)

package/lib/codecept.js

@@ -1,14 +1,15 @@
-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');
+const { existsSync, readFileSync } = require('fs')
+const { globSync } = require('glob')
+const shuffle = require('lodash.shuffle')
+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
@@ -22,10 +23,10 @@ class Codecept {
    * @param {*} opts
    */
   constructor(config, opts) {
-    this.config = Config.create(config);
-    this.opts = opts;
-    this.testFiles = new Array(0);
-    this.requireModules(config.require);
+    this.config = Config.create(config)
+    this.opts = opts
+    this.testFiles = new Array(0)
+    this.requireModules(config.require)
   }
 
   /**
@@ -35,13 +36,13 @@ class Codecept {
    */
   requireModules(requiringModules) {
     if (requiringModules) {
-      requiringModules.forEach((requiredModule) => {
-        const isLocalFile = existsSync(requiredModule) || existsSync(`${requiredModule}.js`);
+      requiringModules.forEach(requiredModule => {
+        const isLocalFile = existsSync(requiredModule) || existsSync(`${requiredModule}.js`)
         if (isLocalFile) {
-          requiredModule = resolve(requiredModule);
+          requiredModule = resolve(requiredModule)
         }
-        require(requiredModule);
-      });
+        require(requiredModule)
+      })
     }
   }
 
@@ -52,10 +53,10 @@ class Codecept {
    * @param {string} dir
    */
   init(dir) {
-    this.initGlobals(dir);
+    this.initGlobals(dir)
     // initializing listeners
-    container.create(this.config, this.opts);
-    this.runHooks();
+    container.create(this.config, this.opts)
+    this.runHooks()
   }
 
   /**
@@ -64,34 +65,37 @@ class Codecept {
    * @param {string} dir
    */
   initGlobals(dir) {
-    global.codecept_dir = dir;
-    global.output_dir = fsPath.resolve(dir, this.config.output);
+    global.codecept_dir = dir
+    global.output_dir = fsPath.resolve(dir, this.config.output)
 
-    if (this.config.emptyOutputFolder) emptyFolder(global.output_dir);
+    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
+      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;
+      const stepDefinitions = require('./mocha/bdd')
+      global.Given = stepDefinitions.Given
+      global.When = stepDefinitions.When
+      global.Then = stepDefinitions.Then
+      global.DefineParameterType = stepDefinitions.defineParameterType
 
       // debug mode
-      global.debugMode = false;
+      global.debugMode = false
+
+      // mask sensitive data
+      global.maskSensitiveData = this.config.maskSensitiveData || false
     }
   }
 
@@ -100,16 +104,19 @@ class Codecept {
    */
   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'));
+    runHook(require('./listener/store'))
+    runHook(require('./listener/steps'))
+    runHook(require('./listener/config'))
+    runHook(require('./listener/result'))
+    runHook(require('./listener/helpers'))
+    runHook(require('./listener/globalTimeout'))
+    runHook(require('./listener/globalRetry'))
+    runHook(require('./listener/retryEnhancer'))
+    runHook(require('./listener/exit'))
+    runHook(require('./listener/emptyRun'))
 
     // custom hooks (previous iteration of plugins)
-    this.config.hooks.forEach(hook => runHook(hook));
+    this.config.hooks.forEach(hook => runHook(hook))
   }
 
   /**
@@ -117,7 +124,7 @@ class Codecept {
    *
    */
   async bootstrap() {
-    return runHook(this.config.bootstrap, 'bootstrap');
+    return runHook(this.config.bootstrap, 'bootstrap')
   }
 
   /**
@@ -125,7 +132,7 @@ class Codecept {
 
    */
   async teardown() {
-    return runHook(this.config.teardown, 'teardown');
+    return runHook(this.config.teardown, 'teardown')
   }
 
   /**
@@ -136,45 +143,91 @@ class Codecept {
   loadTests(pattern) {
     const options = {
       cwd: global.codecept_dir,
-    };
+    }
 
-    let patterns = [pattern];
+    let patterns = [pattern]
     if (!pattern) {
-      patterns = [];
+      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);
+          patterns.push(...this.config.tests)
         } else {
-          patterns.push(this.config.tests);
+          patterns.push(this.config.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);
-          });
+            patterns.push(feature)
+          })
         } else {
-          patterns.push(this.config.gherkin.features);
+          patterns.push(this.config.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));
-        }
-      });
+      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)
     }
   }
 
+  /**
+   * 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
+   */
+  _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)
+
+    if (shardTotal < 1) {
+      throw new Error('Shard total must be at least 1')
+    }
+
+    if (shardIndex < 1 || shardIndex > shardTotal) {
+      throw new Error(`Shard index ${shardIndex} must be between 1 and ${shardTotal}`)
+    }
+
+    if (testFiles.length === 0) {
+      return testFiles
+    }
+
+    // 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)
+  }
+
   /**
    * Run a specific test or all loaded tests.
    *
@@ -182,34 +235,36 @@ class Codecept {
    * @returns {Promise<void>}
    */
   async run(test) {
+    await container.started()
+
     return new Promise((resolve, reject) => {
-      const mocha = container.mocha();
-      mocha.files = this.testFiles;
+      const mocha = container.mocha()
+      mocha.files = this.testFiles
       if (test) {
         if (!fsPath.isAbsolute(test)) {
-          test = fsPath.join(global.codecept_dir, test);
+          test = fsPath.join(global.codecept_dir, test)
         }
-        mocha.files = mocha.files.filter(t => fsPath.basename(t, '.js') === test || t === 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();
-      };
+        event.emit(event.all.result, container.result())
+        event.emit(event.all.after, this)
+        resolve()
+      }
 
       try {
-        event.emit(event.all.before, this);
-        mocha.run(() => done());
+        event.emit(event.all.before, this)
+        mocha.run(() => done())
       } catch (e) {
-        output.error(e.stack);
-        reject(e);
+        output.error(e.stack)
+        reject(e)
       }
-    });
+    })
   }
 
   static version() {
-    return JSON.parse(readFileSync(`${__dirname}/../package.json`, 'utf8')).version;
+    return JSON.parse(readFileSync(`${__dirname}/../package.json`, 'utf8')).version
   }
 }
 
-module.exports = Codecept;
+module.exports = Codecept

package/lib/command/check.js

@@ -0,0 +1,201 @@
+const { getConfig, getTestRoot } = require('./utils')
+const Codecept = require('../codecept')
+const output = require('../output')
+const store = require('../store')
+const container = require('../container')
+const figures = require('figures')
+const chalk = require('chalk')
+const { createTest } = require('../mocha/test')
+const { getMachineInfo } = require('./info')
+const definitions = require('./definitions')
+
+module.exports = async function (options) {
+  const configFile = options.config
+
+  setTimeout(() => {
+    output.error("Something went wrong. Checks didn't pass and timed out. Please check your config and helpers.")
+    process.exit(1)
+  }, options.timeout || 50000)
+
+  const checks = {
+    config: false,
+    container: false,
+    pageObjects: false,
+    plugins: false,
+    ai: true, // we don't need to check AI
+    helpers: false,
+    setup: false,
+    teardown: false,
+    tests: false,
+    def: false,
+  }
+
+  const testRoot = getTestRoot(configFile)
+  let config = getConfig(configFile)
+
+  try {
+    config = getConfig(configFile)
+    checks['config'] = true
+  } catch (err) {
+    checks['config'] = err
+  }
+
+  printCheck('config', checks['config'], config.name)
+
+  let codecept
+  try {
+    codecept = new Codecept(config, options)
+    codecept.init(testRoot)
+    await container.started()
+    checks.container = true
+  } catch (err) {
+    checks.container = err
+  }
+
+  const standardActingHelpers = container.STANDARD_ACTING_HELPERS
+
+  printCheck('container', checks['container'])
+
+  if (codecept) {
+    try {
+      if (options.bootstrap) await codecept.bootstrap()
+      checks.bootstrap = true
+    } catch (err) {
+      checks.bootstrap = err
+    }
+    printCheck('bootstrap', checks['bootstrap'], options.bootstrap ? 'Bootstrap was executed' : 'No bootstrap command')
+  }
+
+  let numTests = 0
+  if (codecept) {
+    try {
+      codecept.loadTests()
+      const mocha = container.mocha()
+      mocha.files = codecept.testFiles
+      mocha.loadFiles()
+      mocha.suite.suites.forEach(suite => {
+        numTests += suite.tests.length
+      })
+      if (numTests > 0) {
+        checks.tests = true
+      } else {
+        throw new Error('No tests found')
+      }
+    } catch (err) {
+      checks.tests = err
+    }
+  }
+
+  if (config?.ai?.request) {
+    checks.ai = true
+    printCheck('ai', checks['ai'], 'Configuration is enabled, request function is set')
+  } else {
+    printCheck('ai', checks['ai'], 'Disabled')
+  }
+
+  printCheck('tests', checks['tests'], `Total: ${numTests} tests`)
+
+  store.dryRun = true
+
+  const helpers = container.helpers()
+
+  try {
+    if (!Object.keys(helpers).length) throw new Error('No helpers found')
+    // load helpers
+    for (const helper of Object.values(helpers)) {
+      if (helper._init) helper._init()
+    }
+    checks.helpers = true
+  } catch (err) {
+    checks.helpers = err
+  }
+
+  printCheck('helpers', checks['helpers'], `${Object.keys(helpers).join(', ')}`)
+
+  const pageObjects = container.support()
+
+  try {
+    if (Object.keys(pageObjects).length) {
+      for (const pageObject of Object.values(pageObjects)) {
+        pageObject.name
+      }
+    }
+    checks.pageObjects = true
+  } catch (err) {
+    checks.pageObjects = err
+  }
+  printCheck('page objects', checks['pageObjects'], `Total: ${Object.keys(pageObjects).length} support objects`)
+
+  checks.plugins = true // how to check plugins?
+  printCheck('plugins', checks['plugins'], Object.keys(container.plugins()).join(', '))
+
+  if (Object.keys(helpers).length) {
+    const suite = container.mocha().suite
+    const test = createTest('test', () => {})
+    checks.setup = true
+    for (const helper of Object.values(helpers)) {
+      try {
+        if (helper._beforeSuite) await helper._beforeSuite(suite)
+        if (helper._before) await helper._before(test)
+      } catch (err) {
+        err.message = `${helper.constructor.name} helper: ${err.message}`
+        if (checks.setup instanceof Error) err.message = `${err.message}\n\n${checks.setup?.message || ''}`.trim()
+        checks.setup = err
+      }
+    }
+
+    printCheck('Helpers Before', checks['setup'], standardActingHelpers.some(h => Object.keys(helpers).includes(h)) ? 'Initializing browser' : '')
+
+    checks.teardown = true
+    for (const helper of Object.values(helpers).reverse()) {
+      try {
+        if (helper._passed) await helper._passed(test)
+        if (helper._after) await helper._after(test)
+        if (helper._finishTest) await helper._finishTest(suite)
+        if (helper._afterSuite) await helper._afterSuite(suite)
+      } catch (err) {
+        err.message = `${helper.constructor.name} helper: ${err.message}`
+        if (checks.teardown instanceof Error) err.message = `${err.message}\n\n${checks.teardown?.message || ''}`.trim()
+        checks.teardown = err
+      }
+    }
+
+    printCheck('Helpers After', checks['teardown'], standardActingHelpers.some(h => Object.keys(helpers).includes(h)) ? 'Closing browser' : '')
+  }
+
+  try {
+    definitions(configFile, { dryRun: true })
+    checks.def = true
+  } catch (err) {
+    checks.def = err
+  }
+
+  printCheck('TypeScript Definitions', checks['def'])
+
+  output.print('')
+
+  if (!Object.values(checks).every(check => check === true)) {
+    output.error("Something went wrong. Checks didn't pass.")
+    output.print()
+    await getMachineInfo()
+    process.exit(1)
+  }
+
+  output.print(output.styles.success('All checks passed'.toUpperCase()), 'Ready to run your tests 🚀')
+  process.exit(0)
+}
+
+function printCheck(name, value, comment = '') {
+  let status = ''
+  if (value == true) {
+    status += chalk.bold.green(figures.tick)
+  } else {
+    status += chalk.bold.red(figures.cross)
+  }
+
+  if (value instanceof Error) {
+    comment = `${comment} ${chalk.red(value.message)}`.trim()
+  }
+
+  output.print(status, name.toUpperCase(), chalk.dim(comment))
+}

package/lib/command/configMigrate.js

@@ -14,9 +14,7 @@ module.exports = function (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(`  It will help you switch from ${colors.cyan.bold('.json')} to ${colors.magenta.bold('.js')} config format at ease`)
   print()
 
   if (!path) {
@@ -53,7 +51,7 @@ module.exports = function (initPath) {
         default: true,
       },
     ])
-    .then((result) => {
+    .then(result => {
       if (result.configFile) {
         const jsonConfigFile = path.join(testsPath, 'codecept.js')
         const config = JSON.parse(fs.readFileSync(jsonConfigFile, 'utf8'))