test(domain): SubmitRegistration + OpenZaakWorker use cases (refs #6)

Failing application-layer tests over fake ports (IWorkflowClient, IAclClient,
IRegistrationStore):
- Submit persists an INGEDIEND registration and starts the registratie process,
  recording the instance id — and persists *before* starting, so the worker can
  correlate the OpenZaakAanmaken job back to its aggregate (ADR-0009).
- The worker opens a zaak via the ACL and attaches it; an unknown registration
  throws (job left for redelivery); a redelivered job is idempotent and opens no
  second zaak (§8.6).

Handlers are stubs (no persistence / no ACL call) so the tests compile and fail
on their assertions; the green commit implements them.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

services/domain/Big.Tests/Big.Tests.csproj

@@ -20,6 +20,7 @@
 
   <ItemGroup>
     <ProjectReference Include="..\Big.Domain\Big.Domain.csproj" />
+    <ProjectReference Include="..\Big.Application\Big.Application.csproj" />
   </ItemGroup>
 
 </Project>

services/domain/Big.Tests/Fakes.cs

@@ -0,0 +1,60 @@
+using Big.Application;
+using Big.Domain;
+
+namespace Big.Tests;
+
+/// <summary>An in-memory <see cref="IRegistrationStore"/> for the application-layer tests. Upserts
+/// keyed on the registration id, mirroring the production in-memory store.</summary>
+internal sealed class InMemoryRegistrationStore : IRegistrationStore
+{
+    private readonly Dictionary<RegistrationId, Registration> _byId = [];
+
+    public int SaveCount { get; private set; }
+
+    public Task SaveAsync(Registration registration, CancellationToken ct = default)
+    {
+        SaveCount++;
+        _byId[registration.Id] = registration;
+        return Task.CompletedTask;
+    }
+
+    public Task<Registration?> GetAsync(RegistrationId id, CancellationToken ct = default)
+        => Task.FromResult(_byId.GetValueOrDefault(id));
+
+    public void Seed(Registration registration) => _byId[registration.Id] = registration;
+}
+
+/// <summary>A fake Workflow Client that records the registration it was asked to start a process for
+/// and returns a fixed process-instance id. An optional callback runs at start time, letting a test
+/// assert ordering (e.g. that the registration was persisted before the process started).</summary>
+internal sealed class FakeWorkflowClient(string processInstanceId = "proc-1", Action<RegistrationId>? onStart = null)
+    : IWorkflowClient
+{
+    public RegistrationId? StartedFor { get; private set; }
+
+    public Task<string> StartRegistrationProcessAsync(RegistrationId registrationId, CancellationToken ct = default)
+    {
+        onStart?.Invoke(registrationId);
+        StartedFor = registrationId;
+        return Task.FromResult(processInstanceId);
+    }
+}
+
+/// <summary>A fake ACL client that records the bsn it was asked to open a zaak for and returns a
+/// fixed zaak URL.</summary>
+internal sealed class FakeAclClient(Uri? zaakUrl = null) : IAclClient
+{
+    public static readonly Uri DefaultZaakUrl = new("http://openzaak/zaken/api/v1/zaken/abc");
+
+    private readonly Uri _zaakUrl = zaakUrl ?? DefaultZaakUrl;
+
+    public string? OpenedForBsn { get; private set; }
+    public int CallCount { get; private set; }
+
+    public Task<Uri> OpenZaakAsync(string bsn, CancellationToken ct = default)
+    {
+        CallCount++;
+        OpenedForBsn = bsn;
+        return Task.FromResult(_zaakUrl);
+    }
+}

services/domain/Big.Tests/OpenZaakWorkerTests.cs

@@ -0,0 +1,60 @@
+using Big.Application;
+using Big.Domain;
+
+namespace Big.Tests;
+
+public class OpenZaakWorkerTests
+{
+    private static Registration Submitted(string bsn = "123456782")
+    {
+        var registration = Registration.Submit(bsn);
+        registration.RecordProcessStarted("proc-1");
+        return registration;
+    }
+
+    [Fact]
+    public async Task Handling_a_job_opens_a_zaak_via_the_acl_and_attaches_it()
+    {
+        var registration = Submitted();
+        var store = new InMemoryRegistrationStore();
+        store.Seed(registration);
+        var acl = new FakeAclClient();
+        var worker = new OpenZaakWorker(store, acl);
+
+        var zaakUrl = await worker.HandleAsync(new OpenZaakJob("job-1", registration.Id));
+
+        Assert.Equal(FakeAclClient.DefaultZaakUrl, zaakUrl);
+        Assert.Equal("123456782", acl.OpenedForBsn);
+        var saved = await store.GetAsync(registration.Id);
+        Assert.Equal(FakeAclClient.DefaultZaakUrl, saved!.ZaakUrl);
+    }
+
+    [Fact]
+    public async Task Handling_a_job_for_an_unknown_registration_throws_and_opens_no_zaak()
+    {
+        var store = new InMemoryRegistrationStore();
+        var acl = new FakeAclClient();
+        var worker = new OpenZaakWorker(store, acl);
+
+        await Assert.ThrowsAsync<InvalidOperationException>(
+            () => worker.HandleAsync(new OpenZaakJob("job-1", RegistrationId.New())));
+        Assert.Equal(0, acl.CallCount);
+    }
+
+    [Fact]
+    public async Task Handling_a_redelivered_job_is_idempotent_and_does_not_open_a_second_zaak()
+    {
+        var registration = Submitted();
+        var store = new InMemoryRegistrationStore();
+        store.Seed(registration);
+        var acl = new FakeAclClient();
+        var worker = new OpenZaakWorker(store, acl);
+        var job = new OpenZaakJob("job-1", registration.Id);
+
+        var first = await worker.HandleAsync(job);
+        var second = await worker.HandleAsync(job);
+
+        Assert.Equal(first, second);
+        Assert.Equal(1, acl.CallCount);
+    }
+}

services/domain/Big.Tests/SubmitRegistrationTests.cs

@@ -0,0 +1,52 @@
+using Big.Application;
+using Big.Domain;
+
+namespace Big.Tests;
+
+public class SubmitRegistrationTests
+{
+    [Fact]
+    public async Task Submitting_persists_an_ingediend_registration_and_starts_the_process()
+    {
+        var store = new InMemoryRegistrationStore();
+        var workflow = new FakeWorkflowClient(processInstanceId: "proc-42");
+        var handler = new SubmitRegistration(store, workflow);
+
+        var id = await handler.HandleAsync(new SubmitRegistrationCommand("123456782"));
+
+        var saved = await store.GetAsync(id);
+        Assert.NotNull(saved);
+        Assert.Equal("123456782", saved.Bsn);
+        Assert.Equal(RegistrationStatus.Ingediend, saved.Status);
+        Assert.Equal("proc-42", saved.ProcessInstanceId);
+        Assert.Equal(id, workflow.StartedFor);
+        Assert.Null(saved.ZaakUrl);
+    }
+
+    [Fact]
+    public async Task Submitting_persists_the_registration_before_starting_the_process()
+    {
+        // The worker correlates the OpenZaakAanmaken job back to the aggregate by id, so the
+        // aggregate must already be persisted when the process starts (ADR-0009).
+        var store = new InMemoryRegistrationStore();
+        Registration? visibleAtStart = null;
+        var workflow = new FakeWorkflowClient(onStart: id => visibleAtStart = store.GetAsync(id).Result);
+        var handler = new SubmitRegistration(store, workflow);
+
+        await handler.HandleAsync(new SubmitRegistrationCommand("123456782"));
+
+        Assert.NotNull(visibleAtStart);
+    }
+
+    [Fact]
+    public async Task Submitting_without_a_bsn_is_rejected_and_starts_no_process()
+    {
+        var store = new InMemoryRegistrationStore();
+        var workflow = new FakeWorkflowClient();
+        var handler = new SubmitRegistration(store, workflow);
+
+        await Assert.ThrowsAnyAsync<ArgumentException>(
+            () => handler.HandleAsync(new SubmitRegistrationCommand("")));
+        Assert.Null(workflow.StartedFor);
+    }
+}