register-referentie/services/domain/Big.Tests/FlowableWorkflowClientTests.cs

using System.Net;
using System.Text;
using Big.Domain;
using Big.Infrastructure;

namespace Big.Tests;

public class FlowableWorkflowClientTests
{
    private static readonly Uri Base = new("http://flowable/flowable-rest/");

    private static FlowableWorkflowClient Client(StubHandler handler) => new(
        new HttpClient(handler),
        new FlowableOptions { BaseUrl = Base, Username = "rest-admin", Password = "test", WorkerId = "worker-x" });

    private static string DecodeBasic(HttpRequestMessage request)
        => Encoding.ASCII.GetString(Convert.FromBase64String(request.Headers.Authorization!.Parameter!));

    [Fact]
    public async Task Start_posts_the_registration_id_variable_and_returns_the_instance_id()
    {
        var capture = new RequestCapture();
        var client = Client(capture.Responds(HttpStatusCode.Created, """{"id":"pi-1"}"""));
        var rid = RegistrationId.New();

        var pid = await client.StartRegistrationProcessAsync(rid);

        Assert.Equal("pi-1", pid);
        Assert.Equal(HttpMethod.Post, capture.Seen!.Method);
        Assert.Equal("http://flowable/flowable-rest/service/runtime/process-instances",
            capture.Seen.RequestUri!.ToString());
        Assert.Equal("Basic", capture.Seen.Headers.Authorization!.Scheme);
        Assert.Equal("rest-admin:test", DecodeBasic(capture.Seen));
        Assert.Contains("\"processDefinitionKey\":\"registratie\"", capture.Body);
        Assert.Contains("\"name\":\"registrationId\"", capture.Body);
        Assert.Contains("\"type\":\"string\"", capture.Body);
        Assert.Contains($"\"value\":\"{rid}\"", capture.Body);
    }

    [Fact]
    public async Task Start_uses_the_configured_worker_credentials_and_defaults()
    {
        var capture = new RequestCapture();
        // Only BaseUrl set — the worker id and (empty) credentials must come from the defaults.
        var client = new FlowableWorkflowClient(
            new HttpClient(capture.Responds(HttpStatusCode.OK, "[]")),
            new FlowableOptions { BaseUrl = Base });

        await client.AcquireOpenZaakJobsAsync(1);

        Assert.Equal(":", DecodeBasic(capture.Seen!));
        Assert.Contains("\"workerId\":\"big-domain-worker\"", capture.Body);
        Assert.Contains("\"lockDuration\":\"PT5M\"", capture.Body);
    }

    [Fact]
    public async Task Acquire_posts_the_topic_and_parses_jobs_with_their_registration_id()
    {
        var rid = RegistrationId.New();
        var capture = new RequestCapture();
        var client = Client(capture.Responds(HttpStatusCode.OK,
            $$"""[{"id":"job-1","variables":[{"name":"registrationId","type":"string","value":"{{rid}}"}]}]"""));

        var jobs = await client.AcquireOpenZaakJobsAsync(3);

        var job = Assert.Single(jobs);
        Assert.Equal("job-1", job.JobId);
        Assert.Equal(rid, job.RegistrationId);
        Assert.Equal("http://flowable/flowable-rest/external-job-api/acquire/jobs",
            capture.Seen!.RequestUri!.ToString());
        Assert.Contains("\"topic\":\"OpenZaakAanmaken\"", capture.Body);
        Assert.Contains("\"numberOfTasks\":3", capture.Body);
        Assert.Contains("\"workerId\":\"worker-x\"", capture.Body);
        Assert.Contains("\"lockDuration\":\"PT5M\"", capture.Body);
    }

    [Theory]
    [InlineData("[]")]
    [InlineData("null")]
    public async Task Acquire_returns_empty_when_flowable_has_no_parked_jobs(string body)
    {
        var capture = new RequestCapture();
        var client = Client(capture.Responds(HttpStatusCode.OK, body));

        var jobs = await client.AcquireOpenZaakJobsAsync(1);

        Assert.NotNull(capture.Seen);
        Assert.Empty(jobs);
    }

    [Fact]
    public async Task Acquire_throws_when_a_job_carries_no_registration_id()
    {
        var capture = new RequestCapture();
        var client = Client(capture.Responds(HttpStatusCode.OK, """[{"id":"job-1","variables":[]}]"""));

        var ex = await Assert.ThrowsAsync<InvalidOperationException>(() => client.AcquireOpenZaakJobsAsync(1));
        Assert.Contains("job-1", ex.Message);
        Assert.Contains("registrationId", ex.Message);
    }

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

        await client.CompleteOpenZaakJobAsync("job-1", new Uri("http://openzaak/zaken/api/v1/zaken/abc"));

        Assert.NotNull(capture.Seen);
        Assert.Equal(HttpMethod.Post, capture.Seen!.Method);
        Assert.Equal("http://flowable/flowable-rest/external-job-api/acquire/jobs/job-1/complete",
            capture.Seen.RequestUri!.ToString());
        Assert.Contains("\"workerId\":\"worker-x\"", capture.Body);
        Assert.Contains("\"name\":\"zaakUrl\"", capture.Body);
        Assert.Contains("\"type\":\"string\"", capture.Body);
        Assert.Contains("\"value\":\"http://openzaak/zaken/api/v1/zaken/abc\"", capture.Body);
    }

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

        await Assert.ThrowsAsync<HttpRequestException>(
            () => client.StartRegistrationProcessAsync(RegistrationId.New()));
    }

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

        await Assert.ThrowsAsync<HttpRequestException>(
            () => client.CompleteOpenZaakJobAsync("job-1", new Uri("http://openzaak/zaken/api/v1/zaken/abc")));
    }
}