Reduce verbosity of test case assertions

MultiversalDiplomacy/Adjudicate/Decision/BinaryAdjudicationDecision.cs

@@ -6,6 +6,11 @@ public abstract class BinaryAdjudicationDecision : AdjudicationDecision
 
     public override bool Resolved => this.Outcome != null;
 
+    public override string ToString()
+    {
+        return $"{this.GetType().Name}={this.Outcome}";
+    }
+
     public bool Update(bool outcome)
     {
         if (this.Outcome == null)

MultiversalDiplomacyTests/DATC_A.cs

@@ -1,6 +1,7 @@
 using MultiversalDiplomacy.Adjudicate;
 using MultiversalDiplomacy.Adjudicate.Decision;
 using MultiversalDiplomacy.Model;
+using MultiversalDiplomacy.Orders;
 
 using NUnit.Framework;
 
@@ -17,9 +18,9 @@ public class DATC_A
         setup["England"]
             .Fleet("North Sea").MovesTo("Picardy").GetReference(out var order);
 
+        // Order should fail.
         setup.ValidateOrders(MovementPhaseAdjudicator.Instance);
-
+        Assert.That(order, Is.Invalid(ValidationReason.UnreachableDestination));
-        Assert.That(order.Validation, Is.Invalid(ValidationReason.UnreachableDestination));
     }
 
     [Test]
@@ -27,6 +28,7 @@ public class DATC_A
     {
         TestCaseBuilder setup = new TestCaseBuilder(StandardEmpty);
 
+        // Order should fail.
         Assert.That(
             () =>
             {
@@ -41,6 +43,7 @@ public class DATC_A
     {
         TestCaseBuilder setup = new TestCaseBuilder(StandardEmpty);
 
+        // Order should fail.
         Assert.That(
             () =>
             {
@@ -57,9 +60,9 @@ public class DATC_A
         setup["Germany"]
             .Fleet("Kiel").MovesTo("Kiel").GetReference(out var order);
 
+        // Program should not crash.
         setup.ValidateOrders(MovementPhaseAdjudicator.Instance);
-
+        Assert.That(order, Is.Invalid(ValidationReason.DestinationMatchesOrigin));
-        Assert.That(order.Validation, Is.Invalid(ValidationReason.DestinationMatchesOrigin));
     }
 
     [Test]
@@ -72,15 +75,20 @@ public class DATC_A
                 .Army("Yorkshire").MovesTo("Yorkshire").GetReference(out var orderYor)
                 .Army("Liverpool").Supports.Army("Yorkshire").MoveTo("Yorkshire")
             ["Germany"]
-                .Fleet("London").MovesTo("Yorkshire")
+                .Fleet("London").MovesTo("Yorkshire").GetReference(out var orderLon)
                 .Army("Wales").Supports.Fleet("London").MoveTo("Yorkshire");
 
+        // The move of the army in Yorkshire is illegal. This makes the support of Liverpool also illegal.
         setup.ValidateOrders(MovementPhaseAdjudicator.Instance);
+        Assert.That(orderLon, Is.Valid);
+        Assert.That(orderNth, Is.Invalid(ValidationReason.DestinationMatchesOrigin));
+        Assert.That(orderYor, Is.Invalid(ValidationReason.DestinationMatchesOrigin));
+        var orderYorRepl = orderYor.GetReplacementReference<HoldOrder>();
 
-        Assert.That(orderNth.Validation, Is.Invalid(ValidationReason.DestinationMatchesOrigin));
+        // Without the support, the Germans have a stronger force. The army in London dislodges the army in Yorkshire.
-        Assert.That(orderYor.Validation, Is.Invalid(ValidationReason.DestinationMatchesOrigin));
+        setup.AdjudicateOrders(MovementPhaseAdjudicator.Instance);
-
+        Assert.That(orderLon, Is.Victorious);
-        // TODO assert dislodge
+        Assert.That(orderYorRepl, Is.Dislodged);
     }
 
     [Test]
@@ -91,9 +99,9 @@ public class DATC_A
             ["Germany"]
                 .Fleet("London", powerName: "England").MovesTo("North Sea").GetReference(out var order);
 
+        // Order should fail.
         setup.ValidateOrders(MovementPhaseAdjudicator.Instance);
-
+        Assert.That(order, Is.Invalid(ValidationReason.InvalidUnitForPower));
-        Assert.That(order.Validation, Is.Invalid(ValidationReason.InvalidUnitForPower));
     }
 
     [Test]
@@ -105,9 +113,9 @@ public class DATC_A
                 .Fleet("London").MovesTo("Belgium")
                 .Fleet("North Sea").Convoys.Army("London").To("Belgium").GetReference(out var order);
 
+        // Move from London to Belgium should fail.
         setup.ValidateOrders(MovementPhaseAdjudicator.Instance);
-
+        Assert.That(order, Is.Invalid(ValidationReason.InvalidOrderTypeForUnit));
-        Assert.That(order.Validation, Is.Invalid(ValidationReason.InvalidOrderTypeForUnit));
     }
 
     [Test]
@@ -122,15 +130,12 @@ public class DATC_A
                 .Fleet("Trieste").Supports.Fleet("Trieste").Hold().GetReference(out var orderTri);
 
         setup.ValidateOrders(MovementPhaseAdjudicator.Instance);
-        Assert.That(orderTri.Validation, Is.Invalid(ValidationReason.NoSelfSupport));
+        Assert.That(orderTri, Is.Invalid(ValidationReason.NoSelfSupport));
+        var orderTriRepl = orderTri.GetReplacementReference<HoldOrder>();
 
         // The army in Trieste should be dislodged.
-        var adjudications = setup.AdjudicateOrders(MovementPhaseAdjudicator.Instance);
+        setup.AdjudicateOrders(MovementPhaseAdjudicator.Instance);
-        // The order reference captures the invalidated order, but the unit is the same.
+        Assert.That(orderTriRepl, Is.Dislodged);
-        var dislodgeTri = adjudications
-            .OfType<IsDislodged>()
-            .Single(adj => adj.Order.Unit == orderTri.Order.Unit);
-        Assert.That(dislodgeTri.Outcome, Is.True, "Expected F Tri to be dislodged");
     }
 
     [Test]
@@ -141,9 +146,9 @@ public class DATC_A
             ["Italy"]
                 .Fleet("Rome").MovesTo("Venice").GetReference(out var order);
 
+        // Move fails. An army can go from Rome to Venice, but a fleet can not.
         setup.ValidateOrders(MovementPhaseAdjudicator.Instance);
-
+        Assert.That(order, Is.Invalid(ValidationReason.UnreachableDestination));
-        Assert.That(order.Validation, Is.Invalid(ValidationReason.UnreachableDestination));
     }
 
     [Test]
@@ -160,12 +165,11 @@ public class DATC_A
         setup.ValidateOrders(MovementPhaseAdjudicator.Instance);
 
         // The support of Rome is illegal, because Venice can not be reached from Rome by a fleet.
-        Assert.That(orderRom.Validation, Is.Invalid(ValidationReason.UnreachableSupport));
+        Assert.That(orderRom, Is.Invalid(ValidationReason.UnreachableSupport));
 
         // Venice is not dislodged.
         setup.AdjudicateOrders(MovementPhaseAdjudicator.Instance);
-        Assert.That(orderVen.Adjudications.OfType<IsDislodged>().Count(), Is.EqualTo(1));
+        Assert.That(orderVen, Is.NotDislodged);
-        Assert.That(orderVen.Adjudications.OfType<IsDislodged>().First().Outcome, Is.False);
     }
 
     [Test]
@@ -179,15 +183,15 @@ public class DATC_A
                 .Army("Venice").MovesTo("Tyrolia").GetReference(out var orderVen);
 
         setup.ValidateOrders(MovementPhaseAdjudicator.Instance);
-        Assert.That(orderVie.Validation, Is.Valid);
+        Assert.That(orderVie, Is.Valid);
-        Assert.That(orderVen.Validation, Is.Valid);
+        Assert.That(orderVen, Is.Valid);
 
-        var adjudications = setup.AdjudicateOrders(MovementPhaseAdjudicator.Instance);
         // The two units bounce.
-        Assert.That(orderVie.Adjudications.OfType<DoesMove>().Count(), Is.EqualTo(1));
+        var adjudications = setup.AdjudicateOrders(MovementPhaseAdjudicator.Instance);
-        Assert.That(orderVie.Adjudications.OfType<DoesMove>().First().Outcome, Is.False);
+        Assert.That(orderVie, Is.Repelled);
-        Assert.That(orderVen.Adjudications.OfType<DoesMove>().Count(), Is.EqualTo(1));
+        Assert.That(orderVie, Is.NotDislodged);
-        Assert.That(orderVen.Adjudications.OfType<DoesMove>().First().Outcome, Is.False);
+        Assert.That(orderVen, Is.Repelled);
+        Assert.That(orderVen, Is.NotDislodged);
     }
 
     [Test]
@@ -203,17 +207,17 @@ public class DATC_A
                 .Army("Venice").MovesTo("Tyrolia").GetReference(out var orderVen);
 
         var validations = setup.ValidateOrders(MovementPhaseAdjudicator.Instance);
-        Assert.That(orderVie.Validation, Is.Valid);
+        Assert.That(orderVie, Is.Valid);
-        Assert.That(orderMun.Validation, Is.Valid);
+        Assert.That(orderMun, Is.Valid);
-        Assert.That(orderVen.Validation, Is.Valid);
+        Assert.That(orderVen, Is.Valid);
 
         var adjudications = setup.AdjudicateOrders(MovementPhaseAdjudicator.Instance);
         // The three units bounce.
-        Assert.That(orderVie.Adjudications.OfType<DoesMove>().Count(), Is.EqualTo(1));
+        Assert.That(orderVie, Is.Repelled);
-        Assert.That(orderVie.Adjudications.OfType<DoesMove>().First().Outcome, Is.False);
+        Assert.That(orderVie, Is.NotDislodged);
-        Assert.That(orderMun.Adjudications.OfType<DoesMove>().Count(), Is.EqualTo(1));
+        Assert.That(orderMun, Is.Repelled);
-        Assert.That(orderMun.Adjudications.OfType<DoesMove>().First().Outcome, Is.False);
+        Assert.That(orderMun, Is.NotDislodged);
-        Assert.That(orderVen.Adjudications.OfType<DoesMove>().Count(), Is.EqualTo(1));
+        Assert.That(orderVen, Is.Repelled);
-        Assert.That(orderVen.Adjudications.OfType<DoesMove>().First().Outcome, Is.False);
+        Assert.That(orderVen, Is.NotDislodged);
     }
 }

MultiversalDiplomacyTests/Is.cs

@@ -1,12 +1,25 @@
 using MultiversalDiplomacy.Adjudicate;
+using MultiversalDiplomacy.Adjudicate.Decision;
 
 namespace MultiversalDiplomacyTests;
 
 public class Is : NUnit.Framework.Is
 {
     public static OrderValidationConstraint Valid
-        => new OrderValidationConstraint(true, ValidationReason.Valid);
+        => new(true, ValidationReason.Valid);
 
     public static OrderValidationConstraint Invalid(ValidationReason expected)
-        => new OrderValidationConstraint(false, expected);
+        => new(false, expected);
+
+    public static OrderBinaryAdjudicationConstraint<IsDislodged> Dislodged
+        => new(true);
+
+    public static OrderBinaryAdjudicationConstraint<IsDislodged> NotDislodged
+        => new(false);
+
+    public static OrderBinaryAdjudicationConstraint<DoesMove> Victorious
+        => new(true);
+
+    public static OrderBinaryAdjudicationConstraint<DoesMove> Repelled
+        => new(false);
 }

MultiversalDiplomacyTests/NullOrder.cs

@@ -1,9 +0,0 @@
-using MultiversalDiplomacy.Model;
-using MultiversalDiplomacy.Orders;
-
-namespace MultiversalDiplomacyTests;
-
-public class NullOrder : Order
-{
-    public NullOrder(Power power) : base(power) {}
-}

MultiversalDiplomacyTests/OrderBinaryAdjudicationConstraint.cs

@@ -0,0 +1,32 @@
+using MultiversalDiplomacy.Adjudicate;
+using MultiversalDiplomacy.Adjudicate.Decision;
+
+using NUnit.Framework.Constraints;
+
+namespace MultiversalDiplomacyTests;
+
+public class OrderBinaryAdjudicationConstraint<DecisionType> : Constraint
+    where DecisionType : BinaryAdjudicationDecision
+{
+    private bool expectedOutcome;
+
+    public override string Description
+    {
+        get => $"{typeof(DecisionType).Name}={expectedOutcome}";
+    }
+
+    public OrderBinaryAdjudicationConstraint(bool outcome)
+    {
+        this.expectedOutcome = outcome;
+    }
+
+    public override ConstraintResult ApplyTo<TActual>(TActual actual)
+    {
+        if (actual is OrderReference orderRef)
+        {
+            DecisionType decision = orderRef.GetDecision<DecisionType>();
+            return new ConstraintResult(this, decision, decision.Outcome == this.expectedOutcome);
+        }
+        return new ConstraintResult(this, actual, false);
+    }
+}

MultiversalDiplomacyTests/OrderReference.cs

@@ -8,16 +8,21 @@ using NUnit.Framework;
 namespace MultiversalDiplomacyTests;
 
 /// <summary>
-/// An object that provides a view into an order's fate during a test case.
+/// An object that provides a view into an order's fate during a test case. This object is
+/// stateless and provides data by encapsulating queries on the state of the origin test case
+/// builder.
 /// </summary>
-public class OrderReference<OrderType> where OrderType : Order
+public abstract class OrderReference
 {
-    private TestCaseBuilder Builder { get; }
+    protected TestCaseBuilder Builder { get; }
 
-    /// <summary>
+    protected Order Order { get; }
-    /// The order.
+
-    /// </summary>
+    public OrderReference(TestCaseBuilder builder, Order order)
-    public OrderType Order { get; }
+    {
+        this.Builder = builder;
+        this.Order = order;
+    }
 
     /// <summary>
     /// The validation result for the order. Throws if validation has not occurred.
@@ -63,6 +68,28 @@ public class OrderReference<OrderType> where OrderType : Order
         }
     }
 
+    /// <summary>
+    /// Returns an <see cref="OrderReference"/> for the order that replaced this order.
+    /// </summary>
+    public OrderReference<ReplacementOrderType> GetReplacementReference<ReplacementOrderType>()
+        where ReplacementOrderType : Order
+    {
+        if (this.Replacement == null)
+        {
+            throw new InvalidOperationException("This order was not replaced");
+        }
+        Assert.That(
+            this.Replacement.Order,
+            Is.AssignableTo(typeof(ReplacementOrderType)),
+            "Unexpected replacement order type");
+        ReplacementOrderType replacementOrder = (ReplacementOrderType)this.Replacement.Order;
+        return new(this.Builder, replacementOrder);
+    }
+
+    /// <summary>
+    /// A list of all adjudication decisions related to this order. Throws if adjudication has not
+    /// occurred.
+    /// </summary>
     public List<AdjudicationDecision> Adjudications
     {
         get
@@ -76,15 +103,35 @@ public class OrderReference<OrderType> where OrderType : Order
                 IsDislodged dislodged => dislodged.Order == this.Order,
                 DoesMove moves => moves.Order == this.Order,
                 GivesSupport supports => supports.Order == this.Order,
+                HasPath path => path.Order == this.Order,
                 AttackStrength attack => attack.Order == this.Order,
                 DefendStrength defend => defend.Order == this.Order,
                 PreventStrength prevent => prevent.Order == this.Order,
+                HoldStrength hold => this.Order is UnitOrder unitOrder
+                    ? hold.Province == unitOrder.Unit.Location.Province
+                    : false,
                 _ => false,
             }).ToList();
             return adjudications;
         }
     }
 
+    /// <summary>
+    /// Returns an adjudication decision of a specified type for this order. Throws if adjudication
+    /// has not occurred.
+    /// </summary>
+    public DecisionType GetDecision<DecisionType>()
+        where DecisionType : AdjudicationDecision
+    {
+        var typeAdjudications = this.Adjudications.OfType<DecisionType>();
+        Assert.That(typeAdjudications.Any(), Is.True, $"No {typeof(DecisionType)} decision found");
+        return typeAdjudications.Single();
+    }
+
+    /// <summary>
+    /// If this order is a unit order and the unit was dislodged, the <see cref="RetreatingUnit"/>
+    /// representing the retreat. Throws if adjudication has not occurred.
+    /// </summary>
     public RetreatingUnit? Retreat
     {
         get
@@ -105,10 +152,23 @@ public class OrderReference<OrderType> where OrderType : Order
             return null;
         }
     }
+}
+
+/// <summary>
+/// An object that provides a view into an order's fate during a test case. This object is
+/// stateless and provides data by encapsulating queries on the state of the origin test case
+/// builder.
+/// </summary>
+public class OrderReference<OrderType> : OrderReference where OrderType : Order
+{
+    /// <summary>
+    /// The order.
+    /// </summary>
+    new public OrderType Order { get; }
 
     public OrderReference(TestCaseBuilder builder, OrderType order)
+        : base(builder, order)
     {
-        this.Builder = builder;
         this.Order = order;
     }
 }

MultiversalDiplomacyTests/OrderValidationConstraint.cs

@@ -22,9 +22,16 @@ public class OrderValidationConstraint : Constraint
 
     public override ConstraintResult ApplyTo<TActual>(TActual actual)
     {
-        bool success = actual is OrderValidation validation
+        bool success = actual switch
-            && validation.Valid == this.valid
+        {
-            && validation.Reason == this.expectedReason;
+            OrderReference reference
+                => reference.Validation.Valid == this.valid
+                && reference.Validation.Reason == this.expectedReason,
+            OrderValidation validation
+                => validation.Valid == this.valid
+                && validation.Reason == this.expectedReason,
+            _ => false,
+        };
         return new ConstraintResult(this, actual, success);
     }
 }