codeceptjs 3.7.0-beta.1 → 3.7.0-beta.10

package/lib/codecept.js

@@ -105,8 +105,8 @@ class Codecept {
     // default hooks
     runHook(require('./listener/store'))
     runHook(require('./listener/steps'))
-    runHook(require('./listener/artifacts'))
     runHook(require('./listener/config'))
+    runHook(require('./listener/result'))
     runHook(require('./listener/helpers'))
     runHook(require('./listener/globalTimeout'))
     runHook(require('./listener/globalRetry'))
@@ -199,7 +199,7 @@ class Codecept {
         mocha.files = mocha.files.filter(t => fsPath.basename(t, '.js') === test || t === test)
       }
       const done = () => {
-        event.emit(event.all.result, this)
+        event.emit(event.all.result, container.result())
         event.emit(event.all.after, this)
         resolve()
       }

package/lib/command/check.js

@@ -0,0 +1,186 @@
+const { getConfig, getTestRoot } = require('./utils')
+const Codecept = require('../codecept')
+const output = require('../output')
+const store = require('../store')
+const container = require('../container')
+const figures = require('figures')
+const chalk = require('chalk')
+const { createTest } = require('../mocha/test')
+const { getMachineInfo } = require('./info')
+const definitions = require('./definitions')
+
+module.exports = async function (options) {
+  const configFile = options.config
+
+  setTimeout(() => {
+    output.error("Something went wrong. Checks didn't pass and timed out. Please check your config and helpers.")
+    process.exit(1)
+  }, options.timeout || 50000)
+
+  const checks = {
+    config: false,
+    container: false,
+    pageObjects: false,
+    plugins: false,
+    ai: true, // we don't need to check AI
+    helpers: false,
+    setup: false,
+    tests: false,
+    def: false,
+  }
+
+  const testRoot = getTestRoot(configFile)
+  let config = getConfig(configFile)
+
+  try {
+    config = getConfig(configFile)
+    checks['config'] = true
+  } catch (err) {
+    checks['config'] = err
+  }
+
+  printCheck('config', checks['config'], config.name)
+
+  let codecept
+  try {
+    codecept = new Codecept(config, options)
+    codecept.init(testRoot)
+    await container.started()
+    checks.container = true
+  } catch (err) {
+    checks.container = err
+  }
+
+  const standardActingHelpers = container.STANDARD_ACTING_HELPERS
+
+  printCheck('container', checks['container'])
+
+  if (codecept) {
+    try {
+      if (options.bootstrap) await codecept.bootstrap()
+      checks.bootstrap = true
+    } catch (err) {
+      checks.bootstrap = err
+    }
+    printCheck('bootstrap', checks['bootstrap'], options.bootstrap ? 'Bootstrap was executed' : 'No bootstrap command')
+  }
+
+  let numTests = 0
+  if (codecept) {
+    try {
+      codecept.loadTests()
+      const mocha = container.mocha()
+      mocha.files = codecept.testFiles
+      mocha.loadFiles()
+      mocha.suite.suites.forEach(suite => {
+        numTests += suite.tests.length
+      })
+      if (numTests > 0) {
+        checks.tests = true
+      } else {
+        throw new Error('No tests found')
+      }
+    } catch (err) {
+      checks.tests = err
+    }
+  }
+
+  if (config?.ai?.request) {
+    checks.ai = true
+    printCheck('ai', checks['ai'], 'AI configuration is enabled, request function is set')
+  } else {
+    printCheck('ai', checks['ai'], 'AI is disabled')
+  }
+
+  printCheck('tests', checks['tests'], `Total: ${numTests} tests`)
+
+  store.dryRun = true
+
+  const helpers = container.helpers()
+
+  try {
+    if (!Object.keys(helpers).length) throw new Error('No helpers found')
+    // load helpers
+    for (const helper of Object.values(helpers)) {
+      if (helper._init) helper._init()
+    }
+    checks.helpers = true
+  } catch (err) {
+    checks.helpers = err
+  }
+
+  printCheck('helpers', checks['helpers'], `${Object.keys(helpers).join(', ')}`)
+
+  const pageObjects = container.support()
+
+  try {
+    if (Object.keys(pageObjects).length) {
+      for (const pageObject of Object.values(pageObjects)) {
+        pageObject.name
+      }
+    }
+    checks.pageObjects = true
+  } catch (err) {
+    checks.pageObjects = err
+  }
+  printCheck('page objects', checks['pageObjects'], `Total: ${Object.keys(pageObjects).length} support objects`)
+
+  checks.plugins = true // how to check plugins?
+  printCheck('plugins', checks['plugins'], Object.keys(container.plugins()).join(', '))
+
+  if (Object.keys(helpers).length) {
+    const suite = container.mocha().suite
+    const test = createTest('test', () => {})
+    try {
+      for (const helper of Object.values(helpers)) {
+        if (helper._beforeSuite) await helper._beforeSuite(suite)
+        if (helper._before) await helper._before(test)
+        if (helper._passed) await helper._passed(test)
+        if (helper._after) await helper._after(test)
+        if (helper._finishTest) await helper._finishTest(suite)
+        if (helper._afterSuite) await helper._afterSuite(suite)
+      }
+      checks.setup = true
+    } catch (err) {
+      checks.setup = err
+    }
+  }
+
+  printCheck('Helpers Before/After', checks['setup'], standardActingHelpers.some(h => Object.keys(helpers).includes(h)) ? 'Initializing and closing browser' : '')
+
+  try {
+    definitions(configFile, { dryRun: true })
+    checks.def = true
+  } catch (err) {
+    checks.def = err
+  }
+
+  printCheck('TypeScript Definitions', checks['def'])
+
+  output.print('')
+
+  if (!Object.values(checks).every(check => check === true)) {
+    output.error("Something went wrong. Checks didn't pass.")
+    output.print()
+    await getMachineInfo()
+    process.exit(1)
+  }
+
+  output.print(output.styles.success('All checks passed'.toUpperCase()), 'Ready to run your tests 🚀')
+  process.exit(0)
+}
+
+function printCheck(name, value, comment = '') {
+  let status = ''
+  if (value == true) {
+    status += chalk.bold.green(figures.tick)
+  } else {
+    status += chalk.bold.red(figures.cross)
+  }
+
+  if (value instanceof Error) {
+    comment = `${comment} ${chalk.red(value.message)}`.trim()
+  }
+
+  output.print(status, name.toUpperCase(), chalk.dim(comment))
+}

package/lib/command/definitions.js

@@ -5,7 +5,7 @@ const { getConfig, getTestRoot } = require('./utils')
 const Codecept = require('../codecept')
 const container = require('../container')
 const output = require('../output')
-const actingHelpers = [...require('../plugin/standardActingHelpers'), 'REST']
+const actingHelpers = [...container.STANDARD_ACTING_HELPERS, 'REST']
 
 /**
  * Prepare data and generate content of definitions file
@@ -185,6 +185,8 @@ module.exports = function (genPath, options) {
     definitionsFileContent += `\n${translationAliases.join('\n')}`
   }
 
+  if (options.dryRun) return
+
   fs.writeFileSync(path.join(targetFolderPath, 'steps.d.ts'), definitionsFileContent)
   output.print('TypeScript Definitions provide autocompletion in Visual Studio Code and other IDEs')
   output.print('Definitions were generated in steps.d.ts')

package/lib/command/interactive.js

@@ -4,7 +4,7 @@ const Codecept = require('../codecept')
 const Container = require('../container')
 const event = require('../event')
 const output = require('../output')
-const webHelpers = require('../plugin/standardActingHelpers')
+const webHelpers = Container.STANDARD_ACTING_HELPERS
 
 module.exports = async function (path, options) {
   // Backward compatibility for --profile

package/lib/command/run-workers.js

@@ -8,12 +8,6 @@ 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'
@@ -30,69 +24,24 @@ module.exports = async function (workerCount, selectedRuns, options) {
   output.print(`CodeceptJS v${require('../codecept').version()} ${output.standWithUkraine()}`)
   output.print(`Running tests in ${output.styles.bold(numberOfWorkers)} workers...`)
   output.print()
+  store.hasWorkers = true
 
   const workers = new Workers(numberOfWorkers, config)
   workers.overrideConfig(overrideConfigs)
 
-  workers.on(event.suite.before, suite => {
-    suiteArr.push(suite)
-  })
-
-  workers.on(event.step.passed, step => {
-    stepArr.push(step)
-  })
-
-  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.on(event.all.result, result => {
     workers.printResults()
   })
 
@@ -100,7 +49,6 @@ module.exports = async function (workerCount, selectedRuns, options) {
     if (options.verbose || options.debug) store.debugMode = true
 
     if (options.verbose) {
-      global.debugMode = true
       const { getMachineInfo } = require('./info')
       await getMachineInfo()
     }

package/lib/command/workers/runTests.js

@@ -1,288 +1,127 @@
-const tty = require('tty');
+const tty = require('tty')
 
 if (!tty.getWindowSize) {
   // this is really old method, long removed from Node, but Mocha
   // reporters fall back on it if they cannot use `process.stdout.getWindowSize`
   // we need to polyfill it.
-  tty.getWindowSize = () => [40, 80];
+  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');
+const { parentPort, workerData } = require('worker_threads')
+const event = require('../../event')
+const container = require('../../container')
+const { getConfig } = require('../utils')
+const { tryOrDefault, deepMerge } = require('../../utils')
 
-let stdout = '';
+let stdout = ''
 
-const stderr = '';
+const stderr = ''
 
 // Requiring of Codecept need to be after tty.getWindowSize is available.
-const Codecept = require(process.env.CODECEPT_CLASS_PATH || '../../codecept');
+const Codecept = require(process.env.CODECEPT_CLASS_PATH || '../../codecept')
 
-const { options, tests, testRoot, workerIndex } = workerData;
+const { options, tests, testRoot, workerIndex } = workerData
 
 // hide worker output
 if (!options.debug && !options.verbose)
   process.stdout.write = string => {
-    stdout += string;
-    return true;
-  };
+    stdout += string
+    return true
+  }
 
-const overrideConfigs = tryOrDefault(() => JSON.parse(options.override), {});
+const overrideConfigs = tryOrDefault(() => JSON.parse(options.override), {})
 
 // important deep merge so dynamic things e.g. functions on config are not overridden
-const config = deepMerge(getConfig(options.config || testRoot), overrideConfigs);
+const config = deepMerge(getConfig(options.config || testRoot), overrideConfigs)
 
 // Load test and run
-const codecept = new Codecept(config, options);
-codecept.init(testRoot);
-codecept.loadTests();
-const mocha = container.mocha();
-filterTests();
+const codecept = new Codecept(config, options)
+codecept.init(testRoot)
+codecept.loadTests()
+const mocha = container.mocha()
+filterTests()
 
 // run tests
-(async function () {
+;(async function () {
   if (mocha.suite.total()) {
-    await runTests();
+    await runTests()
   }
-})();
+})()
 
 async function runTests() {
   try {
-    await codecept.bootstrap();
+    await codecept.bootstrap()
   } catch (err) {
-    throw new Error(`Error while running bootstrap file :${err}`);
+    throw new Error(`Error while running bootstrap file :${err}`)
   }
-  listenToParentThread();
-  initializeListeners();
-  disablePause();
+  listenToParentThread()
+  initializeListeners()
+  disablePause()
   try {
-    await codecept.run();
+    await codecept.run()
   } finally {
-    await codecept.teardown();
+    await codecept.teardown()
   }
 }
 
 function filterTests() {
-  const files = codecept.testFiles;
-  mocha.files = files;
-  mocha.loadFiles();
+  const files = codecept.testFiles
+  mocha.files = files
+  mocha.loadFiles()
 
   for (const suite of mocha.suite.suites) {
-    suite.tests = suite.tests.filter(test => tests.indexOf(test.uid) >= 0);
+    suite.tests = suite.tests.filter(test => tests.indexOf(test.uid) >= 0)
   }
 }
 
 function initializeListeners() {
-  function simplifyError(error) {
-    if (error) {
-      const { stack, uncaught, message, actual, expected } = error;
-
-      return {
-        stack,
-        uncaught,
-        message,
-        actual,
-        expected,
-      };
-    }
-
-    return null;
-  }
-  function simplifyTest(test, err = null) {
-    test = { ...test };
-
-    if (test.start && !test.duration) {
-      const end = new Date();
-      test.duration = end - test.start;
-    }
-
-    if (test.err) {
-      err = simplifyError(test.err);
-      test.status = 'failed';
-    } else if (err) {
-      err = simplifyError(err);
-      test.status = 'failed';
-    }
-    const parent = {};
-    if (test.parent) {
-      parent.title = test.parent.title;
-    }
-
-    if (test.opts) {
-      Object.keys(test.opts).forEach(k => {
-        if (typeof test.opts[k] === 'object') delete test.opts[k];
-        if (typeof test.opts[k] === 'function') delete test.opts[k];
-      });
-    }
-
-    return {
-      opts: test.opts || {},
-      tags: test.tags || [],
-      uid: test.uid,
-      workerIndex,
-      retries: test._retries,
-      title: test.title,
-      status: test.status,
-      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: JSON.stringify(_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 };
-
-    if (step.startTime && !step.duration) {
-      const end = new Date();
-      step.duration = end - step.startTime;
-    }
-
-    if (step.err) {
-      err = simplifyError(step.err);
-      step.status = 'failed';
-    } else if (err) {
-      err = simplifyError(err);
-      step.status = 'failed';
-    }
-
-    const parent = {};
-    if (step.metaStep) {
-      parent.title = step.metaStep.actor;
-    }
-
-    if (step.opts) {
-      Object.keys(step.opts).forEach(k => {
-        if (typeof step.opts[k] === 'object') delete step.opts[k];
-        if (typeof step.opts[k] === 'function') delete step.opts[k];
-      });
-    }
-
-    return {
-      opts: step.opts || {},
-      workerIndex,
-      title: step.name,
-      status: step.status,
-      duration: step.duration || 0,
-      err,
-      parent,
-      test: simplifyTest(step.test),
-    };
-  }
-
-  collectStats();
   // suite
-  event.dispatcher.on(event.suite.before, suite => sendToParentThread({ event: event.suite.before, workerIndex, data: simplifyTest(suite) }));
-  event.dispatcher.on(event.suite.after, suite => sendToParentThread({ event: event.suite.after, workerIndex, data: simplifyTest(suite) }));
+  event.dispatcher.on(event.suite.before, suite => sendToParentThread({ event: event.suite.before, workerIndex, data: suite.simplify() }))
+  event.dispatcher.on(event.suite.after, suite => sendToParentThread({ event: event.suite.after, workerIndex, data: suite.simplify() }))
 
   // calculate duration
-  event.dispatcher.on(event.test.started, test => (test.start = new Date()));
+  event.dispatcher.on(event.test.started, test => (test.start = new Date()))
 
   // tests
-  event.dispatcher.on(event.test.before, test => sendToParentThread({ event: event.test.before, workerIndex, data: simplifyTest(test) }));
-  event.dispatcher.on(event.test.after, test => sendToParentThread({ event: event.test.after, workerIndex, data: simplifyTest(test) }));
+  event.dispatcher.on(event.test.before, test => sendToParentThread({ event: event.test.before, workerIndex, data: test.simplify() }))
+  event.dispatcher.on(event.test.after, test => sendToParentThread({ event: event.test.after, workerIndex, data: test.simplify() }))
   // we should force-send correct errors to prevent race condition
-  event.dispatcher.on(event.test.finished, (test, err) => sendToParentThread({ event: event.test.finished, workerIndex, data: simplifyTest(test, err) }));
-  event.dispatcher.on(event.test.failed, (test, err) => sendToParentThread({ event: event.test.failed, workerIndex, data: simplifyTest(test, err) }));
-  event.dispatcher.on(event.test.passed, (test, err) => sendToParentThread({ event: event.test.passed, workerIndex, data: simplifyTest(test, err) }));
-  event.dispatcher.on(event.test.started, test => sendToParentThread({ event: event.test.started, workerIndex, data: simplifyTest(test) }));
-  event.dispatcher.on(event.test.skipped, test => sendToParentThread({ event: event.test.skipped, workerIndex, data: simplifyTest(test) }));
+  event.dispatcher.on(event.test.finished, (test, err) => sendToParentThread({ event: event.test.finished, workerIndex, data: { ...test.simplify(), err } }))
+  event.dispatcher.on(event.test.failed, (test, err) => sendToParentThread({ event: event.test.failed, workerIndex, data: { ...test.simplify(), err } }))
+  event.dispatcher.on(event.test.passed, (test, err) => sendToParentThread({ event: event.test.passed, workerIndex, data: { ...test.simplify(), err } }))
+  event.dispatcher.on(event.test.started, test => sendToParentThread({ event: event.test.started, workerIndex, data: test.simplify() }))
+  event.dispatcher.on(event.test.skipped, test => sendToParentThread({ event: event.test.skipped, workerIndex, data: test.simplify() }))
 
   // steps
-  event.dispatcher.on(event.step.finished, step => sendToParentThread({ event: event.step.finished, workerIndex, data: simplifyStep(step) }));
-  event.dispatcher.on(event.step.started, step => sendToParentThread({ event: event.step.started, workerIndex, data: simplifyStep(step) }));
-  event.dispatcher.on(event.step.passed, step => sendToParentThread({ event: event.step.passed, workerIndex, data: simplifyStep(step) }));
-  event.dispatcher.on(event.step.failed, step => sendToParentThread({ event: event.step.failed, workerIndex, data: simplifyStep(step) }));
+  event.dispatcher.on(event.step.finished, step => sendToParentThread({ event: event.step.finished, workerIndex, data: step.simplify() }))
+  event.dispatcher.on(event.step.started, step => sendToParentThread({ event: event.step.started, workerIndex, data: step.simplify() }))
+  event.dispatcher.on(event.step.passed, step => sendToParentThread({ event: event.step.passed, workerIndex, data: step.simplify() }))
+  event.dispatcher.on(event.step.failed, step => sendToParentThread({ event: event.step.failed, workerIndex, data: step.simplify() }))
 
-  event.dispatcher.on(event.hook.failed, (test, err) => sendToParentThread({ event: event.hook.failed, workerIndex, data: simplifyTest(test, err) }));
-  event.dispatcher.on(event.hook.passed, (test, err) => sendToParentThread({ event: event.hook.passed, workerIndex, data: simplifyTest(test, err) }));
-  event.dispatcher.on(event.all.failures, data => sendToParentThread({ event: event.all.failures, workerIndex, data }));
+  event.dispatcher.on(event.hook.failed, (hook, err) => sendToParentThread({ event: event.hook.failed, workerIndex, data: { ...hook.simplify(), err } }))
+  event.dispatcher.on(event.hook.passed, hook => sendToParentThread({ event: event.hook.passed, workerIndex, data: hook.simplify() }))
+  event.dispatcher.on(event.hook.finished, hook => sendToParentThread({ event: event.hook.finished, workerIndex, data: hook.simplify() }))
 
+  event.dispatcher.once(event.all.after, () => {
+    sendToParentThread({ event: event.all.after, workerIndex, data: container.result().simplify() })
+  })
   // all
-  event.dispatcher.once(event.all.result, () => parentPort.close());
+  event.dispatcher.once(event.all.result, () => {
+    sendToParentThread({ event: event.all.result, workerIndex, data: container.result().simplify() })
+    parentPort?.close()
+  })
 }
 
 function disablePause() {
-  global.pause = () => {};
-}
-
-function collectStats() {
-  const stats = {
-    passes: 0,
-    failures: 0,
-    skipped: 0,
-    tests: 0,
-    pending: 0,
-  };
-  event.dispatcher.on(event.test.skipped, () => {
-    stats.skipped++;
-  });
-  event.dispatcher.on(event.test.passed, () => {
-    stats.passes++;
-  });
-  event.dispatcher.on(event.test.failed, test => {
-    if (test.ctx._runnable.title.includes('hook: AfterSuite')) {
-      stats.failedHooks += 1;
-    }
-    stats.failures++;
-  });
-  event.dispatcher.on(event.test.skipped, () => {
-    stats.pending++;
-  });
-  event.dispatcher.on(event.test.finished, () => {
-    stats.tests++;
-  });
-  event.dispatcher.once(event.all.after, () => {
-    sendToParentThread({ event: event.all.after, data: stats });
-  });
+  global.pause = () => {}
 }
 
 function sendToParentThread(data) {
-  parentPort.postMessage(data);
+  parentPort?.postMessage(data)
 }
 
 function listenToParentThread() {
-  parentPort.on('message', eventData => {
-    container.append({ support: eventData.data });
-  });
+  parentPort?.on('message', eventData => {
+    container.append({ support: eventData.data })
+  })
 }