codeceptjs 3.6.4 → 3.6.5-beta.1

package/lib/listener/config.js

@@ -1,45 +1,46 @@
-const event = require('../event');
-const container = require('../container');
-const recorder = require('../recorder');
-const { deepMerge, deepClone, ucfirst } = require('../utils');
-const { debug } = require('../output');
+const event = require('../event')
+const container = require('../container')
+const recorder = require('../recorder')
+const { deepMerge, deepClone, ucfirst } = require('../utils')
+const { debug } = require('../output')
 /**
  * Enable Helpers to listen to test events
  */
 module.exports = function () {
-  const helpers = container.helpers();
+  const helpers = container.helpers()
 
-  enableDynamicConfigFor('suite');
-  enableDynamicConfigFor('test');
+  enableDynamicConfigFor('suite')
+  enableDynamicConfigFor('test')
 
   function enableDynamicConfigFor(type) {
     event.dispatcher.on(event[type].before, (context = {}) => {
       function updateHelperConfig(helper, config) {
-        const oldConfig = { ...helper.options };
+        const oldConfig = { ...helper.options }
         try {
-          helper._setConfig(deepMerge(deepClone(oldConfig), config));
-          debug(`[${ucfirst(type)} Config] ${helper.constructor.name} ${JSON.stringify(config)}`);
+          helper._setConfig(deepMerge(deepClone(oldConfig), config))
+          debug(`[${ucfirst(type)} Config] ${helper.constructor.name} ${JSON.stringify(config)}`)
         } catch (err) {
-          recorder.throw(err);
-          return;
+          recorder.throw(err)
+          return
         }
         event.dispatcher.once(event[type].after, () => {
-          helper._setConfig(oldConfig);
-          debug(`[${ucfirst(type)} Config] Reverted for ${helper.constructor.name}`);
-        });
+          helper._setConfig(oldConfig)
+          debug(`[${ucfirst(type)} Config] Reverted for ${helper.constructor.name}`)
+        })
       }
 
       // change config
       if (context.config) {
         for (let name in context.config) {
-          const config = context.config[name];
-          if (name === '0') { // first helper
-            name = Object.keys(helpers)[0];
+          const config = context.config[name]
+          if (name === '0') {
+            // first helper
+            name = Object.keys(helpers)[0]
           }
-          const helper = helpers[name];
-          updateHelperConfig(helper, config);
+          const helper = helpers[name]
+          updateHelperConfig(helper, config)
         }
       }
-    });
+    })
   }
-};
+}

package/lib/listener/exit.js

@@ -1,30 +1,30 @@
-const event = require('../event');
+const event = require('../event')
 
 module.exports = function () {
-  let failedTests = [];
+  let failedTests = []
 
   event.dispatcher.on(event.test.failed, (testOrSuite) => {
     // NOTE When an error happens in one of the hooks (BeforeAll/BeforeEach...) the event object
     // is a suite and not a test
-    const id = testOrSuite.uid || (testOrSuite.ctx && testOrSuite.ctx.test.uid) || 'empty';
-    failedTests.push(id);
-  });
+    const id = testOrSuite.uid || (testOrSuite.ctx && testOrSuite.ctx.test.uid) || 'empty'
+    failedTests.push(id)
+  })
 
   // if test was successful after retries
   event.dispatcher.on(event.test.passed, (testOrSuite) => {
     // NOTE When an error happens in one of the hooks (BeforeAll/BeforeEach...) the event object
     // is a suite and not a test
-    const id = testOrSuite.uid || (testOrSuite.ctx && testOrSuite.ctx.test.uid) || 'empty';
-    failedTests = failedTests.filter(failed => id !== failed);
-  });
+    const id = testOrSuite.uid || (testOrSuite.ctx && testOrSuite.ctx.test.uid) || 'empty'
+    failedTests = failedTests.filter((failed) => id !== failed)
+  })
 
   process.on('beforeExit', (code) => {
     if (failedTests.length) {
-      code = 1;
+      code = 1
     }
 
     if (code) {
-      process.exit(code);
+      process.exit(code)
     }
-  });
-};
+  })
+}

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');
+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
  */
 module.exports = function () {
-  const helpers = container.helpers();
+  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) => 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) => 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) => 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) => error(e))
+  })
 
   event.dispatcher.on(event.test.after, () => {
-    runAsyncHelpersHook('_after', {}, true);
-    recorder.catchWithoutStop(e => 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 @@
-const event = require('../event');
-const container = require('../container');
+const event = require('../event')
+const container = require('../container')
 
 module.exports = function () {
-  let mocha;
+  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 @@
-const event = require('../event');
-const output = require('../output');
-const Config = require('../config');
-const { isNotSet } = require('../utils');
+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']
 
 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.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.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.log(`Retries: ${config.Scenario}`);
+        if (test.retries() === -1) test.retries(config.Scenario)
+        output.log(`Retries: ${config.Scenario}`)
       }
     }
-  });
-};
+  })
+}

package/lib/listener/steps.js

@@ -1,84 +1,83 @@
-const debug = require('debug')('codeceptjs:steps');
-const event = require('../event');
-const store = require('../store');
-const output = require('../output');
+const debug = require('debug')('codeceptjs:steps')
+const event = require('../event')
+const store = require('../store')
+const output = require('../output')
 
-let currentTest;
-let currentHook;
+let currentTest
+let currentHook
 
 /**
  * Register steps inside tests
  */
 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.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.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 @@
-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;
+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;
+  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.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.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, TIMEOUT_ORDER.testOrSuite)
     } else {
-      step.setTimeout(timeout, 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.`)
   }
 }