// SPDX-FileCopyrightText: © 2026 Jeffrey C. Ollie // SPDX-License-Identifier: MIT //! End-to-end tests that drive `Client` against a stand-in Vault server over //! a real loopback socket. //! //! These exist because the interesting parts of a Vault client are on the //! wire: the `/v1/` prefix, KV v2's `data/` and `metadata/` infixes, the //! `X-Vault-Token` header, `?list=true` standing in for the `LIST` verb, and //! the mapping from status codes to errors. Unit tests over the JSON shapes //! cannot check any of that. const std = @import("std"); const Io = std.Io; const net = std.Io.net; const http = std.http; const testing = std.testing; const Client = @import("Client.zig"); const kv1 = @import("kv1.zig"); const kv2 = @import("kv2.zig"); const token = @import("token.zig"); /// What the fake server saw, so tests can assert on the request rather than /// only on the parsed reply. const Recorder = struct { entries: [16]Entry = undefined, count: usize = 0, const Entry = struct { method: http.Method, target_buf: [256]u8, target_len: usize, token_buf: [128]u8, token_len: usize, content_type_buf: [64]u8, content_type_len: usize, body_buf: [512]u8, body_len: usize, fn target(entry: *const Entry) []const u8 { return entry.target_buf[0..entry.target_len]; } fn token(entry: *const Entry) []const u8 { return entry.token_buf[0..entry.token_len]; } fn contentType(entry: *const Entry) []const u8 { return entry.content_type_buf[0..entry.content_type_len]; } fn body(entry: *const Entry) []const u8 { return entry.body_buf[0..entry.body_len]; } }; /// Copies everything interesting out of the request head and returns the /// entry so the caller can fill in the body. This has to happen before the /// body stream is initialized, because that invalidates the head's /// strings. When the log is full the last slot is reused. fn recordHead(recorder: *Recorder, request: *http.Server.Request) *Entry { const entry = &recorder.entries[recorder.count]; entry.method = request.head.method; entry.target_len = @min(request.head.target.len, entry.target_buf.len); @memcpy(entry.target_buf[0..entry.target_len], request.head.target[0..entry.target_len]); entry.token_len = 0; var it = request.iterateHeaders(); while (it.next()) |header| { if (!std.ascii.eqlIgnoreCase(header.name, "x-vault-token")) continue; entry.token_len = @min(header.value.len, entry.token_buf.len); @memcpy(entry.token_buf[0..entry.token_len], header.value[0..entry.token_len]); } entry.content_type_len = 0; if (request.head.content_type) |value| { entry.content_type_len = @min(value.len, entry.content_type_buf.len); @memcpy(entry.content_type_buf[0..entry.content_type_len], value[0..entry.content_type_len]); } entry.body_len = 0; if (recorder.count + 1 < recorder.entries.len) recorder.count += 1; return entry; } fn last(recorder: *const Recorder) *const Entry { return &recorder.entries[recorder.count - 1]; } /// Number of requests seen. `count` indexes the next free slot, which is /// the same thing until the log fills up. fn seen(recorder: *const Recorder) usize { return recorder.count; } }; const Reply = struct { status: http.Status, body: []const u8, location: ?[]const u8 = null, /// Send the head as raw bytes instead of through `respond`, so the /// response can omit content-length while keeping the connection open. /// `respond` cannot express that combination, and it is exactly what /// Vault and OpenBao send for a successful write. raw_head: ?[]const u8 = null, }; const kv2_current = \\{"request_id":"1","lease_duration":0,"renewable":false, \\ "data":{"data":{"password":"hunter2","port":5432}, \\ "metadata":{"created_time":"2024-05-01T12:00:00Z","deletion_time":"", \\ "destroyed":false,"version":7}}} ; const kv2_older = \\{"data":{"data":{"password":"old-secret"}, \\ "metadata":{"created_time":"2024-01-01T00:00:00Z","deletion_time":"", \\ "destroyed":false,"version":2}}} ; /// Routes on the exact request target, so a wrong path or a missing query /// falls through to the catch-all 404 and fails the test loudly. fn route(target: []const u8, method: http.Method, auth: []const u8) Reply { // Writes answer either 200 with version metadata (KV v2) or 204 with // nothing (KV v1, and the version endpoints). const written = \\{"data":{"created_time":"2024-06-01T09:00:00Z","deletion_time":"","destroyed":false,"version":8}} ; if (method == .POST or method == .PATCH or method == .DELETE) { if (std.mem.eql(u8, target, "/v1/auth/token/renew-self")) { // A token at its maximum TTL still answers, but the lease it hands // back has stopped growing. if (std.mem.eql(u8, auth, "s.maxed-token")) return .{ .status = .ok, .body = \\{"auth":{"client_token":"s.maxed-token","lease_duration":0,"renewable":false}} , }; return .{ .status = .ok, .body = \\{"auth":{"client_token":"s.test-token","accessor":"a2","policies":["default"], \\ "lease_duration":3600,"renewable":true,"token_type":"service"}} , }; } if (std.mem.eql(u8, target, "/v1/auth/token/revoke-self")) return .{ .status = .no_content, .body = "" }; if (std.mem.eql(u8, target, "/v1/secret/data/bare-204")) return .{ .status = .no_content, .body = "", .raw_head = "HTTP/1.1 204 No Content\r\ncontent-type: application/json\r\n\r\n", }; if (std.mem.eql(u8, target, "/v1/secret/data/cas-conflict")) return .{ .status = .bad_request, .body = \\{"errors":["check-and-set parameter did not match the current version"]} , }; if (std.mem.startsWith(u8, target, "/v1/secret/data/") and method != .DELETE) return .{ .status = .ok, .body = written }; return .{ .status = .no_content, .body = "" }; } if (std.mem.eql(u8, target, "/v1/auth/token/lookup-self")) { // A root token: no expiry, nothing to renew. if (std.mem.eql(u8, auth, "s.root-token")) return .{ .status = .ok, .body = \\{"data":{"id":"s.root-token","accessor":"a0","display_name":"root", \\ "expire_time":null,"ttl":0,"renewable":false,"policies":["root"],"type":"service"}} , }; // A batch token: leased, but renewal is not possible at all. if (std.mem.eql(u8, auth, "s.batch-token")) return .{ .status = .ok, .body = \\{"data":{"id":"s.batch-token","accessor":"a3","display_name":"batch", \\ "expire_time":"2026-09-01T12:00:00Z","ttl":900,"renewable":false,"type":"batch"}} , }; return .{ .status = .ok, .body = \\{"data":{"id":"s.test-token","accessor":"a2","display_name":"token", \\ "expire_time":"2026-09-01T12:00:00Z","ttl":7200,"creation_ttl":7200, \\ "renewable":true,"policies":["default"],"type":"service"}} , }; } const table = [_]struct { target: []const u8, reply: Reply }{ .{ .target = "/v1/secret/data/myapp/config", .reply = .{ .status = .ok, .body = kv2_current } }, .{ .target = "/v1/secret/data/myapp/config?version=2", .reply = .{ .status = .ok, .body = kv2_older } }, .{ .target = "/v1/secret/metadata/myapp?list=true", .reply = .{ .status = .ok, .body = \\{"data":{"keys":["config","db/"]}} , } }, .{ .target = "/v1/kv/legacy/creds", .reply = .{ .status = .ok, .body = \\{"lease_id":"","renewable":false,"lease_duration":0,"data":{"user":"root"}} , } }, // A path with a space proves the client percent-encodes what it sends. .{ .target = "/v1/secret/data/has%20space", .reply = .{ .status = .ok, .body = kv2_current } }, .{ .target = "/v1/secret/data/denied", .reply = .{ .status = .forbidden, .body = \\{"errors":["permission denied"]} , } }, .{ .target = "/v1/sys/health", .reply = .{ .status = .ok, .body = \\{"initialized":true,"sealed":false,"standby":false} , } }, // A standby node points at the active one instead of answering. .{ .target = "/v1/secret/data/standby", .reply = .{ .status = .temporary_redirect, .body = "", .location = "https://active.vault.example.com:8200/v1/secret/data/standby", } }, .{ .target = "/v1/sys/sealed", .reply = .{ .status = .service_unavailable, .body = \\{"errors":["Vault is sealed"]} , } }, }; for (table) |entry| { if (std.mem.eql(u8, entry.target, target)) return entry.reply; } return .{ .status = .not_found, .body = \\{"errors":[]} }; } /// Serves one connection until the client hangs up. Runs concurrently with /// the test body, so it must not touch the testing allocator. fn serve(io: Io, server: *net.Server, recorder: *Recorder) void { var stream = server.accept(io) catch return; defer stream.close(io); var recv_buffer: [4096]u8 = undefined; var send_buffer: [4096]u8 = undefined; var reader = stream.reader(io, &recv_buffer); var writer = stream.writer(io, &send_buffer); var connection: http.Server = .init(&reader.interface, &writer.interface); var body_buffer: [4096]u8 = undefined; while (true) { var request = connection.receiveHead() catch return; const entry = recorder.recordHead(&request); // The body has to come off the wire before the response goes out, or // the next request on this connection would start mid-payload. Reading // it also invalidates `request.head`, so the recorded copy is what the // router sees from here on. if (request.head.content_length) |length| { if (length > 0) { const body_reader = request.readerExpectNone(&body_buffer); entry.body_len = body_reader.readSliceShort(&entry.body_buf) catch 0; } } const reply = route(entry.target(), entry.method, entry.token()); if (reply.raw_head) |raw| { // Deliberately bypasses `respond`, and deliberately does not close // the connection afterwards: a client that frames this body from // the headers alone will wait here forever. writer.interface.writeAll(raw) catch return; writer.interface.flush() catch return; continue; } var headers: [2]http.Header = undefined; headers[0] = .{ .name = "content-type", .value = "application/json" }; var header_count: usize = 1; if (reply.location) |location| { headers[header_count] = .{ .name = "location", .value = location }; header_count += 1; } request.respond(reply.body, .{ .status = reply.status, .extra_headers = headers[0..header_count], }) catch return; } } /// A listening fake Vault plus a `Client` already pointed at it. const Fixture = struct { threaded: *std.Io.Threaded, io: Io, server: net.Server, recorder: Recorder, future: Io.Future(void), client: Client, fn init(fixture: *Fixture, gpa: std.mem.Allocator, threaded: *std.Io.Threaded) !void { return fixture.initAs(gpa, threaded, "s.test-token"); } /// The fake server varies its token endpoints by the token presented, so /// the Renewer's stop conditions can be exercised. fn initAs( fixture: *Fixture, gpa: std.mem.Allocator, threaded: *std.Io.Threaded, auth_token: []const u8, ) !void { threaded.* = .init(gpa, .{}); const io = threaded.io(); const any_port: net.IpAddress = .{ .ip4 = .loopback(0) }; fixture.threaded = threaded; fixture.io = io; fixture.server = try any_port.listen(io, .{ .reuse_address = true }); fixture.recorder = .{}; fixture.future = try io.concurrent(serve, .{ io, &fixture.server, &fixture.recorder }); var address_buf: [64]u8 = undefined; const address = try std.fmt.bufPrint(&address_buf, "http://127.0.0.1:{d}", .{ fixture.server.socket.address.getPort(), }); fixture.client = try .init(io, gpa, .{ .address = address, .token = auth_token }); } fn deinit(fixture: *Fixture) void { // Closing the client hangs up, which ends the server loop. fixture.client.deinit(); fixture.future.await(fixture.io); fixture.server.deinit(fixture.io); fixture.threaded.deinit(); fixture.* = undefined; } }; test "kv2 read sends the data/ path with the token and parses the secret" { const gpa = testing.allocator; var threaded: std.Io.Threaded = undefined; var fixture: Fixture = undefined; try fixture.init(gpa, &threaded); defer fixture.deinit(); var secret = try kv2.read(&fixture.client, "myapp/config", .{}); defer secret.deinit(); try testing.expectEqualStrings("hunter2", secret.getString("password").?); try testing.expectEqual(@as(u64, 7), secret.metadata().version); const seen = fixture.recorder.last(); try testing.expectEqual(http.Method.GET, seen.method); try testing.expectEqualStrings("/v1/secret/data/myapp/config", seen.target()); try testing.expectEqualStrings("s.test-token", seen.token()); } test "kv2 read of a specific version adds the version query" { const gpa = testing.allocator; var threaded: std.Io.Threaded = undefined; var fixture: Fixture = undefined; try fixture.init(gpa, &threaded); defer fixture.deinit(); var secret = try kv2.read(&fixture.client, "myapp/config", .{ .version = 2 }); defer secret.deinit(); try testing.expectEqualStrings("old-secret", secret.getString("password").?); try testing.expectEqualStrings( "/v1/secret/data/myapp/config?version=2", fixture.recorder.last().target(), ); } test "kv2 readField returns a caller-owned copy of one field" { const gpa = testing.allocator; var threaded: std.Io.Threaded = undefined; var fixture: Fixture = undefined; try fixture.init(gpa, &threaded); defer fixture.deinit(); const password = try kv2.readField(&fixture.client, "myapp/config", "password", .{}); defer gpa.free(password); try testing.expectEqualStrings("hunter2", password); try testing.expectError( error.FieldNotFound, kv2.readField(&fixture.client, "myapp/config", "absent", .{}), ); } test "kv2 list uses the metadata/ path and ?list=true" { const gpa = testing.allocator; var threaded: std.Io.Threaded = undefined; var fixture: Fixture = undefined; try fixture.init(gpa, &threaded); defer fixture.deinit(); var listing = try kv2.list(&fixture.client, "myapp", .{}); defer listing.deinit(); try testing.expectEqual(@as(usize, 2), listing.keys().len); try testing.expectEqualStrings("db/", listing.keys()[1]); try testing.expectEqualStrings("/v1/secret/metadata/myapp?list=true", fixture.recorder.last().target()); } test "kv1 read uses the mount path unchanged" { const gpa = testing.allocator; var threaded: std.Io.Threaded = undefined; var fixture: Fixture = undefined; try fixture.init(gpa, &threaded); defer fixture.deinit(); var secret = try kv1.read(&fixture.client, "legacy/creds", .{ .mount = "kv" }); defer secret.deinit(); try testing.expectEqualStrings("root", secret.getString("user").?); try testing.expectEqualStrings("/v1/kv/legacy/creds", fixture.recorder.last().target()); } test "paths are percent-encoded on the way out" { const gpa = testing.allocator; var threaded: std.Io.Threaded = undefined; var fixture: Fixture = undefined; try fixture.init(gpa, &threaded); defer fixture.deinit(); var secret = try kv2.read(&fixture.client, "has space", .{}); defer secret.deinit(); try testing.expectEqualStrings("/v1/secret/data/has%20space", fixture.recorder.last().target()); } test "status codes become errors and Vault's message is kept" { const gpa = testing.allocator; var threaded: std.Io.Threaded = undefined; var fixture: Fixture = undefined; try fixture.init(gpa, &threaded); defer fixture.deinit(); try testing.expectError( error.PermissionDenied, kv2.read(&fixture.client, "denied", .{}), ); try testing.expectEqualStrings("permission denied", fixture.client.last_error.?); try testing.expectError( error.SecretNotFound, kv2.read(&fixture.client, "no/such/secret", .{}), ); // The 404 body carried an empty `errors` array, so there is nothing to report. try testing.expectEqual(@as(?[]u8, null), fixture.client.last_error); try testing.expectError(error.Sealed, fixture.client.read("sys/sealed", null)); try testing.expectEqualStrings("Vault is sealed", fixture.client.last_error.?); } test "a redirect is reported rather than followed with the token attached" { const gpa = testing.allocator; var threaded: std.Io.Threaded = undefined; var fixture: Fixture = undefined; try fixture.init(gpa, &threaded); defer fixture.deinit(); try testing.expectError(error.Redirected, kv2.read(&fixture.client, "standby", .{})); try testing.expectEqualStrings( "redirected to https://active.vault.example.com:8200/v1/secret/data/standby", fixture.client.last_error.?, ); // Only one request went out: the client did not chase the Location. try testing.expectEqual(@as(usize, 1), fixture.recorder.seen()); } test "health reports on the unauthenticated endpoint" { const gpa = testing.allocator; var threaded: std.Io.Threaded = undefined; var fixture: Fixture = undefined; try fixture.init(gpa, &threaded); defer fixture.deinit(); try testing.expect(try fixture.client.healthy()); try testing.expectEqualStrings("/v1/sys/health", fixture.recorder.last().target()); } test "a raw read returns untyped JSON for endpoints without a helper" { const gpa = testing.allocator; var threaded: std.Io.Threaded = undefined; var fixture: Fixture = undefined; try fixture.init(gpa, &threaded); defer fixture.deinit(); var parsed = try fixture.client.read("sys/health", null); defer parsed.deinit(); try testing.expect(parsed.value.object.get("initialized").?.bool); try testing.expect(!parsed.value.object.get("sealed").?.bool); } test "kv2 write posts the data envelope and reports the new version" { const gpa = testing.allocator; var threaded: std.Io.Threaded = undefined; var fixture: Fixture = undefined; try fixture.init(gpa, &threaded); defer fixture.deinit(); var result = try kv2.write(&fixture.client, "myapp/config", .{ .password = "hunter2", .port = 5432, }, .{}); defer result.deinit(); try testing.expectEqual(@as(u64, 8), result.version()); const seen = fixture.recorder.last(); try testing.expectEqual(http.Method.POST, seen.method); try testing.expectEqualStrings("/v1/secret/data/myapp/config", seen.target()); try testing.expectEqualStrings("s.test-token", seen.token()); try testing.expectEqualStrings("application/json", seen.contentType()); try testing.expectEqualStrings( \\{"data":{"password":"hunter2","port":5432}} , seen.body()); } test "kv2 write with cas sends the check-and-set option" { const gpa = testing.allocator; var threaded: std.Io.Threaded = undefined; var fixture: Fixture = undefined; try fixture.init(gpa, &threaded); defer fixture.deinit(); var result = try kv2.write(&fixture.client, "myapp/config", .{ .a = "b" }, .{ .cas = 7 }); defer result.deinit(); try testing.expectEqualStrings( \\{"data":{"a":"b"},"options":{"cas":7}} , fixture.recorder.last().body()); } test "a failed check-and-set becomes its own error" { const gpa = testing.allocator; var threaded: std.Io.Threaded = undefined; var fixture: Fixture = undefined; try fixture.init(gpa, &threaded); defer fixture.deinit(); try testing.expectError( error.CheckAndSetMismatch, kv2.write(&fixture.client, "cas-conflict", .{ .a = "b" }, .{ .cas = 1 }), ); try testing.expectEqualStrings( "check-and-set parameter did not match the current version", fixture.client.last_error.?, ); } test "kv2 patch uses the merge-patch media type" { const gpa = testing.allocator; var threaded: std.Io.Threaded = undefined; var fixture: Fixture = undefined; try fixture.init(gpa, &threaded); defer fixture.deinit(); var result = try kv2.patch(&fixture.client, "myapp/config", .{ .port = 5433 }, .{}); defer result.deinit(); const seen = fixture.recorder.last(); try testing.expectEqual(http.Method.PATCH, seen.method); try testing.expectEqualStrings("application/merge-patch+json", seen.contentType()); try testing.expectEqualStrings( \\{"data":{"port":5433}} , seen.body()); } test "kv2 delete soft-deletes through the data path" { const gpa = testing.allocator; var threaded: std.Io.Threaded = undefined; var fixture: Fixture = undefined; try fixture.init(gpa, &threaded); defer fixture.deinit(); try kv2.delete(&fixture.client, "myapp/config", .{}); const seen = fixture.recorder.last(); try testing.expectEqual(http.Method.DELETE, seen.method); try testing.expectEqualStrings("/v1/secret/data/myapp/config", seen.target()); } test "the version endpoints post a versions list to their own paths" { const gpa = testing.allocator; var threaded: std.Io.Threaded = undefined; var fixture: Fixture = undefined; try fixture.init(gpa, &threaded); defer fixture.deinit(); try kv2.deleteVersions(&fixture.client, "myapp/config", &.{ 1, 2 }, .{}); try testing.expectEqualStrings("/v1/secret/delete/myapp/config", fixture.recorder.last().target()); try testing.expectEqualStrings( \\{"versions":[1,2]} , fixture.recorder.last().body()); try kv2.undeleteVersions(&fixture.client, "myapp/config", &.{2}, .{}); try testing.expectEqualStrings("/v1/secret/undelete/myapp/config", fixture.recorder.last().target()); try kv2.destroyVersions(&fixture.client, "myapp/config", &.{1}, .{}); try testing.expectEqualStrings("/v1/secret/destroy/myapp/config", fixture.recorder.last().target()); try kv2.deleteMetadata(&fixture.client, "myapp/config", .{}); try testing.expectEqual(http.Method.DELETE, fixture.recorder.last().method); try testing.expectEqualStrings("/v1/secret/metadata/myapp/config", fixture.recorder.last().target()); } test "kv1 write sends the data unwrapped and tolerates a 204" { const gpa = testing.allocator; var threaded: std.Io.Threaded = undefined; var fixture: Fixture = undefined; try fixture.init(gpa, &threaded); defer fixture.deinit(); try kv1.write(&fixture.client, "legacy/creds", .{ .user = "admin" }, .{ .mount = "kv" }); const seen = fixture.recorder.last(); try testing.expectEqual(http.Method.POST, seen.method); try testing.expectEqualStrings("/v1/kv/legacy/creds", seen.target()); // No `data` envelope: KV v1 takes the object as-is. try testing.expectEqualStrings( \\{"user":"admin"} , seen.body()); try kv1.delete(&fixture.client, "legacy/creds", .{ .mount = "kv" }); try testing.expectEqual(http.Method.DELETE, fixture.recorder.last().method); } test "lookupSelf reads the token's own lease" { const gpa = testing.allocator; var threaded: std.Io.Threaded = undefined; var fixture: Fixture = undefined; try fixture.init(gpa, &threaded); defer fixture.deinit(); var lookup = try token.lookupSelf(&fixture.client); defer lookup.deinit(); try testing.expectEqual(@as(u64, 7200), lookup.info().ttl); try testing.expect(lookup.info().renewable); try testing.expect(!lookup.neverExpires()); try testing.expectEqualStrings("/v1/auth/token/lookup-self", fixture.recorder.last().target()); } test "renewSelf posts an increment when one is asked for" { const gpa = testing.allocator; var threaded: std.Io.Threaded = undefined; var fixture: Fixture = undefined; try fixture.init(gpa, &threaded); defer fixture.deinit(); var plain = try token.renewSelf(&fixture.client, .{}); defer plain.deinit(); try testing.expectEqual(@as(u64, 3600), plain.ttl()); try testing.expectEqual(http.Method.POST, fixture.recorder.last().method); try testing.expectEqualStrings("{}", fixture.recorder.last().body()); var bumped = try token.renewSelf(&fixture.client, .{ .increment_s = 3600 }); defer bumped.deinit(); // Vault's duration parser wants the suffixed form. try testing.expectEqualStrings( \\{"increment":"3600s"} , fixture.recorder.last().body()); } test "revokeSelf posts to revoke-self and tolerates the 204" { const gpa = testing.allocator; var threaded: std.Io.Threaded = undefined; var fixture: Fixture = undefined; try fixture.init(gpa, &threaded); defer fixture.deinit(); try token.revokeSelf(&fixture.client); try testing.expectEqualStrings("/v1/auth/token/revoke-self", fixture.recorder.last().target()); } test "Renewer looks the token up once, then renews on the lease it is granted" { const gpa = testing.allocator; var threaded: std.Io.Threaded = undefined; var fixture: Fixture = undefined; try fixture.init(gpa, &threaded); defer fixture.deinit(); var renewer: token.Renewer = .init(&fixture.client, .{}); // First call: lookup-self, then renew-self. switch (try renewer.renew()) { // Half of the 3600s lease the renewal granted, not of the 7200s the // lookup reported. .renewed => |seconds| try testing.expectEqual(@as(u64, 1800), seconds), else => return error.TestUnexpectedResult, } try testing.expectEqual(@as(usize, 2), fixture.recorder.seen()); try testing.expectEqualStrings("/v1/auth/token/renew-self", fixture.recorder.last().target()); // Subsequent calls skip the lookup: state is established. switch (try renewer.renew()) { .renewed => |seconds| try testing.expectEqual(@as(u64, 1800), seconds), else => return error.TestUnexpectedResult, } try testing.expectEqual(@as(usize, 3), fixture.recorder.seen()); } test "Renewer refresh reads the lease without renewing it" { const gpa = testing.allocator; var threaded: std.Io.Threaded = undefined; var fixture: Fixture = undefined; try fixture.init(gpa, &threaded); defer fixture.deinit(); var renewer: token.Renewer = .init(&fixture.client, .{ .max_wait_s = 60 * 60 * 24 }); switch (try renewer.refresh()) { .renewed => |seconds| try testing.expectEqual(@as(u64, 3600), seconds), // half of 7200 else => return error.TestUnexpectedResult, } try testing.expectEqual(@as(usize, 1), fixture.recorder.seen()); try testing.expectEqualStrings("/v1/auth/token/lookup-self", fixture.recorder.last().target()); } test "Renewer stops on a token that never expires" { const gpa = testing.allocator; var threaded: std.Io.Threaded = undefined; var fixture: Fixture = undefined; try fixture.initAs(gpa, &threaded, "s.root-token"); defer fixture.deinit(); var renewer: token.Renewer = .init(&fixture.client, .{}); try testing.expectEqual(token.Renewer.Status.never_expires, try renewer.renew()); // It never reached renew-self, which a root token would reject. try testing.expectEqual(@as(usize, 1), fixture.recorder.seen()); } test "Renewer reports a token that cannot be renewed at all" { const gpa = testing.allocator; var threaded: std.Io.Threaded = undefined; var fixture: Fixture = undefined; try fixture.initAs(gpa, &threaded, "s.batch-token"); defer fixture.deinit(); var renewer: token.Renewer = .init(&fixture.client, .{}); switch (try renewer.renew()) { // The caller learns how long it has left to arrange a new token. .not_renewable => |seconds| try testing.expectEqual(@as(u64, 900), seconds), else => return error.TestUnexpectedResult, } try testing.expectEqual(@as(usize, 1), fixture.recorder.seen()); } test "Renewer stops when the lease has stopped growing" { const gpa = testing.allocator; var threaded: std.Io.Threaded = undefined; var fixture: Fixture = undefined; try fixture.initAs(gpa, &threaded, "s.maxed-token"); defer fixture.deinit(); var renewer: token.Renewer = .init(&fixture.client, .{}); // The lookup says renewable, so it tries; the renewal comes back with a // zero lease, which means the maximum TTL has been reached. switch (try renewer.renew()) { .not_renewable => |seconds| try testing.expectEqual(@as(u64, 0), seconds), else => return error.TestUnexpectedResult, } try testing.expectEqual(@as(usize, 2), fixture.recorder.seen()); } test "a 204 with no content-length is not read as a body" { // Regression test for a hang, not a wrong answer: `std.http` frames the // response body from the headers, so before `Client` special-cased the // bodiless statuses this waited for an end-of-connection that a // keep-alive server never sends. A regression here shows up as this test // never finishing rather than as a failed assertion. const gpa = testing.allocator; var threaded: std.Io.Threaded = undefined; var fixture: Fixture = undefined; try fixture.init(gpa, &threaded); defer fixture.deinit(); var response = try fixture.client.request(.{ .method = .POST, .path = "secret/data/bare-204", .body = "{}", }); defer response.deinit(); try testing.expectEqual(http.Status.no_content, response.status); try testing.expectEqual(@as(usize, 0), response.body.len); }