codeceptjs 3.6.7 → 4.0.0-beta.2

package/lib/listener/helpers.js

@@ -1,79 +1,79 @@
-const path = require('path')
-const event = require('../event')
-const container = require('../container')
-const recorder = require('../recorder')
-const store = require('../store')
-const { error } = require('../output')
+import * as event from '../event.js';
+import container from '../container.js';
+import recorder from '../recorder.js';
+import { store } from '../store.js';
+import * as output from '../output.js';
+
 /**
  * Enable Helpers to listen to test events
  */
-module.exports = function () {
-  const helpers = container.helpers()
+export default function () {
+  const helpers = container.helpers();
 
   const runHelpersHook = (hook, param) => {
-    if (store.dryRun) return
+    if (store.dryRun) return;
     Object.values(helpers).forEach((helper) => {
       if (helper[hook]) {
-        helper[hook](param)
+        helper[hook](param);
       }
-    })
-  }
+    });
+  };
 
   const runAsyncHelpersHook = (hook, param, force) => {
-    if (store.dryRun) return
+    if (store.dryRun) return;
     Object.keys(helpers).forEach((key) => {
-      if (!helpers[key][hook]) return
-      recorder.add(`hook ${key}.${hook}()`, () => helpers[key][hook](param), force, false)
-    })
-  }
+      if (!helpers[key][hook]) return;
+      recorder.add(`hook ${key}.${hook}()`, () => helpers[key][hook](param), force, false);
+    });
+  };
 
   event.dispatcher.on(event.suite.before, (suite) => {
     // if (suite.parent) return; // only for root suite
-    runAsyncHelpersHook('_beforeSuite', suite, true)
-  })
+    runAsyncHelpersHook('_beforeSuite', suite, true);
+  });
 
   event.dispatcher.on(event.suite.after, (suite) => {
     // if (suite.parent) return; // only for root suite
-    runAsyncHelpersHook('_afterSuite', suite, true)
-  })
+    runAsyncHelpersHook('_afterSuite', suite, true);
+  });
 
   event.dispatcher.on(event.test.started, (test) => {
-    runHelpersHook('_test', test)
-    recorder.catch((e) => error(e))
-  })
+    runHelpersHook('_test', test);
+    recorder.catch(e => output.output.error(e));
+  });
 
   event.dispatcher.on(event.test.before, (test) => {
     // schedule config to revert changes
-    runAsyncHelpersHook('_before', test, true)
-    recorder.catchWithoutStop((e) => error(e))
-  })
+    runAsyncHelpersHook('_before', test, true);
+    recorder.catchWithoutStop(e => output.output.error(e));
+  });
 
   event.dispatcher.on(event.test.passed, (test) => {
-    runAsyncHelpersHook('_passed', test, true)
+    runAsyncHelpersHook('_passed', test, true);
     // should not fail test execution, so errors should be caught
-    recorder.catchWithoutStop((e) => error(e))
-  })
+    recorder.catchWithoutStop(e => output.output.error(e));
+  });
 
   event.dispatcher.on(event.test.failed, (test) => {
-    runAsyncHelpersHook('_failed', test, true)
+    runAsyncHelpersHook('_failed', test, true);
     // should not fail test execution, so errors should be caught
-    recorder.catchWithoutStop((e) => error(e))
-  })
+    recorder.catchWithoutStop(e => output.output.error(e));
+  });
 
   event.dispatcher.on(event.test.after, () => {
-    runAsyncHelpersHook('_after', {}, true)
-    recorder.catchWithoutStop((e) => error(e))
-  })
+    runAsyncHelpersHook('_after', {}, true);
+    recorder.catchWithoutStop(e => output.output.error(e));
+  });
 
   event.dispatcher.on(event.step.before, (step) => {
-    runAsyncHelpersHook('_beforeStep', step)
-  })
+    runAsyncHelpersHook('_beforeStep', step);
+  });
 
   event.dispatcher.on(event.step.after, (step) => {
-    runAsyncHelpersHook('_afterStep', step)
-  })
+    runAsyncHelpersHook('_afterStep', step);
+  });
 
   event.dispatcher.on(event.all.result, () => {
-    runAsyncHelpersHook('_finishTest', {}, true)
-  })
+    runAsyncHelpersHook('_finishTest', {}, true);
+  });
 }

package/lib/listener/mocha.js

@@ -1,19 +1,19 @@
-const event = require('../event')
-const container = require('../container')
+import * as event from '../event.js';
+import container from '../container.js';
 
-module.exports = function () {
-  let mocha
+export default function () {
+  let mocha;
 
   event.dispatcher.on(event.all.before, () => {
-    mocha = container.mocha()
-  })
+    mocha = container.mocha();
+  });
 
   event.dispatcher.on(event.test.passed, (test) => {
-    mocha.Runner.emit('pass', test)
-  })
+    mocha.Runner.emit('pass', test);
+  });
 
   event.dispatcher.on(event.test.failed, (test, err) => {
-    test.state = 'failed'
-    mocha.Runner.emit('fail', test, err)
-  })
+    test.state = 'failed';
+    mocha.Runner.emit('fail', test, err);
+  });
 }

package/lib/listener/retry.js

@@ -1,70 +1,68 @@
-const event = require('../event')
-const output = require('../output')
-const Config = require('../config')
-const { isNotSet } = require('../utils')
+import * as event from '../event.js';
+import * as output from '../output.js';
+import Config from '../config.js';
+import { isNotSet } from '../utils.js';
 
-const hooks = ['Before', 'After', 'BeforeSuite', 'AfterSuite']
+const hooks = ['Before', 'After', 'BeforeSuite', 'AfterSuite'];
 
-module.exports = function () {
+export default function () {
   event.dispatcher.on(event.suite.before, (suite) => {
-    let retryConfig = Config.get('retry')
-    if (!retryConfig) return
+    let retryConfig = Config.get('retry');
+    if (!retryConfig) return;
 
     if (Number.isInteger(+retryConfig)) {
       // is number
-      const retryNum = +retryConfig
-      output.log(`Retries: ${retryNum}`)
-      suite.retries(retryNum)
-      return
+      const retryNum = +retryConfig;
+      output.output.log(`Retries: ${retryNum}`);
+      suite.retries(retryNum);
+      return;
     }
 
     if (!Array.isArray(retryConfig)) {
-      retryConfig = [retryConfig]
+      retryConfig = [retryConfig];
     }
 
     for (const config of retryConfig) {
       if (config.grep) {
-        if (!suite.title.includes(config.grep)) continue
+        if (!suite.title.includes(config.grep)) continue;
       }
 
-      hooks
-        .filter((hook) => !!config[hook])
-        .forEach((hook) => {
-          if (isNotSet(suite.opts[`retry${hook}`])) suite.opts[`retry${hook}`] = config[hook]
-        })
+      hooks.filter(hook => !!config[hook]).forEach((hook) => {
+        if (isNotSet(suite.opts[`retry${hook}`])) suite.opts[`retry${hook}`] = config[hook];
+      });
 
       if (config.Feature) {
-        if (isNotSet(suite.retries())) suite.retries(config.Feature)
+        if (isNotSet(suite.retries())) suite.retries(config.Feature);
       }
 
-      output.log(`Retries: ${JSON.stringify(config)}`)
+      output.output.log(`Retries: ${JSON.stringify(config)}`);
     }
-  })
+  });
 
   event.dispatcher.on(event.test.before, (test) => {
-    let retryConfig = Config.get('retry')
-    if (!retryConfig) return
+    let retryConfig = Config.get('retry');
+    if (!retryConfig) return;
 
     if (Number.isInteger(+retryConfig)) {
-      if (test.retries() === -1) test.retries(retryConfig)
-      return
+      if (test.retries() === -1) test.retries(retryConfig);
+      return;
     }
 
     if (!Array.isArray(retryConfig)) {
-      retryConfig = [retryConfig]
+      retryConfig = [retryConfig];
     }
 
-    retryConfig = retryConfig.filter((config) => !!config.Scenario)
+    retryConfig = retryConfig.filter(config => !!config.Scenario);
 
     for (const config of retryConfig) {
       if (config.grep) {
-        if (!test.fullTitle().includes(config.grep)) continue
+        if (!test.fullTitle().includes(config.grep)) continue;
       }
 
       if (config.Scenario) {
-        if (test.retries() === -1) test.retries(config.Scenario)
-        output.log(`Retries: ${config.Scenario}`)
+        if (test.retries() === -1) test.retries(config.Scenario);
+        output.output.log(`Retries: ${config.Scenario}`);
       }
     }
-  })
+  });
 }

package/lib/listener/steps.js

@@ -1,83 +1,86 @@
-const debug = require('debug')('codeceptjs:steps')
-const event = require('../event')
-const store = require('../store')
-const output = require('../output')
+import debug from 'debug';
+import * as event from '../event.js';
+import { store } from '../store.js';
+import * as output from '../output.js';
 
-let currentTest
-let currentHook
+debug('codeceptjs:steps');
+
+let currentTest;
+let currentHook;
 
 /**
  * Register steps inside tests
  */
-module.exports = function () {
+export default function () {
   event.dispatcher.on(event.test.before, (test) => {
-    test.startedAt = +new Date()
-    test.artifacts = {}
-  })
+    test.startedAt = +new Date();
+    test.artifacts = {};
+  });
 
   event.dispatcher.on(event.test.started, (test) => {
-    currentTest = test
-    currentTest.steps = []
-    if (!('retryNum' in currentTest)) currentTest.retryNum = 0
-    else currentTest.retryNum += 1
-  })
+    currentTest = test;
+    currentTest.steps = [];
+    if (!('retryNum' in currentTest)) currentTest.retryNum = 0;
+    else currentTest.retryNum += 1;
+  });
 
   event.dispatcher.on(event.test.after, (test) => {
-    currentTest = null
-  })
+    currentTest = null;
+  });
 
-  event.dispatcher.on(event.test.finished, (test) => {})
+  event.dispatcher.on(event.test.finished, (test) => {
+  });
 
   event.dispatcher.on(event.hook.started, (suite) => {
-    currentHook = suite.ctx.test
-    currentHook.steps = []
+    currentHook = suite.ctx.test;
+    currentHook.steps = [];
 
-    if (suite.ctx && suite.ctx.test) output.log(`--- STARTED ${suite.ctx.test.title} ---`)
-  })
+    if (suite.ctx && suite.ctx.test) output.output.log(`--- STARTED ${suite.ctx.test.title} ---`);
+  });
 
   event.dispatcher.on(event.hook.passed, (suite) => {
-    currentHook = null
-    if (suite.ctx && suite.ctx.test) output.log(`--- ENDED ${suite.ctx.test.title} ---`)
-  })
+    currentHook = null;
+    if (suite.ctx && suite.ctx.test) output.output.log(`--- ENDED ${suite.ctx.test.title} ---`);
+  });
 
   event.dispatcher.on(event.test.failed, () => {
     const cutSteps = function (current) {
-      const failureIndex = current.steps.findIndex((el) => el.status === 'failed')
+      const failureIndex = current.steps.findIndex(el => el.status === 'failed');
       // To be sure that failed test will be failed in report
-      current.state = 'failed'
-      current.steps.length = failureIndex + 1
-      return current
-    }
+      current.state = 'failed';
+      current.steps.length = failureIndex + 1;
+      return current;
+    };
     if (currentHook && Array.isArray(currentHook.steps) && currentHook.steps.length) {
-      currentHook = cutSteps(currentHook)
-      return (currentHook = null)
+      currentHook = cutSteps(currentHook);
+      return currentHook = null;
     }
-    if (!currentTest) return
+    if (!currentTest) return;
     // last step is failing step
-    if (!currentTest.steps.length) return
-    return (currentTest = cutSteps(currentTest))
-  })
+    if (!currentTest.steps.length) return;
+    return currentTest = cutSteps(currentTest);
+  });
 
   event.dispatcher.on(event.test.passed, () => {
-    if (!currentTest) return
+    if (!currentTest) return;
     // To be sure that passed test will be passed in report
-    delete currentTest.err
-    currentTest.state = 'passed'
-  })
+    delete currentTest.err;
+    currentTest.state = 'passed';
+  });
 
   event.dispatcher.on(event.step.started, (step) => {
-    step.startedAt = +new Date()
-    step.test = currentTest
+    step.startedAt = +new Date();
+    step.test = currentTest;
     if (currentHook && Array.isArray(currentHook.steps)) {
-      return currentHook.steps.push(step)
+      return currentHook.steps.push(step);
     }
-    if (!currentTest || !currentTest.steps) return
-    currentTest.steps.push(step)
-  })
+    if (!currentTest || !currentTest.steps) return;
+    currentTest.steps.push(step);
+  });
 
   event.dispatcher.on(event.step.finished, (step) => {
-    step.finishedAt = +new Date()
-    if (step.startedAt) step.duration = step.finishedAt - step.startedAt
-    debug(`Step '${step}' finished; Duration: ${step.duration || 0}ms`)
-  })
+    step.finishedAt = +new Date();
+    if (step.startedAt) step.duration = step.finishedAt - step.startedAt;
+    debug(`Step '${step}' finished; Duration: ${step.duration || 0}ms`);
+  });
 }

package/lib/listener/timeout.js

@@ -1,109 +1,109 @@
-const event = require('../event')
-const output = require('../output')
-const recorder = require('../recorder')
-const Config = require('../config')
-const { timeouts } = require('../store')
-const TIMEOUT_ORDER = require('../step').TIMEOUT_ORDER
-
-module.exports = function () {
-  let timeout
-  let suiteTimeout = []
-  let currentTest
-  let currentTimeout
+import * as event from '../event.js';
+import * as output from '../output.js';
+import recorder from '../recorder.js';
+import Config from '../config.js';
+import { timeouts } from '../store.js';
+import { Step } from '../step.js';
+
+export default function () {
+  let timeout;
+  let suiteTimeout = [];
+  let currentTest;
+  let currentTimeout;
 
   if (!timeouts) {
-    console.log('Timeouts were disabled')
-    return
+    console.log('Timeouts were disabled');
+    return;
   }
 
   event.dispatcher.on(event.suite.before, (suite) => {
-    suiteTimeout = []
-    let timeoutConfig = Config.get('timeout')
+    suiteTimeout = [];
+    let timeoutConfig = Config.get('timeout');
 
     if (timeoutConfig) {
       if (!Number.isNaN(+timeoutConfig)) {
-        checkForSeconds(timeoutConfig)
-        suiteTimeout.push(timeoutConfig)
+        checkForSeconds(timeoutConfig);
+        suiteTimeout.push(timeoutConfig);
       }
 
       if (!Array.isArray(timeoutConfig)) {
-        timeoutConfig = [timeoutConfig]
+        timeoutConfig = [timeoutConfig];
       }
 
-      for (const config of timeoutConfig.filter((c) => !!c.Feature)) {
+      for (const config of timeoutConfig.filter(c => !!c.Feature)) {
         if (config.grep) {
-          if (!suite.title.includes(config.grep)) continue
+          if (!suite.title.includes(config.grep)) continue;
         }
-        suiteTimeout.push(config.Feature)
+        suiteTimeout.push(config.Feature);
       }
     }
 
-    if (suite.totalTimeout) suiteTimeout.push(suite.totalTimeout)
-    output.log(`Timeouts: ${suiteTimeout}`)
-  })
+    if (suite.totalTimeout) suiteTimeout.push(suite.totalTimeout);
+    output.output.log(`Timeouts: ${suiteTimeout}`);
+  });
 
   event.dispatcher.on(event.test.before, (test) => {
-    currentTest = test
-    let testTimeout = null
+    currentTest = test;
+    let testTimeout = null;
 
-    let timeoutConfig = Config.get('timeout')
+    let timeoutConfig = Config.get('timeout');
 
     if (typeof timeoutConfig === 'object' || Array.isArray(timeoutConfig)) {
       if (!Array.isArray(timeoutConfig)) {
-        timeoutConfig = [timeoutConfig]
+        timeoutConfig = [timeoutConfig];
       }
 
-      for (const config of timeoutConfig.filter((c) => !!c.Scenario)) {
-        console.log('Test Timeout', config, test.title.includes(config.grep))
+      for (const config of timeoutConfig.filter(c => !!c.Scenario)) {
+        console.log('Test Timeout', config, test.title.includes(config.grep));
         if (config.grep) {
-          if (!test.title.includes(config.grep)) continue
+          if (!test.title.includes(config.grep)) continue;
         }
-        testTimeout = config.Scenario
+        testTimeout = config.Scenario;
       }
     }
 
-    timeout = test.totalTimeout || testTimeout || suiteTimeout[suiteTimeout.length - 1]
-    if (!timeout) return
-    currentTimeout = timeout
-    output.debug(`Test Timeout: ${timeout}s`)
-    timeout *= 1000
-  })
+    timeout = test.totalTimeout || testTimeout || suiteTimeout[suiteTimeout.length - 1];
+    if (!timeout) return;
+    currentTimeout = timeout;
+    output.output.debug(`Test Timeout: ${timeout}s`);
+    timeout *= 1000;
+  });
 
   event.dispatcher.on(event.test.passed, (test) => {
-    currentTest = null
-  })
+    currentTest = null;
+  });
 
   event.dispatcher.on(event.test.failed, (test) => {
-    currentTest = null
-  })
+    currentTest = null;
+  });
 
   event.dispatcher.on(event.step.before, (step) => {
-    if (typeof timeout !== 'number') return
+    if (typeof timeout !== 'number') return;
 
     if (timeout < 0) {
-      step.setTimeout(0.01, TIMEOUT_ORDER.testOrSuite)
+      step.setTimeout(0.01, Step.TIMEOUT_ORDER.testOrSuite);
     } else {
-      step.setTimeout(timeout, TIMEOUT_ORDER.testOrSuite)
+      step.setTimeout(timeout, Step.TIMEOUT_ORDER.testOrSuite);
     }
-  })
+  });
 
   event.dispatcher.on(event.step.finished, (step) => {
-    if (typeof timeout === 'number' && !Number.isNaN(timeout)) timeout -= step.duration
+    if (typeof timeout === 'number' && !Number.isNaN(timeout)) timeout -= step.duration;
 
     if (typeof timeout === 'number' && timeout <= 0 && recorder.isRunning()) {
       if (currentTest && currentTest.callback) {
-        recorder.reset()
+        recorder.reset();
         // replace mocha timeout with custom timeout
-        currentTest.timeout(0)
-        currentTest.callback(new Error(`Timeout ${currentTimeout}s exceeded (with Before hook)`))
-        currentTest.timedOut = true
+        currentTest.timeout(0);
+        currentTest.callback(new Error(`Timeout ${currentTimeout}s exceeded (with Before hook)`));
+        currentTest.timedOut = true;
       }
     }
-  })
+  });
 }
 
 function checkForSeconds(timeout) {
   if (timeout >= 1000) {
-    console.log(`Warning: Timeout was set to ${timeout}secs.\nGlobal timeout should be specified in seconds.`)
+    console.log(`Warning: Timeout was set to ${timeout}secs.\nGlobal timeout should be specified in seconds.`);
   }
 }

package/lib/locator.js

@@ -1,7 +1,11 @@
-let cssToXPath;
-const { sprintf } = require('sprintf-js');
+import { sprintf } from 'sprintf-js';
+
+import csstoxpath from 'csstoxpath';
 
-const { xpathLocator } = require('./utils');
+import css_to_xpath from 'css-to-xpath';
+import { xpathLocator } from './utils.js';
+
+let cssToXPath;
 
 const locatorTypes = ['css', 'by', 'xpath', 'id', 'name', 'fuzzy', 'frame', 'shadow', 'pw'];
 /** @class */
@@ -178,9 +182,9 @@ class Locator {
     const limitation = [':nth-of-type', ':first-of-type', ':last-of-type', ':nth-last-child', ':nth-last-of-type', ':checked', ':disabled', ':enabled', ':required', ':lang', ':nth-child', ':has'];
 
     if (limitation.some(item => locator.includes(item))) {
-      cssToXPath = require('css-to-xpath');
+      cssToXPath = css_to_xpath;
     } else {
-      cssToXPath = require('csstoxpath');
+      cssToXPath = csstoxpath;
     }
 
     if (this.isXPath()) return this.value;
@@ -522,7 +526,7 @@ Locator.select = {
   },
 };
 
-module.exports = Locator;
+export default Locator;
 
 /**
  * @private

package/lib/mochaFactory.js

@@ -1,20 +1,19 @@
-const Mocha = require('mocha');
-const fsPath = require('path');
-const fs = require('fs');
-const reporter = require('./cli');
-const gherkinParser = require('./interfaces/gherkin');
-const output = require('./output');
-const { genTestId } = require('./utils');
-const ConnectionRefused = require('./helper/errors/ConnectionRefused');
+import Mocha from 'mocha';
+import fs from 'fs';
+import reporter from './cli.js';
+import gherkinParser from './interfaces/gherkin.js';
+import * as output from './output.js';
+import { genTestId } from './utils.js';
+import ConnectionRefused from './helper/errors/ConnectionRefused.js';
 
-const scenarioUi = fsPath.join(__dirname, './ui.js');
+import scenarioUi from './ui.js';
 
 let mocha;
 
-class MochaFactory {
+export class MochaFactory {
   static create(config, opts) {
     mocha = new Mocha(Object.assign(config, opts));
-    output.process(opts.child);
+    output.output.process(opts.child);
     mocha.ui(scenarioUi);
 
     Mocha.Runner.prototype.uncaught = function (err) {
@@ -22,11 +21,11 @@ class MochaFactory {
         if (err.toString().indexOf('ECONNREFUSED') >= 0) {
           err = new ConnectionRefused(err);
         }
-        output.error(err);
-        output.print(err.stack);
+        output.output.error(err);
+        output.output.print(err.stack);
         process.exit(1);
       }
-      output.error('Uncaught undefined exception');
+      output.output.error('Uncaught undefined exception');
       process.exit(1);
     };
 
@@ -61,12 +60,12 @@ class MochaFactory {
         });
         if (dupes.length) {
           // ideally this should be no-op and throw (breaking change)...
-          output.error(`Duplicate test names detected - Feature + Scenario name should be unique:\n${dupes.join('\n')}`);
+          output.output.error(`Duplicate test names detected - Feature + Scenario name should be unique:\n${dupes.join('\n')}`);
         }
 
         if (missingFeatureInFile.length) {
           missingFeatureInFile = [...new Set(missingFeatureInFile)];
-          output.error(`Missing Feature section in:\n${missingFeatureInFile.join('\n')}`);
+          output.output.error(`Missing Feature section in:\n${missingFeatureInFile.join('\n')}`);
         }
       }
     };
@@ -109,5 +108,3 @@ class MochaFactory {
     return mocha;
   }
 }
-
-module.exports = MochaFactory;