zeno-mobile-runner 0.2.12 → 0.2.14

package/src/fake_device.zig

@@ -20,6 +20,8 @@ pub const FakeDevice = struct {
     opened_link: ?[]const u8 = null,
     settles: usize = 0,
     last_settle_timeout_ms: u64 = 0,
+    location_sets: usize = 0,
+    last_location: ?LocationRecord = null,
 
     pub fn init(allocator: std.mem.Allocator, snapshots: []types.ObservationSnapshot) FakeDevice {
         return .{
@@ -71,6 +73,14 @@ pub const FakeDevice = struct {
         self.opened_link = try self.allocator.dupe(u8, url);
     }
 
+    pub fn setLocation(self: *FakeDevice, latitude: f64, longitude: f64) !void {
+        self.location_sets += 1;
+        self.last_location = .{
+            .latitude = latitude,
+            .longitude = longitude,
+        };
+    }
+
     pub fn tap(self: *FakeDevice, x: i32, y: i32) !void {
         _ = x;
         _ = y;
@@ -127,6 +137,11 @@ pub const SwipeRecord = struct {
     duration_ms: u32,
 };
 
+pub const LocationRecord = struct {
+    latitude: f64,
+    longitude: f64,
+};
+
 pub fn cloneSnapshot(allocator: std.mem.Allocator, source: types.ObservationSnapshot) !types.ObservationSnapshot {
     var nodes = try allocator.alloc(types.UiNode, source.nodes.len);
     errdefer allocator.free(nodes);

package/src/ios.zig

@@ -33,6 +33,7 @@ pub const IosDevice = struct {
     app_id: []const u8,
     shim_path: ?[]const u8 = null,
     target_kind: TargetKind = .simulator,
+    expo_dev_client_open_link_mode: bool = false,
 
     pub fn init(
         allocator: std.mem.Allocator,
@@ -131,13 +132,31 @@ pub const IosDevice = struct {
         const result = try self.runSimctl(&.{ "openurl", self.target(), url }, default_max_output);
         defer result.deinit(self.allocator);
         try result.ensureSuccess();
+        if (isExpoDevClientOpenLink(url)) {
+            self.expo_dev_client_open_link_mode = true;
+        }
         // Opening a URL on the simulator can raise a SpringBoard "Open in <App>?"
         // confirmation for universal links (http/https) and, just as often, for
         // custom schemes — the common Expo dev-client case
         // (exp+scheme://expo-development-client/...). Attempt a best-effort accept
         // whenever a shim is configured; the shim probes briefly and returns fast
         // when no dialog is present, so this stays cheap on the no-prompt path.
-        self.acceptOpenURLConfirmationBestEffort();
+        self.acceptOpenURLConfirmationBestEffort(url);
+    }
+
+    pub fn setLocation(self: *IosDevice, latitude: f64, longitude: f64) !void {
+        if (self.target_kind == .physical) return error.UnsupportedDeviceCapability;
+
+        const coordinate = try std.fmt.allocPrint(self.allocator, "{d:.6},{d:.6}", .{ latitude, longitude });
+        defer self.allocator.free(coordinate);
+
+        const grant = try self.runSimctl(&.{ "privacy", self.target(), "grant", "location", self.app_id }, default_max_output);
+        defer grant.deinit(self.allocator);
+        try grant.ensureSuccess();
+
+        const result = try self.runSimctl(&.{ "location", self.target(), "set", coordinate }, default_max_output);
+        defer result.deinit(self.allocator);
+        try result.ensureSuccess();
     }
 
     pub fn tap(self: *IosDevice, x: i32, y: i32) !void {
@@ -189,6 +208,12 @@ pub const IosDevice = struct {
         try self.runShimAction(.{ .kind = .swipe, .x1 = x1, .y1 = y1, .x2 = x2, .y2 = y2, .duration_ms = duration_ms });
     }
 
+    pub fn scrollViewport(self: *IosDevice) !types.Viewport {
+        const response = try self.runShim(.{ .kind = .viewport });
+        defer self.allocator.free(response);
+        return try ios_shim.parseViewportResponse(response);
+    }
+
     pub fn pressBack(self: *IosDevice) !void {
         try self.runShimAction(.{ .kind = .press_back });
     }
@@ -322,20 +347,25 @@ pub const IosDevice = struct {
         try ios_shim.parseOkResponse(response);
     }
 
-    fn acceptOpenURLConfirmationBestEffort(self: *IosDevice) void {
+    fn acceptOpenURLConfirmationBestEffort(self: *IosDevice, url: []const u8) void {
         if (self.shim_path == null) return;
         var attempt: usize = 0;
         while (attempt < open_link_interruption_attempts) {
             attempt += 1;
-            if (self.acceptOpenURLConfirmationOnce() catch return) return;
+            if (self.acceptOpenURLConfirmationOnce(url) catch return) return;
             if (attempt < open_link_interruption_attempts) {
                 stdio.sleepNs(open_link_interruption_retry_delay_ms * std.time.ns_per_ms);
             }
         }
     }
 
-    fn acceptOpenURLConfirmationOnce(self: *IosDevice) !bool {
-        const response = try self.runShimWithTimeout(.{ .kind = .accept_system_alert, .text = "Open" }, shim_best_effort_timeout_ms);
+    fn acceptOpenURLConfirmationOnce(self: *IosDevice, url: []const u8) !bool {
+        const response = try self.runShimWithTimeout(.{
+            .kind = .accept_system_alert,
+            .text = "Open",
+            .url = url,
+            .expo_dev_client_fallback = self.expo_dev_client_open_link_mode,
+        }, shim_best_effort_timeout_ms);
         defer self.allocator.free(response);
         return try ios_shim.parseAcceptSystemAlertResponse(response);
     }
@@ -460,6 +490,11 @@ fn parseShimTimeoutMs(raw: ?[]const u8) u64 {
     return parsed;
 }
 
+fn isExpoDevClientOpenLink(url: []const u8) bool {
+    return std.mem.startsWith(u8, url, "exp+") and
+        std.mem.indexOf(u8, url, "://expo-development-client/") != null;
+}
+
 test "ios simulator openLink keeps sweeping delayed XCTest interruptions until accepted" {
     const allocator = std.heap.page_allocator;
     const argv = [_][*:0]const u8{"zmr-ios-test"};
@@ -523,6 +558,70 @@ test "ios simulator openLink keeps sweeping delayed XCTest interruptions until a
     try std.testing.expectEqual(@as(u8, 6), count);
 }
 
+test "ios simulator setLocation grants app location permission and sets coordinates" {
+    const allocator = std.heap.page_allocator;
+    const argv = [_][*:0]const u8{"zmr-ios-test"};
+    stdio.initProcess(.{
+        .args = .{ .vector = argv[0..] },
+        .environ = .empty,
+    }, allocator);
+    defer stdio.deinitProcess();
+
+    var tmp = std.testing.tmpDir(.{});
+    defer tmp.cleanup();
+
+    var xcrun = try tmp.dir.createFile(stdio.io(), "fake-xcrun-location.sh", .{ .truncate = true });
+    {
+        var buffer: [4096]u8 = undefined;
+        var writer = xcrun.writerStreaming(stdio.io(), &buffer);
+        const script = try std.fmt.allocPrint(allocator,
+            \\#!/usr/bin/env bash
+            \\set -euo pipefail
+            \\printf '%s\n' "$*" >> ".zig-cache/tmp/{s}/xcrun.log"
+            \\if [[ "${{1:-}}" != "simctl" ]]; then
+            \\  echo "expected simctl" >&2
+            \\  exit 2
+            \\fi
+            \\shift
+            \\case "${{1:-}}" in
+            \\  privacy)
+            \\    [[ "${{2:-}}" == "fake-ios-1" && "${{3:-}}" == "grant" && "${{4:-}}" == "location" && "${{5:-}}" == "com.example.mobiletest" ]] || exit 2
+            \\    ;;
+            \\  location)
+            \\    [[ "${{2:-}}" == "fake-ios-1" && "${{3:-}}" == "set" && "${{4:-}}" == "51.507400,-0.127800" ]] || exit 2
+            \\    ;;
+            \\  *)
+            \\    echo "unsupported simctl command: $*" >&2
+            \\    exit 2
+            \\    ;;
+            \\esac
+            \\
+        , .{tmp.sub_path});
+        defer allocator.free(script);
+        try writer.interface.writeAll(script);
+        try writer.interface.flush();
+    }
+    xcrun.close(stdio.io());
+
+    const xcrun_path = try std.fmt.allocPrint(allocator, ".zig-cache/tmp/{s}/fake-xcrun-location.sh", .{tmp.sub_path});
+    defer allocator.free(xcrun_path);
+    const xcrun_path_z = try allocator.dupeZ(u8, xcrun_path);
+    defer allocator.free(xcrun_path_z);
+    if (std.c.chmod(xcrun_path_z, 0o755) != 0) return error.ChmodFailed;
+
+    var device = try IosDevice.initWithShim(allocator, xcrun_path, "fake-ios-1", "com.example.mobiletest", null);
+    defer device.deinit();
+
+    try device.setLocation(51.5074, -0.1278);
+
+    const log_path = try std.fmt.allocPrint(allocator, ".zig-cache/tmp/{s}/xcrun.log", .{tmp.sub_path});
+    defer allocator.free(log_path);
+    const log = try stdio.readFileAlloc(allocator, log_path, 1024);
+    defer allocator.free(log);
+    try std.testing.expect(std.mem.indexOf(u8, log, "simctl privacy fake-ios-1 grant location com.example.mobiletest") != null);
+    try std.testing.expect(std.mem.indexOf(u8, log, "simctl location fake-ios-1 set 51.507400,-0.127800") != null);
+}
+
 pub fn listDevices(allocator: std.mem.Allocator, xcrun_path: []const u8) ![]types.DeviceInfo {
     return try ios_devices.listSimulators(allocator, xcrun_path);
 }

package/src/ios_shim.zig

@@ -5,6 +5,7 @@ const types = @import("types.zig");
 
 pub const CommandKind = enum {
     snapshot,
+    viewport,
     screenshot,
     tap,
     type_text,
@@ -22,6 +23,8 @@ pub const Command = struct {
     kind: CommandKind,
     selector: ?[]const u8 = null,
     text: ?[]const u8 = null,
+    url: ?[]const u8 = null,
+    expo_dev_client_fallback: bool = false,
     x: ?i32 = null,
     y: ?i32 = null,
     x1: ?i32 = null,
@@ -42,6 +45,19 @@ pub const SnapshotResponse = struct {
     }
 };
 
+pub fn parseViewportResponse(content: []const u8) !types.Viewport {
+    var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
+    defer arena.deinit();
+    const parsed = try std.json.parseFromSlice(std.json.Value, arena.allocator(), content, .{});
+    if (parsed.value != .object) return error.IosShimResponseMustBeObject;
+    const status = fieldString(parsed.value.object, "status") orelse return error.IosShimMissingStatus;
+    if (!std.mem.eql(u8, status, "ok")) return error.IosShimResponseNotOk;
+    const viewport_value = parsed.value.object.get("viewport") orelse return error.IosShimMissingViewport;
+    const viewport = parseViewport(viewport_value);
+    if (viewport.width == 0 or viewport.height == 0) return error.IosShimInvalidViewport;
+    return viewport;
+}
+
 pub fn writeCommandJson(writer: anytype, command: Command) !void {
     try writer.writeAll("{\"cmd\":");
     try trace.writeJsonString(writer, commandName(command.kind));
@@ -53,6 +69,13 @@ pub fn writeCommandJson(writer: anytype, command: Command) !void {
         try writer.writeAll(",\"text\":");
         try trace.writeJsonString(writer, text);
     }
+    if (command.url) |url| {
+        try writer.writeAll(",\"url\":");
+        try trace.writeJsonString(writer, url);
+    }
+    if (command.expo_dev_client_fallback) {
+        try writer.writeAll(",\"expoDevClientFallback\":true");
+    }
     if (command.x) |value| try writer.print(",\"x\":{d}", .{value});
     if (command.y) |value| try writer.print(",\"y\":{d}", .{value});
     if (command.x1) |value| try writer.print(",\"x1\":{d}", .{value});
@@ -270,6 +293,7 @@ pub fn selectorString(allocator: std.mem.Allocator, wanted: selectors.Selector)
 fn commandName(kind: CommandKind) []const u8 {
     return switch (kind) {
         .snapshot => "snapshot",
+        .viewport => "viewport",
         .screenshot => "screenshot",
         .tap => "tap",
         .type_text => "type",

package/src/json_fields.zig

@@ -31,6 +31,11 @@ pub fn requiredI32FromObject(object: std.json.ObjectMap, key: []const u8, missin
     return i32Value(value, type_error);
 }
 
+pub fn requiredF64FromObject(object: std.json.ObjectMap, key: []const u8, missing_error: anyerror, type_error: anyerror) !f64 {
+    const value = object.get(key) orelse return missing_error;
+    return f64Value(value, type_error);
+}
+
 pub fn optionalU64(params: ?std.json.Value, key: []const u8, default_value: u64, type_error: anyerror) !u64 {
     const value = field(params, key) orelse return default_value;
     return u64Value(value, type_error);
@@ -72,6 +77,14 @@ fn u64Value(value: std.json.Value, type_error: anyerror) !u64 {
     };
 }
 
+fn f64Value(value: std.json.Value, type_error: anyerror) !f64 {
+    return switch (value) {
+        .float => |actual| actual,
+        .integer => |actual| @as(f64, @floatFromInt(actual)),
+        else => type_error,
+    };
+}
+
 fn boolValue(value: std.json.Value, type_error: anyerror) !bool {
     return switch (value) {
         .bool => |actual| actual,

package/src/runner.zig

@@ -8,6 +8,7 @@ const scenario = @import("scenario.zig");
 const selector = @import("selector.zig");
 const trace = @import("trace.zig");
 const types = @import("types.zig");
+const fake_device = @import("fake_device.zig");
 
 pub const RunOptions = runner_config.RunOptions;
 
@@ -86,6 +87,14 @@ pub fn executeStep(
             if (writer) |tw| try runner_events.recordActionStatus(tw, "app.openLink", "ok", null, url);
             try settleDevice(device, options);
         },
+        .set_location => |location| {
+            device.setLocation(location.latitude, location.longitude) catch |err| {
+                if (writer) |tw| try runner_events.recordSetLocation(tw, "failed", err, location.latitude, location.longitude);
+                return err;
+            };
+            if (writer) |tw| try runner_events.recordSetLocation(tw, "ok", null, location.latitude, location.longitude);
+            try settleDevice(device, options);
+        },
         .tap => |wanted| try tapSelector(device, wanted, writer, options),
         .type_text => |input| {
             if (input.selector) |wanted| return try typeTextSelector(device, wanted, input.text, writer, options);
@@ -309,6 +318,46 @@ fn settleDevice(device: anytype, options: RunOptions) !void {
     try device.settle(options.settle_ms);
 }
 
+test "setLocation dispatches through the device, records trace evidence, and settles" {
+    const allocator = std.testing.allocator;
+    const dir = "zig-cache-test-runner-set-location";
+    std.Io.Dir.cwd().deleteTree(stdio.io(), dir) catch {};
+    defer std.Io.Dir.cwd().deleteTree(stdio.io(), dir) catch {};
+
+    const script_json =
+        \\{
+        \\  "name": "set location",
+        \\  "steps": [
+        \\    {"action": "setLocation", "latitude": 51.5074, "longitude": -0.1278}
+        \\  ]
+        \\}
+    ;
+    const script = try scenario.parseSlice(allocator, script_json);
+    defer script.deinit(allocator);
+
+    var device = fake_device.FakeDevice.init(allocator, &.{});
+    defer device.deinit();
+    var tw = try trace.TraceWriter.init(allocator, dir);
+    defer tw.deinit();
+
+    try runScenario(allocator, &device, script, &tw, .{ .settle_ms = 25 });
+
+    try std.testing.expectEqual(@as(usize, 1), device.location_sets);
+    try std.testing.expectApproxEqAbs(@as(f64, 51.5074), device.last_location.?.latitude, 0.000001);
+    try std.testing.expectApproxEqAbs(@as(f64, -0.1278), device.last_location.?.longitude, 0.000001);
+    try std.testing.expectEqual(@as(usize, 1), device.settles);
+    try std.testing.expectEqual(@as(u64, 25), device.last_settle_timeout_ms);
+
+    const events_path = try std.fs.path.join(allocator, &.{ dir, "events.jsonl" });
+    defer allocator.free(events_path);
+    const events = try stdio.readFileAlloc(allocator, events_path, 1024 * 1024);
+    defer allocator.free(events);
+    try std.testing.expect(std.mem.indexOf(u8, events, "\"kind\":\"device.setLocation\"") != null);
+    try std.testing.expect(std.mem.indexOf(u8, events, "\"status\":\"ok\"") != null);
+    try std.testing.expect(std.mem.indexOf(u8, events, "\"latitude\":51.5074") != null);
+    try std.testing.expect(std.mem.indexOf(u8, events, "\"longitude\":-0.1278") != null);
+}
+
 test "whenVisible skips the conditional block when the visibility probe command fails" {
     const allocator = std.testing.allocator;
     const dir = "zig-cache-test-runner-when-visible-command-failed";
@@ -336,6 +385,12 @@ test "whenVisible skips the conditional block when the visibility probe command
             _ = url;
         }
 
+        pub fn setLocation(self: *@This(), latitude: f64, longitude: f64) !void {
+            _ = self;
+            _ = latitude;
+            _ = longitude;
+        }
+
         pub fn tap(self: *@This(), x: i32, y: i32) !void {
             _ = self;
             _ = x;

package/src/runner_events.zig

@@ -26,6 +26,23 @@ pub fn recordNativeWait(tw: *trace.TraceWriter, kind: []const u8, wanted: select
     try tw.recordEvent(kind, writer.buffered());
 }
 
+pub fn recordNativeScrollUntilVisible(
+    tw: *trace.TraceWriter,
+    wanted: selector.Selector,
+    direction: []const u8,
+    timeout_ms: u64,
+) !void {
+    var payload: std.Io.Writer.Allocating = .init(tw.allocator);
+    defer payload.deinit();
+    const writer = &payload.writer;
+    try writer.writeAll("{\"status\":\"ok\",\"strategy\":\"nativeSelector\",\"selector\":");
+    try trace.writeSelectorJson(writer, wanted);
+    try writer.writeAll(",\"direction\":");
+    try trace.writeJsonString(writer, direction);
+    try writer.print(",\"timeoutMs\":{d}}}", .{timeout_ms});
+    try tw.recordEvent("ui.scrollUntilVisible", writer.buffered());
+}
+
 pub fn recordNativeWaitTimeout(tw: *trace.TraceWriter, kind: []const u8, selectors: []const selector.Selector, timeout_ms: u64) !void {
     var payload: std.Io.Writer.Allocating = .init(tw.allocator);
     defer payload.deinit();
@@ -120,6 +137,20 @@ pub fn recordActionStatus(tw: *trace.TraceWriter, kind: []const u8, status: []co
     try tw.recordEvent(kind, out.buffered());
 }
 
+pub fn recordSetLocation(tw: *trace.TraceWriter, status: []const u8, err: ?anyerror, latitude: f64, longitude: f64) !void {
+    var payload: std.Io.Writer.Allocating = .init(tw.allocator);
+    defer payload.deinit();
+    const out = &payload.writer;
+    try out.writeAll("{\"status\":");
+    try trace.writeJsonString(out, status);
+    if (err) |actual| {
+        try out.writeAll(",\"error\":");
+        try trace.writeJsonString(out, @errorName(actual));
+    }
+    try out.print(",\"latitude\":{d:.6},\"longitude\":{d:.6}}}", .{ latitude, longitude });
+    try tw.recordEvent("device.setLocation", out.buffered());
+}
+
 pub fn recordSwipe(tw: *trace.TraceWriter, x1: i32, y1: i32, x2: i32, y2: i32, duration_ms: u32) !void {
     const payload = try std.fmt.allocPrint(
         tw.allocator,