Something went wrong. Try again.
A client for the HashiCorp Vault and OpenBao HTTP API, for Zig 0.16.
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393// SPDX-FileCopyrightText: © 2026 Jeffrey C. Ollie <jeff@ocjtech.us>// SPDX-License-Identifier: MIT
//! Integration tests against a live Vault or OpenBao server.//!//! The test suite in `src/` runs against a fake server, which proves the//! client sends what it means to send but not that a real server agrees. This//! binary closes that gap: point it at a server with a root-capable token and//! it exercises the library against the genuine article.//!//! ```//! VAULT_ADDR=http://127.0.0.1:8200 VAULT_TOKEN=... vault-integration-tests//! ```//!//! It creates everything it needs, including a KV v1 mount, and removes the//! secrets it wrote. It is destructive under `vaultz-integration/` on the//! `secret/` and `kv/` mounts, so do not aim it at a production cluster.//!//! Exit status is 0 when every check passed and 1 otherwise.
const std = @import("std");const Io = std.Io;const Allocator = std.mem.Allocator;
const vault = @import("vault");
/// Every secret this binary touches lives under here.const prefix = "vaultz-integration";
const Context = struct { gpa: Allocator, io: Io, client: *vault.Client, /// Address and token, kept for the checks that need a second client. address: []const u8, token: []const u8,};
const Check = struct { name: []const u8, run: *const fn (*Context) anyerror!void,};
const checks = [_]Check{ .{ .name = "server reports healthy", .run = checkHealth }, .{ .name = "lookup-self describes the token", .run = checkLookupSelf }, .{ .name = "kv2 write then read round-trips typed values", .run = checkKv2WriteRead }, .{ .name = "kv2 keeps earlier versions readable", .run = checkKv2Versions }, .{ .name = "kv2 check-and-set refuses a stale write", .run = checkKv2CheckAndSet }, .{ .name = "kv2 patch merges without dropping fields", .run = checkKv2Patch }, .{ .name = "kv2 list shows the key", .run = checkKv2List }, .{ .name = "kv2 delete is reversible by undelete", .run = checkKv2DeleteUndelete }, .{ .name = "kv2 deleteMetadata removes the secret entirely", .run = checkKv2DeleteMetadata }, .{ .name = "kv1 write, read and delete on a v1 mount", .run = checkKv1 }, .{ .name = "a missing secret is SecretNotFound", .run = checkMissingSecret }, .{ .name = "a bad token is PermissionDenied", .run = checkPermissionDenied }, .{ .name = "a renewable child token can be renewed", .run = checkTokenRenewal },};
pub fn main(init: std.process.Init) !u8 { const gpa = init.gpa; const io = init.io; const arena = init.arena.allocator();
var stdout_buffer: [4096]u8 = undefined; var stdout_file_writer: Io.File.Writer = .init(.stdout(), io, &stdout_buffer); const out = &stdout_file_writer.interface; defer out.flush() catch {};
var client: vault.Client = try .initFromEnv(io, gpa, init.environ_map, .{}); defer client.deinit();
// Resolving the address and token through the client rather than reading // the environment again means these checks run against whatever the // library itself decided, including its VAULT_/BAO_ precedence. const address = client.address(); const token = client.token orelse { try out.writeAll("no token: set VAULT_TOKEN or BAO_TOKEN, or run `vault login`\n"); return 2; };
var context: Context = .{ .gpa = gpa, .io = io, .client = &client, .address = try arena.dupe(u8, address), .token = try arena.dupe(u8, token), };
try out.print("running {d} checks against {s}\n\n", .{ checks.len, address });
setUp(&context) catch |err| { try out.print("setup failed: {s}\n", .{@errorName(err)}); if (client.last_error) |message| try out.print(" vault said: {s}\n", .{message}); return 1; };
var failed: usize = 0; for (checks) |check| { if (check.run(&context)) { try out.print("ok {s}\n", .{check.name}); } else |err| { failed += 1; try out.print("FAIL {s}: {s}\n", .{ check.name, @errorName(err) }); if (client.last_error) |message| try out.print(" vault said: {s}\n", .{message}); } try out.flush(); }
tearDown(&context);
try out.print("\n{d}/{d} checks passed\n", .{ checks.len - failed, checks.len }); return if (failed == 0) 0 else 1;}
/// Makes sure the mounts the checks need exist and that no leftovers from an/// earlier run are in the way.////// Neither mount can be assumed. A server started with `-dev` mounts KV v2 at/// `secret/` for you, but one that was initialized properly has no mounts at/// all beyond the system ones, so both are created here.fn setUp(context: *Context) !void { try mount(context, "secret", "2"); try mount(context, "kv", "1"); tearDown(context);}
/// Enables a KV secret engine, treating "path is already in use" as success.fn mount(context: *Context, path: []const u8, version: []const u8) !void { const gpa = context.gpa;
const api_path = try std.fmt.allocPrint(gpa, "sys/mounts/{s}", .{path}); defer gpa.free(api_path);
const body = try std.fmt.allocPrint( gpa, \\{{"type":"kv","options":{{"version":"{s}"}}}} , .{version}, ); defer gpa.free(body);
context.client.writeDiscard(api_path, body) catch |err| switch (err) { // Both Vault and OpenBao answer 400 when the path is already mounted, // which is the normal case on a server that has been used before. error.InvalidRequest => {}, else => |e| return e, };}
/// Removes everything the checks create. Failures are ignored: on a clean/// server there is nothing to remove.fn tearDown(context: *Context) void { vault.kv2.deleteMetadata(context.client, prefix ++ "/config", .{}) catch {}; vault.kv2.deleteMetadata(context.client, prefix ++ "/versioned", .{}) catch {}; vault.kv2.deleteMetadata(context.client, prefix ++ "/cas", .{}) catch {}; vault.kv2.deleteMetadata(context.client, prefix ++ "/patch", .{}) catch {}; vault.kv2.deleteMetadata(context.client, prefix ++ "/deleted", .{}) catch {}; vault.kv2.deleteMetadata(context.client, prefix ++ "/gone", .{}) catch {}; vault.kv1.delete(context.client, prefix ++ "/flat", .{ .mount = "kv" }) catch {}; context.client.clearLastError();}
fn checkHealth(context: *Context) !void { if (!try context.client.healthy()) return error.ServerNotHealthy;}
fn checkLookupSelf(context: *Context) !void { var lookup = try vault.token.lookupSelf(context.client); defer lookup.deinit();
if (lookup.info().accessor.len == 0) return error.NoAccessorReported; if (lookup.info().policies.len == 0) return error.NoPoliciesReported;}
fn checkKv2WriteRead(context: *Context) !void { var written = try vault.kv2.write(context.client, prefix ++ "/config", .{ .user = "admin", .password = "hunter2", .port = 5432, .tls = true, }, .{}); defer written.deinit(); if (written.version() == 0) return error.NoVersionReported;
var secret = try vault.kv2.read(context.client, prefix ++ "/config", .{}); defer secret.deinit();
try expectEqualStrings("admin", secret.getString("user") orelse return error.MissingField); try expectEqualStrings("hunter2", secret.getString("password") orelse return error.MissingField); // KV v2 stores arbitrary JSON, so these must survive as their own types. if ((secret.get("port") orelse return error.MissingField).integer != 5432) return error.WrongNumber; if (!(secret.get("tls") orelse return error.MissingField).bool) return error.WrongBool; if (secret.metadata().version != written.version()) return error.VersionMismatch;}
fn checkKv2Versions(context: *Context) !void { var first = try vault.kv2.write(context.client, prefix ++ "/versioned", .{ .value = "one" }, .{}); defer first.deinit(); var second = try vault.kv2.write(context.client, prefix ++ "/versioned", .{ .value = "two" }, .{}); defer second.deinit();
if (second.version() != first.version() + 1) return error.VersionDidNotAdvance;
var latest = try vault.kv2.read(context.client, prefix ++ "/versioned", .{}); defer latest.deinit(); try expectEqualStrings("two", latest.getString("value") orelse return error.MissingField);
var older = try vault.kv2.read(context.client, prefix ++ "/versioned", .{ .version = first.version() }); defer older.deinit(); try expectEqualStrings("one", older.getString("value") orelse return error.MissingField);}
fn checkKv2CheckAndSet(context: *Context) !void { // cas = 0 creates, and only when nothing is there. var created = try vault.kv2.write(context.client, prefix ++ "/cas", .{ .value = "first" }, .{ .cas = 0 }); defer created.deinit();
// The same write again must be refused, because the path is now occupied. if (vault.kv2.write(context.client, prefix ++ "/cas", .{ .value = "clobber" }, .{ .cas = 0 })) |_| { return error.StaleWriteAccepted; } else |err| if (err != error.CheckAndSetMismatch) return err;
// Naming the version that is actually current succeeds. var updated = try vault.kv2.write(context.client, prefix ++ "/cas", .{ .value = "second" }, .{ .cas = created.version(), }); defer updated.deinit();
var secret = try vault.kv2.read(context.client, prefix ++ "/cas", .{}); defer secret.deinit(); try expectEqualStrings("second", secret.getString("value") orelse return error.MissingField);}
fn checkKv2Patch(context: *Context) !void { var written = try vault.kv2.write(context.client, prefix ++ "/patch", .{ .keep = "unchanged", .change = "before", }, .{}); defer written.deinit();
var patched = try vault.kv2.patch(context.client, prefix ++ "/patch", .{ .change = "after" }, .{}); defer patched.deinit();
var secret = try vault.kv2.read(context.client, prefix ++ "/patch", .{}); defer secret.deinit();
try expectEqualStrings("after", secret.getString("change") orelse return error.MissingField); // The whole point of patch: the field it did not mention is still there. try expectEqualStrings("unchanged", secret.getString("keep") orelse return error.PatchDroppedField);}
fn checkKv2List(context: *Context) !void { var written = try vault.kv2.write(context.client, prefix ++ "/config", .{ .a = "b" }, .{}); defer written.deinit();
var listing = try vault.kv2.list(context.client, prefix, .{}); defer listing.deinit();
for (listing.keys()) |key| { if (std.mem.eql(u8, key, "config")) return; } return error.KeyNotListed;}
fn checkKv2DeleteUndelete(context: *Context) !void { var written = try vault.kv2.write(context.client, prefix ++ "/deleted", .{ .value = "here" }, .{}); defer written.deinit();
try vault.kv2.delete(context.client, prefix ++ "/deleted", .{});
// A soft-deleted current version reads as absent. if (vault.kv2.read(context.client, prefix ++ "/deleted", .{})) |secret| { var s = secret; s.deinit(); return error.DeletedSecretStillReadable; } else |err| if (err != error.SecretNotFound) return err;
// ...but the data is still there, and undelete brings it back. try vault.kv2.undeleteVersions(context.client, prefix ++ "/deleted", &.{written.version()}, .{});
var restored = try vault.kv2.read(context.client, prefix ++ "/deleted", .{}); defer restored.deinit(); try expectEqualStrings("here", restored.getString("value") orelse return error.MissingField);}
fn checkKv2DeleteMetadata(context: *Context) !void { var written = try vault.kv2.write(context.client, prefix ++ "/gone", .{ .value = "x" }, .{}); defer written.deinit();
try vault.kv2.deleteMetadata(context.client, prefix ++ "/gone", .{});
if (vault.kv2.read(context.client, prefix ++ "/gone", .{})) |secret| { var s = secret; s.deinit(); return error.DestroyedSecretStillReadable; } else |err| if (err != error.SecretNotFound) return err;
// Destroying every version takes the key out of the listing too. var listing = vault.kv2.list(context.client, prefix, .{}) catch |err| switch (err) { error.SecretNotFound => return, // nothing left under the prefix at all else => |e| return e, }; defer listing.deinit();
for (listing.keys()) |key| { if (std.mem.eql(u8, key, "gone")) return error.DestroyedKeyStillListed; }}
fn checkKv1(context: *Context) !void { const options: vault.kv1.Options = .{ .mount = "kv" };
try vault.kv1.write(context.client, prefix ++ "/flat", .{ .user = "root" }, options);
var secret = try vault.kv1.read(context.client, prefix ++ "/flat", options); defer secret.deinit(); try expectEqualStrings("root", secret.getString("user") orelse return error.MissingField); // A static KV v1 secret carries no lease. if (secret.lease() != null) return error.UnexpectedLease;
try vault.kv1.delete(context.client, prefix ++ "/flat", options);
if (vault.kv1.read(context.client, prefix ++ "/flat", options)) |leftover| { var s = leftover; s.deinit(); return error.DeletedSecretStillReadable; } else |err| if (err != error.SecretNotFound) return err;}
fn checkMissingSecret(context: *Context) !void { if (vault.kv2.read(context.client, prefix ++ "/definitely-not-here", .{})) |secret| { var s = secret; s.deinit(); return error.MissingSecretWasFound; } else |err| if (err != error.SecretNotFound) return err;}
fn checkPermissionDenied(context: *Context) !void { var bad: vault.Client = try .init(context.io, context.gpa, .{ .address = context.address, .token = "not-a-real-token", }); defer bad.deinit();
if (vault.kv2.read(&bad, prefix ++ "/config", .{})) |secret| { var s = secret; s.deinit(); return error.BadTokenAccepted; } else |err| if (err != error.PermissionDenied) return err;}
fn checkTokenRenewal(context: *Context) !void { // A root token has no expiry and cannot be renewed, so the renewal path // needs a child token that does expire. const request = \\{"ttl":"1h","renewable":true,"policies":["default"]} ; var created = try context.client.writeAs( struct { auth: struct { client_token: []const u8 = "" } = .{} }, "auth/token/create", request, ); defer created.deinit();
const child = created.value.auth.client_token; if (child.len == 0) return error.NoChildTokenIssued;
var child_client: vault.Client = try .init(context.io, context.gpa, .{ .address = context.address, .token = child, }); defer child_client.deinit();
var renewer: vault.token.Renewer = .init(&child_client, .{}); switch (try renewer.renew()) { .renewed => |seconds| if (seconds == 0) return error.RenewalReportedNoWait, .never_expires => return error.ChildTokenHasNoExpiry, .not_renewable => return error.ChildTokenNotRenewable, }
// The renewal must not have invalidated the token it renewed. var lookup = try vault.token.lookupSelf(&child_client); defer lookup.deinit(); if (lookup.info().ttl == 0) return error.RenewedTokenHasNoTtl;
try vault.token.revokeSelf(&child_client);}
fn expectEqualStrings(expected: []const u8, actual: []const u8) !void { if (!std.mem.eql(u8, expected, actual)) return error.StringMismatch;}