Something went wrong. Try again.
A client for the HashiCorp Vault and OpenBao HTTP API, for Zig 0.16.
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806// SPDX-FileCopyrightText: © 2026 Jeffrey C. Ollie <jeff@ocjtech.us>// 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);}