appium-webdriveragent 16.2.2 → 16.3.0

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.3.0",
   "description": "Package bundling WebDriverAgent",
   "keywords": [
     "Appium",