codeceptjs 4.0.0-beta.6.esm-aria → 4.0.0-beta.8.esm-aria

package/lib/helper/Appium.js

@@ -1,15 +1,16 @@
-let webdriverio
-
-const fs = require('fs')
-const axios = require('axios').default
-const { v4: uuidv4 } = require('uuid')
-
-const Webdriver = require('./WebDriver')
-const AssertionFailedError = require('../assert/error')
-const { truth } = require('../assert/truth')
-const recorder = require('../recorder')
-const Locator = require('../locator')
-const ConnectionRefused = require('./errors/ConnectionRefused')
+import * as webdriverio from 'webdriverio'
+import fs from 'fs'
+import axios from 'axios'
+import { v4 as uuidv4 } from 'uuid'
+
+import Webdriver from './WebDriver.js'
+import AssertionFailedError from '../assert/error.js'
+import { truth } from '../assert/truth.js'
+import recorder from '../recorder.js'
+import Locator from '../locator.js'
+import ConnectionRefused from './errors/ConnectionRefused.js'
+import ElementNotFound from './errors/ElementNotFound.js'
+import { dontSeeElementError } from './errors/ElementAssertion.js'
 
 const mobileRoot = '//*'
 const webRoot = 'body'
@@ -181,7 +182,6 @@ class Appium extends Webdriver {
     this.appiumV2 = config.appiumV2 || true
     this.axios = axios.create()
 
-    webdriverio = require('webdriverio')
     if (!config.appiumV2) {
       console.log('The Appium core team does not maintain Appium 1.x anymore since the 1st of January 2022. Appium 2.x is used by default.')
       console.log('More info: https://bit.ly/appium-v2-migration')
@@ -261,11 +261,13 @@ class Appium extends Webdriver {
 
     this.platform = null
     if (config.capabilities[`${vendorPrefix.appium}:platformName`]) {
-      this.platform = config.capabilities[`${vendorPrefix.appium}:platformName`].toLowerCase()
+      config.capabilities[`${vendorPrefix.appium}:platformName`] = config.capabilities[`${vendorPrefix.appium}:platformName`].toLowerCase()
+      this.platform = config.capabilities[`${vendorPrefix.appium}:platformName`]
     }
 
     if (config.capabilities.platformName) {
-      this.platform = config.capabilities.platformName.toLowerCase()
+      config.capabilities.platformName = config.capabilities.platformName.toLowerCase()
+      this.platform = config.capabilities.platformName
     }
 
     return config
@@ -275,7 +277,7 @@ class Appium extends Webdriver {
     const _convertedCaps = {}
     for (const [key, value] of Object.entries(capabilities)) {
       if (!key.startsWith(vendorPrefix.appium)) {
-        if (key !== 'platformName' && key !== 'bstack:options') {
+        if (key !== 'platformName' && key !== 'bstack:options' && key !== 'sauce:options') {
           _convertedCaps[`${vendorPrefix.appium}:${key}`] = value
         } else {
           _convertedCaps[`${key}`] = value
@@ -389,6 +391,29 @@ class Appium extends Webdriver {
     return `${protocol}://${hostname}:${port}${normalizedPath}/session/${this.browser.sessionId}`
   }
 
+  /**
+   * Helper method to safely call isDisplayed() on mobile elements.
+   * Handles the case where webdriverio tries to use execute/sync which isn't supported in Appium.
+   * @private
+   */
+  async _isDisplayedSafe(element) {
+    if (this.isWeb) {
+      // For web contexts, use the normal isDisplayed
+      return element.isDisplayed()
+    }
+
+    try {
+      return await element.isDisplayed()
+    } catch (err) {
+      // If isDisplayed fails due to execute/sync not being supported in native mobile contexts,
+      // fall back to assuming the element is displayed (since we found it)
+      if (err.message && err.message.includes('Method is not implemented')) {
+        return true
+      }
+      throw err
+    }
+  }
+
   /**
    * Execute code only on iOS
    *
@@ -617,6 +642,7 @@ class Appium extends Webdriver {
    */
   async resetApp() {
     onlyForApps.call(this)
+    this.isWeb = false // Reset to native context after app reset
     return this.axios({
       method: 'post',
       url: `${this._buildAppiumEndpoint()}/appium/app/reset`,
@@ -1132,7 +1158,7 @@ class Appium extends Webdriver {
         ],
       },
     ])
-    await this.browser.pause(1000)
+    await this.browser.pause(2000)
   }
 
   /**
@@ -1294,28 +1320,26 @@ class Appium extends Webdriver {
     let currentSource
     return browser
       .waitUntil(
-        () => {
+        async () => {
           if (err) {
             return new Error(`Scroll to the end and element ${searchableLocator} was not found`)
           }
-          return browser
-            .$$(parseLocator.call(this, searchableLocator))
-            .then(els => els.length && els[0].isDisplayed())
-            .then(res => {
-              if (res) {
-                return true
-              }
-              return this[direction](scrollLocator, offset, speed)
-                .getSource()
-                .then(source => {
-                  if (source === currentSource) {
-                    err = true
-                  } else {
-                    currentSource = source
-                    return false
-                  }
-                })
-            })
+          const els = await browser.$$(parseLocator.call(this, searchableLocator))
+          if (els.length) {
+            const displayed = await this._isDisplayedSafe(els[0])
+            if (displayed) {
+              return true
+            }
+          }
+
+          await this[direction](scrollLocator, offset, speed)
+          const source = await this.browser.getPageSource()
+          if (source === currentSource) {
+            err = true
+          } else {
+            currentSource = source
+            return false
+          }
         },
         timeout * 1000,
         errorMsg,
@@ -1521,7 +1545,26 @@ class Appium extends Webdriver {
    */
   async dontSeeElement(locator) {
     if (this.isWeb) return super.dontSeeElement(locator)
-    return super.dontSeeElement(parseLocator.call(this, locator))
+
+    // For mobile native apps, use safe isDisplayed wrapper
+    const parsedLocator = parseLocator.call(this, locator)
+    const res = await this._locate(parsedLocator, false)
+
+    if (!res || res.length === 0) {
+      return truth(`elements of ${Locator.build(parsedLocator)}`, 'to be seen').negate(false)
+    }
+
+    const selected = []
+    for (const el of res) {
+      const displayed = await this._isDisplayedSafe(el)
+      if (displayed) selected.push(true)
+    }
+
+    try {
+      return truth(`elements of ${Locator.build(parsedLocator)}`, 'to be seen').negate(selected)
+    } catch (err) {
+      throw err
+    }
   }
 
   /**
@@ -1575,7 +1618,18 @@ class Appium extends Webdriver {
    */
   async grabNumberOfVisibleElements(locator) {
     if (this.isWeb) return super.grabNumberOfVisibleElements(locator)
-    return super.grabNumberOfVisibleElements(parseLocator.call(this, locator))
+
+    // For mobile native apps, use safe isDisplayed wrapper
+    const parsedLocator = parseLocator.call(this, locator)
+    const res = await this._locate(parsedLocator)
+
+    const selected = []
+    for (const el of res) {
+      const displayed = await this._isDisplayedSafe(el)
+      if (displayed) selected.push(true)
+    }
+
+    return selected.length
   }
 
   /**
@@ -1654,7 +1708,26 @@ class Appium extends Webdriver {
    */
   async seeElement(locator) {
     if (this.isWeb) return super.seeElement(locator)
-    return super.seeElement(parseLocator.call(this, locator))
+
+    // For mobile native apps, use safe isDisplayed wrapper
+    const parsedLocator = parseLocator.call(this, locator)
+    const res = await this._locate(parsedLocator, true)
+
+    if (!res || res.length === 0) {
+      throw new ElementNotFound(parsedLocator)
+    }
+
+    const selected = []
+    for (const el of res) {
+      const displayed = await this._isDisplayedSafe(el)
+      if (displayed) selected.push(true)
+    }
+
+    try {
+      return truth(`elements of ${Locator.build(parsedLocator)}`, 'to be seen').assert(selected)
+    } catch (e) {
+      dontSeeElementError(parsedLocator)
+    }
   }
 
   /**
@@ -1701,7 +1774,29 @@ class Appium extends Webdriver {
    */
   async waitForVisible(locator, sec = null) {
     if (this.isWeb) return super.waitForVisible(locator, sec)
-    return super.waitForVisible(parseLocator.call(this, locator), sec)
+
+    // For mobile native apps, use safe isDisplayed wrapper
+    const parsedLocator = parseLocator.call(this, locator)
+    const aSec = sec || this.options.waitForTimeoutInSeconds
+
+    return this.browser.waitUntil(
+      async () => {
+        const res = await this._res(parsedLocator)
+        if (!res || res.length === 0) return false
+
+        const selected = []
+        for (const el of res) {
+          const displayed = await this._isDisplayedSafe(el)
+          if (displayed) selected.push(true)
+        }
+
+        return selected.length > 0
+      },
+      {
+        timeout: aSec * 1000,
+        timeoutMsg: `element (${Locator.build(parsedLocator)}) still not visible after ${aSec} sec`,
+      },
+    )
   }
 
   /**
@@ -1710,7 +1805,26 @@ class Appium extends Webdriver {
    */
   async waitForInvisible(locator, sec = null) {
     if (this.isWeb) return super.waitForInvisible(locator, sec)
-    return super.waitForInvisible(parseLocator.call(this, locator), sec)
+
+    // For mobile native apps, use safe isDisplayed wrapper
+    const parsedLocator = parseLocator.call(this, locator)
+    const aSec = sec || this.options.waitForTimeoutInSeconds
+
+    return this.browser.waitUntil(
+      async () => {
+        const res = await this._res(parsedLocator)
+        if (!res || res.length === 0) return true
+
+        const selected = []
+        for (const el of res) {
+          const displayed = await this._isDisplayedSafe(el)
+          if (displayed) selected.push(true)
+        }
+
+        return selected.length === 0
+      },
+      { timeout: aSec * 1000, timeoutMsg: `element (${Locator.build(parsedLocator)}) still visible after ${aSec} sec` },
+    )
   }
 
   /**
@@ -1786,4 +1900,4 @@ function onlyForApps(expectedPlatform) {
   }
 }
 
-module.exports = Appium
+export default Appium

package/lib/helper/GraphQL.js

@@ -1,5 +1,5 @@
-const axios = require('axios').default
-const HelperModule = require('@codeceptjs/helper')
+import axios from 'axios'
+import HelperModule from '@codeceptjs/helper'
 
 /**
  * GraphQL helper allows to send additional requests to a GraphQl endpoint during acceptance tests.
@@ -227,4 +227,4 @@ class GraphQL extends Helper {
     this.haveRequestHeaders({ Authorization: `Bearer ${accessToken}` })
   }
 }
-module.exports = GraphQL
+export default GraphQL

package/lib/helper/GraphQLDataFactory.js

@@ -1,7 +1,7 @@
-const path = require('path')
+import path from 'path'
 
-const HelperModule = require('@codeceptjs/helper')
-const GraphQL = require('./GraphQL')
+import HelperModule from '@codeceptjs/helper'
+import GraphQL from './GraphQL.js'
 
 /**
  * Helper for managing remote data using GraphQL queries.
@@ -305,4 +305,4 @@ class GraphQLDataFactory extends Helper {
   }
 }
 
-module.exports = GraphQLDataFactory
+export default GraphQLDataFactory

package/lib/helper/JSONResponse.js

@@ -1,6 +1,6 @@
 import Helper from '@codeceptjs/helper'
 import assert from 'assert'
-import joi from 'joi'
+import { z } from 'zod'
 
 /**
  * This helper allows performing assertions on JSON responses paired with following helpers:
@@ -69,17 +69,13 @@ class JSONResponse extends Helper {
 
   _beforeSuite() {
     this.response = null
-    try {
-      if (!this.helpers[this.options.requestHelper]) {
-        throw new Error(`Error setting JSONResponse, helper ${this.options.requestHelper} is not enabled in config, helpers: ${Object.keys(this.helpers)}`)
-      }
-      // connect to REST helper
-      this.helpers[this.options.requestHelper].config.onResponse = response => {
-        this.response = response
-      }
-    } catch (e) {
-      // Temporary workaround for ESM transition - helpers access issue
-      console.log('[JSONResponse] Warning: Could not connect to REST helper during ESM transition:', e.message)
+    if (!this.helpers[this.options.requestHelper]) {
+      throw new Error(`Error setting JSONResponse, helper ${this.options.requestHelper} is not enabled in config, helpers: ${Object.keys(this.helpers)}`)
+    }
+    const origOnResponse = this.helpers[this.options.requestHelper].config.onResponse
+    this.helpers[this.options.requestHelper].config.onResponse = response => {
+      this.response = response
+      if (typeof origOnResponse === 'function') origOnResponse(response)
     }
   }
 
@@ -87,16 +83,7 @@ class JSONResponse extends Helper {
     this.response = null
   }
 
-  static _checkRequirements() {
-    try {
-      // In ESM, joi is already imported at the top
-      // The import will fail at module load time if joi is missing
-      return null
-    } catch (e) {
-      return ['joi']
-    }
-  }
-
+  
   /**
    * Checks that response code is equal to the provided one
    *
@@ -308,28 +295,28 @@ class JSONResponse extends Helper {
   }
 
   /**
-   * Validates JSON structure of response using [joi library](https://joi.dev).
-   * See [joi API](https://joi.dev/api/) for complete reference on usage.
+   * Validates JSON structure of response using [Zod library](https://zod.dev).
+   * See [Zod API](https://zod.dev/) for complete reference on usage.
    *
-   * Use pre-initialized joi instance by passing function callback:
+   * Use pre-initialized Zod instance by passing function callback:
    *
    * ```js
    * // response.data is { name: 'jon', id: 1 }
    *
-   * I.seeResponseMatchesJsonSchema(joi => {
-   *   return joi.object({
-   *     name: joi.string(),
-   *     id: joi.number()
+   * I.seeResponseMatchesJsonSchema(z => {
+   *   return z.object({
+   *     name: z.string(),
+   *     id: z.number()
    *   })
    * });
    *
    * // or pass a valid schema
-   * const joi = require('joi');
+   * import { z } from 'zod';
    *
-   * I.seeResponseMatchesJsonSchema(joi.object({
-   *   name: joi.string(),
-   *   id: joi.number();
-   * });
+   * I.seeResponseMatchesJsonSchema(z.object({
+   *   name: z.string(),
+   *   id: z.number()
+   * }));
    * ```
    *
    * @param {any} fnOrSchema
@@ -338,14 +325,17 @@ class JSONResponse extends Helper {
     this._checkResponseReady()
     let schema = fnOrSchema
     if (typeof fnOrSchema === 'function') {
-      schema = fnOrSchema(joi)
+      schema = fnOrSchema(z)
       const body = fnOrSchema.toString()
       fnOrSchema.toString = () => `${body.split('\n')[1]}...`
     }
-    if (!schema) throw new Error('Empty Joi schema provided, see https://joi.dev/ for details')
-    if (!joi.isSchema(schema)) throw new Error('Invalid Joi schema provided, see https://joi.dev/ for details')
-    schema.toString = () => schema.describe()
-    joi.assert(this.response.data, schema)
+    if (!schema) throw new Error('Empty Zod schema provided, see https://zod.dev/ for details')
+    if (!(schema instanceof z.ZodType)) throw new Error('Invalid Zod schema provided, see https://zod.dev/ for details')
+    schema.toString = () => schema._def.description || JSON.stringify(schema._def)
+    const result = schema.parse(this.response.data)
+    if (!result) {
+      throw new Error('Schema validation failed')
+    }
   }
 
   _checkResponseReady() {
@@ -356,7 +346,25 @@ class JSONResponse extends Helper {
     for (const key in expected) {
       assert(key in actual, `Key "${key}" not found in ${JSON.stringify(actual)}`)
       if (typeof expected[key] === 'object' && expected[key] !== null) {
-        this._assertContains(actual[key], expected[key])
+        if (Array.isArray(expected[key])) {
+          // Handle array comparison: each expected element should have a match in actual array
+          assert(Array.isArray(actual[key]), `Expected array for key "${key}", but got ${typeof actual[key]}`)
+          for (const expectedItem of expected[key]) {
+            let found = false
+            for (const actualItem of actual[key]) {
+              try {
+                this._assertContains(actualItem, expectedItem)
+                found = true
+                break
+              } catch (err) {
+                continue
+              }
+            }
+            assert(found, `No matching element found in array for ${JSON.stringify(expectedItem)}`)
+          }
+        } else {
+          this._assertContains(actual[key], expected[key])
+        }
       } else {
         assert.deepStrictEqual(actual[key], expected[key], `Values for key "${key}" don't match`)
       }

package/lib/helper/Mochawesome.js

@@ -40,7 +40,20 @@ class Mochawesome extends Helper {
   }
 
   _test(test) {
-    currentTest = { test }
+    // If this is a retried test, we want to add context to the retried test
+    // but also potentially preserve context from the original test
+    const originalTest = test.retriedTest && test.retriedTest()
+    if (originalTest) {
+      // This is a retried test - use the retried test for context
+      currentTest = { test }
+
+      // Optionally copy context from original test if it exists
+      // Note: mochawesome context is stored in test.ctx, but we need to be careful
+      // not to break the mocha context structure
+    } else {
+      // Normal test (not a retry)
+      currentTest = { test }
+    }
   }
 
   _failed(test) {
@@ -67,7 +80,16 @@ class Mochawesome extends Helper {
 
   addMochawesomeContext(context) {
     if (currentTest === '') currentTest = { test: currentSuite.ctx.test }
-    return this._addContext(currentTest, context)
+
+    // For retried tests, make sure we're adding context to the current (retried) test
+    // not the original test
+    let targetTest = currentTest
+    if (currentTest.test && currentTest.test.retriedTest && currentTest.test.retriedTest()) {
+      // This test has been retried, make sure we're using the current test for context
+      targetTest = { test: currentTest.test }
+    }
+
+    return this._addContext(targetTest, context)
   }
 }