codeceptjs 3.6.4 → 3.6.5-beta.1

package/lib/command/run-workers.js

@@ -1,89 +1,89 @@
 // 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');
+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;
+  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();
+  output.print(`CodeceptJS v${require('../codecept').version()} ${output.standWithUkraine()}`)
+  output.print(`Running tests in ${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.test.failed(test)
+  })
 
   workers.on(event.test.passed, (test) => {
-    passedTestArr.push(test);
-    output.test.passed(test);
-  });
+    passedTestArr.push(test)
+    output.test.passed(test)
+  })
 
   workers.on(event.test.skipped, (test) => {
-    skippedTestArr.push(test);
-    output.test.skipped(test);
-  });
+    skippedTestArr.push(test)
+    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 +92,24 @@ 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
+      const { getMachineInfo } = require('./info')
+      await getMachineInfo()
     }
-    await workers.bootstrapAll();
-    await workers.run();
+    await workers.bootstrapAll()
+    await workers.run()
   } catch (err) {
-    output.error(err);
-    process.exit(1);
+    output.error(err)
+    process.exit(1)
   } finally {
-    await workers.teardownAll();
+    await workers.teardownAll()
   }
-};
+}

package/lib/command/run.js

@@ -1,48 +1,46 @@
-const {
-  getConfig, printError, getTestRoot, createOutputDir,
-} = require('./utils');
-const Config = require('../config');
-const store = require('../store');
-const Codecept = require('../codecept');
+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) {
   // 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 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);
+    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 } = require('./info')
+      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,117 +1,118 @@
-const fs = require('fs');
-const path = require('path');
-const util = require('util');
-const mkdirp = require('mkdirp');
+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');
+const output = require('../output')
+const { fileExists, beautify } = require('../utils')
 
 // alias to deep merge
-module.exports.deepMerge = require('../utils').deepMerge;
+module.exports.deepMerge = require('../utils').deepMerge
 
 module.exports.getConfig = function (configFile) {
   try {
-    return require('../config').load(configFile);
+    return require('../config').load(configFile)
   } catch (err) {
-    fail(err.stack);
+    fail(err.stack)
   }
-};
+}
 
 module.exports.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.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;
+module.exports.getTestRoot = getTestRoot
 
 function fail(msg) {
-  output.error(msg);
-  process.exit(1);
+  output.error(msg)
+  process.exit(1)
 }
 
-module.exports.fail = fail;
+module.exports.fail = fail
 
 function updateConfig(testsPath, config, extension) {
-  const configFile = path.join(testsPath, `codecept.conf.${extension}`);
+  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;
+    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.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')
 }
 
-module.exports.updateConfig = updateConfig;
+module.exports.updateConfig = updateConfig
 
 function safeFileWrite(file, contents) {
   if (fileExists(file)) {
-    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
 }
 
-module.exports.safeFileWrite = safeFileWrite;
+module.exports.safeFileWrite = safeFileWrite
 
 module.exports.captureStream = (stream) => {
-  let oldStream;
-  let buffer = '';
+  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, '')));
-};
+  output.print('')
+  output.error(err.message)
+  output.print('')
+  output.print(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);
+  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)
   }
-};
+}
 
 module.exports.findConfigFile = (testsPath) => {
-  const extensions = ['js', 'ts'];
+  const extensions = ['js', 'ts']
   for (const ext of extensions) {
-    const configFile = path.join(testsPath, `codecept.conf.${ext}`);
+    const configFile = path.join(testsPath, `codecept.conf.${ext}`)
     if (fileExists(configFile)) {
-      return configFile;
+      return configFile
     }
   }
-  return null;
-};
+  return null
+}

package/lib/data/context.js

@@ -1,129 +1,129 @@
-const { isGenerator } = require('../utils');
-const DataTable = require('./table');
-const DataScenarioConfig = require('./dataScenarioConfig');
-const Secret = require('../secret');
+const { isGenerator } = require('../utils')
+const DataTable = require('./table')
+const DataScenarioConfig = require('./dataScenarioConfig')
+const Secret = require('../secret')
 
 module.exports = function (context) {
   context.Data = function (dataTable) {
-    const data = detectDataType(dataTable);
+    const data = detectDataType(dataTable)
     return {
       Scenario(title, opts, fn) {
-        const scenarios = [];
+        const scenarios = []
         if (typeof opts === 'function' && !fn) {
-          fn = opts;
-          opts = {};
+          fn = opts
+          opts = {}
         }
-        opts.data = data.map(dataRow => dataRow.data);
+        opts.data = data.map((dataRow) => dataRow.data)
         data.forEach((dataRow) => {
-          const dataTitle = replaceTitle(title, dataRow);
+          const dataTitle = replaceTitle(title, dataRow)
           if (dataRow.skip) {
-            context.xScenario(dataTitle);
+            context.xScenario(dataTitle)
           } else {
-            scenarios.push(context.Scenario(dataTitle, opts, fn)
-              .inject({ current: dataRow.data }));
+            scenarios.push(context.Scenario(dataTitle, opts, fn).inject({ current: dataRow.data }))
           }
-        });
-        maskSecretInTitle(scenarios);
-        return new DataScenarioConfig(scenarios);
+        })
+        maskSecretInTitle(scenarios)
+        return new DataScenarioConfig(scenarios)
       },
       only: {
         Scenario(title, opts, fn) {
-          const scenarios = [];
+          const scenarios = []
           if (typeof opts === 'function' && !fn) {
-            fn = opts;
-            opts = {};
+            fn = opts
+            opts = {}
           }
-          opts.data = data.map(dataRow => dataRow.data);
+          opts.data = data.map((dataRow) => dataRow.data)
           data.forEach((dataRow) => {
-            const dataTitle = replaceTitle(title, dataRow);
+            const dataTitle = replaceTitle(title, dataRow)
             if (dataRow.skip) {
-              context.xScenario(dataTitle);
+              context.xScenario(dataTitle)
             } else {
-              scenarios.push(context.Scenario.only(dataTitle, opts, fn)
-                .inject({ current: dataRow.data }));
+              scenarios.push(context.Scenario.only(dataTitle, opts, fn).inject({ current: dataRow.data }))
             }
-          });
-          maskSecretInTitle(scenarios);
-          return new DataScenarioConfig(scenarios);
+          })
+          maskSecretInTitle(scenarios)
+          return new DataScenarioConfig(scenarios)
         },
       },
-    };
-  };
+    }
+  }
 
   context.xData = function (dataTable) {
-    const data = detectDataType(dataTable);
+    const data = detectDataType(dataTable)
     return {
       Scenario: (title) => {
         data.forEach((dataRow) => {
-          const dataTitle = replaceTitle(title, dataRow);
-          context.xScenario(dataTitle);
-        });
-        return new DataScenarioConfig([]);
+          const dataTitle = replaceTitle(title, dataRow)
+          context.xScenario(dataTitle)
+        })
+        return new DataScenarioConfig([])
       },
-    };
-  };
-};
+    }
+  }
+}
 
 function replaceTitle(title, dataRow) {
   if (typeof dataRow.data !== 'object') {
-    return `${title} | {${JSON.stringify(dataRow.data)}}`;
+    return `${title} | {${JSON.stringify(dataRow.data)}}`
   }
 
   // if `dataRow` is object and has own `toString()` method,
   // it should be printed
-  if (Object.prototype.toString.call(dataRow.data) === (Object()).toString()
-    && dataRow.data.toString() !== (Object()).toString()) {
-    return `${title} | ${dataRow.data}`;
+  if (
+    Object.prototype.toString.call(dataRow.data) === Object().toString() &&
+    dataRow.data.toString() !== Object().toString()
+  ) {
+    return `${title} | ${dataRow.data}`
   }
 
-  return `${title} | ${JSON.stringify(dataRow.data)}`;
+  return `${title} | ${JSON.stringify(dataRow.data)}`
 }
 
 function isTableDataRow(row) {
-  const has = Object.prototype.hasOwnProperty;
-  return has.call(row, 'data') && has.call(row, 'skip');
+  const has = Object.prototype.hasOwnProperty
+  return has.call(row, 'data') && has.call(row, 'skip')
 }
 
 function detectDataType(dataTable) {
   if (dataTable instanceof DataTable) {
-    return dataTable.rows;
+    return dataTable.rows
   }
 
   if (isGenerator(dataTable)) {
-    const data = [];
+    const data = []
     for (const dataRow of dataTable()) {
       data.push({
         data: dataRow,
-      });
+      })
     }
-    return data;
+    return data
   }
   if (typeof dataTable === 'function') {
-    return dataTable();
+    return dataTable()
   }
   if (Array.isArray(dataTable)) {
     return dataTable.map((item) => {
       if (isTableDataRow(item)) {
-        return item;
+        return item
       }
       return {
         data: item,
         skip: false,
-      };
-    });
+      }
+    })
   }
 
-  throw new Error('Invalid data type. Data accepts either: DataTable || generator || Array || function');
+  throw new Error('Invalid data type. Data accepts either: DataTable || generator || Array || function')
 }
 
 function maskSecretInTitle(scenarios) {
-  scenarios.forEach(scenario => {
-    const res = [];
+  scenarios.forEach((scenario) => {
+    const res = []
 
-    scenario.test.title.split(',').forEach(item => {
-      res.push(item.replace(/{"_secret":"(.*)"}/, '"*****"'));
-    });
+    scenario.test.title.split(',').forEach((item) => {
+      res.push(item.replace(/{"_secret":"(.*)"}/, '"*****"'))
+    })
 
-    scenario.test.title = res.join(',');
-  });
+    scenario.test.title = res.join(',')
+  })
 }