codeceptjs 4.0.0-beta.2 → 4.0.0-beta.20

package/lib/command/run-rerun.js

@@ -1,39 +1,33 @@
-import {
-  getConfig, getTestRoot, printError, createOutputDir,
-} from './utils.js';
-import Config from '../config.js';
-import Codecept from '../rerun.js';
+import { getConfig, getTestRoot, printError, createOutputDir } from './utils.js'
+import Config from '../config.js'
+import Codecept from '../rerun.js'
 
-export async function runRerun(test, options) {
+export default async function (test, options) {
   // registering options globally to use in config
   // Backward compatibility for --profile
-  process.profile = options.profile;
-  process.env.profile = options.profile;
-  const configFile = options.config;
+  process.profile = options.profile
+  process.env.profile = options.profile
+  const configFile = options.config
 
-  let config = getConfig(configFile);
+  let config = await getConfig(configFile)
   if (options.override) {
-    config = Config.append(JSON.parse(options.override));
+    config = Config.append(JSON.parse(options.override))
   }
-  const testRoot = getTestRoot(configFile);
-  createOutputDir(config, testRoot);
+  const testRoot = getTestRoot(configFile)
+  createOutputDir(config, testRoot)
 
-  function processError(err) {
-    printError(err);
-    process.exit(1);
-  }
-  const codecept = new Codecept(config, options);
+  const codecept = new Codecept(config, options)
 
   try {
-    codecept.init(testRoot);
+    await codecept.init(testRoot)
 
-    await codecept.bootstrap();
-    codecept.loadTests(test);
-    await codecept.run();
+    await codecept.bootstrap()
+    codecept.loadTests(test)
+    await codecept.run()
   } catch (err) {
-    printError(err);
-    process.exitCode = 1;
+    printError(err)
+    process.exitCode = 1
   } finally {
-    await codecept.teardown();
+    await codecept.teardown()
   }
 }

package/lib/command/run-workers.js

@@ -1,117 +1,93 @@
 // For Node version >=10.5.0, have to use experimental flag
-import { tryOrDefault } from '../utils.js';
-import { store } from '../store.js';
-import * as output from '../output.js';
-import * as event from '../event.js';
-import { Workers } from '../workers.js';
-import { getMachineInfo } from './info.js';
-import * as Codecept from '../codecept.js';
+import { tryOrDefault } from '../utils.js'
+import output from '../output.js'
+import store from '../store.js'
+import event from '../event.js'
+import Workers from '../workers.js'
+import Codecept from '../codecept.js'
+import { getMachineInfo } from './info.js'
 
 export default async function (workerCount, selectedRuns, options) {
-  process.env.profile = options.profile;
-
-  const suiteArr = [];
-  const passedTestArr = [];
-  const failedTestArr = [];
-  const skippedTestArr = [];
-  const stepArr = [];
+  process.env.profile = options.profile
+
+  const { config: testConfig, override = '' } = options
+  const overrideConfigs = tryOrDefault(() => JSON.parse(override), {})
+
+  // Determine test split strategy
+  let by = 'test' // default
+  if (options.by) {
+    // Explicit --by option takes precedence
+    by = options.by
+  } else if (options.suites) {
+    // Legacy --suites option
+    by = 'suite'
+  }
 
-  const { config: testConfig, override = '' } = options;
-  const overrideConfigs = tryOrDefault(() => JSON.parse(override), {});
-  const by = options.suites ? 'suite' : 'test';
-  delete options.parent;
+  // Validate the by option
+  const validStrategies = ['test', 'suite', 'pool']
+  if (!validStrategies.includes(by)) {
+    throw new Error(`Invalid --by strategy: ${by}. Valid options are: ${validStrategies.join(', ')}`)
+  }
+  delete options.parent
   const config = {
     by,
     testConfig,
     options,
     selectedRuns,
-  };
-
-  const numberOfWorkers = parseInt(workerCount, 10);
-
-  const version = Codecept.version();
-  output.print(`CodeceptJS v${version} ${output.output.standWithUkraine()}`);
-  output.print(`Running tests in ${output.output.styles.bold(numberOfWorkers)} workers...`);
-  output.print();
-
-  const workers = new Workers(numberOfWorkers, config);
-  workers.overrideConfig(overrideConfigs);
-
-  workers.on(event.suite.before, (suite) => {
-    suiteArr.push(suite);
-  });
-
-  workers.on(event.step.passed, (step) => {
-    stepArr.push(step);
-  });
-
-  workers.on(event.step.failed, (step) => {
-    stepArr.push(step);
-  });
+  }
 
-  workers.on(event.test.failed, (test) => {
-    failedTestArr.push(test);
-    output.output.test.failed(test);
-  });
+  const numberOfWorkers = parseInt(workerCount, 10)
 
-  workers.on(event.test.passed, (test) => {
-    passedTestArr.push(test);
-    output.output.test.passed(test);
-  });
+  output.print(`CodeceptJS v${Codecept.version()} ${output.standWithUkraine()}`)
+  output.print(`Running tests in ${output.styles.bold(numberOfWorkers)} workers...`)
+  output.print()
+  store.hasWorkers = true
 
-  workers.on(event.test.skipped, (test) => {
-    skippedTestArr.push(test);
-    output.output.test.skipped(test);
-  });
+  const workers = new Workers(numberOfWorkers, config)
+  workers.overrideConfig(overrideConfigs)
 
-  workers.on(event.all.result, () => {
-    // expose test stats after all workers finished their execution
-    function addStepsToTest(test, stepArr) {
-      stepArr.test.steps.forEach(step => {
-        if (test.steps.length === 0) {
-          test.steps.push(step);
-        }
-      });
-    }
+  workers.on(event.test.failed, test => {
+    output.test.failed(test)
+  })
 
-    stepArr.forEach(step => {
-      passedTestArr.forEach(test => {
-        if (step.test.title === test.title) {
-          addStepsToTest(test, step);
-        }
-      });
+  workers.on(event.test.passed, test => {
+    output.test.passed(test)
+  })
 
-      failedTestArr.forEach(test => {
-        if (step.test.title === test.title) {
-          addStepsToTest(test, step);
-        }
-      });
-    });
+  workers.on(event.test.skipped, test => {
+    output.test.skipped(test)
+  })
 
-    event.dispatcher.emit(event.workers.result, {
-      suites: suiteArr,
-      tests: {
-        passed: passedTestArr,
-        failed: failedTestArr,
-        skipped: skippedTestArr,
-      },
-    });
-    workers.printResults();
-  });
+  workers.on(event.all.result, result => {
+    workers.printResults()
+  })
 
   try {
-    if (options.verbose || options.debug) store.debugMode = true;
+    if (options.verbose || options.debug) store.debugMode = true
 
     if (options.verbose) {
-      global.debugMode = true;
-      await getMachineInfo();
+      await getMachineInfo()
     }
-    await workers.bootstrapAll();
-    await workers.run();
+    await workers.bootstrapAll()
+    await workers.run()
   } catch (err) {
-    output.output.error(err);
-    process.exit(1);
+    output.error(err)
+    process.exitCode = 1
   } finally {
-    await workers.teardownAll();
+    await workers.teardownAll()
+    
+    // Force exit if event loop doesn't clear naturally
+    // This is needed because worker threads may leave handles open
+    // even after proper cleanup, preventing natural process termination
+    if (!options.noExit) {
+      // Use beforeExit to ensure we run after all other exit handlers
+      // have set the correct exit code
+      process.once('beforeExit', (code) => {
+        // Give cleanup a moment to complete, then force exit with the correct code
+        setTimeout(() => {
+          process.exit(code || process.exitCode || 0)
+        }, 100)
+      })
+    }
   }
 }

package/lib/command/run.js

@@ -1,49 +1,61 @@
-import importSync from 'import-sync';
-import {
-  getConfig, printError, getTestRoot, createOutputDir,
-} from './utils.js';
-import Config from '../config.js';
-import Codecept from '../codecept.js';
-import { store } from '../store.js';
+import { getConfig, printError, getTestRoot, createOutputDir } from './utils.js'
+import Config from '../config.js'
+import store from '../store.js'
+import Codecept from '../codecept.js'
+import container from '../container.js'
 
 export default async function (test, options) {
   // registering options globally to use in config
   // Backward compatibility for --profile
   // TODO: remove in CodeceptJS 4
-  process.profile = options.profile;
+  process.profile = options.profile
 
   if (options.profile) {
-    process.env.profile = options.profile;
+    process.env.profile = options.profile
   }
-  if (options.verbose || options.debug) store.debugMode = true;
+  if (options.verbose || options.debug) store.debugMode = true
 
-  const configFile = options.config;
-
-  let config = getConfig(configFile);
+  const configFile = options.config
 
+  let config = await getConfig(configFile)
   if (options.override) {
-    config = Config.append(JSON.parse(options.override));
+    config = Config.append(JSON.parse(options.override))
   }
-  const testRoot = getTestRoot(configFile);
-  createOutputDir(config, testRoot);
+  const testRoot = getTestRoot(configFile)
+  createOutputDir(config, testRoot)
+
+  const codecept = new Codecept(config, options)
 
-  const codecept = new Codecept(config, options);
   try {
-    codecept.init(testRoot);
-    await codecept.bootstrap();
-    codecept.loadTests(test);
+    await codecept.init(testRoot)
+    await codecept.bootstrap()
+    codecept.loadTests(test)
 
     if (options.verbose) {
-      global.debugMode = true;
-      const { getMachineInfo } = importSync('./info.js');
-      await getMachineInfo();
+      global.debugMode = true
+      const { getMachineInfo } = await import('./info.js')
+      await getMachineInfo()
     }
 
-    await codecept.run();
+    await codecept.run()
   } catch (err) {
-    printError(err);
-    process.exitCode = 1;
+    printError(err)
+    process.exitCode = 1
   } finally {
-    await codecept.teardown();
+    await codecept.teardown()
+
+    // Schedule a delayed exit to prevent process hanging due to browser helper event loops
+    // Only needed for Playwright/Puppeteer which keep the event loop alive
+    // Wait 1 second to allow final cleanup and output to complete
+    if (!process.env.CODECEPT_DISABLE_AUTO_EXIT) {
+      const helpers = container.helpers()
+      const hasBrowserHelper = helpers && (helpers.Playwright || helpers.Puppeteer || helpers.WebDriver)
+      
+      if (hasBrowserHelper) {
+        setTimeout(() => {
+          process.exit(process.exitCode || 0)
+        }, 1000).unref()
+      }
+    }
   }
 }

package/lib/command/utils.js

@@ -1,103 +1,119 @@
-import fs from 'fs';
-import path from 'path';
-import util from 'util';
-import mkdirp from 'mkdirp';
-import * as output from '../output.js';
-import { fileExists, beautify } from '../utils.js';
-import * as config from '../config.js';
-
-export const getConfig = function (configFile) {
+import fs from 'fs'
+import path from 'path'
+import util from 'util'
+import { mkdirp } from 'mkdirp'
+
+import output from '../output.js'
+import { fileExists, beautify, deepMerge } from '../utils.js'
+
+// alias to deep merge
+export { deepMerge }
+
+export async function getConfig(configFile) {
   try {
-    return config.default.load(configFile);
+    const configModule = await import('../config.js')
+    const config = configModule.default || configModule
+    return await config.load(configFile)
   } catch (err) {
-    fail(err.stack);
+    fail(err.stack)
   }
-};
+}
 
-export const readConfig = function (configFile) {
+export function readConfig(configFile) {
   try {
-    const data = fs.readFileSync(configFile, 'utf8');
-    return data;
+    const data = fs.readFileSync(configFile, 'utf8')
+    return data
   } catch (err) {
-    output.output.error(err);
+    output.error(err)
   }
-};
+}
 
 function getTestRoot(currentPath) {
-  if (!currentPath) currentPath = '.';
-  if (!path.isAbsolute(currentPath)) currentPath = path.join(process.cwd(), currentPath);
-  currentPath = fs.lstatSync(currentPath).isDirectory() || !path.extname(currentPath) ? currentPath : path.dirname(currentPath);
-  return currentPath;
+  if (!currentPath) currentPath = '.'
+  if (!path.isAbsolute(currentPath)) currentPath = path.join(process.cwd(), currentPath)
+  currentPath = fs.lstatSync(currentPath).isDirectory() || !path.extname(currentPath) ? currentPath : path.dirname(currentPath)
+  return currentPath
 }
-export { getTestRoot };
+export { getTestRoot }
 
 function fail(msg) {
-  output.output.error(msg);
-  process.exit(1);
+  output.error(msg)
+  process.exit(1)
 }
 
-export { fail };
+export { fail }
 
-function updateConfig(testsPath, config, key, extension = 'js') {
-  const configFile = path.join(testsPath, `codecept.conf.${extension}`);
+function updateConfig(testsPath, config, extension) {
+  const configFile = path.join(testsPath, `codecept.conf.${extension}`)
   if (!fileExists(configFile)) {
-    console.log();
-    const msg = `codecept.conf.${extension} config can\'t be updated automatically`;
-    console.log(`${output.output.colors.bold.red(msg)}`);
-    console.log('Please update it manually:');
-    console.log();
-    console.log(`${key}: ${config[key]}`);
-    console.log();
-    return;
+    const msg = `codecept.conf.${extension} config can\'t be updated automatically`
+    console.log()
+    console.log(`${output.colors.bold.red(msg)}`)
+    console.log(`${output.colors.bold.red('Please update it manually:')}`)
+    console.log()
+    console.log(config)
+    console.log()
+    return
   }
-  console.log(`${output.output.colors.yellow('Updating configuration file...')}`);
-  return fs.writeFileSync(configFile, beautify(`exports.config = ${util.inspect(config, false, 4, false)}`), 'utf-8');
+  console.log(`${output.colors.yellow('Updating configuration file...')}`)
+  return fs.writeFileSync(configFile, beautify(`exports.config = ${util.inspect(config, false, 4, false)}`), 'utf-8')
 }
 
-export { updateConfig };
+export { updateConfig }
 
 function safeFileWrite(file, contents) {
   if (fileExists(file)) {
-    output.output.error(`File ${file} already exist, skipping...`);
-    return false;
+    output.error(`File ${file} already exist, skipping...`)
+    return false
   }
-  fs.writeFileSync(file, contents);
-  return true;
+  fs.writeFileSync(file, contents)
+  return true
 }
 
-export { safeFileWrite };
+export { safeFileWrite }
 
-export const captureStream = (stream) => {
-  let oldStream;
-  let buffer = '';
+export const captureStream = stream => {
+  let oldStream
+  let buffer = ''
 
   return {
     startCapture() {
-      buffer = '';
-      oldStream = stream.write.bind(stream);
-      stream.write = chunk => (buffer += chunk);
+      buffer = ''
+      oldStream = stream.write.bind(stream)
+      stream.write = chunk => (buffer += chunk)
     },
     stopCapture() {
-      if (oldStream !== undefined) stream.write = oldStream;
+      if (oldStream !== undefined) stream.write = oldStream
     },
     getData: () => buffer,
-  };
-};
+  }
+}
 
-export const printError = (err) => {
-  output.print('');
-  output.output.error(err.message);
-  output.print('');
-  output.print(output.output.colors.grey(err.stack.replace(err.message, '')));
-};
+export const printError = err => {
+  output.print('')
+  output.error(err.message)
+  output.print('')
+  output.print(output.colors.grey(err.stack.replace(err.message, '')))
+}
 
 export const createOutputDir = (config, testRoot) => {
-  let outputDir;
-  if (path.isAbsolute(config.output)) outputDir = config.output;
-  else outputDir = path.join(testRoot, config.output);
+  let outputDir
+  if (path.isAbsolute(config.output)) outputDir = config.output
+  else outputDir = path.join(testRoot, config.output)
 
   if (!fileExists(outputDir)) {
-    output.print(`creating output directory: ${outputDir}`);
-    mkdirp.sync(outputDir);
+    output.print(`creating output directory: ${outputDir}`)
+    mkdirp.sync(outputDir)
+  }
+}
+
+export const findConfigFile = testsPath => {
+  const extensions = ['js', 'ts']
+  for (const ext of extensions) {
+    const configFile = path.join(testsPath, `codecept.conf.${ext}`)
+    if (fileExists(configFile)) {
+      return configFile
+    }
   }
-};
+  return null
+}