codeceptjs 4.0.0-beta.2 → 4.0.0-beta.4

package/lib/command/interactive.js

@@ -1,55 +1,55 @@
-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';
+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')
 
-export default async function (path, options) {
+module.exports = 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.output.error(`Error while running bootstrap file :${err}`);
+    output.error(`Error while running bootstrap file :${err}`)
   }
 }

package/lib/command/list.js

@@ -1,36 +1,36 @@
-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';
+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')
 
-export default function (path) {
-  const testsPath = getTestRoot(path);
-  const config = getConfig(testsPath);
-  const codecept = new Codecept(config, {});
-  codecept.init(testsPath);
+module.exports = 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.output.colors.grey(name)} I.${output.output.colors.bold(action)}(${params})`);
-    });
+      const params = getParamsToString(helper[action])
+      actions[action] = 1
+      output.print(` ${output.colors.grey(name)} I.${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.output.colors.bold(name)}(${params})`);
+    const actor = supportI[name]
+    const params = getParamsToString(actor)
+    output.print(` I.${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 @@
-import glob from 'glob';
-import path from 'path';
-import fs from 'fs';
+const glob = require('glob');
+const path = require('path');
+const fs = require('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.
  */
-export const createChunks = (config, patterns = []) => {
+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 @@ export const createChunks = (config, patterns = []) => {
   });
 };
 
-export default {
+module.exports = {
   createChunks,
 };

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

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

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

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

package/lib/command/run-multiple.js

@@ -1,186 +1,206 @@
-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 = {};
+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 = {}
 
 // 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
 
-export default async function (selectedRuns, options) {
+module.exports = 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,39 +1,34 @@
-import {
-  getConfig, getTestRoot, printError, createOutputDir,
-} from './utils.js';
-import Config from '../config.js';
-import Codecept from '../rerun.js';
+const { getConfig, getTestRoot } = require('./utils')
+const { printError, createOutputDir } = require('./utils')
+const Config = require('../config')
+const Codecept = require('../rerun')
 
-export async function runRerun(test, options) {
+module.exports = 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 = 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);
+    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()
   }
 }