not
06c0444859
Ports and failing tests for the ACL half of S-19b-2, ahead of the implementation. Once the projection is sourced from Objecten (ADR-0028's stated direction), a submitted registration has to exist in the register the moment the zaak is opened — otherwise re-sourcing silently drops every INGEDIEND row, since today only approval writes a record. So `OpenZaakAsync` gains a second write, and approval upserts that same record to INGESCHREVEN. The subscriber gets only an object URL on an `objecten` notification (the payload carries no record data) and may not read Objecten itself (§8.1), so `IRegisterRecordGateway` gains a read and `AclService` exposes it. Red: - AclService does not yet write on open → the record assertion fails on an empty list. - ObjectenGateway.GetAsync is a shell throwing NotImplementedException; its tests pin the contract: fetch the object URL directly (no objecttype resolution, no search), the CRS header a geo API requires, static Token auth, and a 404 read as "nothing to project" rather than an error (§8.6).
372 lines
16 KiB
C#
372 lines
16 KiB
C#
using Acl.Application;
|
|
|
|
namespace Acl.Tests;
|
|
|
|
public class AclServiceTests
|
|
{
|
|
private sealed class FakeGateway : IZaakGateway
|
|
{
|
|
// The URLs the catalogus resolves the configured identificatie/omschrijving to (S-27).
|
|
public Uri ResolvedZaaktype { get; } = new("http://openzaak/catalogi/api/v1/zaaktypen/big");
|
|
public Uri ResolvedInformatieobjecttype { get; } = new("http://openzaak/catalogi/api/v1/informatieobjecttypen/dip");
|
|
public string? ResolvedByIdentificatie;
|
|
public string? ResolvedByOmschrijving;
|
|
|
|
public ZaakRequest? Captured;
|
|
public Uri Result { get; } = new("http://openzaak/zaken/api/v1/zaken/abc");
|
|
|
|
public (Uri Zaak, Uri Zaaktype, DateOnly Datum)? Approved;
|
|
|
|
public Task<Uri> OpenZaakAsync(ZaakRequest request, CancellationToken ct = default)
|
|
{
|
|
Captured = request;
|
|
return Task.FromResult(Result);
|
|
}
|
|
|
|
public Task SetZaakToEindstatusAsync(Uri zaakUrl, Uri zaaktypeUrl, DateOnly datumStatusGezet, CancellationToken ct = default)
|
|
{
|
|
Approved = (zaakUrl, zaaktypeUrl, datumStatusGezet);
|
|
return Task.CompletedTask;
|
|
}
|
|
|
|
public (Uri Zaak, Uri Zaaktype, DateOnly Datum)? Cancelled;
|
|
|
|
public Task SetZaakToCancellationStatusAsync(Uri zaakUrl, Uri zaaktypeUrl, DateOnly datumStatusGezet, CancellationToken ct = default)
|
|
{
|
|
Cancelled = (zaakUrl, zaaktypeUrl, datumStatusGezet);
|
|
return Task.CompletedTask;
|
|
}
|
|
|
|
public Uri? ReadReferenceFor;
|
|
|
|
public Task<string> GetZaakIdentificatieAsync(Uri zaakUrl, CancellationToken ct = default)
|
|
{
|
|
ReadReferenceFor = zaakUrl;
|
|
return Task.FromResult("REG-FROM-ZAAK");
|
|
}
|
|
|
|
public DocumentRequest? StoredDocument;
|
|
public Uri DocumentResult { get; } = new("http://openzaak/documenten/api/v1/enkelvoudiginformatieobjecten/doc-1");
|
|
|
|
public Task<Uri> StoreDocumentAsync(DocumentRequest request, CancellationToken ct = default)
|
|
{
|
|
StoredDocument = request;
|
|
return Task.FromResult(DocumentResult);
|
|
}
|
|
|
|
public Task<Uri> ResolveZaaktypeUrlAsync(string identificatie, CancellationToken ct = default)
|
|
{
|
|
ResolvedByIdentificatie = identificatie;
|
|
return Task.FromResult(ResolvedZaaktype);
|
|
}
|
|
|
|
public Task<Uri> ResolveInformatieobjecttypeUrlAsync(string omschrijving, CancellationToken ct = default)
|
|
{
|
|
ResolvedByOmschrijving = omschrijving;
|
|
return Task.FromResult(ResolvedInformatieobjecttype);
|
|
}
|
|
|
|
public IReadOnlyList<ZaaktypeSummary> Zaaktypen { get; } =
|
|
[
|
|
new("BIG-REGISTRATIE", "BIG-registratie", new Uri("http://openzaak/catalogi/api/v1/zaaktypen/big")),
|
|
];
|
|
|
|
public Task<IReadOnlyList<ZaaktypeSummary>> ListZaaktypenAsync(CancellationToken ct = default) =>
|
|
Task.FromResult(Zaaktypen);
|
|
}
|
|
|
|
private sealed class FakeRegisterRecordGateway : IRegisterRecordGateway
|
|
{
|
|
public readonly List<RegisterRecord> Upserted = [];
|
|
|
|
public RegisterRecord? Stored;
|
|
|
|
public Uri? ReadFrom;
|
|
|
|
public Task UpsertAsync(RegisterRecord record, CancellationToken ct = default)
|
|
{
|
|
Upserted.Add(record);
|
|
return Task.CompletedTask;
|
|
}
|
|
|
|
public Task<RegisterRecord?> GetAsync(Uri objectUrl, CancellationToken ct = default)
|
|
{
|
|
ReadFrom = objectUrl;
|
|
return Task.FromResult(Stored);
|
|
}
|
|
}
|
|
|
|
private static AclDefaults Defaults() => new()
|
|
{
|
|
Bronorganisatie = "517439943",
|
|
VerantwoordelijkeOrganisatie = "517439943",
|
|
Vertrouwelijkheidaanduiding = "openbaar",
|
|
ZaaktypeIdentificatie = "BIG-REGISTRATIE",
|
|
InformatieobjecttypeOmschrijving = "Diploma",
|
|
};
|
|
|
|
private static InMemoryDefaultFillStore FillFrom(AclDefaults d) =>
|
|
new(new DefaultFillSettings(d.Bronorganisatie, d.VerantwoordelijkeOrganisatie, d.Vertrouwelijkheidaanduiding));
|
|
|
|
private static AclService ServiceWith(FakeGateway gateway, AclDefaults defaults, DateOnly today) =>
|
|
ServiceWith(gateway, new FakeRegisterRecordGateway(), defaults, today);
|
|
|
|
private static AclService ServiceWith(FakeGateway gateway, FakeRegisterRecordGateway register, AclDefaults defaults, DateOnly today) =>
|
|
new(gateway, register, FillFrom(defaults), new CachedZaaktypeCatalog(gateway, defaults), new FixedClock(today));
|
|
|
|
private sealed class FixedClock(DateOnly today) : IClock
|
|
{
|
|
public DateOnly Today { get; } = today;
|
|
}
|
|
|
|
[Fact]
|
|
public async Task Opening_a_zaak_default_fills_zgw_fields_and_uses_the_resolved_zaaktype()
|
|
{
|
|
var gateway = new FakeGateway();
|
|
var service = ServiceWith(gateway, Defaults(), new DateOnly(2026, 6, 4));
|
|
|
|
var url = await service.OpenZaakAsync(new DomainRegistration("123456782", "reg-77"));
|
|
|
|
Assert.Equal(gateway.Result, url);
|
|
var req = Assert.IsType<ZaakRequest>(gateway.Captured);
|
|
Assert.Equal("517439943", req.Bronorganisatie);
|
|
Assert.Equal("517439943", req.VerantwoordelijkeOrganisatie);
|
|
Assert.Equal("openbaar", req.Vertrouwelijkheidaanduiding);
|
|
// The zaaktype is resolved from the configured identificatie, not a pinned URL (S-27).
|
|
Assert.Equal("BIG-REGISTRATIE", gateway.ResolvedByIdentificatie);
|
|
Assert.Equal(gateway.ResolvedZaaktype, req.Zaaktype);
|
|
Assert.Equal(new DateOnly(2026, 6, 4), req.Startdatum);
|
|
// The registration reference becomes the zaak identificatie (#78).
|
|
Assert.Equal("reg-77", req.Identificatie);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task Opening_a_zaak_also_writes_an_ingediend_register_record(/* S-19b-2 */)
|
|
{
|
|
var gateway = new FakeGateway();
|
|
var register = new FakeRegisterRecordGateway();
|
|
var service = ServiceWith(gateway, register, Defaults(), new DateOnly(2026, 6, 4));
|
|
|
|
await service.OpenZaakAsync(new DomainRegistration("123456782", "reg-77"));
|
|
|
|
// The register — not ZGW — is what the read projection is sourced from (ADR-0028), so a
|
|
// submitted registration has to exist there the moment the zaak is opened, not only on
|
|
// approval. Approval upserts this same record to INGESCHREVEN.
|
|
var record = Assert.Single(register.Upserted);
|
|
Assert.Equal("abc", record.Id);
|
|
Assert.Equal("INGEDIEND", record.Status);
|
|
// The reference comes from the registration itself — no ZGW read-back needed on this path.
|
|
Assert.Equal("reg-77", record.Reference);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task Reading_a_register_record_goes_through_the_objecten_gateway(/* S-19b-2 */)
|
|
{
|
|
var gateway = new FakeGateway();
|
|
var register = new FakeRegisterRecordGateway { Stored = new RegisterRecord("abc", "INGESCHREVEN", "reg-77") };
|
|
var service = ServiceWith(gateway, register, Defaults(), new DateOnly(2026, 6, 4));
|
|
var objectUrl = new Uri("http://objecten.local:8000/api/v2/objects/9de4a2ca");
|
|
|
|
var record = await service.GetRegisterRecordAsync(objectUrl);
|
|
|
|
Assert.Equal(objectUrl, register.ReadFrom);
|
|
Assert.Equal("abc", record!.Id);
|
|
Assert.Equal("INGESCHREVEN", record.Status);
|
|
Assert.Equal("reg-77", record.Reference);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task Reading_a_register_record_from_a_null_url_is_rejected(/* S-19b-2 */)
|
|
{
|
|
var gateway = new FakeGateway();
|
|
var register = new FakeRegisterRecordGateway();
|
|
var service = ServiceWith(gateway, register, Defaults(), new DateOnly(2026, 6, 4));
|
|
|
|
await Assert.ThrowsAsync<ArgumentNullException>(() => service.GetRegisterRecordAsync(null!));
|
|
Assert.Null(register.ReadFrom);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task Opening_a_zaak_reflects_a_default_fill_update(/* S-15b */)
|
|
{
|
|
var gateway = new FakeGateway();
|
|
var service = ServiceWith(gateway, Defaults(), new DateOnly(2026, 6, 4));
|
|
|
|
// A beheerder edits the default-fill; the very next zaak must use the new values (read per zaak).
|
|
service.UpdateDefaultFill(new DefaultFillSettings("999999999", "888888888", "vertrouwelijk"));
|
|
await service.OpenZaakAsync(new DomainRegistration("123456782", "reg-1"));
|
|
|
|
var req = gateway.Captured!;
|
|
Assert.Equal("999999999", req.Bronorganisatie);
|
|
Assert.Equal("888888888", req.VerantwoordelijkeOrganisatie);
|
|
Assert.Equal("vertrouwelijk", req.Vertrouwelijkheidaanduiding);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task Rejects_a_null_registration_without_calling_the_gateway()
|
|
{
|
|
var gateway = new FakeGateway();
|
|
var service = ServiceWith(gateway, Defaults(), new DateOnly(2026, 6, 4));
|
|
|
|
await Assert.ThrowsAsync<ArgumentNullException>(() => service.OpenZaakAsync(null!));
|
|
Assert.Null(gateway.Captured);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task Approving_a_zaak_sets_it_to_its_resolved_zaaktypes_eindstatus_dated_today()
|
|
{
|
|
var gateway = new FakeGateway();
|
|
var service = ServiceWith(gateway, Defaults(), new DateOnly(2026, 6, 4));
|
|
var zaak = new Uri("http://openzaak/zaken/api/v1/zaken/abc");
|
|
|
|
await service.ApproveZaakAsync(zaak);
|
|
|
|
Assert.NotNull(gateway.Approved);
|
|
Assert.Equal(zaak, gateway.Approved!.Value.Zaak);
|
|
Assert.Equal(gateway.ResolvedZaaktype, gateway.Approved.Value.Zaaktype);
|
|
Assert.Equal(new DateOnly(2026, 6, 4), gateway.Approved.Value.Datum);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task Approving_a_null_zaak_is_rejected_without_touching_the_gateway()
|
|
{
|
|
var gateway = new FakeGateway();
|
|
var register = new FakeRegisterRecordGateway();
|
|
var service = ServiceWith(gateway, register, Defaults(), new DateOnly(2026, 6, 4));
|
|
|
|
await Assert.ThrowsAsync<ArgumentNullException>(() => service.ApproveZaakAsync(null!));
|
|
Assert.Null(gateway.Approved);
|
|
Assert.Empty(register.Upserted);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task Approving_a_zaak_writes_the_register_record_to_objecten(/* S-19a */)
|
|
{
|
|
var gateway = new FakeGateway();
|
|
var register = new FakeRegisterRecordGateway();
|
|
var service = ServiceWith(gateway, register, Defaults(), new DateOnly(2026, 6, 4));
|
|
|
|
await service.ApproveZaakAsync(new Uri("http://openzaak/zaken/api/v1/zaken/abc"));
|
|
|
|
var record = Assert.Single(register.Upserted);
|
|
// The record is keyed on the zaak id — the same key the read projection rows carry (S-19b).
|
|
Assert.Equal("abc", record.Id);
|
|
Assert.Equal("INGESCHREVEN", record.Status);
|
|
// The public-safe reference comes from the zaak's identificatie, never from the domain payload.
|
|
Assert.Equal("REG-FROM-ZAAK", record.Reference);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task Cancelling_a_zaak_writes_no_register_record(/* S-19a */)
|
|
{
|
|
var gateway = new FakeGateway();
|
|
var register = new FakeRegisterRecordGateway();
|
|
var service = ServiceWith(gateway, register, Defaults(), new DateOnly(2026, 6, 4));
|
|
|
|
await service.CancelZaakAsync(new Uri("http://openzaak/zaken/api/v1/zaken/abc"));
|
|
|
|
// Only an approval enters the register; a cancelled zaak never becomes a register record.
|
|
Assert.Empty(register.Upserted);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task Cancelling_a_zaak_sets_it_to_the_cancellation_status_dated_today()
|
|
{
|
|
var gateway = new FakeGateway();
|
|
var service = ServiceWith(gateway, Defaults(), new DateOnly(2026, 6, 4));
|
|
var zaak = new Uri("http://openzaak/zaken/api/v1/zaken/abc");
|
|
|
|
await service.CancelZaakAsync(zaak);
|
|
|
|
Assert.NotNull(gateway.Cancelled);
|
|
Assert.Equal(zaak, gateway.Cancelled!.Value.Zaak);
|
|
Assert.Equal(gateway.ResolvedZaaktype, gateway.Cancelled.Value.Zaaktype);
|
|
Assert.Equal(new DateOnly(2026, 6, 4), gateway.Cancelled.Value.Datum);
|
|
// Cancellation must not touch the approval path.
|
|
Assert.Null(gateway.Approved);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task Cancelling_a_null_zaak_is_rejected_without_touching_the_gateway()
|
|
{
|
|
var gateway = new FakeGateway();
|
|
var service = ServiceWith(gateway, Defaults(), new DateOnly(2026, 6, 4));
|
|
|
|
await Assert.ThrowsAsync<ArgumentNullException>(() => service.CancelZaakAsync(null!));
|
|
Assert.Null(gateway.Cancelled);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task Storing_a_diploma_default_fills_the_document_fields_and_uses_the_resolved_informatieobjecttype()
|
|
{
|
|
var gateway = new FakeGateway();
|
|
var service = ServiceWith(gateway, Defaults(), new DateOnly(2026, 6, 4));
|
|
var zaak = new Uri("http://openzaak/zaken/api/v1/zaken/abc");
|
|
|
|
var url = await service.StoreDiplomaAsync(zaak, [1, 2, 3], "diploma.pdf", "application/pdf");
|
|
|
|
Assert.Equal(gateway.DocumentResult, url);
|
|
var req = gateway.StoredDocument!;
|
|
Assert.Equal(zaak, req.Zaak);
|
|
// The informatieobjecttype is resolved from the configured omschrijving (S-27).
|
|
Assert.Equal("Diploma", gateway.ResolvedByOmschrijving);
|
|
Assert.Equal(gateway.ResolvedInformatieobjecttype, req.Informatieobjecttype);
|
|
Assert.Equal("517439943", req.Bronorganisatie);
|
|
Assert.Equal("openbaar", req.Vertrouwelijkheidaanduiding);
|
|
Assert.Equal(new DateOnly(2026, 6, 4), req.Creatiedatum);
|
|
Assert.Equal("nld", req.Taal);
|
|
Assert.Equal("diploma.pdf", req.Bestandsnaam);
|
|
Assert.Equal("application/pdf", req.Formaat);
|
|
Assert.Equal(new byte[] { 1, 2, 3 }, req.Inhoud);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task Storing_a_diploma_rejects_null_or_blank_arguments()
|
|
{
|
|
var service = ServiceWith(new FakeGateway(), Defaults(), new DateOnly(2026, 6, 4));
|
|
var zaak = new Uri("http://openzaak/zaken/api/v1/zaken/abc");
|
|
|
|
await Assert.ThrowsAsync<ArgumentNullException>(() => service.StoreDiplomaAsync(null!, [1], "d.pdf", "application/pdf"));
|
|
await Assert.ThrowsAsync<ArgumentNullException>(() => service.StoreDiplomaAsync(zaak, null!, "d.pdf", "application/pdf"));
|
|
await Assert.ThrowsAnyAsync<ArgumentException>(() => service.StoreDiplomaAsync(zaak, [1], " ", "application/pdf"));
|
|
await Assert.ThrowsAnyAsync<ArgumentException>(() => service.StoreDiplomaAsync(zaak, [1], "d.pdf", " "));
|
|
}
|
|
|
|
[Fact]
|
|
public async Task Reading_a_zaak_reference_returns_the_zaaks_identificatie()
|
|
{
|
|
var gateway = new FakeGateway();
|
|
var service = ServiceWith(gateway, Defaults(), new DateOnly(2026, 6, 4));
|
|
var zaak = new Uri("http://openzaak/zaken/api/v1/zaken/abc");
|
|
|
|
var reference = await service.GetZaakReferenceAsync(zaak);
|
|
|
|
Assert.Equal("REG-FROM-ZAAK", reference);
|
|
Assert.Equal(zaak, gateway.ReadReferenceFor);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task Reading_a_null_zaak_reference_is_rejected()
|
|
{
|
|
var gateway = new FakeGateway();
|
|
var service = ServiceWith(gateway, Defaults(), new DateOnly(2026, 6, 4));
|
|
|
|
await Assert.ThrowsAsync<ArgumentNullException>(() => service.GetZaakReferenceAsync(null!));
|
|
Assert.Null(gateway.ReadReferenceFor);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task Listing_zaaktypen_returns_the_gateways_published_zaaktypen(/* S-15a */)
|
|
{
|
|
var gateway = new FakeGateway();
|
|
var service = ServiceWith(gateway, Defaults(), new DateOnly(2026, 6, 4));
|
|
|
|
var zaaktypen = await service.ListZaaktypenAsync();
|
|
|
|
var only = Assert.Single(zaaktypen);
|
|
Assert.Equal("BIG-REGISTRATIE", only.Identificatie);
|
|
Assert.Equal("BIG-registratie", only.Omschrijving);
|
|
Assert.Equal(new Uri("http://openzaak/catalogi/api/v1/zaaktypen/big"), only.Url);
|
|
}
|
|
}
|