codeceptjs 3.6.6 → 4.0.0-beta.1

package/lib/command/interactive.js

@@ -1,55 +1,55 @@
-const { getConfig, getTestRoot } = require('./utils')
-const recorder = require('../recorder')
-const Codecept = require('../codecept')
-const Container = require('../container')
-const event = require('../event')
-const output = require('../output')
-const webHelpers = require('../plugin/standardActingHelpers')
+import { getConfig, getTestRoot } from './utils.js';
+import recorder from '../recorder.js';
+import Codecept from '../codecept.js';
+import Container from '../container.js';
+import * as event from '../event.js';
+import * as output from '../output.js';
+import webHelpers from '../plugin/standardActingHelpers.js';
 
-module.exports = async function (path, options) {
+export default async function (path, options) {
   // 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;
 
-  const config = getConfig(configFile)
-  const testsPath = getTestRoot(configFile)
+  const config = getConfig(configFile);
+  const testsPath = getTestRoot(configFile);
 
-  const codecept = new Codecept(config, options)
-  codecept.init(testsPath)
+  const codecept = new Codecept(config, options);
+  codecept.init(testsPath);
 
   try {
-    await codecept.bootstrap()
+    await codecept.bootstrap();
 
-    if (options.verbose) output.level(3)
+    if (options.verbose) output.level(3);
 
-    output.print('Starting interactive shell for current suite...')
-    recorder.start()
+    output.print('Starting interactive shell for current suite...');
+    recorder.start();
     event.emit(event.suite.before, {
       fullTitle: () => 'Interactive Shell',
       tests: [],
-    })
+    });
     event.emit(event.test.before, {
       title: '',
       artifacts: {},
-    })
+    });
 
-    const enabledHelpers = Container.helpers()
+    const enabledHelpers = Container.helpers();
     for (const helperName of Object.keys(enabledHelpers)) {
       if (webHelpers.includes(helperName)) {
-        const I = enabledHelpers[helperName]
-        recorder.add(() => I.amOnPage('/'))
-        recorder.catchWithoutStop((e) => output.print(`Error while loading home page: ${e.message}}`))
-        break
+        const I = enabledHelpers[helperName];
+        recorder.add(() => I.amOnPage('/'));
+        recorder.catchWithoutStop(e => output.print(`Error while loading home page: ${e.message}}`));
+        break;
       }
     }
-    require('../pause')()
+    require('../pause')();
     // recorder.catchWithoutStop((err) => console.log(err.stack));
-    recorder.add(() => event.emit(event.test.after, {}))
-    recorder.add(() => event.emit(event.suite.after, {}))
-    recorder.add(() => event.emit(event.all.result, {}))
-    recorder.add(() => codecept.teardown())
+    recorder.add(() => event.emit(event.test.after, {}));
+    recorder.add(() => event.emit(event.suite.after, {}));
+    recorder.add(() => event.emit(event.all.result, {}));
+    recorder.add(() => codecept.teardown());
   } catch (err) {
-    output.error(`Error while running bootstrap file :${err}`)
+    output.output.error(`Error while running bootstrap file :${err}`);
   }
 }

package/lib/command/list.js

@@ -1,36 +1,36 @@
-const { getConfig, getTestRoot } = require('./utils')
-const Codecept = require('../codecept')
-const container = require('../container')
-const { getParamsToString } = require('../parser')
-const { methodsOfObject } = require('../utils')
-const output = require('../output')
+import { getConfig, getTestRoot } from './utils.js';
+import Codecept from '../codecept.js';
+import container from '../container.js';
+import { getParamsToString } from '../parser.js';
+import { methodsOfObject } from '../utils.js';
+import * as output from '../output.js';
 
-module.exports = function (path) {
-  const testsPath = getTestRoot(path)
-  const config = getConfig(testsPath)
-  const codecept = new Codecept(config, {})
-  codecept.init(testsPath)
+export default function (path) {
+  const testsPath = getTestRoot(path);
+  const config = getConfig(testsPath);
+  const codecept = new Codecept(config, {});
+  codecept.init(testsPath);
 
-  output.print('List of test actions: -- ')
-  const helpers = container.helpers()
-  const supportI = container.support('I')
-  const actions = []
+  output.print('List of test actions: -- ');
+  const helpers = container.helpers();
+  const supportI = container.support('I');
+  const actions = [];
   for (const name in helpers) {
-    const helper = helpers[name]
+    const helper = helpers[name];
     methodsOfObject(helper).forEach((action) => {
-      const params = getParamsToString(helper[action])
-      actions[action] = 1
-      output.print(` ${output.colors.grey(name)} I.${output.colors.bold(action)}(${params})`)
-    })
+      const params = getParamsToString(helper[action]);
+      actions[action] = 1;
+      output.print(` ${output.output.colors.grey(name)} I.${output.output.colors.bold(action)}(${params})`);
+    });
   }
   for (const name in supportI) {
     if (actions[name]) {
-      continue
+      continue;
     }
-    const actor = supportI[name]
-    const params = getParamsToString(actor)
-    output.print(` I.${output.colors.bold(name)}(${params})`)
+    const actor = supportI[name];
+    const params = getParamsToString(actor);
+    output.print(` I.${output.output.colors.bold(name)}(${params})`);
   }
-  output.print('PS: Actions are retrieved from enabled helpers. ')
-  output.print('Implement custom actions in your helper classes.')
+  output.print('PS: Actions are retrieved from enabled helpers. ');
+  output.print('Implement custom actions in your helper classes.');
 }

package/lib/command/run-multiple/chunk.js

@@ -1,6 +1,6 @@
-const glob = require('glob');
-const path = require('path');
-const fs = require('fs');
+import glob from 'glob';
+import path from 'path';
+import fs from 'fs';
 
 /**
  * Splits a list to (n) parts, defined via the size argument.
@@ -61,7 +61,7 @@ const mapFileFormats = (files) => {
  * files by the passed number or executing a usder deifned function to perform
  * the splitting.
  */
-const createChunks = (config, patterns = []) => {
+export const createChunks = (config, patterns = []) => {
   const files = patterns.filter(pattern => !!pattern).map((pattern) => {
     return findFiles(pattern).filter((file) => {
       return config.grep ? grepFile(file, config.grep) : true;
@@ -86,6 +86,6 @@ const createChunks = (config, patterns = []) => {
   });
 };
 
-module.exports = {
+export default {
   createChunks,
 };

package/lib/command/run-multiple/collection.js

@@ -1,5 +1,5 @@
-const { createChunks } = require('./chunk');
-const { createRun } = require('./run');
+import { createChunks } from './chunk.js';
+import { createRun } from './run.js';
 
 /**
  * Bootstraps a collection of runs, it combines user defined selection of runs
@@ -190,6 +190,6 @@ function guessBrowser(config) {
   return [config.helpers[firstHelper].browser];
 }
 
-module.exports = {
+export default {
   createRuns,
 };

package/lib/command/run-multiple/run.js

@@ -21,10 +21,6 @@ class Run {
   }
 }
 
-const createRun = (name, config) => {
+export function createRun(name, config) {
   return new Run(name, config);
-};
-
-module.exports = {
-  createRun,
-};
+}

package/lib/command/run-multiple.js

@@ -1,206 +1,186 @@
-const { fork } = require('child_process')
-const path = require('path')
-const crypto = require('crypto')
-
-const runHook = require('../hooks')
-const event = require('../event')
-const collection = require('./run-multiple/collection')
-const { clearString, replaceValueDeep } = require('../utils')
-const { getConfig, getTestRoot, fail } = require('./utils')
-
-const runner = path.join(__dirname, '/../../bin/codecept')
-let config
-const childOpts = {}
-const copyOptions = [
-  'override',
-  'steps',
-  'reporter',
-  'verbose',
-  'config',
-  'reporter-options',
-  'grep',
-  'fgrep',
-  'invert',
-  'debug',
-  'plugins',
-  'colors',
-]
-let overrides = {}
+import { fork } from 'child_process';
+import path, { dirname } from 'path';
+import crypto from 'crypto';
+import { fileURLToPath } from 'url';
+import runHook from '../hooks.js';
+import * as event from '../event.js';
+import collection from './run-multiple/collection.js';
+import { clearString, replaceValueDeep } from '../utils.js';
+import { getConfig, getTestRoot, fail } from './utils.js';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+const runner = path.join(__dirname, '../../bin/codecept.js');
+let config;
+const childOpts = {};
+const copyOptions = ['override', 'steps', 'reporter', 'verbose', 'config', 'reporter-options', 'grep', 'fgrep', 'invert', 'debug', 'plugins', 'colors'];
+let overrides = {};
 
 // codeceptjs run-multiple smoke:chrome regression:firefox - will launch smoke run in chrome and regression in firefox
 // codeceptjs run-multiple smoke:chrome regression - will launch smoke run in chrome and regression in firefox and chrome
 // codeceptjs run-multiple --all - will launch all runs
 // codeceptjs run-multiple smoke regression'
 
-let runId = 1
-let subprocessCount = 0
-let totalSubprocessCount = 0
-let processesDone
+let runId = 1;
+let subprocessCount = 0;
+let totalSubprocessCount = 0;
+let processesDone;
 
-module.exports = async function (selectedRuns, options) {
+export default async function (selectedRuns, options) {
   // registering options globally to use in config
   if (options.profile) {
-    process.env.profile = options.profile
+    process.env.profile = options.profile;
   }
-  const configFile = options.config
+  const configFile = options.config;
 
-  const testRoot = getTestRoot(configFile)
-  global.codecept_dir = testRoot
+  const testRoot = getTestRoot(configFile);
+  global.codecept_dir = testRoot;
 
   // copy opts to run
   Object.keys(options)
-    .filter((key) => copyOptions.indexOf(key) > -1)
+    .filter(key => copyOptions.indexOf(key) > -1)
     .forEach((key) => {
-      childOpts[key] = options[key]
-    })
+      childOpts[key] = options[key];
+    });
 
   try {
-    overrides = JSON.parse(childOpts.override)
-    delete childOpts.override
+    overrides = JSON.parse(childOpts.override);
+    delete childOpts.override;
   } catch (e) {
-    overrides = {}
+    overrides = {};
   }
 
   config = {
     ...getConfig(configFile),
     ...overrides,
-  }
+  };
 
   if (!config.multiple) {
-    fail('Multiple runs not configured, add "multiple": { /../ } section to config')
+    fail('Multiple runs not configured, add "multiple": { /../ } section to config');
   }
 
-  selectedRuns = options.all ? Object.keys(config.multiple) : selectedRuns
+  selectedRuns = options.all ? Object.keys(config.multiple) : selectedRuns;
   if (!selectedRuns.length) {
-    fail('No runs provided. Use --all option to run all configured runs')
+    fail('No runs provided. Use --all option to run all configured runs');
   }
 
-  await runHook(config.bootstrapAll, 'bootstrapAll')
+  await runHook(config.bootstrapAll, 'bootstrapAll');
 
-  event.emit(event.multiple.before, null)
-  if (options.config) {
-    // update paths to config path
+  event.emit(event.multiple.before, null);
+  if (options.config) { // update paths to config path
     if (config.tests) {
-      config.tests = path.resolve(testRoot, config.tests)
+      config.tests = path.resolve(testRoot, config.tests);
     }
     if (config.gherkin && config.gherkin.features) {
-      config.gherkin.features = path.resolve(testRoot, config.gherkin.features)
+      config.gherkin.features = path.resolve(testRoot, config.gherkin.features);
     }
   }
 
   if (options.features) {
-    config.tests = ''
+    config.tests = '';
   }
 
   if (options.tests && config.gherkin) {
-    config.gherkin.features = ''
+    config.gherkin.features = '';
   }
 
   const childProcessesPromise = new Promise((resolve) => {
-    processesDone = resolve
-  })
+    processesDone = resolve;
+  });
 
-  const runsToExecute = []
+  const runsToExecute = [];
   collection.createRuns(selectedRuns, config).forEach((run) => {
-    const runName = run.getOriginalName() || run.getName()
-    const runConfig = run.getConfig()
-    runsToExecute.push(executeRun(runName, runConfig))
-  })
+    const runName = run.getOriginalName() || run.getName();
+    const runConfig = run.getConfig();
+    runsToExecute.push(executeRun(runName, runConfig));
+  });
 
   if (!runsToExecute.length) {
-    fail('Nothing scheduled for execution')
+    fail('Nothing scheduled for execution');
   }
 
   // Execute all forks
-  totalSubprocessCount = runsToExecute.length
-  runsToExecute.forEach((runToExecute) => runToExecute.call(this))
+  totalSubprocessCount = runsToExecute.length;
+  runsToExecute.forEach(runToExecute => runToExecute.call(this));
 
   return childProcessesPromise.then(async () => {
     // fire hook
-    await runHook(config.teardownAll, 'teardownAll')
-    event.emit(event.multiple.after, null)
-  })
+    await runHook(config.teardownAll, 'teardownAll');
+    event.emit(event.multiple.after, null);
+  });
 }
 
 function executeRun(runName, runConfig) {
   // clone config
-  let overriddenConfig = { ...config }
+  let overriddenConfig = { ...config };
 
   // get configuration
-  const browserConfig = runConfig.browser
-  const browserName = browserConfig.browser
+  const browserConfig = runConfig.browser;
+  const browserName = browserConfig.browser;
 
   for (const key in browserConfig) {
-    overriddenConfig.helpers = replaceValueDeep(overriddenConfig.helpers, key, browserConfig[key])
+    overriddenConfig.helpers = replaceValueDeep(overriddenConfig.helpers, key, browserConfig[key]);
   }
 
-  let outputDir = `${runName}_`
+  let outputDir = `${runName}_`;
   if (browserConfig.outputName) {
-    outputDir += typeof browserConfig.outputName === 'function' ? browserConfig.outputName() : browserConfig.outputName
+    outputDir += typeof browserConfig.outputName === 'function' ? browserConfig.outputName() : browserConfig.outputName;
   } else {
-    const hash = crypto.createHash('sha256')
-    hash.update(JSON.stringify(browserConfig))
-    outputDir += hash.digest('hex')
+    const hash = crypto.createHash('sha256');
+    hash.update(JSON.stringify(browserConfig));
+    outputDir += hash.digest('hex');
   }
-  outputDir += `_${runId}`
+  outputDir += `_${runId}`;
 
-  outputDir = clearString(outputDir)
+  outputDir = clearString(outputDir);
 
   // tweaking default output directories and for mochawesome
-  overriddenConfig = replaceValueDeep(overriddenConfig, 'output', path.join(config.output, outputDir))
-  overriddenConfig = replaceValueDeep(overriddenConfig, 'reportDir', path.join(config.output, outputDir))
-  overriddenConfig = replaceValueDeep(
-    overriddenConfig,
-    'mochaFile',
-    path.join(config.output, outputDir, `${browserName}_report.xml`),
-  )
+  overriddenConfig = replaceValueDeep(overriddenConfig, 'output', path.join(config.output, outputDir));
+  overriddenConfig = replaceValueDeep(overriddenConfig, 'reportDir', path.join(config.output, outputDir));
+  overriddenConfig = replaceValueDeep(overriddenConfig, 'mochaFile', path.join(config.output, outputDir, `${browserName}_report.xml`));
 
   // override tests configuration
   if (overriddenConfig.tests) {
-    overriddenConfig.tests = runConfig.tests
+    overriddenConfig.tests = runConfig.tests;
   }
 
   if (overriddenConfig.gherkin && runConfig.gherkin && runConfig.gherkin.features) {
-    overriddenConfig.gherkin.features = runConfig.gherkin.features
+    overriddenConfig.gherkin.features = runConfig.gherkin.features;
   }
 
   // override grep param and collect all params
-  const params = [
-    'run',
-    '--child',
-    `${runId++}.${runName}:${browserName}`,
-    '--override',
-    JSON.stringify(overriddenConfig),
-  ]
+  const params = ['run',
+    '--child', `${runId++}.${runName}:${browserName}`,
+    '--override', JSON.stringify(overriddenConfig),
+  ];
 
   Object.keys(childOpts).forEach((key) => {
-    params.push(`--${key}`)
-    if (childOpts[key] !== true) params.push(childOpts[key])
-  })
+    params.push(`--${key}`);
+    if (childOpts[key] !== true) params.push(childOpts[key]);
+  });
 
   if (runConfig.grep) {
-    params.push('--grep')
-    params.push(runConfig.grep)
+    params.push('--grep');
+    params.push(runConfig.grep);
   }
 
   const onProcessEnd = (errorCode) => {
     if (errorCode !== 0) {
-      process.exitCode = errorCode
+      process.exitCode = errorCode;
     }
-    subprocessCount += 1
+    subprocessCount += 1;
     if (subprocessCount === totalSubprocessCount) {
-      processesDone()
+      processesDone();
     }
-    return errorCode
-  }
+    return errorCode;
+  };
 
   // Return function of fork for later execution
-  return () =>
-    fork(runner, params, { stdio: [0, 1, 2, 'ipc'] })
-      .on('exit', (code) => {
-        return onProcessEnd(code)
-      })
-      .on('error', () => {
-        return onProcessEnd(1)
-      })
+  return () => fork(runner, params, { stdio: [0, 1, 2, 'ipc'] })
+    .on('exit', (code) => {
+      return onProcessEnd(code);
+    })
+    .on('error', () => {
+      return onProcessEnd(1);
+    });
 }

package/lib/command/run-rerun.js

@@ -1,34 +1,39 @@
-const { getConfig, getTestRoot } = require('./utils')
-const { printError, createOutputDir } = require('./utils')
-const Config = require('../config')
-const Codecept = require('../rerun')
+import {
+  getConfig, getTestRoot, printError, createOutputDir,
+} from './utils.js';
+import Config from '../config.js';
+import Codecept from '../rerun.js';
 
-module.exports = async function (test, options) {
+export async function runRerun(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 = 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)
+  function processError(err) {
+    printError(err);
+    process.exit(1);
+  }
+  const codecept = new Codecept(config, options);
 
   try {
-    codecept.init(testRoot)
+    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();
   }
 }