// SPDX-FileCopyrightText: © 2026 Jeffrey C. Ollie // 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; }