codeceptjs 3.6.6-beta.6 → 3.6.7

package/docs/webapi/grabNumberOfVisibleElements.mustache

@@ -3,9 +3,7 @@ Resumes test execution, so **should be used inside async function with `await`**
 
 ```js
 let numOfElements = await I.grabNumberOfVisibleElements('p');
-let numOfElementsWithWait = await I.grabNumberOfVisibleElements('p', 2); // timeout applied
 ```
 
 @param {CodeceptJS.LocatorOrString} locator located by CSS|XPath|strict locator.
-@param {number} [sec] (optional, `1` by default) time in seconds to wait
-@returns {Promise<number>} number of visible elements
+@returns {Promise<number>} number of visible elements

package/lib/cli.js

@@ -145,6 +145,7 @@ class Cli extends Base {
 
   result() {
     const stats = this.stats;
+    stats.failedHooks = 0;
     console.log();
 
     // passes
@@ -216,8 +217,14 @@ class Cli extends Base {
       console.log();
     }
 
+    this.failures.forEach((failure) => {
+      if (failure.constructor.name === 'Hook') {
+        stats.failures -= stats.failures
+        stats.failedHooks += 1
+      }
+    })
     event.emit(event.all.failures, { failuresLog, stats });
-    output.result(stats.passes, stats.failures, stats.pending, ms(stats.duration));
+    output.result(stats.passes, stats.failures, stats.pending, ms(stats.duration), stats.failedHooks);
 
     if (stats.failures && output.level() < 3) {
       output.print(output.styles.debug('Run with --verbose flag to see complete NodeJS stacktrace'));

package/lib/command/run-rerun.js

@@ -17,10 +17,6 @@ module.exports = async function (test, options) {
   const testRoot = getTestRoot(configFile)
   createOutputDir(config, testRoot)
 
-  function processError(err) {
-    printError(err)
-    process.exit(1)
-  }
   const codecept = new Codecept(config, options)
 
   try {

package/lib/command/workers/runTests.js

@@ -161,7 +161,7 @@ function initializeListeners() {
         actor: step.actor,
         name: step.name,
         status: step.status,
-        args: _args,
+        args: JSON.stringify(_args),
         startedAt: step.startedAt,
         startTime: step.startTime,
         endTime: step.endTime,
@@ -264,7 +264,10 @@ function collectStats() {
   event.dispatcher.on(event.test.passed, () => {
     stats.passes++;
   });
-  event.dispatcher.on(event.test.failed, () => {
+  event.dispatcher.on(event.test.failed, (test) => {
+    if (test.ctx._runnable.title.includes('hook: AfterSuite')) {
+      stats.failedHooks += 1;
+    }
     stats.failures++;
   });
   event.dispatcher.on(event.test.skipped, () => {

package/lib/helper/AI.js

@@ -74,7 +74,7 @@ class AI extends Helper {
     for (const chunk of htmlChunks) {
       const messages = [
         { role: gtpRole.user, content: prompt },
-        { role: gtpRole.user, content: `Within this HTML: ${minifyHtml(chunk)}` },
+        { role: gtpRole.user, content: `Within this HTML: ${await minifyHtml(chunk)}` },
       ]
 
       if (htmlChunks.length > 1)
@@ -110,7 +110,7 @@ class AI extends Helper {
 
     const messages = [
       { role: gtpRole.user, content: prompt },
-      { role: gtpRole.user, content: `Within this HTML: ${minifyHtml(html)}` },
+      { role: gtpRole.user, content: `Within this HTML: ${await minifyHtml(html)}` },
     ]
 
     const response = await this._processAIRequest(messages)

package/lib/helper/Playwright.js

@@ -24,7 +24,6 @@ const {
   clearString,
   requireWithFallback,
   normalizeSpacesInString,
-  promiseWithTimeout,
 } = require('../utils')
 const { isColorProperty, convertColorToRGBA } = require('../colorUtils')
 const ElementNotFound = require('./errors/ElementNotFound')
@@ -1852,19 +1851,10 @@ class Playwright extends Helper {
    * {{> grabNumberOfVisibleElements }}
    *
    */
-  async grabNumberOfVisibleElements(locator, sec) {
-    const waitTimeout = sec ? sec * 1000 : this.options.waitForTimeout
+  async grabNumberOfVisibleElements(locator) {
     let els = await this._locate(locator)
-
-    const visibilityChecks = els.map((el) => promiseWithTimeout(el.isVisible(), waitTimeout))
-
-    try {
-      els = await Promise.all(visibilityChecks)
-      return els.filter((v) => v).length
-    } catch (error) {
-      console.error(error)
-      return 0
-    }
+    els = await Promise.all(els.map((el) => el.isVisible()))
+    return els.filter((v) => v).length
   }
 
   /**

package/lib/helper/Puppeteer.js

@@ -28,7 +28,6 @@ const {
   isModifierKey,
   requireWithFallback,
   normalizeSpacesInString,
-  promiseWithTimeout,
 } = require('../utils')
 const { isColorProperty, convertColorToRGBA } = require('../colorUtils')
 const ElementNotFound = require('./errors/ElementNotFound')
@@ -1515,20 +1514,17 @@ class Puppeteer extends Helper {
    * {{> grabNumberOfVisibleElements }}
    * {{ react }}
    */
-  async grabNumberOfVisibleElements(locator, sec) {
-    const waitTimeout = sec ? sec * 1000 : this.options.waitForTimeout
+  async grabNumberOfVisibleElements(locator) {
     let els = await this._locate(locator)
-    els = (await Promise.all(els.map((el) => promiseWithTimeout(el.boundingBox() && el, waitTimeout)))).filter((v) => v)
+    els = (await Promise.all(els.map((el) => el.boundingBox() && el))).filter((v) => v)
     // Puppeteer visibility was ignored? | Remove when Puppeteer is fixed
     els = await Promise.all(
-      els.map((el) =>
-        promiseWithTimeout(
-          el.evaluate(
+      els.map(
+        async (el) =>
+          (await el.evaluate(
             (node) =>
               window.getComputedStyle(node).visibility !== 'hidden' && window.getComputedStyle(node).display !== 'none',
-          ) && el,
-          waitTimeout,
-        ),
+          )) && el,
       ),
     )
 

package/lib/helper/REST.js

@@ -63,6 +63,22 @@ const config = {}
  * }
  * ```
  *
+ * ```js
+ * {
+ *   helpers: {
+ *     REST: {
+ *       endpoint: 'http://site.com/api',
+ *       prettyPrintJson: true,
+ *       httpAgent: {
+ *          ca: fs.readFileSync(__dirname + '/path/to/ca.pem'),
+ *          rejectUnauthorized: false,
+ *          keepAlive: true
+ *       }
+ *     }
+ *   }
+ * }
+ * ```
+ *
  * ## Access From Helpers
  *
  * Send REST requests by accessing `_executeRequest` method:
@@ -101,9 +117,13 @@ class REST extends Helper {
 
     // Create an agent with SSL certificate
     if (this.options.httpAgent) {
-      if (!this.options.httpAgent.key || !this.options.httpAgent.cert)
+      // if one of those keys is there, all good to go
+      if (this.options.httpAgent.ca || this.options.httpAgent.key || this.options.httpAgent.cert) {
+        this.httpsAgent = new Agent(this.options.httpAgent)
+      } else {
+        // otherwise, throws an error of httpAgent config
         throw Error('Please recheck your httpAgent config!')
-      this.httpsAgent = new Agent(this.options.httpAgent)
+      }
     }
 
     this.axios = this.httpsAgent ? axios.create({ httpsAgent: this.httpsAgent }) : axios.create()

package/lib/helper/SoftExpectHelper.js

@@ -0,0 +1,381 @@
+const ExpectHelper = require('./ExpectHelper')
+
+/**
+ * SoftAssertHelper is a utility class for performing soft assertions.
+ * Unlike traditional assertions that stop the execution on failure,
+ * soft assertions allow the execution to continue and report all failures at the end.
+ *
+ * ### Examples
+ *
+ * Zero-configuration when paired with other helpers like REST, Playwright:
+ *
+ * ```js
+ * // inside codecept.conf.js
+ * {
+ *   helpers: {
+ *     Playwright: {...},
+ *     SoftExpectHelper: {},
+ *   }
+ * }
+ * ```
+ *
+ * ```js
+ * // in scenario
+ * I.softExpectEqual('a', 'b')
+ * I.flushSoftAssertions() // Throws an error if any soft assertions have failed. The error message contains all the accumulated failures.
+ * ```
+ *
+ * ## Methods
+ */
+class SoftAssertHelper extends ExpectHelper {
+  constructor() {
+    super()
+    this.errors = []
+  }
+
+  /**
+   * Performs a soft assertion by executing the provided assertion function.
+   * If the assertion fails, the error is caught and stored without halting the execution.
+   *
+   * @param {Function} assertionFn - The assertion function to execute.
+   * @param {string} [customErrorMsg=''] - A custom error message to display if the assertion fails.
+   */
+  softAssert(assertionFn, customErrorMsg = '') {
+    try {
+      assertionFn()
+    } catch (error) {
+      this.errors.push({ customErrorMsg, error })
+    }
+  }
+
+  /**
+   * Throws an error if any soft assertions have failed.
+   * The error message contains all the accumulated failures.
+   *
+   * @throws {Error} If there are any soft assertion failures.
+   */
+  flushSoftAssertions() {
+    if (this.errors.length > 0) {
+      let errorMessage = 'Soft assertions failed:\n'
+      this.errors.forEach((err, index) => {
+        errorMessage += `\n[${index + 1}] ${err.customErrorMsg}\n${err.error.message}\n`
+      })
+      this.errors = []
+      throw new Error(errorMessage)
+    }
+  }
+
+  /**
+   * Softly asserts that two values are equal.
+   *
+   * @param {*} actualValue - The actual value.
+   * @param {*} expectedValue - The expected value.
+   * @param {string} [customErrorMsg=''] - A custom error message to display if the assertion fails.
+   */
+  softExpectEqual(actualValue, expectedValue, customErrorMsg = '') {
+    this.softAssert(() => this.expectEqual(actualValue, expectedValue, customErrorMsg), customErrorMsg)
+  }
+
+  /**
+   * Softly asserts that two values are not equal.
+   *
+   * @param {*} actualValue - The actual value.
+   * @param {*} expectedValue - The expected value.
+   * @param {string} [customErrorMsg=''] - A custom error message to display if the assertion fails.
+   */
+  softExpectNotEqual(actualValue, expectedValue, customErrorMsg = '') {
+    this.softAssert(() => this.expectNotEqual(actualValue, expectedValue, customErrorMsg), customErrorMsg)
+  }
+
+  /**
+   * Softly asserts that two values are deeply equal.
+   *
+   * @param {*} actualValue - The actual value.
+   * @param {*} expectedValue - The expected value.
+   * @param {string} [customErrorMsg=''] - A custom error message to display if the assertion fails.
+   */
+  softExpectDeepEqual(actualValue, expectedValue, customErrorMsg = '') {
+    this.softAssert(() => this.expectDeepEqual(actualValue, expectedValue, customErrorMsg), customErrorMsg)
+  }
+
+  /**
+   * Softly asserts that two values are not deeply equal.
+   *
+   * @param {*} actualValue - The actual value.
+   * @param {*} expectedValue - The expected value.
+   * @param {string} [customErrorMsg=''] - A custom error message to display if the assertion fails.
+   */
+  softExpectNotDeepEqual(actualValue, expectedValue, customErrorMsg = '') {
+    this.softAssert(() => this.expectNotDeepEqual(actualValue, expectedValue, customErrorMsg), customErrorMsg)
+  }
+
+  /**
+   * Softly asserts that a value contains the expected value.
+   *
+   * @param {*} actualValue - The actual value.
+   * @param {*} expectedValueToContain - The value that should be contained within the actual value.
+   * @param {string} [customErrorMsg=''] - A custom error message to display if the assertion fails.
+   */
+  softExpectContain(actualValue, expectedValueToContain, customErrorMsg = '') {
+    this.softAssert(() => this.expectContain(actualValue, expectedValueToContain, customErrorMsg), customErrorMsg)
+  }
+
+  /**
+   * Softly asserts that a value does not contain the expected value.
+   *
+   * @param {*} actualValue - The actual value.
+   * @param {*} expectedValueToNotContain - The value that should not be contained within the actual value.
+   * @param {string} [customErrorMsg=''] - A custom error message to display if the assertion fails.
+   */
+  softExpectNotContain(actualValue, expectedValueToNotContain, customErrorMsg = '') {
+    this.softAssert(() => this.expectNotContain(actualValue, expectedValueToNotContain, customErrorMsg), customErrorMsg)
+  }
+
+  /**
+   * Softly asserts that a value starts with the expected value.
+   *
+   * @param {*} actualValue - The actual value.
+   * @param {*} expectedValueToStartWith - The value that the actual value should start with.
+   * @param {string} [customErrorMsg=''] - A custom error message to display if the assertion fails.
+   */
+  softExpectStartsWith(actualValue, expectedValueToStartWith, customErrorMsg = '') {
+    this.softAssert(() => this.expectStartsWith(actualValue, expectedValueToStartWith, customErrorMsg), customErrorMsg)
+  }
+
+  /**
+   * Softly asserts that a value does not start with the expected value.
+   *
+   * @param {*} actualValue - The actual value.
+   * @param {*} expectedValueToNotStartWith - The value that the actual value should not start with.
+   * @param {string} [customErrorMsg=''] - A custom error message to display if the assertion fails.
+   */
+  softExpectNotStartsWith(actualValue, expectedValueToNotStartWith, customErrorMsg = '') {
+    this.softAssert(
+      () => this.expectNotStartsWith(actualValue, expectedValueToNotStartWith, customErrorMsg),
+      customErrorMsg,
+    )
+  }
+
+  /**
+   * Softly asserts that a value ends with the expected value.
+   *
+   * @param {*} actualValue - The actual value.
+   * @param {*} expectedValueToEndWith - The value that the actual value should end with.
+   * @param {string} [customErrorMsg=''] - A custom error message to display if the assertion fails.
+   */
+  softExpectEndsWith(actualValue, expectedValueToEndWith, customErrorMsg = '') {
+    this.softAssert(() => this.expectEndsWith(actualValue, expectedValueToEndWith, customErrorMsg), customErrorMsg)
+  }
+
+  /**
+   * Softly asserts that a value does not end with the expected value.
+   *
+   * @param {*} actualValue - The actual value.
+   * @param {*} expectedValueToNotEndWith - The value that the actual value should not end with.
+   * @param {string} [customErrorMsg=''] - A custom error message to display if the assertion fails.
+   */
+  softExpectNotEndsWith(actualValue, expectedValueToNotEndWith, customErrorMsg = '') {
+    this.softAssert(
+      () => this.expectNotEndsWith(actualValue, expectedValueToNotEndWith, customErrorMsg),
+      customErrorMsg,
+    )
+  }
+
+  /**
+   * Softly asserts that the target data matches the given JSON schema.
+   *
+   * @param {*} targetData - The data to validate.
+   * @param {Object} jsonSchema - The JSON schema to validate against.
+   * @param {string} [customErrorMsg=''] - A custom error message to display if the assertion fails.
+   */
+  softExpectJsonSchema(targetData, jsonSchema, customErrorMsg = '') {
+    this.softAssert(() => this.expectJsonSchema(targetData, jsonSchema, customErrorMsg), customErrorMsg)
+  }
+
+  /**
+   * Softly asserts that the target data matches the given JSON schema using AJV.
+   *
+   * @param {*} targetData - The data to validate.
+   * @param {Object} jsonSchema - The JSON schema to validate against.
+   * @param {string} [customErrorMsg=''] - A custom error message to display if the assertion fails.
+   * @param {Object} [ajvOptions={ allErrors: true }] - Options to pass to AJV.
+   */
+  softExpectJsonSchemaUsingAJV(targetData, jsonSchema, customErrorMsg = '', ajvOptions = { allErrors: true }) {
+    this.softAssert(
+      () => this.expectJsonSchemaUsingAJV(targetData, jsonSchema, customErrorMsg, ajvOptions),
+      customErrorMsg,
+    )
+  }
+
+  /**
+   * Softly asserts that the target data has the specified property.
+   *
+   * @param {*} targetData - The data to check.
+   * @param {string} propertyName - The property name to check for.
+   * @param {string} [customErrorMsg=''] - A custom error message to display if the assertion
+   fails. */ softExpectHasProperty(targetData, propertyName, customErrorMsg = '') {
+    this.softAssert(() => this.expectHasProperty(targetData, propertyName, customErrorMsg), customErrorMsg)
+  }
+
+  /**
+   Softly asserts that the target data has a property with the specified name.
+   @param {*} targetData - The data to check.
+   @param {string} propertyName - The property name to check for.
+   @param {string} [customErrorMsg=''] - A custom error message to display if the assertion fails.
+   */
+  softExpectHasAProperty(targetData, propertyName, customErrorMsg = '') {
+    this.softAssert(() => this.expectHasAProperty(targetData, propertyName, customErrorMsg), customErrorMsg)
+  }
+
+  /**
+   Softly asserts that the target data is of a specific type.
+   @param {*} targetData - The data to check.
+   @param {string} type - The expected type (e.g., 'string', 'number').
+   @param {string} [customErrorMsg=''] - A custom error message to display if the assertion fails. */
+  softExpectToBeA(targetData, type, customErrorMsg = '') {
+    this.softAssert(() => this.expectToBeA(targetData, type, customErrorMsg), customErrorMsg)
+  }
+
+  /**
+   Softly asserts that the target data is of a specific type (alternative for articles).
+   @param {*} targetData - The data to check.
+   @param {string} type - The expected type (e.g., 'string', 'number').
+   @param {string} [customErrorMsg=''] - A custom error message to display if the assertion fails. */
+  softExpectToBeAn(targetData, type, customErrorMsg = '') {
+    this.softAssert(() => this.expectToBeAn(targetData, type, customErrorMsg), customErrorMsg)
+  }
+
+  /*
+   Softly asserts that the target data matches the specified regular expression.
+   @param {*} targetData - The data to check.
+   @param {RegExp} regex - The regular expression to match.
+   @param {string} [customErrorMsg=''] - A custom error message to display if the assertion fails. */
+  softExpectMatchRegex(targetData, regex, customErrorMsg = '') {
+    this.softAssert(() => this.expectMatchRegex(targetData, regex, customErrorMsg), customErrorMsg)
+  }
+
+  /**
+   Softly asserts that the target data has a specified length.
+   @param {*} targetData - The data to check.
+   @param {number} length - The expected length.
+   @param {string} [customErrorMsg=''] - A custom error message to display if the assertion fails. */
+  softExpectLengthOf(targetData, length, customErrorMsg = '') {
+    this.softAssert(() => this.expectLengthOf(targetData, length, customErrorMsg), customErrorMsg)
+  }
+
+  /**
+
+   Softly asserts that the target data is empty.
+   @param {*} targetData - The data to check.
+   @param {string} [customErrorMsg=''] - A custom error message to display if the assertion fails. */
+  softExpectEmpty(targetData, customErrorMsg = '') {
+    this.softAssert(() => this.expectEmpty(targetData, customErrorMsg), customErrorMsg)
+  }
+
+  /**
+
+   Softly asserts that the target data is true.
+   @param {*} targetData - The data to check.
+   @param {string} [customErrorMsg=''] - A custom error message to display if the assertion fails. */
+  softExpectTrue(targetData, customErrorMsg = '') {
+    this.softAssert(() => this.expectTrue(targetData, customErrorMsg), customErrorMsg)
+  }
+
+  /**
+
+   Softly asserts that the target data is false.
+   @param {*} targetData - The data to check.
+   @param {string} [customErrorMsg=''] - A custom error message to display if the assertion fails. */
+  softExpectFalse(targetData, customErrorMsg = '') {
+    this.softAssert(() => this.expectFalse(targetData, customErrorMsg), customErrorMsg)
+  }
+
+  /**
+
+   Softly asserts that the target data is above a specified value.
+   @param {*} targetData - The data to check.
+   @param {*} aboveThan - The value that the target data should be above.
+   @param {string} [customErrorMsg=''] - A custom error message to display if the assertion fails. */
+  softExpectAbove(targetData, aboveThan, customErrorMsg = '') {
+    this.softAssert(() => this.expectAbove(targetData, aboveThan, customErrorMsg), customErrorMsg)
+  }
+
+  /**
+
+   Softly asserts that the target data is below a specified value.
+   @param {*} targetData - The data to check.
+   @param {*} belowThan - The value that the target data should be below.
+   @param {string} [customErrorMsg=''] - A custom error message to display if the assertion fails. */
+  softExpectBelow(targetData, belowThan, customErrorMsg = '') {
+    this.softAssert(() => this.expectBelow(targetData, belowThan, customErrorMsg), customErrorMsg)
+  }
+
+  /**
+
+   Softly asserts that the length of the target data is above a specified value.
+   @param {*} targetData - The data to check.
+   @param {number} lengthAboveThan - The length that the target data should be above.
+   @param {string} [customErrorMsg=''] - A custom error message to display if the assertion fails. */
+  softExpectLengthAboveThan(targetData, lengthAboveThan, customErrorMsg = '') {
+    this.softAssert(() => this.expectLengthAboveThan(targetData, lengthAboveThan, customErrorMsg), customErrorMsg)
+  }
+
+  /**
+   Softly asserts that the length of the target data is below a specified value.
+   @param {*} targetData - The data to check.
+   @param {number} lengthBelowThan - The length that the target data should be below.
+   @param {string} [customErrorMsg=''] - A custom error message to display if the assertion fails. */
+  softExpectLengthBelowThan(targetData, lengthBelowThan, customErrorMsg = '') {
+    this.softAssert(() => this.expectLengthBelowThan(targetData, lengthBelowThan, customErrorMsg), customErrorMsg)
+  }
+
+  /**
+   Softly asserts that two values are equal, ignoring case.
+   @param {string} actualValue - The actual string value.
+   @param {string} expectedValue - The expected string value.
+   @param {string} [customErrorMsg=''] - A custom error message to display if the assertion fails. */
+  softExpectEqualIgnoreCase(actualValue, expectedValue, customErrorMsg = '') {
+    this.softAssert(() => this.expectEqualIgnoreCase(actualValue, expectedValue, customErrorMsg), customErrorMsg)
+  }
+
+  /**
+   Softly asserts that two arrays have deep equality, considering members in any order.
+   @param {Array} actualValue - The actual array.
+   @param {Array} expectedValue - The expected array.
+   @param {string} [customErrorMsg=''] - A custom error message to display if the assertion fails. */
+  softExpectDeepMembers(actualValue, expectedValue, customErrorMsg = '') {
+    this.softAssert(() => this.expectDeepMembers(actualValue, expectedValue, customErrorMsg), customErrorMsg)
+  }
+
+  /**
+   Softly asserts that an array (superset) deeply includes all members of another array (set).
+   @param {Array} superset - The array that should contain the expected members.
+   @param {Array} set - The array with members that should be included.
+   @param {string} [customErrorMsg=''] - A custom error message to display if the assertion fails. */
+  softExpectDeepIncludeMembers(superset, set, customErrorMsg = '') {
+    this.softAssert(() => this.expectDeepIncludeMembers(superset, set, customErrorMsg), customErrorMsg)
+  }
+
+  /**
+   Softly asserts that two objects are deeply equal, excluding specified fields.
+   @param {Object} actualValue - The actual object.
+   @param {Object} expectedValue - The expected object.
+   @param {Array<string>} fieldsToExclude - The fields to exclude from the comparison.
+   @param {string} [customErrorMsg=''] - A custom error message to display if the assertion fails. */
+  softExpectDeepEqualExcluding(actualValue, expectedValue, fieldsToExclude, customErrorMsg = '') {
+    this.softAssert(
+      () => this.expectDeepEqualExcluding(actualValue, expectedValue, fieldsToExclude, customErrorMsg),
+      customErrorMsg,
+    )
+  }
+
+  /**
+   Softly asserts that a value matches the expected pattern.
+   @param {*} actualValue - The actual value.
+   @param {*} expectedPattern - The pattern the value should match.
+   @param {string} [customErrorMsg=''] - A custom error message to display if the assertion fails. */
+  softExpectMatchesPattern(actualValue, expectedPattern, customErrorMsg = '') {
+    this.softAssert(() => this.expectMatchesPattern(actualValue, expectedPattern, customErrorMsg), customErrorMsg)
+  }
+}
+module.exports = SoftAssertHelper

package/lib/helper/TestCafe.js

@@ -15,7 +15,7 @@ const stringIncludes = require('../assert/include').includes
 const { urlEquals } = require('../assert/equal')
 const { empty } = require('../assert/empty')
 const { truth } = require('../assert/truth')
-const { xpathLocator, normalizeSpacesInString, promiseWithTimeout } = require('../utils')
+const { xpathLocator, normalizeSpacesInString } = require('../utils')
 const Locator = require('../locator')
 
 /**
@@ -696,12 +696,8 @@ class TestCafe extends Helper {
   /**
    * {{> grabNumberOfVisibleElements }}
    */
-  async grabNumberOfVisibleElements(locator, sec) {
-    const waitTimeout = sec ? sec * 1000 : this.options.waitForTimeout
-
-    const elements = await promiseWithTimeout(findElements.call(this, this.context, locator), waitTimeout)
-    const visibleElements = await elements.filterVisible()
-    const count = visibleElements.count
+  async grabNumberOfVisibleElements(locator) {
+    const count = (await findElements.call(this, this.context, locator)).filterVisible().count
     return count
   }
 

package/lib/helper/WebDriver.js

@@ -19,7 +19,6 @@ const {
   screenshotOutputFolder,
   getNormalizedKeyAttributeValue,
   modifierKeys,
-  promiseWithTimeout,
 } = require('../utils')
 const { isColorProperty, convertColorToRGBA } = require('../colorUtils')
 const ElementNotFound = require('./errors/ElementNotFound')
@@ -1702,16 +1701,12 @@ class WebDriver extends Helper {
   /**
    * {{> grabNumberOfVisibleElements }}
    */
-  async grabNumberOfVisibleElements(locator, sec) {
-    const waitTimeout = sec || this.options.waitForTimeoutInSeconds
+  async grabNumberOfVisibleElements(locator) {
     const res = await this._locate(locator)
 
-    let selected = await forEachAsync(res, async (el) => promiseWithTimeout(el.isDisplayed(), waitTimeout))
-
+    let selected = await forEachAsync(res, async (el) => el.isDisplayed())
     if (!Array.isArray(selected)) selected = [selected]
-
     selected = selected.filter((val) => val === true)
-
     return selected.length
   }
 

package/lib/output.js

@@ -206,7 +206,7 @@ module.exports = {
    * @param {number} skipped
    * @param {number|string} duration
    */
-  result(passed, failed, skipped, duration) {
+  result(passed, failed, skipped, duration, failedHooks = 0) {
     let style = colors.bgGreen;
     let msg = ` ${passed || 0} passed`;
     let status = style.bold('  OK ');
@@ -215,6 +215,12 @@ module.exports = {
       status = style.bold('  FAIL ');
       msg += `, ${failed} failed`;
     }
+
+    if (failedHooks > 0) {
+      style = style.bgRed;
+      status = style.bold('  FAIL ');
+      msg += `, ${failedHooks} failedHooks`;
+    }
     status += style.grey(' |');
 
     if (skipped) {

package/lib/rerun.js

@@ -70,6 +70,7 @@ class CodeceptRerunner extends BaseCodecept {
       await this.runTests(test);
     } catch (e) {
       output.error(e.stack);
+      throw e;
     } finally {
       event.emit(event.all.result, this);
       event.emit(event.all.after, this);

package/lib/utils.js

@@ -476,11 +476,3 @@ module.exports.printObjectProperties = (obj) => {
 module.exports.normalizeSpacesInString = (string) => {
   return string.replace(/\s+/g, ' ');
 };
-
-module.exports.promiseWithTimeout = (promise, timeout = 1000) => {
-  return Promise.race([
-    promise,
-    new Promise((_, reject) => { setTimeout(() => reject(new Error(`Set timeout: ${timeout / 1000} sec(s). Timeout exceeded`)), timeout) },
-    ),
-  ]);
-};

package/lib/workers.js

@@ -357,6 +357,7 @@ class Workers extends EventEmitter {
 
   run() {
     this.stats.start = new Date();
+    this.stats.failedHooks = 0
     recorder.startUnlessRunning();
     event.dispatcher.emit(event.workers.before);
     process.env.RUNS_WITH_WORKERS = 'true';
@@ -471,6 +472,7 @@ class Workers extends EventEmitter {
     this.stats.failures += newStats.failures;
     this.stats.tests += newStats.tests;
     this.stats.pending += newStats.pending;
+    this.stats.failedHooks += newStats.failedHooks;
   }
 
   printResults() {
@@ -492,7 +494,7 @@ class Workers extends EventEmitter {
       this.failuresLog.forEach(log => output.print(...log));
     }
 
-    output.result(this.stats.passes, this.stats.failures, this.stats.pending, ms(this.stats.duration));
+    output.result(this.stats.passes, this.stats.failures, this.stats.pending, ms(this.stats.duration), this.stats.failedHooks);
     process.env.RUNS_WITH_WORKERS = 'false';
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codeceptjs",
-  "version": "3.6.6-beta.6",
+  "version": "3.6.7",
   "description": "Supercharged End 2 End Testing Framework for NodeJS",
   "keywords": [
     "acceptance",
@@ -92,7 +92,7 @@
     "css-to-xpath": "0.1.0",
     "csstoxpath": "1.6.0",
     "devtools": "8.40.2",
-    "envinfo": "7.11.1",
+    "envinfo": "7.14.0",
     "escape-string-regexp": "4.0.0",
     "figures": "3.2.0",
     "fn-args": "4.0.0",
@@ -105,7 +105,7 @@
     "lodash.clonedeep": "4.5.0",
     "lodash.merge": "4.6.2",
     "mkdirp": "1.0.4",
-    "mocha": "10.6.0",
+    "mocha": "10.7.3",
     "monocart-coverage-reports": "2.10.3",
     "ms": "2.1.3",
     "ora-classic": "5.4.2",
@@ -118,17 +118,17 @@
     "uuid": "10.0"
   },
   "optionalDependencies": {
-    "@codeceptjs/detox-helper": "1.0.8"
+    "@codeceptjs/detox-helper": "1.1.2"
   },
   "devDependencies": {
     "@codeceptjs/mock-request": "0.3.1",
     "@faker-js/faker": "7.6.0",
     "@pollyjs/adapter-puppeteer": "6.0.6",
     "@pollyjs/core": "5.1.0",
-    "@types/chai": "4.3.16",
+    "@types/chai": "4.3.19",
     "@types/inquirer": "9.0.3",
-    "@types/node": "20.11.30",
-    "@wdio/sauce-service": "9.0.4",
+    "@types/node": "22.5.5",
+    "@wdio/sauce-service": "9.0.9",
     "@wdio/selenium-standalone-service": "8.3.2",
     "@wdio/utils": "9.0.6",
     "@xmldom/xmldom": "0.8.10",
@@ -140,19 +140,19 @@
     "electron": "31.3.1",
     "eslint": "8.57.0",
     "eslint-config-airbnb-base": "15.0.0",
-    "eslint-plugin-import": "2.29.1",
+    "eslint-plugin-import": "2.30.0",
     "eslint-plugin-mocha": "10.5.0",
     "expect": "29.7.0",
     "express": "4.19.2",
     "graphql": "16.9.0",
-    "husky": "9.1.4",
+    "husky": "9.1.6",
     "inquirer-test": "2.0.1",
     "jsdoc": "4.0.3",
     "jsdoc-typeof-plugin": "1.0.0",
     "json-server": "0.10.1",
     "playwright": "1.45.3",
     "prettier": "^3.3.2",
-    "puppeteer": "22.12.1",
+    "puppeteer": "23.3.0",
     "qrcode-terminal": "0.12.0",
     "rosie": "2.1.1",
     "runok": "0.9.3",
@@ -164,9 +164,9 @@
     "ts-node": "10.9.2",
     "tsd": "^0.31.0",
     "tsd-jsdoc": "2.5.0",
-    "typedoc": "0.26.5",
+    "typedoc": "0.26.7",
     "typedoc-plugin-markdown": "4.2.6",
-    "typescript": "5.5.3",
+    "typescript": "5.6.2",
     "wdio-docker-service": "1.5.0",
     "webdriverio": "8.39.1",
     "xml2js": "0.6.2",

package/typings/promiseBasedTypes.d.ts

@@ -963,13 +963,11 @@ declare namespace CodeceptJS {
          *
          * ```js
          * let numOfElements = await I.grabNumberOfVisibleElements('p');
-         * let numOfElementsWithWait = await I.grabNumberOfVisibleElements('p', 2); // timeout applied
          * ```
          * @param locator - located by CSS|XPath|strict locator.
-         * @param [sec] - (optional, `1` by default) time in seconds to wait
          * @returns number of visible elements
          */
-        grabNumberOfVisibleElements(locator: CodeceptJS.LocatorOrString, sec?: number): Promise<number>;
+        grabNumberOfVisibleElements(locator: CodeceptJS.LocatorOrString): Promise<number>;
         /**
          * Can be used for apps only with several values ("contentDescription", "text", "className", "resourceId")
          *
@@ -1183,6 +1181,9 @@ declare namespace CodeceptJS {
      * ## Methods
      */
     // @ts-ignore
+    // @ts-ignore
+    // @ts-ignore
+    // @ts-ignore
     class ExpectHelper {
         expectEqual(actualValue: any, expectedValue: any, customErrorMsg?: any): Promise<any>;
         expectNotEqual(actualValue: any, expectedValue: any, customErrorMsg?: any): Promise<any>;
@@ -1295,6 +1296,9 @@ declare namespace CodeceptJS {
      * ## Methods
      */
     // @ts-ignore
+    // @ts-ignore
+    // @ts-ignore
+    // @ts-ignore
     class ExpectHelper {
         expectEqual(actualValue: any, expectedValue: any, customErrorMsg?: any): Promise<any>;
         expectNotEqual(actualValue: any, expectedValue: any, customErrorMsg?: any): Promise<any>;
@@ -1967,6 +1971,9 @@ declare namespace CodeceptJS {
      * @property [httpsOpts] - key & cert values are the paths to .key and .crt files
      */
     // @ts-ignore
+    // @ts-ignore
+    // @ts-ignore
+    // @ts-ignore
     type MockServerConfig = {
         port?: number;
         host?: string;
@@ -2092,6 +2099,9 @@ declare namespace CodeceptJS {
      * ## Methods
      */
     // @ts-ignore
+    // @ts-ignore
+    // @ts-ignore
+    // @ts-ignore
     class MockServer {
         /**
          * Start the mock server
@@ -2407,13 +2417,11 @@ declare namespace CodeceptJS {
          *
          * ```js
          * let numOfElements = await I.grabNumberOfVisibleElements('p');
-         * let numOfElementsWithWait = await I.grabNumberOfVisibleElements('p', 2); // timeout applied
          * ```
          * @param locator - located by CSS|XPath|strict locator.
-         * @param [sec] - (optional, `1` by default) time in seconds to wait
          * @returns number of visible elements
          */
-        grabNumberOfVisibleElements(locator: CodeceptJS.LocatorOrString, sec?: number): Promise<number>;
+        grabNumberOfVisibleElements(locator: CodeceptJS.LocatorOrString): Promise<number>;
         /**
          * Perform a click on a link or a button, given by a locator.
          * If a fuzzy locator is given, the page will be searched for a button, link, or image matching the locator string.
@@ -3168,6 +3176,9 @@ declare namespace CodeceptJS {
      * @property [testIdAttribute = data-testid] - locate elements based on the testIdAttribute. See more of [locate by test id](https://playwright.dev/docs/locators#locate-by-test-id).
      */
     // @ts-ignore
+    // @ts-ignore
+    // @ts-ignore
+    // @ts-ignore
     type PlaywrightConfig = {
         url?: string;
         browser?: 'chromium' | 'firefox' | 'webkit' | 'electron';
@@ -4316,13 +4327,11 @@ declare namespace CodeceptJS {
          *
          * ```js
          * let numOfElements = await I.grabNumberOfVisibleElements('p');
-         * let numOfElementsWithWait = await I.grabNumberOfVisibleElements('p', 2); // timeout applied
          * ```
          * @param locator - located by CSS|XPath|strict locator.
-         * @param [sec] - (optional, `1` by default) time in seconds to wait
          * @returns number of visible elements
          */
-        grabNumberOfVisibleElements(locator: CodeceptJS.LocatorOrString, sec?: number): Promise<number>;
+        grabNumberOfVisibleElements(locator: CodeceptJS.LocatorOrString): Promise<number>;
         /**
          * Checks that current url contains a provided fragment.
          *
@@ -5979,13 +5988,11 @@ declare namespace CodeceptJS {
          *
          * ```js
          * let numOfElements = await I.grabNumberOfVisibleElements('p');
-         * let numOfElementsWithWait = await I.grabNumberOfVisibleElements('p', 2); // timeout applied
          * ```
          * @param locator - located by CSS|XPath|strict locator.
-         * @param [sec] - (optional, `1` by default) time in seconds to wait
          * @returns number of visible elements
          */
-        grabNumberOfVisibleElements(locator: CodeceptJS.LocatorOrString, sec?: number): Promise<number>;
+        grabNumberOfVisibleElements(locator: CodeceptJS.LocatorOrString): Promise<number>;
         /**
          * Checks that all elements with given locator have given CSS properties.
          *
@@ -6549,6 +6556,9 @@ declare namespace CodeceptJS {
      * @property [highlightElement] - highlight the interacting elements. Default: false. Note: only activate under verbose mode (--verbose).
      */
     // @ts-ignore
+    // @ts-ignore
+    // @ts-ignore
+    // @ts-ignore
     type PuppeteerConfig = {
         url: string;
         basicAuth?: any;
@@ -7490,15 +7500,12 @@ declare namespace CodeceptJS {
          *
          * ```js
          * let numOfElements = await I.grabNumberOfVisibleElements('p');
-         * let numOfElementsWithWait = await I.grabNumberOfVisibleElements('p', 2); // timeout applied
          * ```
          * @param locator - located by CSS|XPath|strict locator.
-         * @param [sec] - (optional, `1` by default) time in seconds to wait
          * @returns number of visible elements
-         *
          * {{ react }}
          */
-        grabNumberOfVisibleElements(locator: CodeceptJS.LocatorOrString, sec?: number): Promise<number>;
+        grabNumberOfVisibleElements(locator: CodeceptJS.LocatorOrString): Promise<number>;
         /**
          * Checks that current url contains a provided fragment.
          *
@@ -8359,6 +8366,9 @@ declare namespace CodeceptJS {
      * @property [maxUploadFileSize] - set the max content file size in MB when performing api calls.
      */
     // @ts-ignore
+    // @ts-ignore
+    // @ts-ignore
+    // @ts-ignore
     type RESTConfig = {
         endpoint?: string;
         prettyPrintJson?: boolean;
@@ -8411,6 +8421,22 @@ declare namespace CodeceptJS {
      * }
      * ```
      *
+     * ```js
+     * {
+     *   helpers: {
+     *     REST: {
+     *       endpoint: 'http://site.com/api',
+     *       prettyPrintJson: true,
+     *       httpAgent: {
+     *          ca: fs.readFileSync(__dirname + '/path/to/ca.pem'),
+     *          rejectUnauthorized: false,
+     *          keepAlive: true
+     *       }
+     *     }
+     *   }
+     * }
+     * ```
+     *
      * ## Access From Helpers
      *
      * Send REST requests by accessing `_executeRequest` method:
@@ -9265,13 +9291,11 @@ declare namespace CodeceptJS {
          *
          * ```js
          * let numOfElements = await I.grabNumberOfVisibleElements('p');
-         * let numOfElementsWithWait = await I.grabNumberOfVisibleElements('p', 2); // timeout applied
          * ```
          * @param locator - located by CSS|XPath|strict locator.
-         * @param [sec] - (optional, `1` by default) time in seconds to wait
          * @returns number of visible elements
          */
-        grabNumberOfVisibleElements(locator: CodeceptJS.LocatorOrString, sec?: number): Promise<number>;
+        grabNumberOfVisibleElements(locator: CodeceptJS.LocatorOrString): Promise<number>;
         /**
          * Checks that the given input field or textarea equals to given value.
          * For fuzzy locators, fields are matched by label text, the "name" attribute, CSS, and XPath.
@@ -9724,6 +9748,9 @@ declare namespace CodeceptJS {
      * @property [devtoolsProtocol = false] - enable devtools protocol. Default: false. More info: https://webdriver.io/docs/automationProtocols/#devtools-protocol.
      */
     // @ts-ignore
+    // @ts-ignore
+    // @ts-ignore
+    // @ts-ignore
     type WebDriverConfig = {
         url: string;
         browser: string;
@@ -10812,13 +10839,11 @@ declare namespace CodeceptJS {
          *
          * ```js
          * let numOfElements = await I.grabNumberOfVisibleElements('p');
-         * let numOfElementsWithWait = await I.grabNumberOfVisibleElements('p', 2); // timeout applied
          * ```
          * @param locator - located by CSS|XPath|strict locator.
-         * @param [sec] - (optional, `1` by default) time in seconds to wait
          * @returns number of visible elements
          */
-        grabNumberOfVisibleElements(locator: CodeceptJS.LocatorOrString, sec?: number): Promise<number>;
+        grabNumberOfVisibleElements(locator: CodeceptJS.LocatorOrString): Promise<number>;
         /**
          * Checks that current url contains a provided fragment.
          *

package/typings/types.d.ts

@@ -971,13 +971,11 @@ declare namespace CodeceptJS {
          *
          * ```js
          * let numOfElements = await I.grabNumberOfVisibleElements('p');
-         * let numOfElementsWithWait = await I.grabNumberOfVisibleElements('p', 2); // timeout applied
          * ```
          * @param locator - located by CSS|XPath|strict locator.
-         * @param [sec] - (optional, `1` by default) time in seconds to wait
          * @returns number of visible elements
          */
-        grabNumberOfVisibleElements(locator: CodeceptJS.LocatorOrString, sec?: number): Promise<number>;
+        grabNumberOfVisibleElements(locator: CodeceptJS.LocatorOrString): Promise<number>;
         /**
          * Can be used for apps only with several values ("contentDescription", "text", "className", "resourceId")
          *
@@ -1207,6 +1205,9 @@ declare namespace CodeceptJS {
      * ## Methods
      */
     // @ts-ignore
+    // @ts-ignore
+    // @ts-ignore
+    // @ts-ignore
     class ExpectHelper {
         expectEqual(actualValue: any, expectedValue: any, customErrorMsg?: any): void;
         expectNotEqual(actualValue: any, expectedValue: any, customErrorMsg?: any): void;
@@ -1319,6 +1320,9 @@ declare namespace CodeceptJS {
      * ## Methods
      */
     // @ts-ignore
+    // @ts-ignore
+    // @ts-ignore
+    // @ts-ignore
     class ExpectHelper {
         expectEqual(actualValue: any, expectedValue: any, customErrorMsg?: any): void;
         expectNotEqual(actualValue: any, expectedValue: any, customErrorMsg?: any): void;
@@ -1994,6 +1998,9 @@ declare namespace CodeceptJS {
      * @property [httpsOpts] - key & cert values are the paths to .key and .crt files
      */
     // @ts-ignore
+    // @ts-ignore
+    // @ts-ignore
+    // @ts-ignore
     type MockServerConfig = {
         port?: number;
         host?: string;
@@ -2119,6 +2126,9 @@ declare namespace CodeceptJS {
      * ## Methods
      */
     // @ts-ignore
+    // @ts-ignore
+    // @ts-ignore
+    // @ts-ignore
     class MockServer {
         /**
          * Start the mock server
@@ -2454,13 +2464,11 @@ declare namespace CodeceptJS {
          *
          * ```js
          * let numOfElements = await I.grabNumberOfVisibleElements('p');
-         * let numOfElementsWithWait = await I.grabNumberOfVisibleElements('p', 2); // timeout applied
          * ```
          * @param locator - located by CSS|XPath|strict locator.
-         * @param [sec] - (optional, `1` by default) time in seconds to wait
          * @returns number of visible elements
          */
-        grabNumberOfVisibleElements(locator: CodeceptJS.LocatorOrString, sec?: number): Promise<number>;
+        grabNumberOfVisibleElements(locator: CodeceptJS.LocatorOrString): Promise<number>;
         /**
          * Perform a click on a link or a button, given by a locator.
          * If a fuzzy locator is given, the page will be searched for a button, link, or image matching the locator string.
@@ -3261,6 +3269,9 @@ declare namespace CodeceptJS {
      * @property [testIdAttribute = data-testid] - locate elements based on the testIdAttribute. See more of [locate by test id](https://playwright.dev/docs/locators#locate-by-test-id).
      */
     // @ts-ignore
+    // @ts-ignore
+    // @ts-ignore
+    // @ts-ignore
     type PlaywrightConfig = {
         url?: string;
         browser?: 'chromium' | 'firefox' | 'webkit' | 'electron';
@@ -4446,13 +4457,11 @@ declare namespace CodeceptJS {
          *
          * ```js
          * let numOfElements = await I.grabNumberOfVisibleElements('p');
-         * let numOfElementsWithWait = await I.grabNumberOfVisibleElements('p', 2); // timeout applied
          * ```
          * @param locator - located by CSS|XPath|strict locator.
-         * @param [sec] - (optional, `1` by default) time in seconds to wait
          * @returns number of visible elements
          */
-        grabNumberOfVisibleElements(locator: CodeceptJS.LocatorOrString, sec?: number): Promise<number>;
+        grabNumberOfVisibleElements(locator: CodeceptJS.LocatorOrString): Promise<number>;
         /**
          * Checks that current url contains a provided fragment.
          *
@@ -6187,13 +6196,11 @@ declare namespace CodeceptJS {
          *
          * ```js
          * let numOfElements = await I.grabNumberOfVisibleElements('p');
-         * let numOfElementsWithWait = await I.grabNumberOfVisibleElements('p', 2); // timeout applied
          * ```
          * @param locator - located by CSS|XPath|strict locator.
-         * @param [sec] - (optional, `1` by default) time in seconds to wait
          * @returns number of visible elements
          */
-        grabNumberOfVisibleElements(locator: CodeceptJS.LocatorOrString, sec?: number): Promise<number>;
+        grabNumberOfVisibleElements(locator: CodeceptJS.LocatorOrString): Promise<number>;
         /**
          * Checks that all elements with given locator have given CSS properties.
          *
@@ -6793,6 +6800,9 @@ declare namespace CodeceptJS {
      * @property [highlightElement] - highlight the interacting elements. Default: false. Note: only activate under verbose mode (--verbose).
      */
     // @ts-ignore
+    // @ts-ignore
+    // @ts-ignore
+    // @ts-ignore
     type PuppeteerConfig = {
         url: string;
         basicAuth?: any;
@@ -7798,15 +7808,12 @@ declare namespace CodeceptJS {
          *
          * ```js
          * let numOfElements = await I.grabNumberOfVisibleElements('p');
-         * let numOfElementsWithWait = await I.grabNumberOfVisibleElements('p', 2); // timeout applied
          * ```
          * @param locator - located by CSS|XPath|strict locator.
-         * @param [sec] - (optional, `1` by default) time in seconds to wait
          * @returns number of visible elements
-         *
          * {{ react }}
          */
-        grabNumberOfVisibleElements(locator: CodeceptJS.LocatorOrString, sec?: number): Promise<number>;
+        grabNumberOfVisibleElements(locator: CodeceptJS.LocatorOrString): Promise<number>;
         /**
          * Checks that current url contains a provided fragment.
          *
@@ -8739,6 +8746,9 @@ declare namespace CodeceptJS {
      * @property [maxUploadFileSize] - set the max content file size in MB when performing api calls.
      */
     // @ts-ignore
+    // @ts-ignore
+    // @ts-ignore
+    // @ts-ignore
     type RESTConfig = {
         endpoint?: string;
         prettyPrintJson?: boolean;
@@ -8791,6 +8801,22 @@ declare namespace CodeceptJS {
      * }
      * ```
      *
+     * ```js
+     * {
+     *   helpers: {
+     *     REST: {
+     *       endpoint: 'http://site.com/api',
+     *       prettyPrintJson: true,
+     *       httpAgent: {
+     *          ca: fs.readFileSync(__dirname + '/path/to/ca.pem'),
+     *          rejectUnauthorized: false,
+     *          keepAlive: true
+     *       }
+     *     }
+     *   }
+     * }
+     * ```
+     *
      * ## Access From Helpers
      *
      * Send REST requests by accessing `_executeRequest` method:
@@ -9679,13 +9705,11 @@ declare namespace CodeceptJS {
          *
          * ```js
          * let numOfElements = await I.grabNumberOfVisibleElements('p');
-         * let numOfElementsWithWait = await I.grabNumberOfVisibleElements('p', 2); // timeout applied
          * ```
          * @param locator - located by CSS|XPath|strict locator.
-         * @param [sec] - (optional, `1` by default) time in seconds to wait
          * @returns number of visible elements
          */
-        grabNumberOfVisibleElements(locator: CodeceptJS.LocatorOrString, sec?: number): Promise<number>;
+        grabNumberOfVisibleElements(locator: CodeceptJS.LocatorOrString): Promise<number>;
         /**
          * Checks that the given input field or textarea equals to given value.
          * For fuzzy locators, fields are matched by label text, the "name" attribute, CSS, and XPath.
@@ -10164,6 +10188,9 @@ declare namespace CodeceptJS {
      * @property [devtoolsProtocol = false] - enable devtools protocol. Default: false. More info: https://webdriver.io/docs/automationProtocols/#devtools-protocol.
      */
     // @ts-ignore
+    // @ts-ignore
+    // @ts-ignore
+    // @ts-ignore
     type WebDriverConfig = {
         url: string;
         browser: string;
@@ -11319,13 +11346,11 @@ declare namespace CodeceptJS {
          *
          * ```js
          * let numOfElements = await I.grabNumberOfVisibleElements('p');
-         * let numOfElementsWithWait = await I.grabNumberOfVisibleElements('p', 2); // timeout applied
          * ```
          * @param locator - located by CSS|XPath|strict locator.
-         * @param [sec] - (optional, `1` by default) time in seconds to wait
          * @returns number of visible elements
          */
-        grabNumberOfVisibleElements(locator: CodeceptJS.LocatorOrString, sec?: number): Promise<number>;
+        grabNumberOfVisibleElements(locator: CodeceptJS.LocatorOrString): Promise<number>;
         /**
          * Checks that current url contains a provided fragment.
          *
@@ -12950,6 +12975,7 @@ declare namespace CodeceptJS {
      * * `reloadReactNative` - should be enabled for React Native applications.
      * * `reuse` - reuse application for tests. By default, Detox reinstalls and relaunches app.
      * * `registerGlobals` - (default: true) Register Detox helper functions `by`, `element`, `expect`, `waitFor` globally.
+     * * `url` - URL to open via deep-link each time the app is launched (android) or immediately afterwards (iOS). Useful for opening a bundle URL at the beginning of tests when working with Expo.
      */
     class Detox {
         /**