codeceptjs 3.6.4-beta.2 → 3.6.5-beta.1

package/lib/interfaces/scenarioConfig.js

@@ -1,7 +1,7 @@
 /** @class */
 class ScenarioConfig {
   constructor(test) {
-    this.test = test;
+    this.test = test
   }
 
   /**
@@ -12,8 +12,8 @@ class ScenarioConfig {
    * @returns {this}
    */
   throws(err) {
-    this.test.throws = err;
-    return this;
+    this.test.throws = err
+    return this
   }
 
   /**
@@ -24,8 +24,8 @@ class ScenarioConfig {
    * @returns {this}
    */
   fails() {
-    this.test.throws = new Error();
-    return this;
+    this.test.throws = new Error()
+    return this
   }
 
   /**
@@ -35,9 +35,9 @@ class ScenarioConfig {
    * @returns {this}
    */
   retry(retries) {
-    if (process.env.SCENARIO_ONLY) retries = -retries;
-    this.test.retries(retries);
-    return this;
+    if (process.env.SCENARIO_ONLY) retries = -retries
+    this.test.retries(retries)
+    return this
   }
 
   /**
@@ -46,12 +46,12 @@ class ScenarioConfig {
    * @returns {this}
    */
   timeout(timeout) {
-    console.log(`Scenario('${this.test.title}', () => {}).timeout(${timeout}) is deprecated!`);
-    console.log(`Please use Scenario('${this.test.title}', { timeout: ${timeout / 1000} }, () => {}) instead`);
-    console.log('Timeout should be set in seconds');
+    console.log(`Scenario('${this.test.title}', () => {}).timeout(${timeout}) is deprecated!`)
+    console.log(`Please use Scenario('${this.test.title}', { timeout: ${timeout / 1000} }, () => {}) instead`)
+    console.log('Timeout should be set in seconds')
 
-    this.test.timeout(timeout);
-    return this;
+    this.test.timeout(timeout)
+    return this
   }
 
   /**
@@ -60,8 +60,8 @@ class ScenarioConfig {
    * @returns {this}
    */
   inject(obj) {
-    this.test.inject = obj;
-    return this;
+    this.test.inject = obj
+    return this
   }
 
   /**
@@ -73,17 +73,17 @@ class ScenarioConfig {
    */
   async config(helper, obj) {
     if (!obj) {
-      obj = helper;
-      helper = 0;
+      obj = helper
+      helper = 0
     }
     if (typeof obj === 'function') {
-      obj = await obj(this.test);
+      obj = await obj(this.test)
     }
     if (!this.test.config) {
-      this.test.config = {};
+      this.test.config = {}
     }
-    this.test.config[helper] = obj;
-    return this;
+    this.test.config[helper] = obj
+    return this
   }
 
   /**
@@ -92,10 +92,10 @@ class ScenarioConfig {
    * @returns {this}
    */
   tag(tagName) {
-    if (tagName[0] !== '@') tagName = `@${tagName}`;
-    this.test.tags.push(tagName);
-    this.test.title = `${this.test.title.trim()} ${tagName}`;
-    return this;
+    if (tagName[0] !== '@') tagName = `@${tagName}`
+    this.test.tags.push(tagName)
+    this.test.title = `${this.test.title.trim()} ${tagName}`
+    return this
   }
 
   /**
@@ -105,10 +105,10 @@ class ScenarioConfig {
    */
   injectDependencies(dependencies) {
     Object.keys(dependencies).forEach((key) => {
-      this.test.inject[key] = dependencies[key];
-    });
-    return this;
+      this.test.inject[key] = dependencies[key]
+    })
+    return this
   }
 }
 
-module.exports = ScenarioConfig;
+module.exports = ScenarioConfig

package/lib/listener/artifacts.js

@@ -1,19 +1,19 @@
-const event = require('../event');
-const recorder = require('../recorder');
+const event = require('../event')
+const recorder = require('../recorder')
 
 /**
  * Create and clean up empty artifacts
  */
 module.exports = function () {
   event.dispatcher.on(event.test.before, (test) => {
-    test.artifacts = {};
-  });
+    test.artifacts = {}
+  })
 
   event.dispatcher.on(event.test.after, (test) => {
     recorder.add('clean up empty artifacts', () => {
-      for (const key in (test.artifacts || {})) {
-        if (!test.artifacts[key]) delete test.artifacts[key];
+      for (const key in test.artifacts || {}) {
+        if (!test.artifacts[key]) delete test.artifacts[key]
       }
-    });
-  });
-};
+    })
+  })
+}

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`)
+  })
+}