codeceptjs 3.6.6 → 4.0.0-beta.1

package/lib/command/run-workers.js

@@ -1,89 +1,92 @@
 // For Node version >=10.5.0, have to use experimental flag
-const { tryOrDefault } = require('../utils')
-const output = require('../output')
-const store = require('../store')
-const event = require('../event')
-const Workers = require('../workers')
-
-module.exports = async function (workerCount, selectedRuns, options) {
-  process.env.profile = options.profile
-
-  const suiteArr = []
-  const passedTestArr = []
-  const failedTestArr = []
-  const skippedTestArr = []
-  const stepArr = []
-
-  const { config: testConfig, override = '' } = options
-  const overrideConfigs = tryOrDefault(() => JSON.parse(override), {})
-  const by = options.suites ? 'suite' : 'test'
-  delete options.parent
+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';
+
+export default async function (workerCount, selectedRuns, options) {
+  process.env.profile = options.profile;
+
+  const suiteArr = [];
+  const passedTestArr = [];
+  const failedTestArr = [];
+  const skippedTestArr = [];
+  const stepArr = [];
+
+  const { config: testConfig, override = '' } = options;
+  const overrideConfigs = tryOrDefault(() => JSON.parse(override), {});
+  const by = options.suites ? 'suite' : 'test';
+  delete options.parent;
   const config = {
     by,
     testConfig,
     options,
     selectedRuns,
-  }
+  };
 
-  const numberOfWorkers = parseInt(workerCount, 10)
+  const numberOfWorkers = parseInt(workerCount, 10);
 
-  output.print(`CodeceptJS v${require('../codecept').version()} ${output.standWithUkraine()}`)
-  output.print(`Running tests in ${output.styles.bold(numberOfWorkers)} workers...`)
-  output.print()
+  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)
+  const workers = new Workers(numberOfWorkers, config);
+  workers.overrideConfig(overrideConfigs);
 
   workers.on(event.suite.before, (suite) => {
-    suiteArr.push(suite)
-  })
+    suiteArr.push(suite);
+  });
 
   workers.on(event.step.passed, (step) => {
-    stepArr.push(step)
-  })
+    stepArr.push(step);
+  });
 
   workers.on(event.step.failed, (step) => {
-    stepArr.push(step)
-  })
+    stepArr.push(step);
+  });
 
   workers.on(event.test.failed, (test) => {
-    failedTestArr.push(test)
-    output.test.failed(test)
-  })
+    failedTestArr.push(test);
+    output.output.test.failed(test);
+  });
 
   workers.on(event.test.passed, (test) => {
-    passedTestArr.push(test)
-    output.test.passed(test)
-  })
+    passedTestArr.push(test);
+    output.output.test.passed(test);
+  });
 
   workers.on(event.test.skipped, (test) => {
-    skippedTestArr.push(test)
-    output.test.skipped(test)
-  })
+    skippedTestArr.push(test);
+    output.output.test.skipped(test);
+  });
 
   workers.on(event.all.result, () => {
     // expose test stats after all workers finished their execution
     function addStepsToTest(test, stepArr) {
-      stepArr.test.steps.forEach((step) => {
+      stepArr.test.steps.forEach(step => {
         if (test.steps.length === 0) {
-          test.steps.push(step)
+          test.steps.push(step);
         }
-      })
+      });
     }
 
-    stepArr.forEach((step) => {
-      passedTestArr.forEach((test) => {
+    stepArr.forEach(step => {
+      passedTestArr.forEach(test => {
         if (step.test.title === test.title) {
-          addStepsToTest(test, step)
+          addStepsToTest(test, step);
         }
-      })
+      });
 
-      failedTestArr.forEach((test) => {
+      failedTestArr.forEach(test => {
         if (step.test.title === test.title) {
-          addStepsToTest(test, step)
+          addStepsToTest(test, step);
         }
-      })
-    })
+      });
+    });
 
     event.dispatcher.emit(event.workers.result, {
       suites: suiteArr,
@@ -92,24 +95,23 @@ module.exports = async function (workerCount, selectedRuns, options) {
         failed: failedTestArr,
         skipped: skippedTestArr,
       },
-    })
-    workers.printResults()
-  })
+    });
+    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
-      const { getMachineInfo } = require('./info')
-      await getMachineInfo()
+      global.debugMode = true;
+      await getMachineInfo();
     }
-    await workers.bootstrapAll()
-    await workers.run()
+    await workers.bootstrapAll();
+    await workers.run();
   } catch (err) {
-    output.error(err)
-    process.exit(1)
+    output.output.error(err);
+    process.exit(1);
   } finally {
-    await workers.teardownAll()
+    await workers.teardownAll();
   }
 }

package/lib/command/run.js

@@ -1,46 +1,49 @@
-const { getConfig, printError, getTestRoot, createOutputDir } = require('./utils')
-const Config = require('../config')
-const store = require('../store')
-const Codecept = require('../codecept')
-
-module.exports = async function (test, options) {
+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';
+
+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;
 
-  const configFile = options.config
+  let config = getConfig(configFile);
 
-  let config = 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 codecept = new Codecept(config, options)
+  const testRoot = getTestRoot(configFile);
+  createOutputDir(config, testRoot);
 
+  const codecept = new Codecept(config, options);
   try {
-    codecept.init(testRoot)
-    await codecept.bootstrap()
-    codecept.loadTests(test)
+    codecept.init(testRoot);
+    await codecept.bootstrap();
+    codecept.loadTests(test);
 
     if (options.verbose) {
-      global.debugMode = true
-      const { getMachineInfo } = require('./info')
-      await getMachineInfo()
+      global.debugMode = true;
+      const { getMachineInfo } = importSync('./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();
   }
 }

package/lib/command/utils.js

@@ -1,118 +1,103 @@
-const fs = require('fs')
-const path = require('path')
-const util = require('util')
-const mkdirp = require('mkdirp')
-
-const output = require('../output')
-const { fileExists, beautify } = require('../utils')
-
-// alias to deep merge
-module.exports.deepMerge = require('../utils').deepMerge
-
-module.exports.getConfig = function (configFile) {
+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) {
   try {
-    return require('../config').load(configFile)
+    return config.default.load(configFile);
   } catch (err) {
-    fail(err.stack)
+    fail(err.stack);
   }
-}
+};
 
-module.exports.readConfig = function (configFile) {
+export const readConfig = function (configFile) {
   try {
-    const data = fs.readFileSync(configFile, 'utf8')
-    return data
+    const data = fs.readFileSync(configFile, 'utf8');
+    return data;
   } catch (err) {
-    output.error(err)
+    output.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;
 }
-module.exports.getTestRoot = getTestRoot
+export { getTestRoot };
 
 function fail(msg) {
-  output.error(msg)
-  process.exit(1)
+  output.output.error(msg);
+  process.exit(1);
 }
 
-module.exports.fail = fail
+export { fail };
 
-function updateConfig(testsPath, config, extension) {
-  const configFile = path.join(testsPath, `codecept.conf.${extension}`)
+function updateConfig(testsPath, config, key, extension = 'js') {
+  const configFile = path.join(testsPath, `codecept.conf.${extension}`);
   if (!fileExists(configFile)) {
-    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();
+    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;
   }
-  console.log(`${output.colors.yellow('Updating configuration file...')}`)
-  return fs.writeFileSync(configFile, beautify(`exports.config = ${util.inspect(config, false, 4, false)}`), 'utf-8')
+  console.log(`${output.output.colors.yellow('Updating configuration file...')}`);
+  return fs.writeFileSync(configFile, beautify(`exports.config = ${util.inspect(config, false, 4, false)}`), 'utf-8');
 }
 
-module.exports.updateConfig = updateConfig
+export { updateConfig };
 
 function safeFileWrite(file, contents) {
   if (fileExists(file)) {
-    output.error(`File ${file} already exist, skipping...`)
-    return false
+    output.output.error(`File ${file} already exist, skipping...`);
+    return false;
   }
-  fs.writeFileSync(file, contents)
-  return true
+  fs.writeFileSync(file, contents);
+  return true;
 }
 
-module.exports.safeFileWrite = safeFileWrite
+export { safeFileWrite };
 
-module.exports.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,
-  }
-}
+  };
+};
 
-module.exports.printError = (err) => {
-  output.print('')
-  output.error(err.message)
-  output.print('')
-  output.print(output.colors.grey(err.stack.replace(err.message, '')))
-}
+export const printError = (err) => {
+  output.print('');
+  output.output.error(err.message);
+  output.print('');
+  output.print(output.output.colors.grey(err.stack.replace(err.message, '')));
+};
 
-module.exports.createOutputDir = (config, testRoot) => {
-  let outputDir
-  if (path.isAbsolute(config.output)) outputDir = config.output
-  else outputDir = path.join(testRoot, config.output)
+export const createOutputDir = (config, testRoot) => {
+  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)
-  }
-}
-
-module.exports.findConfigFile = (testsPath) => {
-  const extensions = ['js', 'ts']
-  for (const ext of extensions) {
-    const configFile = path.join(testsPath, `codecept.conf.${ext}`)
-    if (fileExists(configFile)) {
-      return configFile
-    }
+    output.print(`creating output directory: ${outputDir}`);
+    mkdirp.sync(outputDir);
   }
-  return null
-}
+};

package/lib/command/workers/runTests.js

@@ -1,4 +1,10 @@
-const tty = require('tty');
+import tty from 'tty';
+import { parentPort, workerData } from 'worker_threads';
+import * as event from '../../event.js';
+import Container from '../../container.js';
+import { getConfig } from '../utils.js';
+import { deepMerge, tryOrDefault } from '../../utils.js';
+import Codecept from '../../codecept.js';
 
 if (!tty.getWindowSize) {
   // this is really old method, long removed from Node, but Mocha
@@ -7,19 +13,13 @@ if (!tty.getWindowSize) {
   tty.getWindowSize = () => [40, 80];
 }
 
-const { parentPort, workerData } = require('worker_threads');
-const event = require('../../event');
-const container = require('../../container');
-const { getConfig } = require('../utils');
-const { tryOrDefault, deepMerge } = require('../../utils');
-
 // eslint-disable-next-line no-unused-vars
 let stdout = '';
 /* eslint-enable no-unused-vars */
 const stderr = '';
 
 // Requiring of Codecept need to be after tty.getWindowSize is available.
-const Codecept = require(process.env.CODECEPT_CLASS_PATH || '../../codecept');
+// const Codecept = importSync(process.env.CODECEPT_CLASS_PATH || '../../codecept.js');
 
 const {
   options, tests, testRoot, workerIndex,
@@ -37,7 +37,7 @@ const config = deepMerge(getConfig(options.config || testRoot), overrideConfigs)
 const codecept = new Codecept(config, options);
 codecept.init(testRoot);
 codecept.loadTests();
-const mocha = container.mocha();
+const mocha = Container.mocha();
 filterTests();
 
 (async function () {
@@ -287,6 +287,6 @@ function sendToParentThread(data) {
 
 function listenToParentThread() {
   parentPort.on('message', (eventData) => {
-    container.append({ support: eventData.data });
+    Container.append({ support: eventData.data });
   });
 }

package/lib/config.js

@@ -1,11 +1,9 @@
-const fs = require('fs');
-const path = require('path');
-const {
-  fileExists,
-  isFile,
-  deepMerge,
-  deepClone,
-} = require('./utils');
+import fs from 'fs';
+import path from 'path';
+import importSync from 'import-sync';
+import {
+  fileExists, isFile, deepMerge, deepClone,
+} from './utils.js';
 
 const defaultConfig = {
   output: './_output',
@@ -142,7 +140,7 @@ class Config {
   }
 }
 
-module.exports = Config;
+export default Config;
 
 function loadConfigFile(configFile) {
   const extensionName = path.extname(configFile);
@@ -157,7 +155,8 @@ function loadConfigFile(configFile) {
 
   // .conf.js config file
   if (extensionName === '.js' || extensionName === '.ts' || extensionName === '.cjs') {
-    return Config.create(require(configFile).config);
+    const { config } = importSync(configFile);
+    return Config.create(config);
   }
 
   // json config provided