Skip to content

graff — a fast agentic coding harness in Zig: multi-provider, MCP, workflows, DGM evolution loop, TS/Python SDKs

Python
11.7 KB
Raw Blame
//! Unit tests for recoverable HTTP client generation lifetime and fault hooks.

const std = @import("std");
const http_client = @import("http_client.zig");
const Recovery = http_client.Recovery;
const RecoveryOutcome = http_client.RecoveryOutcome;

test "HTTP client integration coverage" {
    _ = @import("http_client_integration_tests.zig");
    _ = @import("http_client_trajectory_tests.zig");
}

fn recoverTask(recovery: *Recovery, client: *std.http.Client) RecoveryOutcome {
    return recovery.recoverConstructionTls(client);
}

fn shutdownTask(recovery: *Recovery) void {
    recovery.shutdown();
}

test "runtime teardown leaves the global transport closed to late acquisitions" {
    const gpa = std.testing.allocator;
    const io = std.testing.io;
    var runtime: http_client.Runtime = undefined;
    runtime.init(gpa, io);
    runtime.deinit(io);

    var late = http_client.acquire(&runtime.client);
    defer late.release();
    try std.testing.expect(!late.available);

    var unrelated: std.http.Client = .{ .allocator = gpa, .io = io };
    defer unrelated.deinit();
    var unmanaged = http_client.acquire(&unrelated);
    defer unmanaged.release();
    try std.testing.expect(unmanaged.available);
}

fn runtimeDeinitTask(runtime: *http_client.Runtime, io: std.Io) void {
    runtime.deinit(io);
}

test "runtime teardown closes admission before draining an active lease" {
    const gpa = std.testing.allocator;
    const io = std.testing.io;
    var runtime: http_client.Runtime = undefined;
    runtime.init(gpa, io);
    http_client.waitForReady(io);
    var lease = http_client.acquire(&runtime.client);
    try std.testing.expect(lease.available);

    var teardown = io.async(runtimeDeinitTask, .{ &runtime, io });
    for (0..100) |_| {
        if (runtime.recovery.stats().shutting_down) break;
        try io.sleep(.fromMilliseconds(1), .awake);
    }
    try std.testing.expect(runtime.recovery.stats().shutting_down);
    var denied = http_client.acquire(&runtime.client);
    defer denied.release();
    try std.testing.expect(!denied.available);

    lease.release();
    _ = teardown.await(io);
}

fn waitReadyTask(io: std.Io) void {
    http_client.waitForReady(io);
}

fn uninstallTask() void {
    http_client.uninstallForTest();
}

test "lifecycle teardown drains callers already waiting for CA readiness" {
    const gpa = std.testing.allocator;
    const io = std.testing.io;
    var original: std.http.Client = .{ .allocator = gpa, .io = io };
    defer original.deinit();
    var recovery: Recovery = undefined;
    recovery.init(gpa, io, &original, false);
    defer recovery.deinit();
    var ready: std.Io.Event = .unset;
    var wait_entered: std.Io.Event = .unset;
    http_client.installForTest(&recovery, &ready, &wait_entered);

    var waiter = io.async(waitReadyTask, .{io});
    wait_entered.waitUncancelable(io);
    var teardown = io.async(uninstallTask, .{});
    ready.set(io);
    _ = waiter.await(io);
    _ = teardown.await(io);
}

test "retired generation stays alive until its final concurrent lease releases" {
    const gpa = std.testing.allocator;
    const io = std.testing.io;
    var original: std.http.Client = .{ .allocator = gpa, .io = io };
    defer original.deinit();
    var recovery: Recovery = undefined;
    recovery.init(gpa, io, &original, false);
    defer recovery.deinit();

    var first = recovery.acquire(&original);
    var second = recovery.acquire(&original);
    try std.testing.expectEqual(RecoveryOutcome.rotated, recovery.recoverConstructionTls(first.client));
    try std.testing.expectEqual(@as(usize, 1), recovery.stats().retired);
    first.release();
    try std.testing.expectEqual(@as(usize, 1), recovery.stats().retired);
    second.release();
    try std.testing.expectEqual(@as(usize, 0), recovery.stats().retired);
}

test "replacement allocation failures keep the current generation usable" {
    const backing = std.testing.allocator;
    const io = std.testing.io;
    var original: std.http.Client = .{ .allocator = backing, .io = io };
    defer original.deinit();

    for (0..2) |fail_index| {
        var failing = std.testing.FailingAllocator.init(backing, .{ .fail_index = fail_index });
        var recovery: Recovery = undefined;
        recovery.init(failing.allocator(), io, &original, false);
        defer recovery.deinit();
        var lease = recovery.acquire(&original);
        defer lease.release();
        try std.testing.expectEqual(RecoveryOutcome.unavailable, recovery.recoverConstructionTls(lease.client));
        try std.testing.expectEqual(@as(u64, 0), recovery.stats().active_id);
    }
}

test "unmanaged client TLS failure does not rotate the launch generation" {
    const gpa = std.testing.allocator;
    const io = std.testing.io;
    var original: std.http.Client = .{ .allocator = gpa, .io = io };
    defer original.deinit();
    var unrelated: std.http.Client = .{ .allocator = gpa, .io = io };
    defer unrelated.deinit();
    var recovery: Recovery = undefined;
    recovery.init(gpa, io, &original, false);
    defer recovery.deinit();

    try std.testing.expectEqual(RecoveryOutcome.unavailable, recovery.recoverConstructionTls(&unrelated));
    try std.testing.expectEqual(@as(u64, 0), recovery.stats().active_id);
}

test "replacement CA warm failure is attributed to the triggering rotation" {
    const gpa = std.testing.allocator;
    const io = std.testing.io;
    var original: std.http.Client = .{ .allocator = gpa, .io = io };
    defer original.deinit();
    var recovery: Recovery = undefined;
    recovery.init(gpa, io, &original, true);
    defer recovery.deinit();

    var failed = recovery.acquire(&original);
    defer failed.release();
    http_client.injectReplacementCaWarmFailureForTest();
    try std.testing.expectEqual(RecoveryOutcome.rotated_ca_warm_failed, recovery.recoverConstructionTls(failed.client));
}

test "request-construction TLS recovery reaches later root and child trajectories" {
    const gpa = std.testing.allocator;
    const io = std.testing.io;
    var original: std.http.Client = .{ .allocator = gpa, .io = io };
    defer original.deinit();
    var recovery: Recovery = undefined;
    recovery.init(gpa, io, &original, false);
    defer recovery.deinit();

    var failed_root = recovery.acquire(&original);
    try std.testing.expectEqual(@as(u64, 0), failed_root.generation_id);
    try std.testing.expectEqual(RecoveryOutcome.rotated, recovery.recoverConstructionTls(failed_root.client));

    var later_root = recovery.acquire(&original);
    defer later_root.release();
    var child = recovery.acquire(&original);
    defer child.release();
    try std.testing.expectEqual(@as(u64, 1), later_root.generation_id);
    try std.testing.expectEqual(later_root.generation_id, child.generation_id);
    try std.testing.expect(later_root.client == child.client);
    try std.testing.expect(later_root.client != failed_root.client);
    failed_root.release();
}

test "concurrent stale TLS reports rotate a generation only once" {
    const gpa = std.testing.allocator;
    const io = std.testing.io;
    var original: std.http.Client = .{ .allocator = gpa, .io = io };
    defer original.deinit();
    var recovery: Recovery = undefined;
    recovery.init(gpa, io, &original, false);
    defer recovery.deinit();

    var first = recovery.acquire(&original);
    var concurrent = recovery.acquire(&original);
    var first_fut = io.async(recoverTask, .{ &recovery, first.client });
    var second_fut = io.async(recoverTask, .{ &recovery, concurrent.client });
    const first_result = first_fut.await(io);
    const second_result = second_fut.await(io);
    try std.testing.expect(first_result != .unavailable);
    try std.testing.expect(second_result != .unavailable);
    try std.testing.expect(first_result != second_result);
    var after = recovery.acquire(&original);
    defer after.release();
    try std.testing.expectEqual(@as(u64, 1), after.generation_id);
    first.release();
    concurrent.release();
}

test "shutdown rejects new managed acquisitions and drains an in-flight replacement" {
    const gpa = std.testing.allocator;
    const io = std.testing.io;
    var original: std.http.Client = .{ .allocator = gpa, .io = io };
    defer original.deinit();
    var recovery: Recovery = undefined;
    recovery.init(gpa, io, &original, false);
    defer recovery.deinit();

    var initial = recovery.acquire(&original);
    try std.testing.expectEqual(RecoveryOutcome.rotated, recovery.recoverConstructionTls(initial.client));
    initial.release();
    var in_flight = recovery.acquire(&original);
    try std.testing.expectEqual(@as(u64, 1), in_flight.generation_id);

    var shutdown = io.async(shutdownTask, .{&recovery});
    for (0..100) |_| {
        if (recovery.stats().shutting_down) break;
        try io.sleep(.fromMilliseconds(1), .awake);
    }
    try std.testing.expect(recovery.stats().shutting_down);
    const denied = recovery.acquire(&original);
    try std.testing.expect(!denied.available);
    try std.testing.expectEqual(@as(usize, 1), recovery.stats().total_refs);

    in_flight.release();
    _ = shutdown.await(io);
    try std.testing.expectEqual(@as(usize, 0), recovery.stats().total_refs);
}

test "owned retired client remains alive until both stale leases release" {
    const gpa = std.testing.allocator;
    const io = std.testing.io;
    var original: std.http.Client = .{ .allocator = gpa, .io = io };
    defer original.deinit();
    var recovery: Recovery = undefined;
    recovery.init(gpa, io, &original, false);
    defer recovery.deinit();

    var initial = recovery.acquire(&original);
    try std.testing.expectEqual(RecoveryOutcome.rotated, recovery.recoverConstructionTls(initial.client));
    initial.release();
    var first = recovery.acquire(&original);
    var second = recovery.acquire(&original);
    try std.testing.expectEqual(RecoveryOutcome.rotated, recovery.recoverConstructionTls(first.client));
    try std.testing.expectEqual(@as(usize, 1), recovery.stats().retired);
    first.release();
    try std.testing.expectEqual(@as(usize, 1), recovery.stats().retired);
    second.release();
    try std.testing.expectEqual(@as(usize, 0), recovery.stats().retired);
}

test "generation zero injection never intercepts an unmanaged client" {
    const gpa = std.testing.allocator;
    const io = std.testing.io;
    var original: std.http.Client = .{ .allocator = gpa, .io = io };
    defer original.deinit();
    var unrelated: std.http.Client = .{ .allocator = gpa, .io = io };
    defer unrelated.deinit();
    var recovery: Recovery = undefined;
    recovery.init(gpa, io, &original, false);
    defer recovery.deinit();
    http_client.installForTest(&recovery, null, null);
    defer http_client.uninstallForTest();

    http_client.injectConstructionTlsForTest(0);
    var unmanaged = recovery.acquire(&unrelated);
    defer unmanaged.release();
    try std.testing.expect(http_client.injectedConstructionTls(&unmanaged) == null);
    var managed = recovery.acquire(&original);
    defer managed.release();
    try std.testing.expectEqual(error.TlsRequestConstructionFailed, http_client.injectedConstructionTls(&managed).?);
}

test "post-prewarm generation allocation failure cleans up and preserves active client" {
    const gpa = std.testing.allocator;
    const io = std.testing.io;
    var original: std.http.Client = .{ .allocator = gpa, .io = io };
    defer original.deinit();
    var recovery: Recovery = undefined;
    recovery.init(gpa, io, &original, true);
    defer recovery.deinit();

    var lease = recovery.acquire(&original);
    defer lease.release();
    http_client.injectGenerationAllocationFailureForTest();
    try std.testing.expectEqual(RecoveryOutcome.unavailable, recovery.recoverConstructionTls(lease.client));
    try std.testing.expectEqual(@as(u64, 0), recovery.stats().active_id);
    try std.testing.expect(lease.client == &original);
}