register-referentie/services/event-subscriber/EventSubscriber.Tests/AclHttpClientTests.cs

using System.Net;
using System.Text;
using EventSubscriber.Api;

namespace EventSubscriber.Tests;

/// <summary>
/// Unit tests for the subscriber's ACL client, which reads a register record through the ACL — the
/// only code allowed to talk to Objecten (§8.1, ADR-0028/ADR-0030). Uses a scripted message handler
/// so no real ACL is required.
/// </summary>
public class AclHttpClientTests
{
    private const string ObjectUrl = "http://objecten.local:8000/api/v2/objects/obj-9";

    private static AclHttpClient Client(StubHandler handler) =>
        new(new HttpClient(handler) { BaseAddress = new Uri("http://acl/") });

    [Fact]
    public async Task Reads_a_register_record_by_posting_the_object_url()
    {
        var capture = new RequestCapture();
        var client = Client(capture.Responds(
            HttpStatusCode.OK, """{"id":"zaak-1","status":"INGESCHREVEN","reference":"REG-42"}"""));

        var record = await client.GetRegisterRecordAsync(new Uri(ObjectUrl));

        Assert.Equal("zaak-1", record!.Id);
        Assert.Equal("INGESCHREVEN", record.Status);
        Assert.Equal("REG-42", record.Reference);
        Assert.Equal(HttpMethod.Post, capture.Seen!.Method);
        Assert.Equal("http://acl/register-records/read", capture.Seen.RequestUri!.ToString());
        Assert.Contains($"\"objectUrl\":\"{ObjectUrl}\"", capture.Body);
    }

    [Fact]
    public async Task Reads_a_missing_record_as_nothing_to_project()
    {
        var capture = new RequestCapture();
        var client = Client(capture.Responds(HttpStatusCode.NotFound));

        // The object may be gone by the time a redelivered notification is handled (§8.6).
        Assert.Null(await client.GetRegisterRecordAsync(new Uri(ObjectUrl)));
    }

    [Fact]
    public async Task Throws_when_the_acl_rejects_the_request()
    {
        var capture = new RequestCapture();
        var client = Client(capture.Responds(HttpStatusCode.BadGateway));

        await Assert.ThrowsAsync<HttpRequestException>(
            () => client.GetRegisterRecordAsync(new Uri(ObjectUrl)));
    }

    [Fact]
    public async Task Throws_when_the_acl_returns_an_empty_body()
    {
        var capture = new RequestCapture();
        var client = Client(capture.Responds(HttpStatusCode.OK, "null"));

        var ex = await Assert.ThrowsAsync<InvalidOperationException>(
            () => client.GetRegisterRecordAsync(new Uri(ObjectUrl)));
        Assert.Contains("empty", ex.Message, StringComparison.OrdinalIgnoreCase);
    }

    [Fact]
    public async Task Rejects_a_null_object_url_without_sending_a_request()
    {
        var capture = new RequestCapture();
        var client = Client(capture.Responds(HttpStatusCode.OK, "{}"));

        await Assert.ThrowsAsync<ArgumentNullException>(() => client.GetRegisterRecordAsync(null!));
        Assert.Null(capture.Seen);
    }
}

/// <summary>A test double for <see cref="HttpMessageHandler"/> that records the last request and
/// returns a scripted response — mirrors the ACL/domain gateway tests.</summary>
internal sealed class StubHandler(Func<HttpRequestMessage, Task<HttpResponseMessage>> onSend) : HttpMessageHandler
{
    protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken ct)
        => onSend(request);
}

/// <summary>Captures the request a client sent, including the (buffered) body.</summary>
internal sealed class RequestCapture
{
    public HttpRequestMessage? Seen { get; private set; }
    public string? Body { get; private set; }

    public StubHandler Responds(HttpStatusCode status, string? json = null) => new(async req =>
    {
        Seen = req;
        Body = req.Content is null ? null : await req.Content.ReadAsStringAsync();
        var response = new HttpResponseMessage(status);
        if (json is not null)
            response.Content = new StringContent(json, Encoding.UTF8, "application/json");
        return response;
    });
}