appium-webdriveragent 16.2.2 → 16.4.0

package/WebDriverAgentTests/IntegrationTests_watchOS/WDAFindIntegrationTests.swift

@@ -0,0 +1,126 @@
+/**
+ * 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.
+ */
+
+import XCTest
+
+/// Covers FBFindElementCommands: find/sub-find/active-element, not-found errors, and every
+/// locator strategy (accessibility id/name/id, class name, class chain, xpath, predicate
+/// string, link text). getVisibleCells is skipped - no table/collection view to test it against.
+final class WDAFindIntegrationTests: WDAWatchIntegrationTestCase {
+  func testFindElementByAccessibilityId() throws {
+    let elementId = try findElement(byAccessibilityId: "tapMeButton")
+    XCTAssertFalse(elementId.isEmpty)
+  }
+
+  func testFindElementByNameAndIdAliases() throws {
+    // "name" and "id" are aliases for "accessibility id".
+    for using in ["name", "id"] {
+      let response = try client.post("/session/\(sessionId!)/element", body: [
+        "using": using,
+        "value": "tapMeButton",
+      ])
+      XCTAssertEqual(response.statusCode, 200, "using: \(using)")
+      XCTAssertNotNil(response.valueDict?["ELEMENT"], "using: \(using)")
+    }
+  }
+
+  func testFindElementByPredicateString() throws {
+    let response = try client.post("/session/\(sessionId!)/element", body: [
+      "using": "predicate string",
+      "value": "label == \"Tap Me\"",
+    ])
+    XCTAssertEqual(response.statusCode, 200)
+    XCTAssertNotNil(response.valueDict?["ELEMENT"])
+  }
+
+  func testFindElementsByClassChain() throws {
+    let response = try client.post("/session/\(sessionId!)/elements", body: [
+      "using": "class chain",
+      "value": "**/XCUIElementTypeButton",
+    ])
+    XCTAssertEqual(response.statusCode, 200)
+    XCTAssertGreaterThanOrEqual((response.value as? [[String: Any]])?.count ?? 0, 1)
+  }
+
+  func testFindElementByXPath() throws {
+    let response = try client.post("/session/\(sessionId!)/element", body: [
+      "using": "xpath",
+      "value": "//XCUIElementTypeButton[@name=\"tapMeButton\"]",
+    ])
+    XCTAssertEqual(response.statusCode, 200)
+    XCTAssertNotNil(response.valueDict?["ELEMENT"])
+  }
+
+  func testFindElementByLinkTextAndPartialLinkText() throws {
+    // WDA matches (partial) link text against `name`, not an actual hyperlink search.
+    for using in ["link text", "partial link text"] {
+      let value = using == "link text" ? "tapMeButton" : "tapMe"
+      let response = try client.post("/session/\(sessionId!)/element", body: [
+        "using": using,
+        "value": value,
+      ])
+      XCTAssertEqual(response.statusCode, 200, "using: \(using)")
+      XCTAssertNotNil(response.valueDict?["ELEMENT"], "using: \(using)")
+    }
+  }
+
+  func testFindElementThatDoesNotExistReturnsAnError() throws {
+    let response = try client.post("/session/\(sessionId!)/element", body: [
+      "using": "accessibility id",
+      "value": "thisElementDoesNotExist",
+    ])
+    XCTAssertNotEqual(response.statusCode, 200)
+  }
+
+  func testFindElements() throws {
+    let response = try client.post("/session/\(sessionId!)/elements", body: [
+      "using": "class name",
+      "value": "XCUIElementTypeButton",
+    ])
+    XCTAssertEqual(response.statusCode, 200)
+    guard let elements = response.value as? [[String: Any]] else {
+      return XCTFail("Expected an array of elements: \(String(describing: response.json))")
+    }
+    XCTAssertGreaterThanOrEqual(elements.count, 1)
+  }
+
+  func testFindSubElementAndSubElements() throws {
+    let windowResponse = try client.post("/session/\(sessionId!)/element", body: [
+      "using": "class name",
+      "value": "XCUIElementTypeWindow",
+    ])
+    guard let windowId = windowResponse.valueDict?["ELEMENT"] as? String else {
+      return XCTFail("Could not find the root window element")
+    }
+
+    let subElementResponse = try client.post("/session/\(sessionId!)/element/\(windowId)/element", body: [
+      "using": "accessibility id",
+      "value": "tapMeButton",
+    ])
+    XCTAssertEqual(subElementResponse.statusCode, 200)
+    XCTAssertNotNil(subElementResponse.valueDict?["ELEMENT"])
+
+    let subElementsResponse = try client.post("/session/\(sessionId!)/element/\(windowId)/elements", body: [
+      "using": "class name",
+      "value": "XCUIElementTypeButton",
+    ])
+    XCTAssertEqual(subElementsResponse.statusCode, 200)
+    XCTAssertGreaterThanOrEqual((subElementsResponse.value as? [[String: Any]])?.count ?? 0, 1)
+  }
+
+  func testActiveElementResolvesToTheFocusedTextField() throws {
+    let fieldId = try findElement(byAccessibilityId: "typingField")
+    try client.post("/session/\(sessionId!)/element/\(fieldId)/click")
+    // Give the keyboard-sheet transition a moment to finish before checking focus.
+    Thread.sleep(forTimeInterval: 1)
+
+    let response = try client.get("/session/\(sessionId!)/element/active")
+    XCTAssertEqual(response.statusCode, 200)
+    XCTAssertNotNil(response.valueDict?["ELEMENT"])
+  }
+}

package/WebDriverAgentTests/IntegrationTests_watchOS/WDAScreenshotAndSourceIntegrationTests.swift

@@ -0,0 +1,52 @@
+/**
+ * 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.
+ */
+
+import XCTest
+
+/// Covers device/element screenshots and /source, /wda/accessibleSource.
+final class WDAScreenshotAndSourceIntegrationTests: WDAWatchIntegrationTestCase {
+  private static let pngMagicBytes: [UInt8] = [0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A]
+
+  private func assertLooksLikeAPNG(_ base64String: String?, file: StaticString = #filePath, line: UInt = #line) {
+    guard let base64String = base64String, let data = Data(base64Encoded: base64String) else {
+      return XCTFail("Response value was not base64 data", file: file, line: line)
+    }
+    XCTAssertGreaterThan(data.count, Self.pngMagicBytes.count, file: file, line: line)
+    XCTAssertEqual(Array(data.prefix(Self.pngMagicBytes.count)), Self.pngMagicBytes, "response was not a PNG", file: file, line: line)
+  }
+
+  func testDeviceScreenshot() throws {
+    let response = try client.get("/session/\(sessionId!)/screenshot")
+    XCTAssertEqual(response.statusCode, 200)
+    assertLooksLikeAPNG(response.valueString)
+  }
+
+  func testElementScreenshot() throws {
+    let buttonId = try findElement(byAccessibilityId: "tapMeButton")
+    let response = try client.get("/session/\(sessionId!)/element/\(buttonId)/screenshot")
+    XCTAssertEqual(response.statusCode, 200)
+    assertLooksLikeAPNG(response.valueString)
+  }
+
+  func testPageSourceContainsTheKnownElements() throws {
+    let response = try client.get("/session/\(sessionId!)/source?format=xml")
+    XCTAssertEqual(response.statusCode, 200)
+    guard let xml = response.valueString else {
+      return XCTFail("No XML source returned")
+    }
+    XCTAssertTrue(xml.contains("tapMeButton"))
+    XCTAssertTrue(xml.contains("resultLabel"))
+    XCTAssertTrue(xml.contains("typingField"))
+  }
+
+  func testAccessibleSource() throws {
+    let response = try client.get("/session/\(sessionId!)/wda/accessibleSource")
+    XCTAssertEqual(response.statusCode, 200)
+    XCTAssertNotNil(response.value)
+  }
+}

package/WebDriverAgentTests/IntegrationTests_watchOS/WDASessionIntegrationTests.swift

@@ -0,0 +1,72 @@
+/**
+ * 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.
+ */
+
+import XCTest
+
+/// Covers FBSessionCommands. Manages its own session lifecycle per test, since that's what's
+/// under test here, rather than using WDAWatchIntegrationTestCase.
+final class WDASessionIntegrationTests: XCTestCase {
+  let client = WDAWatchHTTPClient()
+
+  override func setUp() {
+    super.setUp()
+    continueAfterFailure = false
+  }
+
+  func testStatusIsReadyWithoutASession() throws {
+    let response = try client.get("/status")
+    XCTAssertEqual(response.statusCode, 200)
+    XCTAssertEqual(response.valueDict?["ready"] as? Bool, true)
+    XCTAssertEqual(response.valueDict?["state"] as? String, "success")
+  }
+
+  func testHealthCheck() throws {
+    let response = try client.get("/wda/healthcheck")
+    XCTAssertEqual(response.statusCode, 200)
+  }
+
+  func testCreateGetActiveAndDeleteSessionLifecycle() throws {
+    let createResponse = try client.post("/session", body: [
+      "capabilities": ["alwaysMatch": ["bundleId": WDAWatchIntegrationTestCase.integrationAppBundleId]]
+    ])
+    XCTAssertEqual(createResponse.statusCode, 200)
+    guard let sessionId = createResponse.valueDict?["sessionId"] as? String else {
+      return XCTFail("No sessionId in create-session response: \(String(describing: createResponse.json))")
+    }
+    XCTAssertFalse(sessionId.isEmpty)
+
+    let activeResponse = try client.get("/session/\(sessionId)")
+    XCTAssertEqual(activeResponse.statusCode, 200)
+    XCTAssertEqual(activeResponse.valueDict?["sessionId"] as? String, sessionId)
+
+    let deleteResponse = try client.delete("/session/\(sessionId)")
+    XCTAssertEqual(deleteResponse.statusCode, 200)
+  }
+
+  func testTimeoutsAndAppiumSettingsRoundTrip() throws {
+    let createResponse = try client.post("/session", body: [
+      "capabilities": ["alwaysMatch": ["bundleId": WDAWatchIntegrationTestCase.integrationAppBundleId]]
+    ])
+    guard let sessionId = createResponse.valueDict?["sessionId"] as? String else {
+      return XCTFail("No sessionId in create-session response")
+    }
+    defer { _ = try? client.delete("/session/\(sessionId)") }
+
+    let timeoutsResponse = try client.post("/session/\(sessionId)/timeouts", body: ["implicit": 500])
+    XCTAssertEqual(timeoutsResponse.statusCode, 200)
+
+    let getSettingsResponse = try client.get("/session/\(sessionId)/appium/settings")
+    XCTAssertEqual(getSettingsResponse.statusCode, 200)
+    XCTAssertNotNil(getSettingsResponse.valueDict)
+
+    let setSettingsResponse = try client.post("/session/\(sessionId)/appium/settings", body: [
+      "settings": ["shouldUseCompactResponses": false]
+    ])
+    XCTAssertEqual(setSettingsResponse.statusCode, 200)
+  }
+}

package/WebDriverAgentTests/IntegrationTests_watchOS/WDATypingIntegrationTests.swift

@@ -0,0 +1,57 @@
+/**
+ * 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.
+ */
+
+import XCTest
+
+/// Covers /element/:uuid/value, /element/:uuid/clear, and /wda/keyboard/dismiss.
+///
+/// KNOWN LIMITATION (see XCUIElement+FBTyping.m): the keyboard opens and the field gets focus,
+/// but no keystrokes land. Wrapped in XCTExpectFailure so this re-verifies itself and starts
+/// failing loudly the moment it starts working, instead of silently staying stale.
+final class WDATypingIntegrationTests: WDAWatchIntegrationTestCase {
+  func testSetValueOpensTheKeyboardAndAttemptsToTypeIntoTheField() throws {
+    let fieldId = try findElement(byAccessibilityId: "typingField")
+    XCTAssertEqual(try attributeValue(fieldId, "value"), "Type here", "expected the untouched placeholder")
+
+    let setValueResponse = try client.post("/session/\(sessionId!)/element/\(fieldId)/value", body: [
+      "value": ["h", "i"]
+    ])
+    XCTAssertEqual(setValueResponse.statusCode, 200, "the route itself should not error even though typing doesn't land")
+
+    XCTExpectFailure("watchOS keystroke delivery into the on-screen keyboard is a known unresolved limitation") {
+      let value = try? attributeValue(fieldId, "value")
+      XCTAssertEqual(value, "hi")
+    }
+
+    // Back out so later tests start clean.
+    if let cancelId = try? findElement(byAccessibilityId: "Cancel") {
+      _ = try? client.post("/session/\(sessionId!)/element/\(cancelId)/click")
+    }
+  }
+
+  func testClearingAnAlreadyEmptyFieldSucceeds() throws {
+    // Clearing an empty field short-circuits, so this works despite the typing limitation.
+    let fieldId = try findElement(byAccessibilityId: "typingField")
+    let clearResponse = try client.post("/session/\(sessionId!)/element/\(fieldId)/clear")
+    XCTAssertEqual(clearResponse.statusCode, 200)
+  }
+
+  func testDismissKeyboardRouteRespondsWithoutCrashingTheServer() throws {
+    // Only asserts the route round-trips cleanly, not that dismissal actually happens.
+    let fieldId = try findElement(byAccessibilityId: "typingField")
+    try client.post("/session/\(sessionId!)/element/\(fieldId)/click")
+    Thread.sleep(forTimeInterval: 1)
+
+    _ = try client.post("/session/\(sessionId!)/wda/keyboard/dismiss")
+
+    // Back out regardless of whether dismiss actually closed the sheet.
+    if let cancelId = try? findElement(byAccessibilityId: "Cancel") {
+      _ = try? client.post("/session/\(sessionId!)/element/\(cancelId)/click")
+    }
+  }
+}

package/WebDriverAgentTests/IntegrationTests_watchOS/WDAUnknownCommandIntegrationTests.swift

@@ -0,0 +1,24 @@
+/**
+ * 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.
+ */
+
+import XCTest
+
+/// Covers the catch-all 404 routes and the OPTIONS ping route - neither needs a session.
+final class WDAUnknownCommandIntegrationTests: XCTestCase {
+  let client = WDAWatchHTTPClient()
+
+  func testUnknownRouteReturnsAnError() throws {
+    let response = try client.get("/this/route/does/not/exist")
+    XCTAssertNotEqual(response.statusCode, 200)
+  }
+
+  func testPing() throws {
+    let response = try client.send("OPTIONS", "/anything")
+    XCTAssertEqual(response.statusCode, 200)
+  }
+}

package/WebDriverAgentTests/IntegrationTests_watchOS/WDAWatchHTTPClient.swift

@@ -0,0 +1,95 @@
+/**
+ * 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.
+ */
+
+import Foundation
+
+/// Minimal synchronous JSON/HTTP client for driving the real WebDriverAgentRunner_watchOS
+/// server, the same way a real client (Appium, curl) would. Requires the server to already be
+/// running, e.g. via `xcodebuild test -scheme WebDriverAgentRunner_watchOS`.
+struct WDAWatchHTTPClient {
+  struct Response {
+    let statusCode: Int
+    let json: [String: Any]?
+
+    var value: Any? { json?["value"] }
+    var valueDict: [String: Any]? { value as? [String: Any] }
+    var valueString: String? { value as? String }
+  }
+
+  enum ClientError: Error, CustomStringConvertible {
+    case requestFailed(String)
+
+    var description: String {
+      switch self {
+      case .requestFailed(let message): return message
+      }
+    }
+  }
+
+  let baseURL: URL
+
+  init() {
+    let host = ProcessInfo.processInfo.environment["WDA_TEST_HOST"] ?? "127.0.0.1"
+    let port = ProcessInfo.processInfo.environment["WDA_TEST_PORT"] ?? "8100"
+    self.baseURL = URL(string: "http://\(host):\(port)")!
+  }
+
+  /// Splits path/query before resolving against baseURL - appendingPathComponent would
+  /// percent-encode a literal "?" instead of treating it as a query delimiter.
+  private func url(for path: String) -> URL {
+    let parts = path.split(separator: "?", maxSplits: 1)
+    var components = URLComponents(url: baseURL, resolvingAgainstBaseURL: false)!
+    components.path = components.path + parts[0]
+    if parts.count > 1 {
+      components.percentEncodedQuery = String(parts[1])
+    }
+    return components.url!
+  }
+
+  @discardableResult
+  func send(_ method: String, _ path: String, body: [String: Any]? = nil, timeout: TimeInterval = 20) throws -> Response {
+    var request = URLRequest(url: url(for: path))
+    request.httpMethod = method
+    request.timeoutInterval = timeout
+    if let body = body {
+      request.setValue("application/json", forHTTPHeaderField: "Content-Type")
+      request.httpBody = try JSONSerialization.data(withJSONObject: body)
+    }
+
+    let semaphore = DispatchSemaphore(value: 0)
+    var resultData: Data?
+    var resultResponse: URLResponse?
+    var resultError: Error?
+
+    URLSession.shared.dataTask(with: request) { data, response, error in
+      resultData = data
+      resultResponse = response
+      resultError = error
+      semaphore.signal()
+    }.resume()
+
+    if semaphore.wait(timeout: .now() + timeout + 5) == .timedOut {
+      throw ClientError.requestFailed("Request to \(method) \(path) timed out")
+    }
+    if let resultError = resultError {
+      throw ClientError.requestFailed("Request to \(method) \(path) failed: \(resultError)")
+    }
+    guard let httpResponse = resultResponse as? HTTPURLResponse else {
+      throw ClientError.requestFailed("Request to \(method) \(path) returned no HTTP response")
+    }
+    var json: [String: Any]?
+    if let resultData = resultData, !resultData.isEmpty {
+      json = try? JSONSerialization.jsonObject(with: resultData) as? [String: Any]
+    }
+    return Response(statusCode: httpResponse.statusCode, json: json)
+  }
+
+  func get(_ path: String) throws -> Response { try send("GET", path) }
+  func post(_ path: String, body: [String: Any] = [:]) throws -> Response { try send("POST", path, body: body) }
+  func delete(_ path: String) throws -> Response { try send("DELETE", path) }
+}

package/WebDriverAgentTests/IntegrationTests_watchOS/WDAWatchIntegrationTestCase.swift

@@ -0,0 +1,61 @@
+/**
+ * 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.
+ */
+
+import XCTest
+
+/// Creates a fresh WDA session against IntegrationApp_watchOS per test, so each starts clean.
+class WDAWatchIntegrationTestCase: XCTestCase {
+  static let integrationAppBundleId = ProcessInfo.processInfo.environment["WDA_TEST_BUNDLE_ID"]
+    ?? "com.facebook.wda.IntegrationApp.watchOS"
+
+  let client = WDAWatchHTTPClient()
+  var sessionId: String!
+
+  override func setUp() {
+    super.setUp()
+    continueAfterFailure = false
+    do {
+      let response = try client.post("/session", body: [
+        "capabilities": ["alwaysMatch": ["bundleId": Self.integrationAppBundleId]]
+      ])
+      guard response.statusCode == 200, let sessionId = response.valueDict?["sessionId"] as? String else {
+        XCTFail("Failed to create session: \(String(describing: response.json))")
+        return
+      }
+      self.sessionId = sessionId
+    } catch {
+      XCTFail("Failed to create session: \(error)")
+    }
+  }
+
+  override func tearDown() {
+    if let sessionId = sessionId {
+      _ = try? client.delete("/session/\(sessionId)")
+    }
+    super.tearDown()
+  }
+
+  /// Finds an element by accessibility id and returns its WDA element UUID.
+  @discardableResult
+  func findElement(byAccessibilityId accessibilityId: String, file: StaticString = #filePath, line: UInt = #line) throws -> String {
+    let response = try client.post("/session/\(sessionId!)/element", body: [
+      "using": "accessibility id",
+      "value": accessibilityId,
+    ])
+    guard response.statusCode == 200, let elementId = response.valueDict?["ELEMENT"] as? String else {
+      XCTFail("Could not find element '\(accessibilityId)': \(String(describing: response.json))", file: file, line: line)
+      throw WDAWatchHTTPClient.ClientError.requestFailed("element not found")
+    }
+    return elementId
+  }
+
+  func attributeValue(_ elementId: String, _ name: String) throws -> String? {
+    let response = try client.get("/session/\(sessionId!)/element/\(elementId)/attribute/\(name)")
+    return response.valueString
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "appium-webdriveragent",
-  "version": "16.2.2",
+  "version": "16.4.0",
   "description": "Package bundling WebDriverAgent",
   "keywords": [
     "Appium",