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

using Big.Domain;

namespace Big.Tests;

public class RegistrationTests
{
    // A fixed inscription moment for the approval tests; its exact value is irrelevant to them.
    private static readonly DateTimeOffset Ingeschreven = new(2026, 1, 1, 0, 0, 0, TimeSpan.Zero);

    [Fact]
    public void Submitting_a_registration_starts_in_ingediend()
    {
        var registration = Registration.Submit("123456782");

        Assert.Equal(RegistrationStatus.Ingediend, registration.Status);
        Assert.Equal("123456782", registration.Bsn);
        Assert.NotEqual(Guid.Empty, registration.Id.Value);
        Assert.Null(registration.ZaakUrl);
        Assert.Null(registration.ProcessInstanceId);
    }

    [Fact]
    public void A_registration_defaults_to_a_domestic_diploma()
        => Assert.Equal(DiplomaOrigin.Binnenlands, Registration.Submit("123456782").DiplomaOrigin);

    [Fact]
    public void A_foreign_diploma_submission_records_its_origin()
        => Assert.Equal(DiplomaOrigin.Buitenlands,
            Registration.Submit("123456782", DiplomaOrigin.Buitenlands).DiplomaOrigin);

    [Theory]
    [InlineData("")]
    [InlineData("   ")]
    [InlineData(null)]
    public void Submitting_without_a_bsn_is_rejected(string? bsn)
        => Assert.ThrowsAny<ArgumentException>(() => Registration.Submit(bsn!));

    [Fact]
    public void Recording_the_started_process_keeps_its_instance_id()
    {
        var registration = Registration.Submit("123456782");

        registration.RecordProcessStarted("proc-42");

        Assert.Equal("proc-42", registration.ProcessInstanceId);
    }

    [Theory]
    [InlineData("")]
    [InlineData("   ")]
    [InlineData(null)]
    public void Recording_an_empty_process_instance_id_is_rejected(string? processInstanceId)
    {
        var registration = Registration.Submit("123456782");

        Assert.ThrowsAny<ArgumentException>(() => registration.RecordProcessStarted(processInstanceId!));
    }

    [Fact]
    public void Attaching_a_zaak_records_its_url_and_keeps_the_status_ingediend()
    {
        var registration = Registration.Submit("123456782");
        var zaak = new Uri("http://openzaak/zaken/api/v1/zaken/abc");

        registration.AttachZaak(zaak);

        Assert.Equal(zaak, registration.ZaakUrl);
        Assert.Equal(RegistrationStatus.Ingediend, registration.Status);
    }

    [Fact]
    public void Attaching_a_null_zaak_is_rejected()
    {
        var registration = Registration.Submit("123456782");

        Assert.Throws<ArgumentNullException>(() => registration.AttachZaak(null!));
    }

    [Fact]
    public void Re_attaching_the_same_zaak_is_idempotent()
    {
        var registration = Registration.Submit("123456782");
        var zaak = new Uri("http://openzaak/zaken/api/v1/zaken/abc");

        registration.AttachZaak(zaak);
        registration.AttachZaak(zaak);

        Assert.Equal(zaak, registration.ZaakUrl);
    }

    [Fact]
    public void Attaching_a_conflicting_zaak_is_rejected()
    {
        var registration = Registration.Submit("123456782");
        registration.AttachZaak(new Uri("http://openzaak/zaken/api/v1/zaken/abc"));

        var ex = Assert.Throws<InvalidOperationException>(
            () => registration.AttachZaak(new Uri("http://openzaak/zaken/api/v1/zaken/other")));
        Assert.Contains("/zaken/abc", ex.Message);
        Assert.Contains("/zaken/other", ex.Message);
    }

    [Fact]
    public void Approving_a_registration_with_a_zaak_sets_it_ingeschreven()
    {
        var registration = Registration.Submit("123456782");
        registration.AttachZaak(new Uri("http://openzaak/zaken/api/v1/zaken/abc"));

        registration.Approve(Ingeschreven);

        Assert.Equal(RegistrationStatus.Ingeschreven, registration.Status);
    }

    [Fact]
    public void Approving_before_the_zaak_is_opened_is_rejected()
    {
        var registration = Registration.Submit("123456782");

        var ex = Assert.Throws<InvalidOperationException>(() => registration.Approve(Ingeschreven));

        Assert.Contains("no zaak", ex.Message, StringComparison.OrdinalIgnoreCase);
        Assert.Equal(RegistrationStatus.Ingediend, registration.Status);
    }

    [Fact]
    public void Approving_an_already_ingeschreven_registration_is_rejected()
    {
        var registration = Registration.Submit("123456782");
        registration.AttachZaak(new Uri("http://openzaak/zaken/api/v1/zaken/abc"));
        registration.Approve(Ingeschreven);

        var ex = Assert.Throws<InvalidOperationException>(() => registration.Approve(Ingeschreven));
        Assert.Contains("only an INGEDIEND", ex.Message);
        Assert.Equal(RegistrationStatus.Ingeschreven, registration.Status);
    }

    [Fact]
    public void Taking_a_registration_into_behandeling_moves_it_to_in_behandeling()
    {
        var registration = Registration.Submit("123456782");

        registration.TakeIntoBehandeling();

        Assert.Equal(RegistrationStatus.InBehandeling, registration.Status);
    }

    [Fact]
    public void Re_taking_an_in_behandeling_registration_is_idempotent()
    {
        var registration = Registration.Submit("123456782");
        registration.TakeIntoBehandeling();

        registration.TakeIntoBehandeling();

        Assert.Equal(RegistrationStatus.InBehandeling, registration.Status);
    }

    [Fact]
    public void Taking_a_decided_registration_into_behandeling_is_rejected()
    {
        var registration = Registration.Submit("123456782");
        registration.AttachZaak(new Uri("http://openzaak/zaken/api/v1/zaken/abc"));
        registration.Approve(Ingeschreven);

        var ex = Assert.Throws<InvalidOperationException>(() => registration.TakeIntoBehandeling());
        Assert.Contains("only an INGEDIEND", ex.Message);
        Assert.Equal(RegistrationStatus.Ingeschreven, registration.Status);
    }

    [Fact]
    public void Approving_an_in_behandeling_registration_with_a_zaak_sets_it_ingeschreven()
    {
        var registration = Registration.Submit("123456782");
        registration.AttachZaak(new Uri("http://openzaak/zaken/api/v1/zaken/abc"));
        registration.TakeIntoBehandeling();

        registration.Approve(Ingeschreven);

        Assert.Equal(RegistrationStatus.Ingeschreven, registration.Status);
    }

    [Fact]
    public void Rejecting_a_registration_sets_it_afgewezen()
    {
        var registration = Registration.Submit("123456782");

        registration.Reject();

        Assert.Equal(RegistrationStatus.Afgewezen, registration.Status);
    }

    [Fact]
    public void Rejecting_needs_no_zaak()
    {
        // A registration can be turned down before its zaak is ever opened, so Reject must not require one.
        var registration = Registration.Submit("123456782");

        registration.Reject();

        Assert.Equal(RegistrationStatus.Afgewezen, registration.Status);
        Assert.Null(registration.ZaakUrl);
    }

    [Fact]
    public void Rejecting_an_in_behandeling_registration_sets_it_afgewezen()
    {
        var registration = Registration.Submit("123456782");
        registration.TakeIntoBehandeling();

        registration.Reject();

        Assert.Equal(RegistrationStatus.Afgewezen, registration.Status);
    }

    [Fact]
    public void Deciding_an_already_decided_registration_is_rejected()
    {
        var registration = Registration.Submit("123456782");
        registration.Reject();

        var approveEx = Assert.Throws<InvalidOperationException>(() =>
        {
            registration.AttachZaak(new Uri("http://openzaak/zaken/api/v1/zaken/abc"));
            registration.Approve(Ingeschreven);
        });
        Assert.Contains("IN_BEHANDELING", approveEx.Message);

        var rejectEx = Assert.Throws<InvalidOperationException>(() => registration.Reject());
        Assert.Contains("Afgewezen", rejectEx.Message);
        Assert.Equal(RegistrationStatus.Afgewezen, registration.Status);
    }

    [Fact]
    public void Withdrawing_an_ingediend_registration_sets_it_ingetrokken()
    {
        var registration = Registration.Submit("123456782");

        registration.Withdraw();

        Assert.Equal(RegistrationStatus.Ingetrokken, registration.Status);
    }

    [Fact]
    public void Withdrawing_an_in_behandeling_registration_sets_it_ingetrokken()
    {
        // A citizen can still pull a registration back while a behandelaar has it in behandeling.
        var registration = Registration.Submit("123456782");
        registration.TakeIntoBehandeling();

        registration.Withdraw();

        Assert.Equal(RegistrationStatus.Ingetrokken, registration.Status);
    }

    [Fact]
    public void Withdrawing_needs_no_zaak()
    {
        // Withdrawal is the citizen's own action and does not depend on the zaak having been opened.
        var registration = Registration.Submit("123456782");

        registration.Withdraw();

        Assert.Equal(RegistrationStatus.Ingetrokken, registration.Status);
        Assert.Null(registration.ZaakUrl);
    }

    [Fact]
    public void Re_withdrawing_an_already_ingetrokken_registration_is_idempotent()
    {
        var registration = Registration.Submit("123456782");
        registration.Withdraw();

        registration.Withdraw();

        Assert.Equal(RegistrationStatus.Ingetrokken, registration.Status);
    }

    [Fact]
    public void Withdrawing_an_approved_registration_is_rejected()
    {
        var registration = Registration.Submit("123456782");
        registration.AttachZaak(new Uri("http://openzaak/zaken/api/v1/zaken/abc"));
        registration.Approve(Ingeschreven);

        var ex = Assert.Throws<InvalidOperationException>(() => registration.Withdraw());
        Assert.Contains("only an INGEDIEND", ex.Message);
        Assert.Equal(RegistrationStatus.Ingeschreven, registration.Status);
    }

    [Fact]
    public void Withdrawing_a_rejected_registration_is_rejected()
    {
        var registration = Registration.Submit("123456782");
        registration.Reject();

        var ex = Assert.Throws<InvalidOperationException>(() => registration.Withdraw());
        Assert.Contains("only an INGEDIEND", ex.Message);
        Assert.Equal(RegistrationStatus.Afgewezen, registration.Status);
    }

    [Fact]
    public void Expiring_an_ingediend_registration_sets_it_verlopen()
    {
        // The 30-day document-wait timer fired before the documents arrived (S-10a): the case is
        // cancelled and the aggregate becomes terminal VERLOPEN.
        var registration = Registration.Submit("123456782");

        registration.Expire();

        Assert.Equal(RegistrationStatus.Verlopen, registration.Status);
    }

    [Fact]
    public void Expiring_needs_no_zaak()
    {
        // The timer fires on a purely time-based boundary; expiry does not depend on the zaak.
        var registration = Registration.Submit("123456782");

        registration.Expire();

        Assert.Equal(RegistrationStatus.Verlopen, registration.Status);
        Assert.Null(registration.ZaakUrl);
    }

    [Fact]
    public void Re_expiring_an_already_verlopen_registration_is_idempotent()
    {
        // The RegistratieVerlopen worker job may be redelivered (§8.6); re-expiring is a no-op.
        var registration = Registration.Submit("123456782");
        registration.Expire();

        registration.Expire();

        Assert.Equal(RegistrationStatus.Verlopen, registration.Status);
    }

    [Fact]
    public void Expiring_an_approved_registration_is_rejected()
    {
        var registration = Registration.Submit("123456782");
        registration.AttachZaak(new Uri("http://openzaak/zaken/api/v1/zaken/abc"));
        registration.Approve(Ingeschreven);

        var ex = Assert.Throws<InvalidOperationException>(() => registration.Expire());
        Assert.Contains("only an INGEDIEND", ex.Message);
        Assert.Equal(RegistrationStatus.Ingeschreven, registration.Status);
    }

    [Fact]
    public void Expiring_a_withdrawn_registration_is_rejected()
    {
        var registration = Registration.Submit("123456782");
        registration.Withdraw();

        var ex = Assert.Throws<InvalidOperationException>(() => registration.Expire());
        Assert.Contains("only an INGEDIEND", ex.Message);
        Assert.Equal(RegistrationStatus.Ingetrokken, registration.Status);
    }
}