codeceptjs 3.5.11 → 3.5.12-beta.2

package/docs/locators.md

@@ -163,12 +163,20 @@ locate('form').withDescendant('select');
 
 #### withText
 
-Finds element containing a text
+Find an element containing a text
 
 ```js
 locate('span').withText('Warning');
 ```
 
+#### withTextEquals
+
+Find an element with exact text
+
+```js
+locate('button').withTextEquals('Add');
+```
+
 #### first
 
 Get first element:

package/docs/webapi/waitForNumberOfTabs.mustache

@@ -0,0 +1,9 @@
+Waits for number of tabs.
+
+```js
+I.waitForNumberOfTabs(2);
+```
+
+@param {number} expectedTabs expecting the number of tabs.
+@param {number} sec number of secs to wait.
+@returns {void} automatically synchronized promise through #recorder

package/docs/webdriver.md

@@ -7,11 +7,11 @@ title: Testing with WebDriver
 
 How does your client, manager, or tester, or any other non-technical person, know your web application is working? By opening the browser, accessing a site, clicking on links, filling in the forms, and actually seeing the content on a web page.
 
-End to End tests can cover standard but complex scenarios from a user's perspective. With e2e tests you can be confident that users, following all defined scenarios, won't get errors. We check **functionality of application and a user interface** (UI) as well.
+End-to-End tests can cover standard but complex scenarios from a user's perspective. With e2e tests you can be confident that users, following all defined scenarios, won't get errors. We check **functionality of application and a user interface** (UI) as well.
 
 ## What is Selenium WebDriver
 
-The standard and proved way to run browser test automation over years is Selenium WebDriver. Over years this technology was standartized and works over all popular browsers and operating systems. There are cloud services like SauceLabs or BrowserStack which allow executing such browsers in the cloud. The superset of WebDriver protocol is also used to test [native and hybrid mobile applications](/mobile).
+The standard and proved way to run browser test automation over years is Selenium WebDriver. Over years this technology was standardized and works over all popular browsers and operating systems. There are cloud services like SauceLabs or BrowserStack which allow executing such browsers in the cloud. The superset of WebDriver protocol is also used to test [native and hybrid mobile applications](/mobile).
 
 Let's clarify the terms:
 
@@ -53,14 +53,60 @@ exports.config = {
 
 > ⚠ It is not recommended to use wdio plugin & selenium-standalone when running tests in parallel. Consider **switching to Selenoid** if you need parallel run or using cloud services.
 
+🛩️ With the release of WebdriverIO version v8.14.0, and onwards, all driver management hassles are now a thing of the past 🙌. Read more [here](https://webdriver.io/blog/2023/07/31/driver-management/).
+One of the significant advantages of this update is that you can now get rid of any driver services you previously had to manage, such as
+`wdio-chromedriver-service`, `wdio-geckodriver-service`, `wdio-edgedriver-service`, `wdio-safaridriver-service`, and even `@wdio/selenium-standalone-service`.
+
+For those who require custom driver options, fear not; WebDriver Helper allows you to pass in driver options through custom WebDriver configuration.
+If you have a custom grid, use a cloud service, or prefer to run your own driver, there's no need to worry since WebDriver Helper will only start a driver when there are no other connection information settings like hostname or port specified.
+
+Example:
+
+```js
+{
+   helpers: {
+     WebDriver : {
+       smartWait: 5000,
+       browser: "chrome",
+       restart: false,
+       windowSize: "maximize",
+       timeouts: {
+         "script": 60000,
+         "page load": 10000
+       }
+     }
+   }
+}
+```
+
+Testing Chrome locally is now more convenient than ever. You can define a browser channel, and WebDriver Helper will take care of downloading the specified browser version for you.
+For example:
+
+```js
+{
+   helpers: {
+     WebDriver : {
+       smartWait: 5000,
+       browser: "chrome",
+       browserVersion: '116.0.5793.0', // or 'stable', 'beta', 'dev' or 'canary'
+       restart: false,
+       windowSize: "maximize",
+       timeouts: {
+         "script": 60000,
+         "page load": 10000
+       }
+     }
+   }
+}
+```
 
 ## Configuring WebDriver
 
 WebDriver can be configured to run browser tests in window, headlessly, on a remote server or in a cloud.
 
-> By default CodeceptJS is already configured to run WebDriver tests locally with Chrome or Firefox. If you just need to start running tests - proceed to the next chapter.
+> By default, CodeceptJS is already configured to run WebDriver tests locally with Chrome or Firefox. If you just need to start running tests - proceed to the next chapter.
 
-Configuration for WebDriver should be provided inside `codecept.conf.js` file under `helpers: WebDriver` section:
+Configuration for WebDriver should be provided inside `codecept.conf.(js|ts)` file under `helpers: WebDriver` section:
 
 ```js
   helpers: {
@@ -80,7 +126,7 @@ Configuration for WebDriver should be provided inside `codecept.conf.js` file un
   }
 ```
 
-By default CodeceptJS runs tests in the same browser window but clears cookies and local storage after each test. This behavior can be changed with these options:
+By default, CodeceptJS runs tests in the same browser window but clears cookies and local storage after each test. This behavior can be changed with these options:
 
 ```js
 // change to true to restart browser between tests
@@ -152,7 +198,7 @@ desiredCapabilities: {
 
 WebDriver protocol works over HTTP, so you need to have a Selenium Server to be running or any other service that will launch a browser for you. That's why you may need to specify `host`, `port`, `protocol`, and `path` parameters.
 
-By default, those parameters are set to connect to local Selenium Server but they should be changed if you want to run tests via [Cloud Providers](/helpers/WebDriver#cloud-providers). You may also need `user` and `key` parameters to authenticate on cloud service.
+By default, those parameters are set to connect to local Selenium Server, but they should be changed if you want to run tests via [Cloud Providers](/helpers/WebDriver#cloud-providers). You may also need `user` and `key` parameters to authenticate on cloud service.
 
 There are also [browser and platform specific capabilities](https://github.com/SeleniumHQ/selenium/wiki/DesiredCapabilities). Services like SauceLabs, BrowserStack or browser vendors can provide their own specific capabilities for more tuning.
 

package/lib/command/run-multiple.js

@@ -28,7 +28,9 @@ let processesDone;
 
 module.exports = async function (selectedRuns, options) {
   // registering options globally to use in config
-  process.env.profile = options.profile;
+  if (options.profile) {
+    process.env.profile = options.profile;
+  }
   const configFile = options.config;
 
   const testRoot = getTestRoot(configFile);

package/lib/command/run-workers.js

@@ -11,6 +11,7 @@ module.exports = async function (workerCount, selectedRuns, options) {
   const passedTestArr = [];
   const failedTestArr = [];
   const skippedTestArr = [];
+  const stepArr = [];
 
   const { config: testConfig, override = '' } = options;
   const overrideConfigs = tryOrDefault(() => JSON.parse(override), {});
@@ -36,6 +37,14 @@ module.exports = async function (workerCount, selectedRuns, options) {
     suiteArr.push(suite);
   });
 
+  workers.on(event.step.passed, (step) => {
+    stepArr.push(step);
+  });
+
+  workers.on(event.step.failed, (step) => {
+    stepArr.push(step);
+  });
+
   workers.on(event.test.failed, (test) => {
     failedTestArr.push(test);
     output.test.failed(test);
@@ -48,11 +57,33 @@ module.exports = async function (workerCount, selectedRuns, options) {
 
   workers.on(event.test.skipped, (test) => {
     skippedTestArr.push(test);
-    output.test.passed(test);
+    output.test.skipped(test);
   });
 
   workers.on(event.all.result, () => {
     // expose test stats after all workers finished their execution
+    function addStepsToTest(test, stepArr) {
+      stepArr.test.steps.forEach(step => {
+        if (test.steps.length === 0) {
+          test.steps.push(step);
+        }
+      });
+    }
+
+    stepArr.forEach(step => {
+      passedTestArr.forEach(test => {
+        if (step.test.title === test.title) {
+          addStepsToTest(test, step);
+        }
+      });
+
+      failedTestArr.forEach(test => {
+        if (step.test.title === test.title) {
+          addStepsToTest(test, step);
+        }
+      });
+    });
+
     event.dispatcher.emit(event.workers.result, {
       suites: suiteArr,
       tests: {

package/lib/command/workers/runTests.js

@@ -132,7 +132,7 @@ function initializeListeners() {
       duration: test.duration || 0,
       err,
       parent,
-      steps: test.steps ? simplifyStepsInTestObject(test.steps, err) : [],
+      steps: test.steps && test.steps.length > 0 ? simplifyStepsInTestObject(test.steps, err) : [],
     };
   }
 
@@ -161,7 +161,7 @@ function initializeListeners() {
         actor: step.actor,
         name: step.name,
         status: step.status,
-        agrs: _args,
+        args: _args,
         startedAt: step.startedAt,
         startTime: step.startTime,
         endTime: step.endTime,

package/lib/css2xpath/js/css_to_xpath.js

@@ -0,0 +1,20 @@
+(function() {
+    var self = this;
+    var parser, xpathBuilder, Expression, parse, convertToXpath;
+    parser = require("bo-selector").parser;
+    xpathBuilder = require("xpath-builder").dsl();
+    Expression = require("./expression");
+    parser.yy.create = function(data) {
+        var self = this;
+        return new Expression(data);
+    };
+    parse = function(selector) {
+        return parser.parse(selector).render(xpathBuilder, "descendant");
+    };
+    convertToXpath = function(selector) {
+        return parse(selector).toXPath();
+    };
+    convertToXpath.parse = parse;
+    convertToXpath.xPathBuilder = xpathBuilder;
+    module.exports = convertToXpath;
+}).call(this);

package/lib/css2xpath/js/expression.js

@@ -0,0 +1,23 @@
+(function() {
+    var self = this;
+    var Renderer, Expression, extend;
+    Renderer = require("./renderer");
+    Expression = function(data) {
+        extend(this, data);
+        return this;
+    };
+    Expression.prototype.render = function(xpath, combinator) {
+        var self = this;
+        return new Renderer().render(self, xpath, combinator);
+    };
+    extend = function(o, d) {
+        var k;
+        for (k in d) {
+            (function(k) {
+                o[k] = d[k];
+            })(k);
+        }
+        return void 0;
+    };
+    module.exports = Expression;
+}).call(this);

package/lib/css2xpath/js/renderer.js

@@ -0,0 +1,239 @@
+(function() {
+    var self = this;
+    var xpathBuilder, Renderer;
+    xpathBuilder = require("xpath-builder").dsl();
+    Renderer = function() {
+        return this;
+    };
+    Renderer.prototype = {
+        render: function(node, xpath, combinator) {
+            var self = this;
+            var fn;
+            fn = self[node.type];
+            if (!fn) {
+                throw new Error("No renderer for '" + node.type + "'");
+            }
+            return fn.call(self, node, xpath, combinator);
+        },
+        selector_list: function(node, xpath, combinator) {
+            var self = this;
+            var x, i;
+            x = self.render(node.selectors[0], xpath, combinator);
+            for (i = 1; i < node.selectors.length; ++i) {
+                x = x.union(self.render(node.selectors[i], xpath, combinator));
+            }
+            return x;
+        },
+        constraint_list: function(node, xpath, combinator) {
+            var self = this;
+            return self.element(node, xpath, combinator);
+        },
+        element: function(node, xpath, combinator) {
+            var self = this;
+            return self.applyConstraints(node, xpath[combinator].call(xpath, node.name || "*"));
+        },
+        combinator_selector: function(node, xpath, combinator) {
+            var self = this;
+            var left;
+            left = self.render(node.left, xpath, combinator);
+            return self.render(node.right, left, node.combinator);
+        },
+        immediate_child: function(node, xpath) {
+            var self = this;
+            return self.render(node.child, xpath, "child");
+        },
+        pseudo_func: function(node, xpath) {
+            var self = this;
+            var fn;
+            fn = self[node.func.name.replace(/-/g, "_")];
+            if (fn) {
+                return fn.call(self, node, xpath);
+            } else {
+                throw new Error("Unsupported pseudo function :" + node.func.name + "()");
+            }
+        },
+        pseudo_class: function(node, xpath) {
+            var self = this;
+            var fn;
+            fn = self[node.name.replace(/-/g, "_")];
+            if (fn) {
+                return fn.call(self, node, xpath);
+            } else {
+                throw new Error("Unsupported pseudo class :" + node.name);
+            }
+        },
+        has: function(node, xpath) {
+            var self = this;
+            return self.render(node.func.args, xpathBuilder, "descendant");
+        },
+        not: function(node, xpath) {
+            var self = this;
+            var firstChild, childType;
+            firstChild = node.func.args.selectors[0];
+            childType = firstChild.type;
+            if (childType === "constraint_list") {
+                return self.combineConstraints(firstChild, xpath).inverse();
+            } else {
+                return self.matchesSelectorList(node.func.args, xpath).inverse();
+            }
+        },
+        nth_child: function(node, xpath) {
+            var self = this;
+            return xpath.nthChild(Number(node.func.args));
+        },
+        first_child: function(node, xpath) {
+            var self = this;
+            return xpath.firstChild();
+        },
+        last_child: function(node, xpath) {
+            var self = this;
+            return xpath.lastChild();
+        },
+        nth_last_child: function(node, xpath) {
+            var self = this;
+            return xpath.nthLastChild(Number(node.func.args));
+        },
+        only_child: function(node, xpath) {
+            var self = this;
+            return xpath.onlyChild();
+        },
+        only_of_type: function(node, xpath) {
+            var self = this;
+            return xpath.onlyOfType();
+        },
+        nth_of_type: function(node, xpath) {
+            var self = this;
+            var type;
+            type = node.func.args.type;
+            if (type === "odd") {
+                return xpath.nthOfTypeOdd();
+            } else if (type === "even") {
+                return xpath.nthOfTypeEven();
+            } else if (type === "an") {
+                return xpath.nthOfTypeMod(Number(node.func.args.a));
+            } else if (type === "n_plus_b") {
+                return xpath.nthOfTypeMod(1, Number(node.func.args.b));
+            } else if (type === "an_plus_b") {
+                return xpath.nthOfTypeMod(Number(node.func.args.a), Number(node.func.args.b));
+            } else {
+                return xpath.nthOfType(Number(node.func.args));
+            }
+        },
+        nth_last_of_type: function(node, xpath) {
+            var self = this;
+            var type;
+            type = node.func.args.type;
+            if (type === "odd") {
+                return xpath.nthLastOfTypeOdd();
+            } else if (type === "even") {
+                return xpath.nthLastOfTypeEven();
+            } else if (type === "an") {
+                return xpath.nthLastOfTypeMod(Number(node.func.args.a));
+            } else if (type === "n_plus_b") {
+                return xpath.nthLastOfTypeMod(1, Number(node.func.args.b));
+            } else if (type === "an_plus_b") {
+                return xpath.nthLastOfTypeMod(Number(node.func.args.a), Number(node.func.args.b));
+            } else {
+                return xpath.nthLastOfType(Number(node.func.args));
+            }
+        },
+        last_of_type: function(node, xpath) {
+            var self = this;
+            return xpath.lastOfType();
+        },
+        empty: function(node, xpath) {
+            var self = this;
+            return xpath.empty();
+        },
+        has_attribute: function(node, xpath) {
+            var self = this;
+            return xpathBuilder.attr(node.name);
+        },
+        attribute_equals: function(node, xpath) {
+            var self = this;
+            return xpathBuilder.attr(node.name).equals(node.value);
+        },
+        attribute_contains: function(node, xpath) {
+            var self = this;
+            return xpathBuilder.attr(node.name).contains(node.value);
+        },
+        attribute_contains_word: function(node, xpath) {
+            var self = this;
+            return xpath.concat(" ", xpathBuilder.attr(node.name).normalize(), " ").contains(" " + node.value + " ");
+        },
+        attribute_contains_prefix: function(node) {
+            var self = this;
+            return xpathBuilder.attr(node.name).startsWith(node.value).or(xpathBuilder.attr(node.name).startsWith(node.value + "-"));
+        },
+        attribute_starts_with: function(node, xpath) {
+            var self = this;
+            return xpathBuilder.attr(node.name).startsWith(node.value);
+        },
+        attribute_ends_with: function(node) {
+            var self = this;
+            return xpathBuilder.attr(node.name).endsWith(node.value);
+        },
+        "class": function(node) {
+            var self = this;
+            return self.attribute_contains_word({
+                name: "class",
+                value: node.name
+            }, xpathBuilder);
+        },
+        id: function(node) {
+            var self = this;
+            return xpathBuilder.attr("id").equals(node.name);
+        },
+        previous_sibling: function(node, xpath, combinator) {
+            var self = this;
+            var left;
+            left = self.render(node.left, xpath, combinator);
+            return self.applyConstraints(node.right, left.axis("following-sibling", node.right.name));
+        },
+        adjacent_sibling: function(node, xpath, combinator) {
+            var self = this;
+            var left;
+            left = self.render(node.left, xpath, combinator);
+            return self.applyConstraints(node.right, left.axis("following-sibling::*[1]/self", node.right.name));
+        },
+        first_of_type: function(node, xpath) {
+            var self = this;
+            return xpath.firstOfType();
+        },
+        matchesSelectorList: function(node, xpath) {
+            var self = this;
+            var condition, i;
+            if (node.selectors.length > 0) {
+                condition = self.matchesSelector(node.selectors[0], xpathBuilder);
+                for (i = 1; i < node.selectors.length; ++i) {
+                    condition = condition.or(self.matchesSelector(node.selectors[i], xpathBuilder));
+                }
+                return condition;
+            } else {
+                return xpath;
+            }
+        },
+        matchesSelector: function(node, xpath) {
+            var self = this;
+            return xpath.name().equals(node.name);
+        },
+        combineConstraints: function(node, xpath) {
+            var self = this;
+            var condition, i;
+            condition = self.render(node.constraints[0], xpath);
+            for (i = 1; i < node.constraints.length; ++i) {
+                condition = condition.and(self.render(node.constraints[i], condition));
+            }
+            return condition;
+        },
+        applyConstraints: function(node, xpath) {
+            var self = this;
+            if (node.constraints.length > 0) {
+                return xpath.where(self.combineConstraints(node, xpath));
+            } else {
+                return xpath;
+            }
+        }
+    };
+    module.exports = Renderer;
+}).call(this);

package/lib/helper/Playwright.js

@@ -517,8 +517,9 @@ class Playwright extends Helper {
       if (this.options.userAgent) contextOptions.userAgent = this.options.userAgent;
       if (this.options.locale) contextOptions.locale = this.options.locale;
       if (this.options.colorScheme) contextOptions.colorScheme = this.options.colorScheme;
+      this.contextOptions = contextOptions;
       if (!this.browserContext || !restartsSession()) {
-        this.browserContext = await this.browser.newContext(contextOptions); // Adding the HTTPSError ignore in the context so that we can ignore those errors
+        this.browserContext = await this.browser.newContext(this.contextOptions); // Adding the HTTPSError ignore in the context so that we can ignore those errors
       }
     }
 
@@ -606,7 +607,7 @@ class Playwright extends Helper {
           page = await browser.firstWindow();
         } else {
           try {
-            browserContext = await this.browser.newContext(Object.assign(this.options, config));
+            browserContext = await this.browser.newContext(Object.assign(this.contextOptions, config));
             page = await browserContext.newPage();
           } catch (e) {
             if (this.playwrightOptions.userDataDir) {
@@ -2583,6 +2584,24 @@ class Playwright extends Helper {
     });
   }
 
+  /**
+   * {{> waitForNumberOfTabs }}
+   */
+  async waitForNumberOfTabs(expectedTabs, sec) {
+    const waitTimeout = sec ? sec * 1000 : this.options.waitForTimeout;
+    let currentTabs;
+    let count = 0;
+
+    do {
+      currentTabs = await this.grabNumberOfOpenTabs();
+      await this.wait(1);
+      count += 1000;
+      if (currentTabs >= expectedTabs) return;
+    } while (count <= waitTimeout);
+
+    throw new Error(`Expected ${expectedTabs} tabs are not met after ${waitTimeout / 1000} sec.`);
+  }
+
   async _getContext() {
     if (this.context && this.context.constructor.name === 'FrameLocator') {
       return this.context;

package/lib/helper/Puppeteer.js

@@ -2151,6 +2151,24 @@ class Puppeteer extends Helper {
     });
   }
 
+  /**
+   * {{> waitForNumberOfTabs }}
+   */
+  async waitForNumberOfTabs(expectedTabs, sec) {
+    const waitTimeout = sec ? sec * 1000 : this.options.waitForTimeout;
+    let currentTabs;
+    let count = 0;
+
+    do {
+      currentTabs = await this.grabNumberOfOpenTabs();
+      await this.wait(1);
+      count += 1000;
+      if (currentTabs >= expectedTabs) return;
+    } while (count <= waitTimeout);
+
+    throw new Error(`Expected ${expectedTabs} tabs are not met after ${waitTimeout / 1000} sec.`);
+  }
+
   async _getContext() {
     if (this.context && this.context.constructor.name === 'Frame') {
       return this.context;