JustDummies

[Fact]
public void A_pending_order_can_be_cancelled() {
    // Arrange
    OrderReference anyReference  = OrderReference.Create("ORD-54XEM4545");
    CustomerId     anyCustomerId = CustomerId.Create(Guid.NewGuid());
    Money          anyTotal      = Money.Create(42.00m);

    Order order = new Order(anyReference, anyCustomerId, anyTotal, OrderStatus.Pending);

    // Act
    order.Cancel();

    // Assert
    Assert.Equal(OrderStatus.Cancelled, order.Status);
}

[Fact]
public void A_pending_order_can_be_cancelled_with_factories() {
    // Arrange
    OrderReference anyReference  = AnyOrderReference.Generate();
    CustomerId     anyCustomerId = AnyCustomerId.Generate();
    Money          anyTotal      = AnyMoney.Generate();

    Order order = new Order(anyReference, anyCustomerId, anyTotal, OrderStatus.Pending);

    // Act
    order.Cancel();

    // Assert
    Assert.Equal(OrderStatus.Cancelled, order.Status);
}

public static class AnyOrderReference {

    public static OrderReference Generate() {
        return OrderReference.Create("ORD-54XEM4545");
    }

}

// ... and AnyCustomerId and AnyMoney, which say the same thing

using JustDummies;

public static class AnyOrderReference {

    public static OrderReference Generate() {
        return OrderReference.Create(Any.String().Generate());
    }

}

public static OrderReference Create(string value) {
    ArgumentException.ThrowIfNullOrWhiteSpace(value);

    if (!value.StartsWith("ORD-", StringComparison.Ordinal)) {
        throw new ArgumentException("An order reference must start with ORD-.", nameof(value));
    }

    if (value.Length < 8) {
        throw new ArgumentException("An order reference cannot be shorter than 8 characters.", nameof(value));
    }

    if (value.Length > 20) {
        throw new ArgumentException("An order reference cannot exceed 20 characters.", nameof(value));
    }

    if (!value[4..].All(character => char.IsAsciiLetterUpper(character) || char.IsAsciiDigit(character))) {
        throw new ArgumentException("An order reference holds only uppercase letters and digits after ORD-.", nameof(value));
    }

    return new OrderReference(value);
}

using JustDummies;

public static class AnyOrderReference {

    public static OrderReference Generate() {
        string reference = Any.String()
                              .AlphaNumeric()
                              .InUpperCase()
                              .StartingWith("ORD-")
                              .WithLengthBetween(8, 20)
                              .Generate();

        return OrderReference.Create(reference);
    }

}

[Fact, Reproducible]
public void A_pending_order_can_be_cancelled() {
    Order order = CreateAnyPendingOrder();   // one line, and this is the one we want

    order.Cancel();

    Assert.Equal(OrderStatus.Cancelled, order.Status);
}

// Scaffolded by dum (JustDummies). This file is yours: read it, edit it, commit it.
// `dum generate Order --force` overwrites it. This type is partial, so members you add in a
// neighbouring file survive.

using JustDummies;

namespace JustDummies.SnippetValidation.Domain;

/// <summary>
///     A generator of arbitrary <see cref="Order" /> values. It draws from the ambient random
///     context, so a reproducibility scope pins it; to draw from an isolated
///     <c>Any.WithSeed(...)</c> context, pass that context's generators through the
///     <c>With…</c> overloads.
/// </summary>
public sealed partial class AnyOrder : IAny<Order> {

    private readonly IAny<OrderReference> _reference;
    private readonly IAny<CustomerId>     _customerId;
    private readonly IAny<Money>          _total;
    private readonly IAny<OrderStatus>    _status;

    /// <summary>Creates the generator with a default recipe for every constructor parameter.</summary>
    public AnyOrder()
        : this(reference:  ReferenceFactory(),
               customerId: CustomerIdFactory(),
               total:      TotalFactory(),
               status:     StatusFactory()) { }

    private static IAny<OrderReference> ReferenceFactory() {
        // TODO(dum): 'OrderReference reference' may be guarded by something dum could not read (§9).
        //   This is dum's best generator for the type; verify it honours the real invariant,
        //   or replace it, then delete the line below.
        _ = TODO_verify_the_generator_for_reference;

        return Any.String().WithLengthBetween(8, 20).As(OrderReference.Create);
    }

    private static IAny<CustomerId> CustomerIdFactory() {
        return Any.Guid().NonEmpty().As(CustomerId.Create);
    }

    private static IAny<Money> TotalFactory() {
        return Any.Decimal().Positive().As(Money.Create);
    }

    private static IAny<OrderStatus> StatusFactory() {
        return Any.Enum<OrderStatus>();
    }

    private AnyOrder(IAny<OrderReference> reference,
                     IAny<CustomerId>     customerId,
                     IAny<Money>          total,
                     IAny<OrderStatus>    status) {
        _reference  = reference;
        _customerId = customerId;
        _total      = total;
        _status     = status;
    }

    /// <summary>Pins <c>reference</c> to a fixed value.</summary>
    public AnyOrder WithReference(OrderReference value) {
        return WithReference(new FixedValue<OrderReference>(value));
    }

    /// <summary>Draws <c>reference</c> from <paramref name="generator" />.</summary>
    public AnyOrder WithReference(IAny<OrderReference> generator) {
        return new AnyOrder(generator, _customerId, _total, _status);
    }

    /// <summary>Pins <c>customerId</c> to a fixed value.</summary>
    public AnyOrder WithCustomerId(CustomerId value) {
        return WithCustomerId(new FixedValue<CustomerId>(value));
    }

    /// <summary>Draws <c>customerId</c> from <paramref name="generator" />.</summary>
    public AnyOrder WithCustomerId(IAny<CustomerId> generator) {
        return new AnyOrder(_reference, generator, _total, _status);
    }

    /// <summary>Pins <c>total</c> to a fixed value.</summary>
    public AnyOrder WithTotal(Money value) {
        return WithTotal(new FixedValue<Money>(value));
    }

    /// <summary>Draws <c>total</c> from <paramref name="generator" />.</summary>
    public AnyOrder WithTotal(IAny<Money> generator) {
        return new AnyOrder(_reference, _customerId, generator, _status);
    }

    /// <summary>Pins <c>status</c> to a fixed value.</summary>
    public AnyOrder WithStatus(OrderStatus value) {
        return WithStatus(new FixedValue<OrderStatus>(value));
    }

    /// <summary>Draws <c>status</c> from <paramref name="generator" />.</summary>
    public AnyOrder WithStatus(IAny<OrderStatus> generator) {
        return new AnyOrder(_reference, _customerId, _total, generator);
    }

    /// <summary>Produces one arbitrary <see cref="Order" />.</summary>
    public Order Generate() {
        return new Order(_reference.Generate(),
                         _customerId.Generate(),
                         _total.Generate(),
                         _status.Generate());
    }

    private sealed class FixedValue<TValue> : IAny<TValue> {

        private readonly TValue _value;

        public FixedValue(TValue value) {
            _value = value;
        }

        public TValue Generate() {
            return _value;
        }

    }

}

[Fact, Reproducible]
public void A_pending_order_can_be_cancelled() {
    Order order = Any.Order().WithStatus(OrderStatus.Pending).Generate();

    order.Cancel();

    Assert.Equal(OrderStatus.Cancelled, order.Status);
}

[Fact, Reproducible]
public void A_pending_order_can_be_cancelled() {
    Order order = Any.Order().WithStatus(OrderStatus.Pending).Generate();

    order.Cancel();

    Assert.Equal(OrderStatus.Cancelled, order.Status);
}

[Fact, Reproducible]
public void A_pending_order_can_be_cancelled() {
    Order order = new AnyOrder().Generate();

    order.Cancel();

    Assert.Equal(OrderStatus.Cancelled, order.Status);
}

[Fact, Reproducible(Seed = -1808250554)]
public void A_pending_order_can_be_cancelled() {
    Order order = new AnyOrder().Generate();

    order.Cancel();

    Assert.Equal(OrderStatus.Cancelled, order.Status);
}