codeceptjs 4.0.0-beta.1 → 4.0.0-beta.3

package/lib/listener/helpers.js

@@ -1,79 +1,79 @@
-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';
-
+const path = require('path')
+const event = require('../event')
+const container = require('../container')
+const recorder = require('../recorder')
+const store = require('../store')
+const { error } = require('../output')
 /**
  * Enable Helpers to listen to test events
  */
-export default function () {
-  const helpers = container.helpers();
+module.exports = 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 => output.output.error(e));
-  });
+    runHelpersHook('_test', test)
+    recorder.catch((e) => error(e))
+  })
 
   event.dispatcher.on(event.test.before, (test) => {
     // schedule config to revert changes
-    runAsyncHelpersHook('_before', test, true);
-    recorder.catchWithoutStop(e => output.output.error(e));
-  });
+    runAsyncHelpersHook('_before', test, true)
+    recorder.catchWithoutStop((e) => 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 => output.output.error(e));
-  });
+    recorder.catchWithoutStop((e) => 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 => output.output.error(e));
-  });
+    recorder.catchWithoutStop((e) => error(e))
+  })
 
   event.dispatcher.on(event.test.after, () => {
-    runAsyncHelpersHook('_after', {}, true);
-    recorder.catchWithoutStop(e => output.output.error(e));
-  });
+    runAsyncHelpersHook('_after', {}, true)
+    recorder.catchWithoutStop((e) => 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 @@
-import * as event from '../event.js';
-import container from '../container.js';
+const event = require('../event')
+const container = require('../container')
 
-export default function () {
-  let mocha;
+module.exports = 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,68 +1,70 @@
-import * as event from '../event.js';
-import * as output from '../output.js';
-import Config from '../config.js';
-import { isNotSet } from '../utils.js';
+const event = require('../event')
+const output = require('../output')
+const Config = require('../config')
+const { isNotSet } = require('../utils')
 
-const hooks = ['Before', 'After', 'BeforeSuite', 'AfterSuite'];
+const hooks = ['Before', 'After', 'BeforeSuite', 'AfterSuite']
 
-export default function () {
+module.exports = 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.output.log(`Retries: ${retryNum}`);
-      suite.retries(retryNum);
-      return;
+      const retryNum = +retryConfig
+      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.output.log(`Retries: ${JSON.stringify(config)}`);
+      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.output.log(`Retries: ${config.Scenario}`);
+        if (test.retries() === -1) test.retries(config.Scenario)
+        output.log(`Retries: ${config.Scenario}`)
       }
     }
-  });
+  })
 }

package/lib/listener/steps.js

@@ -1,86 +1,83 @@
-import debug from 'debug';
-import * as event from '../event.js';
-import { store } from '../store.js';
-import * as output from '../output.js';
+const debug = require('debug')('codeceptjs:steps')
+const event = require('../event')
+const store = require('../store')
+const output = require('../output')
 
-debug('codeceptjs:steps');
-
-let currentTest;
-let currentHook;
+let currentTest
+let currentHook
 
 /**
  * Register steps inside tests
  */
-export default function () {
+module.exports = 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.output.log(`--- STARTED ${suite.ctx.test.title} ---`);
-  });
+    if (suite.ctx && suite.ctx.test) output.log(`--- STARTED ${suite.ctx.test.title} ---`)
+  })
 
   event.dispatcher.on(event.hook.passed, (suite) => {
-    currentHook = null;
-    if (suite.ctx && suite.ctx.test) output.output.log(`--- ENDED ${suite.ctx.test.title} ---`);
-  });
+    currentHook = null
+    if (suite.ctx && suite.ctx.test) 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 @@
-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;
+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
 
   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.output.log(`Timeouts: ${suiteTimeout}`);
-  });
+    if (suite.totalTimeout) suiteTimeout.push(suite.totalTimeout)
+    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.output.debug(`Test Timeout: ${timeout}s`);
-    timeout *= 1000;
-  });
+    timeout = test.totalTimeout || testTimeout || suiteTimeout[suiteTimeout.length - 1]
+    if (!timeout) return
+    currentTimeout = timeout
+    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, Step.TIMEOUT_ORDER.testOrSuite);
+      step.setTimeout(0.01, TIMEOUT_ORDER.testOrSuite)
     } else {
-      step.setTimeout(timeout, Step.TIMEOUT_ORDER.testOrSuite);
+      step.setTimeout(timeout, 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,11 +1,7 @@
-import { sprintf } from 'sprintf-js';
-
-import csstoxpath from 'csstoxpath';
-
-import css_to_xpath from 'css-to-xpath';
-import { xpathLocator } from './utils.js';
-
 let cssToXPath;
+const { sprintf } = require('sprintf-js');
+
+const { xpathLocator } = require('./utils');
 
 const locatorTypes = ['css', 'by', 'xpath', 'id', 'name', 'fuzzy', 'frame', 'shadow', 'pw'];
 /** @class */
@@ -182,9 +178,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 = css_to_xpath;
+      cssToXPath = require('css-to-xpath');
     } else {
-      cssToXPath = csstoxpath;
+      cssToXPath = require('csstoxpath');
     }
 
     if (this.isXPath()) return this.value;
@@ -526,7 +522,7 @@ Locator.select = {
   },
 };
 
-export default Locator;
+module.exports = Locator;
 
 /**
  * @private

package/lib/mochaFactory.js

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