@craft-native/ios 0.0.451 → 0.0.464

package/templates/testing/DriverTests.swift.template

@@ -61,6 +61,8 @@ final class DriverTests: XCTestCase {
     let tabs: [String] = {{TABS}}
     let tabIdentifiers: [String: String] = {{TAB_IDENTIFIERS}}
     private var bundledJourney = false
+    private var lastTappedInput: XCUIElement?
+    private var lastBooleanTap: [String: Any]?
 
     func get(_ path: String, timeout: Double = 15) -> Data? {
         var result: Data?
@@ -293,8 +295,6 @@ final class DriverTests: XCTestCase {
         return (parts[0], parts.count > 1 ? Double(parts[1]) ?? 10 : 10)
     }
 
-    /// A switch reports "0" or "1". Any other value is not a switch state to
-    /// wait on, so the tap stands as it would for any other control.
     /// The switch answers `/exec` with 200 whatever the hook did, its first
     /// word the hook's exit code: only `exit 0` is a hook that worked.
     func hookSucceeded(_ answer: String) -> Bool {
@@ -308,16 +308,26 @@ final class DriverTests: XCTestCase {
         return fields.count >= 2 && fields[1] == "0"
     }
 
+    /// UIKit and Craft's solid toggle both publish "0" or "1", regardless
+    /// of the accessibility element type that XCTest assigns to them.
     func switchFlipped(from before: String?, to after: String?) -> Bool {
         let states: Set<String> = ["0", "1"]
-        guard let before, let after, states.contains(before), states.contains(after) else { return true }
+        // A lost accessibility value is missing evidence, not a successful tap.
+        guard let before, let after, states.contains(before), states.contains(after) else { return false }
         return before != after
     }
 
     /// Deliver one gesture; the command's observation determines success.
     func press(_ element: XCUIElement) {
+        // Resolve this before activation: a menu item can disappear as soon
+        // as its gesture completes (for example Select All).
+        let input = [.textField, .secureTextField, .textView, .searchField].contains(element.elementType)
+            ? element : nil
         if element.isHittable { element.tap() }
         else { element.coordinate(withNormalizedOffset: CGVector(dx: 0.5, dy: 0.5)).tap() }
+        // A tap on a read-only text view need not open the keyboard. Only a
+        // following type command observes whether this target took focus.
+        lastTappedInput = input
     }
 
     func answerOpenPrompt() {
@@ -353,6 +363,11 @@ final class DriverTests: XCTestCase {
         let parts = line.split(separator: " ", maxSplits: 1).map(String.init)
         let command = parts[0]
         let arg = parts.count > 1 ? parts[1] : ""
+        // Context changes can move focus without going through press().
+        if ["launch", "activate", "terminate", "home", "background", "openurl", "universallink",
+            "back", "return", "tab", "tapxy", "edge", "notifications", "systemtap", "longpressid", "exec"].contains(command) {
+            lastTappedInput = nil
+        }
         if bundledJourney && ["net", "delay", "exec"].contains(command) {
             check(false, "\(command) requires a control-server journey")
             return
@@ -470,12 +485,15 @@ final class DriverTests: XCTestCase {
             if let target = poll(10, { exact(arg) }) { press(target); note("tapexact \(arg): ok") }
             else { XCTFail("Element not found"); note("FAIL tapexact \(arg): NOT FOUND") }
         case "tapid":
+            lastBooleanTap = nil
             let target = identified(arg)
             if !target.waitForExistence(timeout: 10) { XCTFail("Element not found"); note("FAIL tapid \(arg): NOT FOUND") }
-            else if target.elementType == .switch {
+            else if target.elementType == .switch || ["0", "1"].contains(target.value as? String ?? "") {
                 // Observe one physical gesture. Retapping could conceal a
                 // renderer or hit-testing failure (HQ agreement job 7570).
                 let before = target.value as? String
+                let enabledBefore = target.isEnabled
+                let frameBefore = target.frame
                 press(target)
                 let settle = Date().addingTimeInterval(1.5)
                 var flipped = false
@@ -483,6 +501,15 @@ final class DriverTests: XCTestCase {
                     flipped = switchFlipped(from: before, to: target.value as? String)
                     if !flipped { Thread.sleep(forTimeInterval: 0.25) }
                 } while !flipped && Date() < settle
+                let observation: [String: Any] = [
+                    "id": arg, "gestures": 1, "flipped": flipped,
+                    "enabledBefore": enabledBefore, "enabledAfter": target.isEnabled,
+                    "valueBefore": before ?? "unknown", "valueAfter": target.value as? String ?? "unknown",
+                    "frameBefore": [frameBefore.origin.x, frameBefore.origin.y, frameBefore.width, frameBefore.height],
+                ]
+                lastBooleanTap = observation
+                if let data = try? JSONSerialization.data(withJSONObject: observation, options: [.sortedKeys]),
+                   let json = String(data: data, encoding: .utf8) { note("BOOLEAN_TAP \(json)") }
                 check(flipped, "tapid \(arg) flips the switch")
             }
             else { press(target); note("tapid \(arg): ok") }
@@ -596,9 +623,20 @@ final class DriverTests: XCTestCase {
                 start.press(forDuration: 0.05, thenDragTo: app.coordinate(withNormalizedOffset: CGVector(dx: 0.8, dy: 0.5)))
                 note("back: edge swipe")
             }
-        case "type": app.typeText(arg)
+        case "type":
+            let target = lastTappedInput ?? app
+            lastTappedInput = nil
+            // A returned gesture is not proof of keyboard focus. Observe the
+            // one gesture before typing, including WebKit/cold-keyboard focus
+            // delivery. Never retap and conceal a dropped input event.
+            guard poll(15, { self.hasKeyboardFocus(target) ? target : nil }) != nil else {
+                check(false, "type into \(target.label) takes keyboard focus")
+                return
+            }
+            app.typeText(arg)
         case "return": app.typeText(XCUIKeyboardKey.return.rawValue); note("return")
         case "typeid":
+            lastTappedInput = nil
             let idParts = arg.split(separator: " ", maxSplits: 1).map(String.init)
             let target = identified(idParts[0])
             if target.waitForExistence(timeout: 10) {
@@ -627,6 +665,7 @@ final class DriverTests: XCTestCase {
             let target = XCUIApplication(bundleIdentifier: bundle)
             check(target.wait(for: .runningForeground, timeout: seconds), "expectapp \(bundle)")
         case "field":
+            lastTappedInput = nil
             let fieldParts = arg.split(separator: " ", maxSplits: 1).map(String.init)
             let index = Int(fieldParts[0]) ?? 0
             let fields = app.textFields.allElementsBoundByIndex + app.secureTextFields.allElementsBoundByIndex