@craft-native/ios 0.0.237 → 0.0.238

package/templates/CraftRecordingArchive.swift

@@ -0,0 +1,85 @@
+import CryptoKit
+import Foundation
+import Darwin
+
+/// Immutable completed recordings and durable acknowledgement tombstones.
+/// IDs are opaque values; their SHA-256, never caller path text, names a file.
+enum CraftRecordingArchive {
+    typealias Writer = (Data, URL) throws -> Void
+    static func writeAtomically(_ data: Data, _ url: URL) throws {
+        try FileManager.default.createDirectory(at: url.deletingLastPathComponent(), withIntermediateDirectories: true)
+        let temporary = url.deletingLastPathComponent().appendingPathComponent(".craft-atomic-" + UUID().uuidString)
+        defer { try? FileManager.default.removeItem(at: temporary) }
+        try data.write(to: temporary, options: .withoutOverwriting)
+        let file = try FileHandle(forWritingTo: temporary)
+        do { try file.synchronize(); try file.close() }
+        catch { try? file.close(); throw error }
+        try FileManager.default.setAttributes([.protectionKey: FileProtectionType.completeUntilFirstUserAuthentication], ofItemAtPath: temporary.path)
+        var protected = temporary
+        var values = URLResourceValues()
+        values.isExcludedFromBackup = true
+        try protected.setResourceValues(values)
+        let result = temporary.path.withCString { source in url.path.withCString { destination in Darwin.rename(source, destination) } }
+        if result != 0 { throw NSError(domain: NSPOSIXErrorDomain, code: Int(errno)) }
+    }
+
+    private static func url(_ directory: URL, _ kind: String, _ id: String, acknowledged: Bool = false) -> URL {
+        let digest = SHA256.hash(data: Data(id.utf8)).map { String(format: "%02x", $0) }.joined()
+        return directory.appendingPathComponent("craft-\(kind)-\(acknowledged ? "ack" : "completed")-\(digest).json")
+    }
+    static func startId(_ options: [String: Any], directory: URL, kind: String, currentId: String?) throws -> String {
+        let id: String
+        if options.keys.contains("recordingId") {
+            guard let requested = options["recordingId"] as? String,
+                  !requested.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty else {
+                throw CraftNativeActionError(code: "INVALID_ARGUMENT", message: "recordingId must be a nonempty recording ID")
+            }
+            id = requested
+        } else { id = UUID().uuidString }
+        let acknowledged = try isAcknowledged(directory, kind, id)
+        if id == currentId || acknowledged || FileManager.default.fileExists(atPath: url(directory, kind, id).path) {
+            throw CraftNativeActionError(code: "RECORDING_CONFLICT", message: "Recording IDs cannot be reused")
+        }
+        return id
+    }
+    static func isAcknowledged(_ directory: URL, _ kind: String, _ id: String) throws -> Bool {
+        let marker = url(directory, kind, id, acknowledged: true)
+        guard FileManager.default.fileExists(atPath: marker.path) else { return false }
+        guard try Data(contentsOf: marker) == Data(id.utf8) else {
+            throw CraftNativeActionError(code: "RECORDING_STORAGE_ERROR", message: "Invalid recording acknowledgement")
+        }
+        return true
+    }
+    static func read(_ directory: URL, _ kind: String, _ id: String) throws -> [String: Any]? {
+        if try isAcknowledged(directory, kind, id) {
+            try acknowledge(directory, kind, id)
+            throw CraftNativeActionError(code: "RECORDING_NOT_FOUND", message: "This recording has been acknowledged")
+        }
+        let source = url(directory, kind, id)
+        guard FileManager.default.fileExists(atPath: source.path) else { return nil }
+        let data = try Data(contentsOf: source)
+        guard let value = try JSONSerialization.jsonObject(with: data) as? [String: Any],
+              value["id"] as? String == id, value["active"] as? Bool == false,
+              value[kind == "location" ? "locations" : "samples"] is [[String: Any]] else {
+            throw CraftNativeActionError(code: "RECORDING_STORAGE_ERROR", message: "Invalid completed recording archive")
+        }
+        return value
+    }
+    static func save(_ directory: URL, _ kind: String, _ state: [String: Any], samples: [[String: Any]], writer: Writer = writeAtomically) throws {
+        guard let id = state["id"] as? String else { return }
+        if try isAcknowledged(directory, kind, id) { try acknowledge(directory, kind, id); return }
+        if try read(directory, kind, id) != nil { return }
+        var completed = state
+        completed["active"] = false
+        completed["paused"] = false
+        completed["sampleCount"] = samples.count
+        completed[kind == "location" ? "locations" : "samples"] = samples
+        try writer(JSONSerialization.data(withJSONObject: completed), url(directory, kind, id))
+    }
+    static func acknowledge(_ directory: URL, _ kind: String, _ id: String) throws {
+        let marker = url(directory, kind, id, acknowledged: true)
+        if try !isAcknowledged(directory, kind, id) { try writeAtomically(Data(id.utf8), marker) }
+        let archive = url(directory, kind, id)
+        if FileManager.default.fileExists(atPath: archive.path) { try FileManager.default.removeItem(at: archive) }
+    }
+}

package/templates/testing/DriverTests.swift.template

@@ -53,6 +53,7 @@ final class DriverTests: XCTestCase {
     let control = ProcessInfo.processInfo.environment["CRAFT_TEST_CONTROL"] ?? {{CONTROL_URL}}
     let app = XCUIApplication(bundleIdentifier: {{BUNDLE_ID}})
     let tabs: [String] = {{TABS}}
+    let tabIdentifiers: [String: String] = {{TAB_IDENTIFIERS}}
     private var bundledJourney = false
 
     func get(_ path: String, timeout: Double = 15) -> Data? {
@@ -140,9 +141,15 @@ final class DriverTests: XCTestCase {
 
     /// The native tab bar's button: Craft's floating bar is not a UITabBar, and
     /// XCUITest calls its buttons not hittable, so it is the button with this
-    /// label in the bottom fifth of the window.
+    /// label in the bottom fifth of the window. A configured stable identifier
+    /// keeps dynamic captions from changing the tab's native identity.
     func tabButton(_ name: String) -> XCUIElement? {
         let height = app.windows.firstMatch.frame.height
+        if let identifier = tabIdentifiers[name] {
+            let candidate = app.buttons.matching(NSPredicate(format: "identifier == %@", identifier)).firstMatch
+            if candidate.exists && candidate.frame.minY > height * 0.8 && candidate.frame.maxY <= height + 1 && candidate.frame.width > 0 { return candidate }
+            return nil
+        }
         let matches = app.buttons.matching(NSPredicate(format: "label == %@", name))
         for index in 0..<min(matches.count, 10) {
             let candidate = matches.element(boundBy: index)