fix: issues

Author: kobenguyent

lib/helper/Appium.js

@@ -391,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
    *
@@ -1523,34 +1546,23 @@ class Appium extends Webdriver {
    */
   async dontSeeElement(locator) {
     if (this.isWeb) return super.dontSeeElement(locator)
-    
-    // For mobile native apps, handle isDisplayed error gracefully
+
+    // For mobile native apps, use safe isDisplayed wrapper
     const parsedLocator = parseLocator.call(this, locator)
     const res = await this._locate(parsedLocator, false)
     const { truth } = require('../assert/truth')
     const Locator = require('../locator')
-    
+
     if (!res || res.length === 0) {
       return truth(`elements of ${new Locator(parsedLocator)}`, 'to be seen').negate(false)
     }
-    
+
     const selected = []
     for (const el of res) {
-      try {
-        const displayed = await el.isDisplayed()
-        if (displayed) selected.push(true)
-      } catch (err) {
-        // If isDisplayed fails due to execute/sync not being supported,
-        // fall back to checking if element exists (which we already verified)
-        if (err.message && err.message.includes('Method is not implemented')) {
-          // Element exists, assume it's displayed
-          selected.push(true)
-        } else {
-          throw err
-        }
-      }
+      const displayed = await this._isDisplayedSafe(el)
+      if (displayed) selected.push(true)
     }
-    
+
     try {
       return truth(`elements of ${new Locator(parsedLocator)}`, 'to be seen').negate(selected)
     } catch (err) {
@@ -1609,7 +1621,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
   }
 
   /**
@@ -1688,38 +1711,25 @@ class Appium extends Webdriver {
    */
   async seeElement(locator) {
     if (this.isWeb) return super.seeElement(locator)
-    
-    // For mobile native apps, we need to handle isDisplayed differently
-    // because webdriverio's isDisplayed() tries to execute JavaScript which isn't supported
+
+    // For mobile native apps, use safe isDisplayed wrapper
     const parsedLocator = parseLocator.call(this, locator)
     const res = await this._locate(parsedLocator, true)
     const ElementNotFound = require('./errors/ElementNotFound')
     const { truth } = require('../assert/truth')
     const { dontSeeElementError } = require('./errors/ElementAssertion')
     const Locator = require('../locator')
-    
+
     if (!res || res.length === 0) {
       throw new ElementNotFound(parsedLocator)
     }
-    
-    // Use a safer approach for mobile: check if element exists and try isDisplayed with error handling
+
     const selected = []
     for (const el of res) {
-      try {
-        const displayed = await el.isDisplayed()
-        if (displayed) selected.push(true)
-      } catch (err) {
-        // If isDisplayed fails due to execute/sync not being supported,
-        // fall back to checking if element exists (which we already verified)
-        if (err.message && err.message.includes('Method is not implemented')) {
-          // Element exists, assume it's displayed since we found it
-          selected.push(true)
-        } else {
-          throw err
-        }
-      }
+      const displayed = await this._isDisplayedSafe(el)
+      if (displayed) selected.push(true)
     }
-    
+
     try {
       return truth(`elements of ${new Locator(parsedLocator)}`, 'to be seen').assert(selected)
     } catch (e) {
@@ -1771,7 +1781,30 @@ 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
+    const Locator = require('../locator')
+
+    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 (${new Locator(parsedLocator)}) still not visible after ${aSec} sec`,
+      },
+    )
   }
 
   /**
@@ -1780,7 +1813,27 @@ 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
+    const Locator = require('../locator')
+
+    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 (${new Locator(parsedLocator)}) still visible after ${aSec} sec` },
+    )
   }
 
   /**