Something went wrong. Try again.
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337const std = @import("std");const zttp = @import("zttp");const zio = @import("zio");const Io = std.Io;const a = std.testing.allocator;const ms = std.time.ns_per_ms;
const Peer = struct { server: Io.net.Server, future: ?Io.Future(anyerror!void) = null, head_delay: u64 = 0, body_delay: u64 = 0, response: []const u8, body: []const u8 = "", ready: std.atomic.Value(bool) = .init(false), sensitive: std.atomic.Value(bool) = .init(false), tls_record: bool = false, ready_at: i128 = 0, hold: Io.Event = .unset,
fn init(response: []const u8, head_delay: u64, body_delay: u64, body: []const u8) !*Peer { return initMode(response, head_delay, body_delay, body, false); } fn initMode(response: []const u8, head_delay: u64, body_delay: u64, body: []const u8, tls_record: bool) !*Peer { const peer = try a.create(Peer); errdefer a.destroy(peer); peer.* = .{ .server = try (Io.net.IpAddress{ .ip4 = .loopback(0) }).listen(std.testing.io, .{}), .response = response, .head_delay = head_delay, .body_delay = body_delay, .body = body, .tls_record = tls_record, }; errdefer peer.server.deinit(std.testing.io); peer.future = try std.testing.io.concurrent(serve, .{peer}); return peer; } fn deinit(peer: *Peer) void { _ = peer.future.?.cancel(std.testing.io) catch {}; peer.server.deinit(std.testing.io); a.destroy(peer); } fn url(peer: *Peer, buffer: []u8) ![]const u8 { return std.fmt.bufPrint(buffer, "http://127.0.0.1:{d}/", .{peer.server.socket.address.getPort()}); } fn serve(peer: *Peer) anyerror!void { const io = std.testing.io; const stream = try peer.server.accept(io); defer stream.close(io); var read_buffer: [4096]u8 = undefined; var reader = stream.reader(io, &read_buffer); if (peer.tls_record) { const header = try reader.interface.takeArray(5); if (header[0] != 22) return error.InvalidTlsRecord; const length = std.mem.readInt(u16, header[3..5], .big); if (length == 0 or length > 16 * 1024) return error.InvalidTlsRecord; try reader.interface.discardAll(length); peer.ready_at = Io.Clock.awake.now(io).nanoseconds; peer.ready.store(true, .release); try io.sleep(.fromNanoseconds(peer.head_delay), .awake); return; } while (true) { const line = try reader.interface.takeDelimiterInclusive('\n'); if (std.mem.eql(u8, line, "\r\n")) break; for ([_][]const u8{ "authorization:", "cookie:", "proxy-authorization:" }) |name| { if (std.ascii.startsWithIgnoreCase(line, name)) peer.sensitive.store(true, .release); } } peer.ready.store(true, .release); try io.sleep(.fromNanoseconds(peer.head_delay), .awake); var buffer: [4096]u8 = undefined; var writer = stream.writer(io, &buffer); try writer.interface.writeAll(peer.response); try writer.interface.flush(); try io.sleep(.fromNanoseconds(peer.body_delay), .awake); try writer.interface.writeAll(peer.body); try writer.interface.flush(); try peer.hold.wait(io); }};
fn configured(io: Io) zttp.Client { var client = zttp.Client.init(io, a); client.head_deadline_ns = 200 * ms; client.dead_connection_attempts = 1; client.max_response_size = 1024 * 1024; client.stall = .{ .idle_ns = 200 * ms, .min_bytes_per_s = 0 }; return client;}fn fetch(client: *zttp.Client, url: []const u8) !void { var result = try client.fetch(.{ .url = url }); defer result.deinit(a);}fn heartbeat(io: Io) !i64 { const start = Io.Clock.awake.now(io).nanoseconds; try io.sleep(.fromMilliseconds(20), .awake); return @intCast(Io.Clock.awake.now(io).nanoseconds - start);}fn deadline(io: Io) !void { const peer = try Peer.init("HTTP/1.1 200 OK\r\nContent-Length: 2\r\n\r\nok", 300 * ms, 0, ""); defer peer.deinit(); var buffer: [128]u8 = undefined; var client = configured(io); defer client.deinit(); client.head_deadline_ns = 60 * ms; var tick = try io.concurrent(heartbeat, .{io}); defer _ = tick.cancel(io) catch {}; const start = Io.Clock.awake.now(io).nanoseconds; try std.testing.expectError(error.ResponseHeadTimeout, fetch(&client, try peer.url(&buffer))); try bounded("operation completion", Io.Clock.awake.now(io).nanoseconds - start, 200 * ms); try bounded("heartbeat", try tick.await(io), 100 * ms);}fn callerDelay(io: Io) !void { const peer = try Peer.init("HTTP/1.1 200 OK\r\nContent-Length: 2\r\n\r\nok", 0, 0, ""); defer peer.deinit(); var buffer: [128]u8 = undefined; var client = configured(io); defer client.deinit(); const response = try client.open(.{ .url = try peer.url(&buffer), .deadline_ns = 60 * ms }); defer response.deinit(); try io.sleep(.fromMilliseconds(100), .awake); var storage: [2]u8 = undefined; var sink = Io.Writer.fixed(&storage); try std.testing.expectError(error.RequestDeadlineExceeded, response.stream(&sink, .{}));}fn cleanup(response: *zttp.Client.Response, io: Io, done: *Io.Event) !void { response.deinit(); done.set(io);}fn unreadCleanup(io: Io) !void { const peer = try Peer.init("HTTP/1.1 200 OK\r\nContent-Length: 100\r\n\r\n", 0, 0, ""); defer peer.deinit(); var buffer: [128]u8 = undefined; var client = configured(io); defer client.deinit(); const response = try client.open(.{ .url = try peer.url(&buffer) }); var done: Io.Event = .unset; var task = try io.concurrent(cleanup, .{ response, io, &done }); defer _ = task.cancel(io) catch {}; try io.sleep(.fromMilliseconds(50), .awake); try std.testing.expect(done.isSet()); try task.await(io);}fn cancellation(io: Io) !void { for ([_]bool{ false, true }) |guarded| { for ([_][]const u8{ "", "HTTP/1.1 200 OK\r\nContent-Length: 100\r\n\r\n", "HTTP/1.1 200 OK\r\nTransfer-Encoding: chunked\r\n\r\n" }) |head| { const peer = try Peer.init(head, 0, 0, ""); defer peer.deinit(); var buffer: [128]u8 = undefined; var client = configured(io); defer client.deinit(); client.head_deadline_ns = if (guarded) 5000 * ms else 0; client.stall.idle_ns = if (guarded) 5000 * ms else 0; var task = try io.concurrent(fetch, .{ &client, try peer.url(&buffer) }); while (!peer.ready.load(.acquire)) try io.sleep(.fromMilliseconds(1), .awake); try io.sleep(.fromMilliseconds(30), .awake); const start = Io.Clock.awake.now(io).nanoseconds; try std.testing.expectError(error.Canceled, task.cancel(io)); try bounded("operation completion", Io.Clock.awake.now(io).nanoseconds - start, 200 * ms); } }}fn suite(io: Io) !void { try check("head deadline and heartbeat", io, deadline); try check("external cancellation", io, cancellation); try check("caller delay", io, callerDelay); try check("unread response cleanup", io, unreadCleanup); try check("upload cancellation", io, upload); try check("TLS handshake deadline", io, tlsDeadline); try check("reused progress", io, reusedProgress); try check("redirect credentials", io, redirectCredentials);}
fn bounded(name: []const u8, elapsed: i128, limit: i128) !void { if (elapsed >= limit) std.debug.print("{s} took {d} ns; bound is {d} ns\n", .{ name, elapsed, limit }); try std.testing.expect(elapsed < limit);}
fn check(name: []const u8, io: Io, comptime operation: anytype) !void { operation(io) catch |err| { std.debug.print("runtime contract failed: {s}: {t}\n", .{ name, err }); return err; };}
fn redirectCredentials(io: Io) !void { const target = try Peer.init("HTTP/1.1 200 OK\r\nContent-Length: 2\r\n\r\nok", 0, 0, ""); defer target.deinit(); var target_buffer: [128]u8 = undefined; const redirect = try std.fmt.allocPrint(a, "HTTP/1.1 302 Found\r\nLocation: {s}\r\nContent-Length: 100\r\n\r\n", .{try target.url(&target_buffer)}); defer a.free(redirect); const origin = try Peer.init(redirect, 0, 0, ""); defer origin.deinit(); var client = configured(io); defer client.deinit(); var origin_buffer: [128]u8 = undefined; var result = try client.fetch(.{ .url = try origin.url(&origin_buffer), .extra_headers = &.{ .{ .name = "Authorization", .value = "Bearer fixture" }, .{ .name = "Cookie", .value = "sid=fixture" }, .{ .name = "Proxy-Authorization", .value = "Basic fixture" }, }, }); defer result.deinit(a); try std.testing.expectEqualStrings("ok", result.body); try std.testing.expect(origin.sensitive.load(.acquire)); try std.testing.expect(!target.sensitive.load(.acquire));}
test "contract: Threaded" { var threaded: Io.Threaded = .init(a, .{ .async_limit = .nothing }); defer threaded.deinit(); for (0..8) |_| try suite(threaded.io());}test "contract: zio fibers and native callers" { for ([_]u8{ 1, 4 }) |count| { const runtime = try zio.Runtime.init(a, .{ .executors = .exact(count), .enable_main_executor = false }); defer runtime.deinit(); for (0..8) |iteration| { var task = try runtime.spawn(suite, .{runtime.io()}); task.join() catch |err| { std.debug.print("zio fiber contract failed with {d} executors at iteration {d}: {t}\n", .{ count, iteration, err }); return err; }; suite(runtime.io()) catch |err| { std.debug.print("zio native contract failed with {d} executors at iteration {d}: {t}\n", .{ count, iteration, err }); return err; }; } }}
test "contract: concurrency exhaustion fails closed" { var threaded: Io.Threaded = .init(a, .{ .concurrent_limit = .nothing }); defer threaded.deinit(); const peer = try Peer.init("HTTP/1.1 200 OK\r\nContent-Length: 2\r\n\r\nok", 100 * ms, 0, ""); defer peer.deinit(); var client = configured(threaded.io()); defer client.deinit(); var buffer: [128]u8 = undefined; try std.testing.expectError(error.ConcurrencyUnavailable, fetch(&client, try peer.url(&buffer))); client.head_deadline_ns = 0; const response = try client.open(.{ .url = try peer.url(&buffer) }); defer response.deinit(); var storage: [2]u8 = undefined; var sink = Io.Writer.fixed(&storage); try std.testing.expectError(error.ConcurrencyUnavailable, response.stream(&sink, .{}));}
fn fetchUpload(client: *zttp.Client, url: []const u8, payload: []const u8) !void { var result = try client.fetch(.{ .url = url, .method = .POST, .payload = payload, .content_type = "application/octet-stream" }); defer result.deinit(a);}fn upload(io: Io) !void { const payload = try a.alloc(u8, 16 * 1024 * 1024); defer a.free(payload); @memset(payload, 'x'); for ([_]bool{ false, true }) |guarded| { const peer = try Peer.init("", 0, 0, ""); defer peer.deinit(); var client = configured(io); defer client.deinit(); client.head_deadline_ns = if (guarded) 5000 * ms else 0; client.stall = .{ .idle_ns = 0, .min_bytes_per_s = 0 }; var buffer: [128]u8 = undefined; var task = try io.concurrent(fetchUpload, .{ &client, try peer.url(&buffer), payload }); while (!peer.ready.load(.acquire)) try io.sleep(.fromMilliseconds(1), .awake); try io.sleep(.fromMilliseconds(20), .awake); const start = Io.Clock.awake.now(io).nanoseconds; try std.testing.expectError(error.Canceled, task.cancel(io)); try bounded("operation completion", Io.Clock.awake.now(io).nanoseconds - start, 200 * ms); }}fn tlsDeadline(io: Io) !void { const peer = try Peer.initMode("", 3000 * ms, 0, "", true); defer peer.deinit(); var client = configured(io); defer client.deinit(); client.http_client.now = Io.Clock.real.now(io); client.head_deadline_ns = 500 * ms; var buffer: [128]u8 = undefined; const url = try std.fmt.bufPrint(&buffer, "https://127.0.0.1:{d}/", .{peer.server.socket.address.getPort()}); var tick = try io.concurrent(tlsHeartbeat, .{ io, peer }); defer _ = tick.cancel(io) catch {}; const start = Io.Clock.awake.now(io).nanoseconds; try std.testing.expectError(error.ResponseHeadTimeout, fetch(&client, url)); try bounded("TLS request completion", Io.Clock.awake.now(io).nanoseconds - start, 1500 * ms); try bounded("heartbeat", try tick.await(io), 100 * ms);}
fn tlsHeartbeat(io: Io, peer: *Peer) !i64 { const start = Io.Clock.awake.now(io).nanoseconds; while (!peer.ready.load(.acquire)) { if (Io.Clock.awake.now(io).nanoseconds - start > 2000 * ms) return error.TlsClientHelloNotReceived; try io.sleep(.fromMilliseconds(1), .awake); } try io.sleep(.fromMilliseconds(20), .awake); return @intCast(Io.Clock.awake.now(io).nanoseconds - peer.ready_at);}fn reusedProgress(io: Io) !void { const peer = try Peer.init("HTTP/1.1 200 OK\r\nContent-Length: 100\r\n\r\n", 0, 0, ""); defer peer.deinit(); var client = configured(io); defer client.deinit(); var buffer: [128]u8 = undefined; const response = try client.open(.{ .url = try peer.url(&buffer) }); defer response.deinit(); var progress: zttp.Progress = .{}; progress.done.store(true, .release); progress.bytes.store(999, .release); var storage: [128]u8 = undefined; var sink = Io.Writer.fixed(&storage); try std.testing.expectError(error.TransferStalled, response.stream(&sink, .{ .progress = &progress, .stall = .{ .idle_ns = 60 * ms, .min_bytes_per_s = 0 } })); try std.testing.expectEqual(@as(usize, 0), progress.bytes.load(.acquire));}
fn allocatingRequest(allocator: std.mem.Allocator) !void { const peer = try Peer.init("HTTP/1.1 200 OK\r\nTransfer-Encoding: , ChUnKeD,\r\nX-Test: yes\r\n\r\n2\r\nok\r\n0\r\n\r\n", 0, 0, ""); defer peer.deinit(); var client = zttp.Client.init(std.testing.io, allocator); defer client.deinit(); var buffer: [128]u8 = undefined; const response = try client.open(.{ .url = try peer.url(&buffer), .capture_headers = &.{"x-test"} }); defer response.deinit(); var storage: [2]u8 = undefined; var sink = Io.Writer.fixed(&storage); try std.testing.expectEqual(@as(u64, 2), try response.stream(&sink, .{})); try std.testing.expectEqualStrings("ok", sink.buffered()); try std.testing.expectEqualStrings("yes", response.headers.get("x-test").?);}test "contract: allocation failure unwinds normalized response storage" { try std.testing.checkAllAllocationFailures(a, allocatingRequest, .{});}