WIP: refactor: add remote_roundtrip_test

test/remote_roundtrip_test.zig

@@ -0,0 +1,113 @@
+const std = @import("std");
+const thespian = @import("thespian");
+const cbor = @import("cbor");
+const framing = @import("framing");
+const build_options = @import("build_options");
+
+const Allocator = std.mem.Allocator;
+const result = thespian.result;
+const unexpected = thespian.unexpected;
+const pid_ref = thespian.pid_ref;
+const Receiver = thespian.Receiver;
+const message = thespian.message;
+const extract = thespian.extract;
+const subprocess = thespian.subprocess;
+
+const tag = "subprocess";
+
+const Parent = struct {
+    allocator: Allocator,
+    proc: subprocess,
+    accumulator: framing.Accumulator,
+    receiver: Receiver(*@This()),
+    pong_received: bool = false,
+
+    const Args = struct { allocator: Allocator };
+
+    fn start(args: Args) result {
+        return init(args) catch |e| return thespian.exit_error(e, @errorReturnTrace());
+    }
+
+    fn init(args: Args) !void {
+        var proc = try subprocess.init(
+            args.allocator,
+            message.fmt(.{build_options.remote_child_roundtrip_path}),
+            tag,
+            .Pipe,
+        );
+
+        // Encode ["ping"] and send it as a framed message to the child's stdin.
+        var msg_buf: [64]u8 = undefined;
+        var msg_stream: std.Io.Writer = .fixed(&msg_buf);
+        try cbor.writeValue(&msg_stream, .{"ping"});
+
+        var frame_buf: [68]u8 = undefined;
+        var frame_stream: std.Io.Writer = .fixed(&frame_buf);
+        try framing.write_frame(&frame_stream, msg_stream.buffered());
+        try proc.send(frame_stream.buffered());
+
+        const self = try args.allocator.create(@This());
+        self.* = .{
+            .allocator = args.allocator,
+            .proc = proc,
+            .accumulator = .{},
+            .receiver = .init(receive_fn, deinit, self),
+        };
+        errdefer self.deinit();
+        thespian.receive(&self.receiver);
+    }
+
+    fn deinit(self: *@This()) void {
+        self.proc.deinit();
+        self.allocator.destroy(self);
+    }
+
+    fn receive_fn(self: *@This(), from: pid_ref, m: message) result {
+        return self.receive(from, m) catch |e| return thespian.exit_error(e, @errorReturnTrace());
+    }
+
+    fn receive(self: *@This(), _: pid_ref, m: message) !void {
+        var bytes: []const u8 = "";
+        var exit_code: i64 = 0;
+
+        if (try m.match(.{ tag, "stdout", extract(&bytes) })) {
+            if (self.accumulator.feed(bytes)) |frame| {
+                try std.testing.expect(try cbor.match(frame, .{"pong"}));
+                self.pong_received = true;
+            }
+        } else if (try m.match(.{ tag, "term", "exited", extract(&exit_code) })) {
+            try std.testing.expect(self.pong_received);
+            try std.testing.expectEqual(@as(i64, 0), exit_code);
+            return thespian.exit("success");
+        } else if (try m.match(.{ tag, "stderr", extract(&bytes) })) {
+            // ignore stderr from child
+        } else {
+            return unexpected(m);
+        }
+    }
+};
+
+test "remote: round-trip ping/pong between parent and child" {
+    const allocator = std.testing.allocator;
+    var ctx = try thespian.context.init(allocator);
+    defer ctx.deinit();
+
+    var success = false;
+    var exit_handler = thespian.make_exit_handler(&success, struct {
+        fn handle(ok: *bool, status: []const u8) void {
+            ok.* = std.mem.eql(u8, status, "success");
+        }
+    }.handle);
+
+    _ = try ctx.spawn_link(
+        Parent.Args{ .allocator = allocator },
+        Parent.start,
+        "remote_roundtrip",
+        &exit_handler,
+        null,
+    );
+
+    ctx.run();
+
+    if (!success) return error.TestFailed;
+}