codeceptjs 3.4.1 → 3.5.1-2.beta.7

package/lib/command/info.js

@@ -37,3 +37,27 @@ module.exports = async function (path) {
   output.print('Please copy environment info when you report issues on GitHub: https://github.com/Codeception/CodeceptJS/issues');
   output.print('***************************************');
 };
+
+module.exports.getMachineInfo = async () => {
+  const info = {
+    nodeInfo: await envinfo.helpers.getNodeInfo(),
+    osInfo: await envinfo.helpers.getOSInfo(),
+    cpuInfo: await envinfo.helpers.getCPUInfo(),
+    chromeInfo: await envinfo.helpers.getChromeInfo(),
+    edgeInfo: await envinfo.helpers.getEdgeInfo(),
+    firefoxInfo: await envinfo.helpers.getFirefoxInfo(),
+    safariInfo: await envinfo.helpers.getSafariInfo(),
+  };
+
+  output.print('***************************************');
+  for (const [key, value] of Object.entries(info)) {
+    if (Array.isArray(value)) {
+      output.print(`${key}:  ${value[1]}`);
+    } else {
+      output.print(`${key}:  ${JSON.stringify(value, null, ' ')}`);
+    }
+  }
+  output.print('If you need more detailed info, just run this: npx codeceptjs info');
+  output.print('***************************************');
+  return info;
+};

package/lib/command/init.js

@@ -20,7 +20,7 @@ const defaultConfig = {
   include: {},
 };
 
-const helpers = ['Playwright', 'WebDriver', 'Puppeteer', 'REST', 'GraphQL', 'Appium', 'TestCafe', 'Nightmare'];
+const helpers = ['Playwright', 'WebDriver', 'Puppeteer', 'REST', 'GraphQL', 'Appium', 'TestCafe'];
 const translations = Object.keys(require('../../translations'));
 
 const noTranslation = 'English (no localization)';
@@ -55,6 +55,18 @@ module.exports = function() {
 }
 `;
 
+const defaultActorTs = `// in this file you can append custom step methods to 'I' object
+
+export = function() {
+  return actor({
+
+    // Define custom steps here, use 'this' to access default methods of I.
+    // It is recommended to place a general 'login' function here.
+
+  });
+}
+`;
+
 module.exports = function (initPath) {
   const testsPath = getTestRoot(initPath);
 
@@ -188,8 +200,14 @@ module.exports = function (initPath) {
       // create steps file by default
       // no extra step file for typescript (as it doesn't match TS conventions)
       const stepFile = `./steps_file.${extension}`;
-      fs.writeFileSync(path.join(testsPath, stepFile), defaultActor);
-      config.include.I = isTypeScript === true ? './steps_file' : stepFile;
+      fs.writeFileSync(path.join(testsPath, stepFile), extension === 'ts' ? defaultActorTs : defaultActor);
+
+      if (isTypeScript) {
+        config.include = _actorTranslation('./steps_file', config.translation);
+      } else {
+        config.include = _actorTranslation(stepFile, config.translation);
+      }
+
       print(`Steps file created at ${stepFile}`);
 
       let configSource;
@@ -304,7 +322,17 @@ module.exports = function (initPath) {
     };
 
     print('Configure helpers...');
-    inquirer.prompt(helperConfigs).then((helperResult) => {
+    inquirer.prompt(helperConfigs).then(async (helperResult) => {
+      if (helperResult.Playwright_browser === 'electron') {
+        delete helperResult.Playwright_url;
+        delete helperResult.Playwright_show;
+
+        helperResult.Playwright_electron = {
+          executablePath: '// require("electron") or require("electron-forge")',
+          args: ['path/to/your/main.js'],
+        };
+      }
+
       Object.keys(helperResult).forEach((key) => {
         const parts = key.split('_');
         const helperName = parts[0];
@@ -314,12 +342,12 @@ module.exports = function (initPath) {
       });
 
       print('');
-      finish();
+      await finish();
     });
   });
 };
 
-function install(dependencies, verbose) {
+function install(dependencies) {
   let command;
   let args;
 
@@ -352,9 +380,39 @@ function install(dependencies, verbose) {
     ].concat(dependencies);
   }
 
+  if (process.env._INIT_DRY_RUN_INSTALL) {
+    args.push('--dry-run');
+  }
+
   const { status } = spawn.sync(command, args, { stdio: 'inherit' });
   if (status !== 0) {
     throw new Error(`${command} ${args.join(' ')} failed`);
   }
   return true;
 }
+
+function _actorTranslation(stepFile, translationSelected) {
+  let actor;
+
+  for (const translationAvailable of translations) {
+    if (actor) {
+      break;
+    }
+
+    if (translationSelected === translationAvailable) {
+      const nameOfActor = require('../../translations')[translationAvailable].I;
+
+      actor = {
+        [nameOfActor]: stepFile,
+      };
+    }
+  }
+
+  if (!actor) {
+    actor = {
+      I: stepFile,
+    };
+  }
+
+  return actor;
+}

package/lib/command/interactive.js

@@ -1,8 +1,10 @@
 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');
 
 module.exports = async function (path, options) {
   // Backward compatibility for --profile
@@ -29,9 +31,21 @@ module.exports = async function (path, options) {
     });
     event.emit(event.test.before, {
       title: '',
+      artifacts: {},
     });
+
+    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;
+      }
+    }
     require('../pause')();
-    recorder.add(() => event.emit(event.test.after));
+    // 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());

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

@@ -47,14 +47,26 @@ class Collection {
    */
   prepareRuns(selectedRuns, config) {
     selectedRuns.forEach((selectedRun) => {
-      const [runName] = selectedRun.split(':');
-      const runConfig = config.multiple[runName];
+      const runConfig = [];
+      const runName = [];
 
-      if (!runConfig) {
-        throw new Error(`run ${runName} was not configured in "multiple" section of config`);
+      if (selectedRun === 'all') {
+        Object.keys(config.multiple).forEach(name => {
+          runName.push(name);
+          runConfig.push(config.multiple[name]);
+        });
+      } else {
+        runName.push(selectedRun.split(':')[0]);
+        runConfig.push(config.multiple[runName[0]]);
       }
 
-      this.addRun(createRun(runName, runConfig));
+      for (let i = 0; i < runConfig.length; i++) {
+        if (!runConfig[i]) {
+          throw new Error(`run ${runName[i]} was not configured in "multiple" section of config`);
+        }
+
+        this.addRun(createRun(runName[i], runConfig[i]));
+      }
     });
 
     return this;

package/lib/command/run-multiple.js

@@ -28,7 +28,9 @@ let processesDone;
 
 module.exports = async function (selectedRuns, options) {
   // registering options globally to use in config
-  process.env.profile = options.profile;
+  if (options.profile) {
+    process.env.profile = options.profile;
+  }
   const configFile = options.config;
 
   const testRoot = getTestRoot(configFile);
@@ -124,7 +126,7 @@ function executeRun(runName, runConfig) {
   if (browserConfig.outputName) {
     outputDir += typeof browserConfig.outputName === 'function' ? browserConfig.outputName() : browserConfig.outputName;
   } else {
-    const hash = crypto.createHash('md5');
+    const hash = crypto.createHash('sha256');
     hash.update(JSON.stringify(browserConfig));
     outputDir += hash.digest('hex');
   }

package/lib/command/run-workers.js

@@ -4,9 +4,15 @@ const output = require('../output');
 const event = require('../event');
 const Workers = require('../workers');
 
-module.exports = async function (workerCount, options) {
+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';
@@ -15,6 +21,7 @@ module.exports = async function (workerCount, options) {
     by,
     testConfig,
     options,
+    selectedRuns,
   };
 
   const numberOfWorkers = parseInt(workerCount, 10);
@@ -25,19 +32,75 @@ module.exports = async function (workerCount, options) {
 
   const workers = new Workers(numberOfWorkers, config);
   workers.overrideConfig(overrideConfigs);
-  workers.on(event.test.failed, (failedTest) => {
-    output.test.failed(failedTest);
+
+  workers.on(event.suite.before, (suite) => {
+    suiteArr.push(suite);
+  });
+
+  workers.on(event.step.passed, (step) => {
+    stepArr.push(step);
   });
 
-  workers.on(event.test.passed, (successTest) => {
-    output.test.passed(successTest);
+  workers.on(event.step.failed, (step) => {
+    stepArr.push(step);
+  });
+
+  workers.on(event.test.failed, (test) => {
+    failedTestArr.push(test);
+    output.test.failed(test);
+  });
+
+  workers.on(event.test.passed, (test) => {
+    passedTestArr.push(test);
+    output.test.passed(test);
+  });
+
+  workers.on(event.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 => {
+        if (test.steps.length === 0) {
+          test.steps.push(step);
+        }
+      });
+    }
+
+    stepArr.forEach(step => {
+      passedTestArr.forEach(test => {
+        if (step.test.title === test.title) {
+          addStepsToTest(test, step);
+        }
+      });
+
+      failedTestArr.forEach(test => {
+        if (step.test.title === test.title) {
+          addStepsToTest(test, step);
+        }
+      });
+    });
+
+    event.dispatcher.emit(event.workers.result, {
+      suites: suiteArr,
+      tests: {
+        passed: passedTestArr,
+        failed: failedTestArr,
+        skipped: skippedTestArr,
+      },
+    });
     workers.printResults();
   });
 
   try {
+    if (options.verbose) {
+      global.debugMode = true;
+      const { getMachineInfo } = require('./info');
+      await getMachineInfo();
+    }
     await workers.bootstrapAll();
     await workers.run();
   } catch (err) {

package/lib/command/run.js

@@ -28,6 +28,13 @@ module.exports = async function (test, options) {
     codecept.init(testRoot);
     await codecept.bootstrap();
     codecept.loadTests(test);
+
+    if (options.verbose) {
+      global.debugMode = true;
+      const { getMachineInfo } = require('./info');
+      await getMachineInfo();
+    }
+
     await codecept.run();
   } catch (err) {
     printError(err);

package/lib/command/workers/runTests.js

@@ -132,9 +132,48 @@ function initializeListeners() {
       duration: test.duration || 0,
       err,
       parent,
+      steps: test.steps && test.steps.length > 0 ? simplifyStepsInTestObject(test.steps, err) : [],
     };
   }
 
+  function simplifyStepsInTestObject(steps, err) {
+    steps = [...steps];
+    const _steps = [];
+
+    for (step of steps) {
+      const _args = [];
+
+      if (step.args) {
+        for (const arg of step.args) {
+          // check if arg is a JOI object
+          if (arg && arg.$_root) {
+            _args.push(JSON.stringify(arg).slice(0, 300));
+          // check if arg is a function
+          } else if (arg && typeof arg === 'function') {
+            _args.push(arg.name);
+          } else {
+            _args.push(arg);
+          }
+        }
+      }
+
+      _steps.push({
+        actor: step.actor,
+        name: step.name,
+        status: step.status,
+        args: _args,
+        startedAt: step.startedAt,
+        startTime: step.startTime,
+        endTime: step.endTime,
+        finishedAt: step.finishedAt,
+        duration: step.duration,
+        err,
+      });
+    }
+
+    return _steps;
+  }
+
   function simplifyStep(step, err = null) {
     step = { ...step };
 

package/lib/container.js

@@ -165,7 +165,17 @@ function createHelpers(config) {
       } else {
         moduleName = `./helper/${helperName}`; // built-in helper
       }
-      const HelperClass = require(moduleName);
+
+      // @ts-ignore
+      let HelperClass;
+      // check if the helper is the built-in, use the require() syntax.
+      if (moduleName.startsWith('./helper/')) {
+        HelperClass = require(moduleName);
+      } else {
+        // check if the new syntax export default HelperName is used and loads the Helper, otherwise loads the module that used old syntax export = HelperName.
+        HelperClass = require(moduleName).default || require(moduleName);
+      }
+
       if (HelperClass._checkRequirements) {
         const requirements = HelperClass._checkRequirements();
         if (requirements) {
@@ -351,8 +361,8 @@ function loadSupportObject(modulePath, supportObjectName) {
       }
     }
     if (typeof obj !== 'function'
-        && Object.getPrototypeOf(obj) !== Object.prototype
-        && !Array.isArray(obj)
+      && Object.getPrototypeOf(obj) !== Object.prototype
+      && !Array.isArray(obj)
     ) {
       const methods = getObjectMethods(obj);
       Object.keys(methods)

package/lib/data/context.js

@@ -23,6 +23,7 @@ module.exports = function (context) {
               .inject({ current: dataRow.data }));
           }
         });
+        maskSecretInTitle(scenarios);
         return new DataScenarioConfig(scenarios);
       },
       only: {
@@ -42,6 +43,7 @@ module.exports = function (context) {
                 .inject({ current: dataRow.data }));
             }
           });
+          maskSecretInTitle(scenarios);
           return new DataScenarioConfig(scenarios);
         },
       },
@@ -71,12 +73,6 @@ function replaceTitle(title, dataRow) {
   // it should be printed
   if (Object.prototype.toString.call(dataRow.data) === (Object()).toString()
     && dataRow.data.toString() !== (Object()).toString()) {
-    Object.entries(dataRow.data).forEach(entry => {
-      const [key, value] = entry;
-      if (value instanceof Secret) {
-        dataRow.data[key] = value.getMasked();
-      }
-    });
     return `${title} | ${dataRow.data}`;
   }
 
@@ -119,3 +115,15 @@ function detectDataType(dataTable) {
 
   throw new Error('Invalid data type. Data accepts either: DataTable || generator || Array || function');
 }
+
+function maskSecretInTitle(scenarios) {
+  scenarios.forEach(scenario => {
+    const res = [];
+
+    scenario.test.title.split(',').forEach(item => {
+      res.push(item.replace(/{"_secret":"(.*)"}/, '"*****"'));
+    });
+
+    scenario.test.title = res.join(',');
+  });
+}

package/lib/event.js

@@ -91,6 +91,8 @@ module.exports = {
   bddStep: {
     before: 'bddStep.before',
     after: 'bddStep.after',
+    started: 'bddStep.started',
+    finished: 'bddStep.finished',
   },
   /**
    * @type {object}
@@ -125,10 +127,12 @@ module.exports = {
    * @inner
    * @property {'workers.before'} before
    * @property {'workers.after'} after
+   * @property {'workers.result'} result
    */
   workers: {
     before: 'workers.before',
     after: 'workers.after',
+    result: 'workers.result',
   },
 
   /**

package/lib/helper/ApiDataFactory.js

@@ -309,7 +309,8 @@ class ApiDataFactory extends Helper {
       } catch (e) {
         modulePath = path.join(global.codecept_dir, modulePath);
       }
-      const builder = require(modulePath);
+      // check if the new syntax `export default new Factory()` is used and loads the builder, otherwise loads the module that used old syntax `module.exports = new Factory()`.
+      const builder = require(modulePath).default || require(modulePath);
       return builder.build(data, options);
     } catch (err) {
       throw new Error(`Couldn't load factory file from ${modulePath}, check that