appium-webdriveragent 16.4.0 → 16.5.0

package/WebDriverAgent.xcodeproj/xcshareddata/xcschemes/IntegrationTests_watchOS.xcscheme

@@ -14,7 +14,7 @@
             buildForAnalyzing = "NO">
             <BuildableReference
                BuildableIdentifier = "primary"
-               BlueprintIdentifier = "4632809915F58C9095914E85"
+               BlueprintIdentifier = "5D9539D7055B5E6EED56D100"
                BuildableName = "IntegrationTests_watchOS.xctest"
                BlueprintName = "IntegrationTests_watchOS"
                ReferencedContainer = "container:WebDriverAgent.xcodeproj">
@@ -32,7 +32,7 @@
             skipped = "NO">
             <BuildableReference
                BuildableIdentifier = "primary"
-               BlueprintIdentifier = "4632809915F58C9095914E85"
+               BlueprintIdentifier = "5D9539D7055B5E6EED56D100"
                BuildableName = "IntegrationTests_watchOS.xctest"
                BlueprintName = "IntegrationTests_watchOS"
                ReferencedContainer = "container:WebDriverAgent.xcodeproj">
@@ -53,7 +53,7 @@
       <MacroExpansion>
          <BuildableReference
             BuildableIdentifier = "primary"
-            BlueprintIdentifier = "4632809915F58C9095914E85"
+            BlueprintIdentifier = "5D9539D7055B5E6EED56D100"
             BuildableName = "IntegrationTests_watchOS.xctest"
             BlueprintName = "IntegrationTests_watchOS"
             ReferencedContainer = "container:WebDriverAgent.xcodeproj">
@@ -69,7 +69,7 @@
       <MacroExpansion>
          <BuildableReference
             BuildableIdentifier = "primary"
-            BlueprintIdentifier = "4632809915F58C9095914E85"
+            BlueprintIdentifier = "5D9539D7055B5E6EED56D100"
             BuildableName = "IntegrationTests_watchOS.xctest"
             BlueprintName = "IntegrationTests_watchOS"
             ReferencedContainer = "container:WebDriverAgent.xcodeproj">

package/WebDriverAgentLib/FBAlert.m

@@ -236,17 +236,18 @@
   }
 
   XCUIElement *acceptButton = nil;
-  if (FBConfiguration.sharedInstance.acceptAlertButtonSelector.length) {
+  NSString *acceptAlertButtonSelector = FBConfiguration.sharedInstance.acceptAlertButtonSelector ?: @"";
+  if (acceptAlertButtonSelector.length) {
     NSString *errorReason = nil;
     @try {
-      acceptButton = [[alertElement fb_descendantsMatchingClassChain:FBConfiguration.sharedInstance.acceptAlertButtonSelector
+      acceptButton = [[alertElement fb_descendantsMatchingClassChain:acceptAlertButtonSelector
                                            shouldReturnAfterFirstMatch:YES] firstObject];
     } @catch (NSException *ex) {
       errorReason = ex.reason;
     }
     if (nil == acceptButton) {
       [FBLogger logFmt:@"Cannot find any match for Accept alert button using the class chain selector '%@'",
-       FBConfiguration.sharedInstance.acceptAlertButtonSelector];
+       acceptAlertButtonSelector];
       if (nil != errorReason) {
         [FBLogger logFmt:@"Original error: %@", errorReason];
       }
@@ -293,17 +294,18 @@
   }
 
   XCUIElement *dismissButton = nil;
-  if (FBConfiguration.sharedInstance.dismissAlertButtonSelector.length) {
+  NSString *dismissAlertButtonSelector = FBConfiguration.sharedInstance.dismissAlertButtonSelector ?: @"";
+  if (dismissAlertButtonSelector.length) {
     NSString *errorReason = nil;
     @try {
-      dismissButton = [[alertElement fb_descendantsMatchingClassChain:FBConfiguration.sharedInstance.dismissAlertButtonSelector
+      dismissButton = [[alertElement fb_descendantsMatchingClassChain:dismissAlertButtonSelector
                                             shouldReturnAfterFirstMatch:YES] firstObject];
     } @catch (NSException *ex) {
       errorReason = ex.reason;
     }
     if (nil == dismissButton) {
       [FBLogger logFmt:@"Cannot find any match for Dismiss alert button using the class chain selector '%@'",
-       FBConfiguration.sharedInstance.dismissAlertButtonSelector];
+       dismissAlertButtonSelector];
       if (nil != errorReason) {
         [FBLogger logFmt:@"Original error: %@", errorReason];
       }

package/WebDriverAgentLib/Info.plist

@@ -15,11 +15,11 @@
     <key>CFBundlePackageType</key>
     <string>FMWK</string>
     <key>CFBundleShortVersionString</key>
-    <string>16.4.0</string>
+    <string>16.5.0</string>
     <key>CFBundleSignature</key>
     <string>????</string>
     <key>CFBundleVersion</key>
-    <string>16.4.0</string>
+    <string>16.5.0</string>
     <key>NSPrincipalClass</key>
     <string/>
   </dict>

package/WebDriverAgentTests/IntegrationTests_watchOS/IntegrationTests_watchOS-Bridging-Header.h

@@ -0,0 +1,21 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+// Exposes the WebDriverAgentLib_watchOS categories these tests call directly, in-process,
+// instead of going through the HTTP server.
+
+#import "XCUIElement+FBFind.h"
+#import "XCUIElement+FBClassChain.h"
+#import "XCUIElement+FBIsVisible.h"
+#import "XCUIElement+FBUtilities.h"
+#import "XCUIElement+FBWebDriverAttributes.h"
+#import "XCUIElement+FBTyping.h"
+#import "XCUIApplication+FBHelpers.h"
+#import "XCUIDevice+FBHelpers.h"
+#import "FBAlert.h"
+#import "FBElement.h"

package/WebDriverAgentTests/IntegrationTests_watchOS/WDAAlertIntegrationTests.swift

@@ -8,16 +8,18 @@
 
 import XCTest
 
-/// Covers FBAlertViewCommands' error path - IntegrationApp_watchOS never presents a real alert,
-/// so this only exercises the "no alert open" error, not the success path.
-final class WDAAlertIntegrationTests: WDAWatchIntegrationTestCase {
-  func testAlertTextWithNoAlertPresentReturnsAnError() throws {
-    let response = try client.get("/session/\(sessionId!)/alert/text")
-    XCTAssertNotEqual(response.statusCode, 200)
+/// Covers FBAlert's no-alert-present behavior directly, in-process. IntegrationApp_watchOS never
+/// presents a real alert, so this only exercises the "no alert open" path (`text`/`buttonLabels`
+/// both just return nil - no HTTP-error-style throw at this layer), not the success path.
+final class WDAAlertIntegrationTests: WDAWatchInProcessTestCase {
+  // All reads, no taps/typing - reuse the same running app across the whole class.
+  override class var relaunchForEachTest: Bool { false }
+
+  func testAlertTextWithNoAlertPresentReturnsNil() {
+    XCTAssertNil(FBAlert(application: app).text())
   }
 
-  func testAlertButtonsWithNoAlertPresentReturnsAnError() throws {
-    let response = try client.get("/session/\(sessionId!)/wda/alert/buttons")
-    XCTAssertNotEqual(response.statusCode, 200)
+  func testAlertButtonsWithNoAlertPresentReturnsNil() {
+    XCTAssertNil(FBAlert(application: app).buttonLabels())
   }
 }

package/WebDriverAgentTests/IntegrationTests_watchOS/WDAAppLifecycleIntegrationTests.swift

@@ -8,50 +8,30 @@
 
 import XCTest
 
-/// Covers the app lifecycle routes (launch/activate/terminate/state/list). Unlike
-/// /wda/homescreen or /wda/lock, these only ever target IntegrationApp_watchOS, so they're
-/// safe to run repeatedly without disrupting shared simulator state.
-final class WDAAppLifecycleIntegrationTests: WDAWatchIntegrationTestCase {
-  // XCUIApplicationState raw values: NotRunning = 1, RunningForeground = 4.
-  private static let notRunningState = 1
-  private static let runningForegroundState = 4
-
-  func testAppsListIncludesTheAppUnderTest() throws {
-    let response = try client.get("/session/\(sessionId!)/wda/apps/list")
-    XCTAssertEqual(response.statusCode, 200)
-    guard let apps = response.value as? [[String: Any]] else {
-      return XCTFail("Expected an array of active apps: \(String(describing: response.json))")
-    }
-    XCTAssertTrue(apps.contains { $0["bundleId"] as? String == Self.integrationAppBundleId })
+/// Covers the app lifecycle routes (launch/activate/terminate/state/list). FBSession's
+/// implementations of these are themselves thin wrappers over plain XCTest XCUIApplication
+/// APIs (see FBSession.m), so this calls `.launch()`/`.activate()`/`.terminate()`/`.state`
+/// directly instead of going through the HTTP server; only the apps-list route has a real WDA
+/// category behind it (`+fb_activeAppsInfo`).
+final class WDAAppLifecycleIntegrationTests: WDAWatchInProcessTestCase {
+  func testAppsListIncludesTheAppUnderTest() {
+    let apps = XCUIApplication.fb_activeAppsInfo()
+    XCTAssertTrue(apps.contains { $0["bundleId"] as? String == WDAWatchInProcessTestCase.integrationAppBundleId })
   }
 
-  func testTerminateThenRelaunchLifecycle() throws {
-    let bundleId = Self.integrationAppBundleId
-
-    let terminateResponse = try client.post("/session/\(sessionId!)/wda/apps/terminate", body: ["bundleId": bundleId])
-    XCTAssertEqual(terminateResponse.statusCode, 200)
-    XCTAssertEqual(terminateResponse.value as? Bool, true)
-
-    let stateAfterTerminate = try client.post("/session/\(sessionId!)/wda/apps/state", body: ["bundleId": bundleId])
-    XCTAssertEqual(stateAfterTerminate.value as? Int, Self.notRunningState)
+  func testTerminateThenRelaunchLifecycle() {
+    app.terminate()
+    XCTAssertEqual(app.state, .notRunning)
 
-    let launchResponse = try client.post("/session/\(sessionId!)/wda/apps/launch", body: ["bundleId": bundleId])
-    XCTAssertEqual(launchResponse.statusCode, 200)
-    Thread.sleep(forTimeInterval: 1)
-
-    let stateAfterLaunch = try client.post("/session/\(sessionId!)/wda/apps/state", body: ["bundleId": bundleId])
-    XCTAssertEqual(stateAfterLaunch.value as? Int, Self.runningForegroundState)
+    app.launch()
+    XCTAssertEqual(app.state, .runningForeground)
 
     // The app relaunched fresh, so its accessibility tree should be back too.
-    XCTAssertNoThrow(try findElement(byAccessibilityId: "tapMeButton"))
+    XCTAssertTrue(app.buttons["tapMeButton"].waitForExistence(timeout: 15))
   }
 
-  func testActivateBringsTheAppToTheForeground() throws {
-    let bundleId = Self.integrationAppBundleId
-    let activateResponse = try client.post("/session/\(sessionId!)/wda/apps/activate", body: ["bundleId": bundleId])
-    XCTAssertEqual(activateResponse.statusCode, 200)
-
-    let stateResponse = try client.post("/session/\(sessionId!)/wda/apps/state", body: ["bundleId": bundleId])
-    XCTAssertEqual(stateResponse.value as? Int, Self.runningForegroundState)
+  func testActivateBringsTheAppToTheForeground() {
+    app.activate()
+    XCTAssertEqual(app.state, .runningForeground)
   }
 }

package/WebDriverAgentTests/IntegrationTests_watchOS/WDAClickIntegrationTests.swift

@@ -8,24 +8,18 @@
 
 import XCTest
 
-/// Covers /element/:uuid/click - the only tap-like interaction registered on watchOS
-/// (gesture synthesis routes aren't).
-final class WDAClickIntegrationTests: WDAWatchIntegrationTestCase {
-  func testClickingButtonUpdatesTheResultLabel() throws {
-    let labelId = try findElement(byAccessibilityId: "resultLabel")
-    XCTAssertEqual(try attributeValue(labelId, "label"), "Idle")
+/// Covers /element/:uuid/click, which on watchOS (like iOS) is just standard XCTest `-tap`
+/// (see FBElementCommands.handleClick:) - so this just calls `.tap()` directly, the same way
+/// the iOS/tvOS integration tests do. The "click a nonexistent element UUID" case isn't a `tap`
+/// behavior at all (it's FBElementCache's UUID-lookup failure), so it's covered by the HTTP
+/// end-to-end tests instead, where there's an actual UUID/route layer to miss against.
+final class WDAClickIntegrationTests: WDAWatchInProcessTestCase {
+  func testClickingButtonUpdatesTheResultLabel() {
+    let label = app.staticTexts["resultLabel"]
+    XCTAssertEqual(label.wdValue ?? label.wdLabel, "Idle")
 
-    let buttonId = try findElement(byAccessibilityId: "tapMeButton")
-    let clickResponse = try client.post("/session/\(sessionId!)/element/\(buttonId)/click")
-    XCTAssertEqual(clickResponse.statusCode, 200)
+    app.buttons["tapMeButton"].tap()
 
-    // Re-find: element UUIDs aren't stable across snapshots, and the label just changed.
-    let updatedLabelId = try findElement(byAccessibilityId: "resultLabel")
-    XCTAssertEqual(try attributeValue(updatedLabelId, "label"), "Tapped")
-  }
-
-  func testClickingAnElementThatDoesNotExistReturnsAnError() throws {
-    let response = try client.post("/session/\(sessionId!)/element/00000000-0000-0000-0000-000000000000/click")
-    XCTAssertNotEqual(response.statusCode, 200)
+    XCTAssertEqual(label.wdValue ?? label.wdLabel, "Tapped")
   }
 }

package/WebDriverAgentTests/IntegrationTests_watchOS/WDADeviceIntegrationTests.swift

@@ -6,46 +6,37 @@
  * LICENSE file in the root directory of this source tree.
  */
 
+import CoreLocation
+import WatchKit
 import XCTest
 
-/// Covers device-info and location routes. These only read device state or set a simulated
-/// GPS fix, so unlike /wda/lock or /wda/voiceOver/enable, they won't disrupt later tests.
-final class WDADeviceIntegrationTests: WDAWatchIntegrationTestCase {
-  func testDeviceInfo() throws {
-    let response = try client.get("/session/\(sessionId!)/wda/device/info")
-    XCTAssertEqual(response.statusCode, 200)
-    XCTAssertFalse((response.valueDict?["name"] as? String ?? "").isEmpty)
-    XCTAssertFalse((response.valueDict?["model"] as? String ?? "").isEmpty)
+/// Covers device-info, active-app-info, simulated location, digital crown rotation, and hand
+/// gesture, calling the same underlying APIs FBCustomCommands/XCUIDevice+FBHelpers use directly
+/// in-process. The real (non-simulated) GPS location route and the two pure argument-validation
+/// cases (missing delta/gesture name, rejected before any category method is even called) aren't
+/// WDA category behavior, so they're not covered here.
+final class WDADeviceIntegrationTests: WDAWatchInProcessTestCase {
+  func testDeviceInfo() {
+    XCTAssertFalse(WKInterfaceDevice.current().name.isEmpty)
+    XCTAssertFalse(WKInterfaceDevice.current().model.isEmpty)
   }
 
-  func testActiveAppInfo() throws {
-    let response = try client.get("/session/\(sessionId!)/wda/activeAppInfo")
-    XCTAssertEqual(response.statusCode, 200)
-    XCTAssertEqual(response.valueDict?["bundleId"] as? String, Self.integrationAppBundleId)
-    XCTAssertGreaterThan(response.valueDict?["pid"] as? Int ?? 0, 0)
-  }
-
-  func testDeviceLocation() throws {
-    let response = try client.get("/session/\(sessionId!)/wda/device/location")
-    XCTAssertEqual(response.statusCode, 200)
-    XCTAssertNotNil(response.valueDict?["latitude"])
-    XCTAssertNotNil(response.valueDict?["authorizationStatus"])
+  func testActiveAppInfo() {
+    let apps = XCUIApplication.fb_activeAppsInfo()
+    let ourApp = apps.first { $0["bundleId"] as? String == WDAWatchInProcessTestCase.integrationAppBundleId }
+    XCTAssertNotNil(ourApp)
+    XCTAssertGreaterThan(ourApp?["pid"] as? Int ?? 0, 0)
   }
 
   func testSimulatedLocationRoundTrip() throws {
-    let setResponse = try client.post("/session/\(sessionId!)/wda/simulatedLocation", body: [
-      "latitude": 37.3230,
-      "longitude": -122.0322,
-    ])
-    XCTAssertEqual(setResponse.statusCode, 200)
+    let location = CLLocation(latitude: 37.3230, longitude: -122.0322)
+    try XCUIDevice.shared.fb_setSimulatedLocation(location)
 
-    let getResponse = try client.get("/session/\(sessionId!)/wda/simulatedLocation")
-    XCTAssertEqual(getResponse.statusCode, 200)
-    XCTAssertEqual(getResponse.valueDict?["latitude"] as? Double ?? 0, 37.3230, accuracy: 0.001)
-    XCTAssertEqual(getResponse.valueDict?["longitude"] as? Double ?? 0, -122.0322, accuracy: 0.001)
+    let fetched = try XCUIDevice.shared.fb_getSimulatedLocation()
+    XCTAssertEqual(fetched.coordinate.latitude, 37.3230, accuracy: 0.001)
+    XCTAssertEqual(fetched.coordinate.longitude, -122.0322, accuracy: 0.001)
 
-    let clearResponse = try client.delete("/session/\(sessionId!)/wda/simulatedLocation")
-    XCTAssertEqual(clearResponse.statusCode, 200)
+    try XCUIDevice.shared.fb_clearSimulatedLocation()
   }
 
   /// rotateDigitalCrownByDelta:/performHandGesture: were only added to the SDK in Xcode 16.3 - WDA calls
@@ -53,61 +44,49 @@ final class WDADeviceIntegrationTests: WDAWatchIntegrationTestCase {
   /// when the toolchain that built this very test bundle (same build as the runner) is new enough. Checked
   /// the same way WDA itself does, via responds(to:), rather than hardcoding an Xcode/OS version number here.
   private var supportsDigitalCrownAndHandGesture: Bool {
-    XCUIDevice.shared.responds(to: Selector(("rotateDigitalCrownByDelta:")))
-  }
-
-  func testRotateDigitalCrown() throws {
-    let response = try client.post("/session/\(sessionId!)/wda/rotateDigitalCrown", body: [
-      "delta": 0.2,
-      "velocity": 1.0,
-    ])
-    XCTAssertEqual(response.statusCode, supportsDigitalCrownAndHandGesture ? 200 : 500)
+    XCUIDevice.shared.responds(to: NSSelectorFromString("rotateDigitalCrownByDelta:"))
   }
 
-  func testRotateDigitalCrownDefaultVelocity() throws {
-    let response = try client.post("/session/\(sessionId!)/wda/rotateDigitalCrown", body: [
-      "delta": -0.2,
-    ])
-    XCTAssertEqual(response.statusCode, supportsDigitalCrownAndHandGesture ? 200 : 500)
+  private func assertSucceeds(_ expectedToSucceed: Bool, file: StaticString = #filePath, line: UInt = #line, _ body: () throws -> Void) {
+    do {
+      try body()
+      XCTAssertTrue(expectedToSucceed, "expected this to throw, but it didn't", file: file, line: line)
+    } catch {
+      XCTAssertFalse(expectedToSucceed, "expected this to succeed, but it threw \(error)", file: file, line: line)
+    }
   }
 
-  func testRotateDigitalCrownMissingDelta() throws {
-    // Argument validation happens before the dynamic dispatch check, so this is always a 400.
-    let response = try client.post("/session/\(sessionId!)/wda/rotateDigitalCrown")
-    XCTAssertEqual(response.statusCode, 400)
+  func testRotateDigitalCrown() {
+    assertSucceeds(supportsDigitalCrownAndHandGesture) {
+      try XCUIDevice.shared.fb_rotateDigitalCrown(0.2, velocity: 1.0)
+    }
   }
 
-  func testPerformHandGestureDoubleTap() throws {
-    let response = try client.post("/session/\(sessionId!)/wda/performHandGesture", body: [
-      "name": "doubleTap",
-    ])
-    XCTAssertEqual(response.statusCode, supportsDigitalCrownAndHandGesture ? 200 : 500)
+  func testPerformHandGestureDoubleTap() {
+    assertSucceeds(supportsDigitalCrownAndHandGesture) {
+      try XCUIDevice.shared.fb_performHandGesture("doubleTap")
+    }
   }
 
-  func testPerformHandGestureFlick() throws {
-    let response = try client.post("/session/\(sessionId!)/wda/performHandGesture", body: [
-      "name": "flick",
-    ])
+  func testPerformHandGestureFlick() {
     // flick additionally needs watchOS 26+ (still internally versioned 12.0 pre-rename) on top of the
     // Xcode 16.3+ toolchain floor - below that OS version it isn't even advertised as a supported name,
     // so the server rejects it the same way it would reject any other unknown gesture name.
-    if #available(watchOS 12.0, *), supportsDigitalCrownAndHandGesture {
-      XCTAssertEqual(response.statusCode, 200)
+    let shouldSucceed: Bool
+    if #available(watchOS 12.0, *) {
+      shouldSucceed = supportsDigitalCrownAndHandGesture
     } else {
-      XCTAssertEqual(response.statusCode, 500)
+      shouldSucceed = false
+    }
+    assertSucceeds(shouldSucceed) {
+      try XCUIDevice.shared.fb_performHandGesture("flick")
     }
   }
 
-  func testPerformHandGestureUnsupportedName() throws {
+  func testPerformHandGestureUnsupportedName() {
     // Not a real gesture name in any environment, so always rejected regardless of toolchain/OS version.
-    let response = try client.post("/session/\(sessionId!)/wda/performHandGesture", body: [
-      "name": "clench",
-    ])
-    XCTAssertEqual(response.statusCode, 500)
-  }
-
-  func testPerformHandGestureMissingName() throws {
-    let response = try client.post("/session/\(sessionId!)/wda/performHandGesture")
-    XCTAssertEqual(response.statusCode, 400)
+    assertSucceeds(false) {
+      try XCUIDevice.shared.fb_performHandGesture("clench")
+    }
   }
 }

package/WebDriverAgentTests/IntegrationTests_watchOS/WDAElementAttributeIntegrationTests.swift

@@ -8,50 +8,32 @@
 
 import XCTest
 
-/// Covers FBElementCommands' read-only element/window attribute routes.
-final class WDAElementAttributeIntegrationTests: WDAWatchIntegrationTestCase {
-  func testWindowSizeAndRect() throws {
-    let sizeResponse = try client.get("/session/\(sessionId!)/window/size")
-    XCTAssertEqual(sizeResponse.statusCode, 200)
-    XCTAssertGreaterThan(sizeResponse.valueDict?["width"] as? Double ?? 0, 0)
-    XCTAssertGreaterThan(sizeResponse.valueDict?["height"] as? Double ?? 0, 0)
-
-    let rectResponse = try client.get("/session/\(sessionId!)/window/rect")
-    XCTAssertEqual(rectResponse.statusCode, 200)
-    XCTAssertGreaterThan(rectResponse.valueDict?["width"] as? Double ?? 0, 0)
+/// Covers the FBElement attribute properties (wdEnabled/wdVisible/wdRect/wdType/wdLabel/
+/// wdSelected/wdAccessible/fb_valueForWDAttributeName:) directly, in-process - the same
+/// properties FBElementCommands' attribute routes read from.
+final class WDAElementAttributeIntegrationTests: WDAWatchInProcessTestCase {
+  // All reads, no taps/typing - reuse the same running app across the whole class.
+  override class var relaunchForEachTest: Bool { false }
+
+  func testWindowSizeAndRect() {
+    XCTAssertGreaterThan(app.wdFrame.width, 0)
+    XCTAssertGreaterThan(app.wdFrame.height, 0)
   }
 
-  func testButtonAttributes() throws {
-    let buttonId = try findElement(byAccessibilityId: "tapMeButton")
-
-    let enabledResponse = try client.get("/session/\(sessionId!)/element/\(buttonId)/enabled")
-    XCTAssertEqual(enabledResponse.value as? Bool, true)
-
-    let displayedResponse = try client.get("/session/\(sessionId!)/element/\(buttonId)/displayed")
-    XCTAssertEqual(displayedResponse.value as? Bool, true)
-
-    let rectResponse = try client.get("/session/\(sessionId!)/element/\(buttonId)/rect")
-    XCTAssertEqual(rectResponse.statusCode, 200)
-    XCTAssertGreaterThan(rectResponse.valueDict?["width"] as? Double ?? 0, 0)
-
-    let nameResponse = try client.get("/session/\(sessionId!)/element/\(buttonId)/name")
-    XCTAssertEqual(nameResponse.valueString, "XCUIElementTypeButton")
-
-    let labelResponse = try client.get("/session/\(sessionId!)/element/\(buttonId)/attribute/label")
-    XCTAssertEqual(labelResponse.valueString, "Tap Me")
-
-    let accessibleResponse = try client.get("/session/\(sessionId!)/wda/element/\(buttonId)/accessible")
-    XCTAssertEqual(accessibleResponse.statusCode, 200)
+  func testButtonAttributes() {
+    let button = app.buttons["tapMeButton"]
+    XCTAssertTrue(button.isWDEnabled)
+    XCTAssertTrue(button.isWDVisible)
+    XCTAssertGreaterThan(button.wdRect["width"] as? Double ?? 0, 0)
+    XCTAssertEqual(button.wdType, "XCUIElementTypeButton")
+    XCTAssertEqual(button.wdLabel, "Tap Me")
+    XCTAssertEqual(button.fb_value(forWDAttributeName: "label") as? String, "Tap Me")
+    XCTAssertTrue(button.isWDAccessible)
   }
 
-  func testResultLabelTextAndSelectedState() throws {
-    let labelId = try findElement(byAccessibilityId: "resultLabel")
-
-    let textResponse = try client.get("/session/\(sessionId!)/element/\(labelId)/text")
-    XCTAssertEqual(textResponse.valueString, "Idle")
-
-    let selectedResponse = try client.get("/session/\(sessionId!)/element/\(labelId)/selected")
-    XCTAssertEqual(selectedResponse.statusCode, 200)
-    XCTAssertEqual(selectedResponse.value as? Bool, false)
+  func testResultLabelTextAndSelectedState() {
+    let label = app.staticTexts["resultLabel"]
+    XCTAssertEqual(label.wdValue ?? label.wdLabel, "Idle")
+    XCTAssertFalse(label.isWDSelected)
   }
 }