codeceptjs 3.0.3 → 3.0.7

package/lib/helper/WebDriver.js

@@ -396,6 +396,7 @@ class WebDriver extends Helper {
     this.isRunning = false;
     this.sessionWindows = {};
     this.activeSessionName = '';
+    this.customLocatorStrategies = config.customLocatorStrategies;
 
     this._setConfig(config);
 
@@ -503,6 +504,33 @@ class WebDriver extends Helper {
     }
   }
 
+  _lookupCustomLocator(customStrategy) {
+    if (typeof (this.customLocatorStrategies) !== 'object') {
+      return null;
+    }
+    const strategy = this.customLocatorStrategies[customStrategy];
+    return typeof (strategy) === 'function' ? strategy : null;
+  }
+
+  _isCustomLocator(locator) {
+    const locatorObj = new Locator(locator);
+    if (locatorObj.isCustom()) {
+      const customLocator = this._lookupCustomLocator(locatorObj.type);
+      if (customLocator) {
+        return true;
+      }
+      throw new Error('Please define "customLocatorStrategies" as an Object and the Locator Strategy as a "function".');
+    }
+    return false;
+  }
+
+  async _res(locator) {
+    const res = (this._isShadowLocator(locator) || this._isCustomLocator(locator))
+      ? await this._locate(locator)
+      : await this.$$(withStrictLocator(locator));
+    return res;
+  }
+
   async _startBrowser() {
     try {
       if (this.options.multiremote) {
@@ -530,9 +558,22 @@ class WebDriver extends Helper {
     await this._resizeWindowIfNeeded(this.browser, this.options.windowSize);
 
     this.$$ = this.browser.$$.bind(this.browser);
+
+    if (this._isCustomLocatorStrategyDefined()) {
+      Object.keys(this.customLocatorStrategies).forEach(async (customLocator) => {
+        this.debugSection('Weddriver', `adding custom locator strategy: ${customLocator}`);
+        const locatorFunction = this._lookupCustomLocator(customLocator);
+        this.browser.addLocatorStrategy(customLocator, locatorFunction);
+      });
+    }
+
     return this.browser;
   }
 
+  _isCustomLocatorStrategyDefined() {
+    return this.customLocatorStrategies && Object.keys(this.customLocatorStrategies).length;
+  }
+
   async _stopBrowser() {
     if (this.browser && this.isRunning) await this.browser.deleteSession();
   }
@@ -718,7 +759,7 @@ class WebDriver extends Helper {
    * @param {object} locator
    */
   async _smartWait(locator) {
-    this.debugSection(`SmartWait (${this.options.smartWait}ms)`, `Locating ${locator} in ${this.options.smartWait}`);
+    this.debugSection(`SmartWait (${this.options.smartWait}ms)`, `Locating ${JSON.stringify(locator)} in ${this.options.smartWait}`);
     await this.defineTimeout({ implicit: this.options.smartWait });
   }
 
@@ -755,17 +796,34 @@ class WebDriver extends Helper {
     }
 
     if (!this.options.smartWait || !smartWait) {
+      if (this._isCustomLocator(locator)) {
+        const locatorObj = new Locator(locator);
+        return this.browser.custom$$(locatorObj.type, locatorObj.value);
+      }
+
       const els = await this.$$(withStrictLocator(locator));
       return els;
     }
 
     await this._smartWait(locator);
 
+    if (this._isCustomLocator(locator)) {
+      const locatorObj = new Locator(locator);
+      return this.browser.custom$$(locatorObj.type, locatorObj.value);
+    }
+
     const els = await this.$$(withStrictLocator(locator));
     await this.defineTimeout({ implicit: 0 });
     return els;
   }
 
+  _grabCustomLocator(locator) {
+    if (typeof locator === 'string') {
+      locator = new Locator(locator);
+    }
+    return locator.value ? locator.value : locator.custom;
+  }
+
   /**
    * Find a checkbox by providing human readable text:
    *
@@ -962,6 +1020,7 @@ class WebDriver extends Helper {
   /**
    * {{> fillField }}
    * {{ react }}
+   * {{ custom }}
    *
    */
   async fillField(field, value) {
@@ -1335,7 +1394,7 @@ class WebDriver extends Helper {
    *
    */
   async seeElementInDOM(locator) {
-    const res = await this.$$(withStrictLocator(locator));
+    const res = await this._res(locator);
     return empty('elements').negate(res);
   }
 
@@ -1344,7 +1403,7 @@ class WebDriver extends Helper {
    *
    */
   async dontSeeElementInDOM(locator) {
-    const res = await this.$$(withStrictLocator(locator));
+    const res = await this._res(locator);
     return empty('elements').assert(res);
   }
 
@@ -1370,7 +1429,7 @@ class WebDriver extends Helper {
    */
   async grabBrowserLogs() {
     if (this.browser.isW3C) {
-      this.debug('Logs not awailable in W3C specification');
+      this.debug('Logs not available in W3C specification');
       return;
     }
     return this.browser.getLogs('browser');
@@ -1991,7 +2050,7 @@ class WebDriver extends Helper {
       }, aSec * 1000, `element (${new Locator(locator)}) still not enabled after ${aSec} sec`);
     }
     return this.browser.waitUntil(async () => {
-      const res = await this.$$(withStrictLocator(locator));
+      const res = await this._res(locator);
       if (!res || res.length === 0) {
         return false;
       }
@@ -2018,7 +2077,7 @@ class WebDriver extends Helper {
       }, aSec * 1000, `element (${locator}) still not present on page after ${aSec} sec`);
     }
     return this.browser.waitUntil(async () => {
-      const res = await this.$$(withStrictLocator(locator));
+      const res = await this._res(locator);
       return res && res.length;
     }, { timeout: aSec * 1000, timeoutMsg: `element (${locator}) still not present on page after ${aSec} sec` });
   }
@@ -2188,9 +2247,7 @@ class WebDriver extends Helper {
       }, aSec * 1000, `element (${new Locator(locator)}) still not visible after ${aSec} sec`);
     }
     return this.browser.waitUntil(async () => {
-      const res = (this._isShadowLocator(locator))
-        ? await this._locate(withStrictLocator(locator))
-        : await this.$$(withStrictLocator(locator));
+      const res = await this._res(locator);
       if (!res || res.length === 0) return false;
       const selected = await forEachAsync(res, async el => el.isDisplayed());
       if (Array.isArray(selected)) {
@@ -2217,7 +2274,7 @@ class WebDriver extends Helper {
       }, aSec * 1000, `The number of elements (${new Locator(locator)}) is not ${num} after ${aSec} sec`);
     }
     return this.browser.waitUntil(async () => {
-      const res = await this.$$(withStrictLocator(locator));
+      const res = await this._res(locator);
       if (!res || res.length === 0) return false;
       let selected = await forEachAsync(res, async el => el.isDisplayed());
 
@@ -2241,7 +2298,7 @@ class WebDriver extends Helper {
       }, aSec * 1000, `element (${new Locator(locator)}) still visible after ${aSec} sec`);
     }
     return this.browser.waitUntil(async () => {
-      const res = await this.$$(withStrictLocator(locator));
+      const res = await this._res(locator);
       if (!res || res.length === 0) return true;
       const selected = await forEachAsync(res, async el => el.isDisplayed());
       return !selected.length;
@@ -2262,7 +2319,7 @@ class WebDriver extends Helper {
     const aSec = sec || this.options.waitForTimeout;
     if (isWebDriver5()) {
       return this.browser.waitUntil(async () => {
-        const res = await this.$$(withStrictLocator(locator));
+        const res = await this._res(locator);
         if (!res || res.length === 0) {
           return true;
         }
@@ -2270,7 +2327,7 @@ class WebDriver extends Helper {
       }, aSec * 1000, `element (${new Locator(locator)}) still on page after ${aSec} sec`);
     }
     return this.browser.waitUntil(async () => {
-      const res = await this.$$(withStrictLocator(locator));
+      const res = await this._res(locator);
       if (!res || res.length === 0) {
         return true;
       }
@@ -2543,12 +2600,9 @@ async function proceedSee(assertType, text, context, strict = false) {
   }
 
   const smartWaitEnabled = assertType === 'assert';
-
   const res = await this._locate(withStrictLocator(context), smartWaitEnabled);
   assertElementExists(res, context);
-
   const selected = await forEachAsync(res, async el => this.browser.getElementText(getElementId(el)));
-
   if (strict) {
     if (Array.isArray(selected) && selected.length !== 0) {
       return selected.map(elText => equals(description)[assertType](text, elText));
@@ -2616,6 +2670,11 @@ async function filterAsync(array, callback) {
 
 async function findClickable(locator, locateFn) {
   locator = new Locator(locator);
+
+  if (this._isCustomLocator(locator)) {
+    return locateFn(locator.value);
+  }
+
   if (locator.isAccessibilityId() && !this.isWeb) return locateFn(locator, true);
   if (!locator.isFuzzy()) return locateFn(locator, true);
 
@@ -2637,6 +2696,10 @@ async function findClickable(locator, locateFn) {
 async function findFields(locator) {
   locator = new Locator(locator);
 
+  if (this._isCustomLocator(locator)) {
+    return this._locate(locator);
+  }
+
   if (locator.isAccessibilityId() && !this.isWeb) return this._locate(locator, true);
   if (!locator.isFuzzy()) return this._locate(locator, true);
 
@@ -2742,6 +2805,10 @@ async function findCheckable(locator, locateFn) {
   let els;
   locator = new Locator(locator);
 
+  if (this._isCustomLocator(locator)) {
+    return locateFn(locator.value);
+  }
+
   if (locator.isAccessibilityId() && !this.isWeb) return locateFn(locator, true);
   if (!locator.isFuzzy()) return locateFn(locator, true);
 
@@ -2787,6 +2854,7 @@ function getElementId(el) {
   if (el.ELEMENT) {
     return el.ELEMENT;
   }
+
   return null;
 }
 

package/lib/interfaces/gherkin.js

@@ -6,6 +6,7 @@ const event = require('../event');
 const scenario = require('../scenario');
 const Step = require('../step');
 const DataTableArgument = require('../data/dataTableArgument');
+const transform = require('../transform');
 
 const parser = new Parser();
 parser.stopAtFirstError = false;
@@ -31,7 +32,13 @@ module.exports = (text) => {
       const metaStep = new Step.MetaStep(null, step.text);
       metaStep.actor = step.keyword.trim();
       const setMetaStep = (step) => {
-        if (step.metaStep) step = step.metaStep; // assign metastep to metastep for nested steps
+        if (step.metaStep) {
+          if (step.metaStep === metaStep) {
+            return;
+          }
+          setMetaStep(step.metaStep);
+          return;
+        }
         step.metaStep = metaStep;
       };
       const fn = matchStep(step.text);
@@ -46,14 +53,14 @@ module.exports = (text) => {
       step.startTime = Date.now();
       step.match = fn.line;
       event.emit(event.bddStep.before, step);
-      event.dispatcher.on(event.step.before, setMetaStep);
+      event.dispatcher.prependListener(event.step.before, setMetaStep);
       try {
         await fn(...fn.params);
         step.status = 'passed';
       } catch (err) {
         step.status = 'failed';
         step.err = err;
-        return err;
+        throw err;
       } finally {
         step.endTime = Date.now();
         event.dispatcher.removeListener(event.step.before, setMetaStep);
@@ -75,7 +82,7 @@ module.exports = (text) => {
           const current = {};
           for (const index in example.cells) {
             const placeholder = fields[index];
-            const value = example.cells[index].value;
+            const value = transform('gherkin.examples', example.cells[index].value);
             current[placeholder] = value;
             exampleSteps = exampleSteps.map((step) => {
               step = { ...step };

package/lib/output.js

@@ -39,12 +39,12 @@ module.exports = {
   /**
    * Print information for a process
    * Used in multiple-run
-   * @param {string} process
+   * @param {string | null} process
    * @returns {string}
    */
   process(process) {
     if (process === null) return outputProcess = '';
-    if (process) outputProcess = `[${process}]`;
+    if (process) outputProcess = String(process).length === 1 ? `[0${process}]` : `[${process}]`;
     return outputProcess;
   },
 
@@ -102,14 +102,14 @@ module.exports = {
     if (!step) return;
     // Avoid to print non-gherkin steps, when gherkin is running for --steps mode
     if (outputLevel === 1) {
-      if (!step.isMetaStep() && step.hasBDDAncestor()) {
+      if (step.hasBDDAncestor()) {
         return;
       }
     }
 
     let stepLine = step.toString();
     if (step.metaStep && outputLevel >= 1) {
-      this.stepShift += 2;
+      // this.stepShift += 2;
       stepLine = colors.green(truncate(stepLine, this.spaceShift));
     }
     if (step.comment) {
@@ -190,6 +190,9 @@ module.exports = {
    * @param {string} [color]
    */
   say(message, color = 'cyan') {
+    if (colors[color] === undefined) {
+      color = 'cyan';
+    }
     if (outputLevel >= 1) print(`   ${colors[color].bold(message)}`);
   },
 

package/lib/plugin/allure.js

@@ -261,13 +261,9 @@ module.exports = (config) => {
     if (isHookSteps === false) {
       startMetaStep(step.metaStep);
       if (currentStep !== step) {
-        // The reason we need to do this cause
-        // the step actor contains this and hence
-        // the allure reporter could not parse and
-        // generate the report
-        if (step.actor.includes('\u001b[36m')) {
-          step.actor = step.actor.replace('\u001b[36m', '').replace('\u001b[39m', '');
-        }
+        // In multi-session scenarios, actors' names will be highlighted with ANSI
+        // escape sequences which are invalid XML values
+        step.actor = step.actor.replace(ansiRegExp(), '');
         reporter.startStep(step.toString());
         currentStep = step;
       }

package/lib/plugin/fakerTransform.js

@@ -0,0 +1,51 @@
+const faker = require('faker');
+const transform = require('../transform');
+
+/**
+ * Use the [faker.js](https://www.npmjs.com/package/faker) package to generate fake data inside examples on your gherkin tests
+ *
+ * ![Faker.js](https://raw.githubusercontent.com/Marak/faker.js/master/logo.png)
+ *
+ * #### Usage
+ *
+ * To start please install `faker.js` package
+ *
+ * ```
+ * npm install -D faker
+ * ```
+ *
+ * ```
+ * yarn add -D faker
+ * ```
+ *
+ * Add this plugin to config file:
+ *
+ * ```js
+ * plugins: {
+ *    fakerTransform: {
+ *      enabled: true
+ *    }
+ * }
+ * ```
+ *
+ * Add the faker API using a mustache string format inside examples tables in your gherkin scenario outline
+ *
+ * ```feature
+ * Scenario Outline: ...
+ *             Given ...
+ *              When ...
+ *              Then ...
+ *         Examples:
+ *   | productName          | customer              | email              | anythingMore |
+ *   | {{commerce.product}} | Dr. {{name.findName}} | {{internet.email}} | staticData   |
+ * ```
+ *
+ */
+module.exports = function (config) {
+  transform.addTransformerBeforeAll('gherkin.examples', (value) => {
+    if (typeof value === 'string' && value.length > 0) {
+      return faker.fake(value);
+    }
+    return value;
+  });
+};

package/lib/plugin/screenshotOnFail.js

@@ -99,8 +99,7 @@ module.exports = function (config) {
         await helper.saveScreenshot(fileName, options.fullPageScreenshots);
 
         test.artifacts.screenshot = path.join(global.output_dir, fileName);
-
-        if (Container.mocha().options.reporterOptions['mocha-junit-reporter'] && Container.mocha().options.reporterOptions['mocha-junit-reporter'].attachments) {
+        if (Container.mocha().options.reporterOptions['mocha-junit-reporter'] && Container.mocha().options.reporterOptions['mocha-junit-reporter'].options.attachments) {
           test.attachments = [path.join(global.output_dir, fileName)];
         }
 
@@ -108,6 +107,11 @@ module.exports = function (config) {
         if (allureReporter) {
           allureReporter.addAttachment('Last Seen Screenshot', fs.readFileSync(path.join(global.output_dir, fileName)), 'image/png');
         }
+
+        const cucumberReporter = Container.plugins('cucumberJsonReporter');
+        if (cucumberReporter) {
+          cucumberReporter.addScreenshot(test.artifacts.screenshot);
+        }
       } catch (err) {
         output.plugin(err);
         if (

package/lib/recorder.js

@@ -321,6 +321,15 @@ module.exports = {
     return tasks.join('\n');
   },
 
+  /**
+   * Get the queue id
+   * @return {number}
+   * @inner
+   */
+  getQueueId() {
+    return queueId;
+  },
+
   /**
    * Get a state of current queue and tasks
    * @return {string}

package/lib/step.js

@@ -208,9 +208,10 @@ class MetaStep extends Step {
     let result;
 
     const registerStep = (step) => {
+      this.metaStep = null;
       step.metaStep = this;
     };
-    event.dispatcher.on(event.step.before, registerStep);
+    event.dispatcher.prependListener(event.step.before, registerStep);
     try {
       this.startTime = Date.now();
       result = fn.apply(this.context, this.args);

package/lib/transform.js

@@ -0,0 +1,26 @@
+const transformers = {
+  'gherkin.examples': [],
+};
+
+function transform(target, value) {
+  if (target in transformers) {
+    for (const transform of transformers[target]) {
+      value = transform(value);
+    }
+  }
+  return value;
+}
+
+transform.addTransformer = function (target, transformer) {
+  if (target in transformers) {
+    transformers[target].push(transformer);
+  }
+};
+
+transform.addTransformerBeforeAll = function (target, transformer) {
+  if (target in transformers) {
+    transformers[target].unshift(transformer);
+  }
+};
+
+module.exports = transform;

package/lib/ui.js

@@ -176,8 +176,12 @@ module.exports = function (suite) {
      * @kind constant
      * @type {CodeceptJS.IScenario}
      */
-    context.xScenario = context.Scenario.skip = function (title) {
-      return context.Scenario(title, {});
+    context.xScenario = context.Scenario.skip = function (title, opts = {}, fn) {
+      if (typeof opts === 'function' && !fn) {
+        opts = {};
+      }
+
+      return context.Scenario(title, opts);
     };
 
     /**

package/lib/within.js

@@ -20,7 +20,7 @@ function within(context, fn) {
     const defineMetaStep = step => step.metaStep = metaStep;
     recorder.session.start('within');
 
-    event.dispatcher.on(event.step.before, defineMetaStep);
+    event.dispatcher.prependListener(event.step.before, defineMetaStep);
 
     Object.keys(helpers).forEach((helper) => {
       if (helpers[helper]._withinBegin) recorder.add(`[${helper}] start within`, () => helpers[helper]._withinBegin(context));

package/lib/workers.js

@@ -4,6 +4,7 @@ const path = require('path');
 const mkdirp = require('mkdirp');
 const { Worker } = require('worker_threads');
 const { Suite, Test, reporters: { Base } } = require('mocha');
+const ms = require('ms');
 const Codecept = require('./codecept');
 const MochaFactory = require('./mochaFactory');
 const Container = require('./container');
@@ -164,7 +165,7 @@ class Workers extends EventEmitter {
     super();
     this.setMaxListeners(50);
     this.codecept = initializeCodecept(config.testConfig, config.options);
-    this.finishedTests = {};
+    this.failuresLog = [];
     this.errors = [];
     this.numberOfWorkers = 0;
     this.closedWorkers = 0;
@@ -318,29 +319,45 @@ class Workers extends EventEmitter {
   _listenWorkerEvents(worker) {
     worker.on('message', (message) => {
       output.process(message.workerIndex);
+
+      // deal with events that are not test cycle related
+      if (!message.event) {
+        return this.emit('message', message);
+      }
+
       switch (message.event) {
+        case event.all.failures:
+          this.failuresLog = this.failuresLog.concat(message.data.failuresLog);
+          this._appendStats(message.data.stats);
+          break;
+        case event.suite.before:
+          this.emit(event.suite.before, repackTest(message.data));
+          break;
         case event.hook.failed:
           this.emit(event.hook.failed, repackTest(message.data));
           this.errors.push(message.data.err);
           break;
+        case event.test.before:
+          this.emit(event.test.before, repackTest(message.data));
+          break;
+        case event.test.started:
+          this.emit(event.test.started, repackTest(message.data));
+          break;
         case event.test.failed:
-          this._updateFinishedTests(repackTest(message.data));
           this.emit(event.test.failed, repackTest(message.data));
           break;
         case event.test.passed:
-          this._updateFinishedTests(repackTest(message.data));
           this.emit(event.test.passed, repackTest(message.data));
           break;
         case event.test.skipped:
-          this._updateFinishedTests(repackTest(message.data));
           this.emit(event.test.skipped, repackTest(message.data));
           break;
-        case event.test.finished: this.emit(event.test.finished, repackTest(message.data)); break;
+        case event.test.finished:
+          this.emit(event.test.finished, repackTest(message.data));
+          break;
         case event.test.after:
           this.emit(event.test.after, repackTest(message.data));
           break;
-        case event.all.after:
-          this._appendStats(message.data); break;
       }
     });
 
@@ -363,7 +380,8 @@ class Workers extends EventEmitter {
     } else {
       process.exitCode = 0;
     }
-    this.emit(event.all.result, !this.isFailed(), this.finishedTests, this.stats);
+    // removed this.finishedTests because in all /lib only first argument (!this.isFailed()) is used)
+    this.emit(event.all.result, !this.isFailed());
     this.emit('end'); // internal event
   }
 
@@ -374,30 +392,26 @@ class Workers extends EventEmitter {
     this.stats.pending += newStats.pending;
   }
 
-  _updateFinishedTests(test) {
-    const { id } = test;
-    if (this.finishedTests[id]) {
-      const stats = { passes: 0, failures: -1, tests: 0 };
-      this._appendStats(stats);
-    }
-    this.finishedTests[id] = test;
-  }
-
   printResults() {
     this.stats.end = new Date();
     this.stats.duration = this.stats.end - this.stats.start;
+
+    // Reset process for logs in main thread
+    output.process(null);
     output.print();
-    if (this.stats.tests === 0 || (this.stats.passes && !this.errors.length)) {
-      output.result(this.stats.passes, this.stats.failures, this.stats.pending, `${this.stats.duration || 0 / 1000}s`);
-    }
-    if (this.stats.failures) {
+
+    this.failuresLog = this.failuresLog
+      .filter(log => log.length && typeof log[1] === 'number')
+      // mocha/lib/reporters/base.js
+      .map(([format, num, title, message, stack], i) => [format, i + 1, title, message, stack]);
+
+    if (this.failuresLog.length) {
       output.print();
       output.print('-- FAILURES:');
-      const failedList = Object.keys(this.finishedTests)
-        .filter(key => this.finishedTests[key].err)
-        .map(key => this.finishedTests[key]);
-      Base.list(failedList);
+      this.failuresLog.forEach(log => output.print(...log));
     }
+
+    output.result(this.stats.passes, this.stats.failures, this.stats.pending, ms(this.stats.duration));
   }
 }