Reduce verbosity of test case assertions

This commit is contained in:
Jaculabilis 2022-03-28 15:05:04 -07:00
parent 609e8cc60c
commit ff64b459ca
7 changed files with 176 additions and 64 deletions

View File

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

View File

@ -1,6 +1,7 @@
using MultiversalDiplomacy.Adjudicate; using MultiversalDiplomacy.Adjudicate;
using MultiversalDiplomacy.Adjudicate.Decision; using MultiversalDiplomacy.Adjudicate.Decision;
using MultiversalDiplomacy.Model; using MultiversalDiplomacy.Model;
using MultiversalDiplomacy.Orders;
using NUnit.Framework; using NUnit.Framework;
@ -17,9 +18,9 @@ public class DATC_A
setup["England"] setup["England"]
.Fleet("North Sea").MovesTo("Picardy").GetReference(out var order); .Fleet("North Sea").MovesTo("Picardy").GetReference(out var order);
// Order should fail.
setup.ValidateOrders(MovementPhaseAdjudicator.Instance); setup.ValidateOrders(MovementPhaseAdjudicator.Instance);
Assert.That(order, Is.Invalid(ValidationReason.UnreachableDestination));
Assert.That(order.Validation, Is.Invalid(ValidationReason.UnreachableDestination));
} }
[Test] [Test]
@ -27,6 +28,7 @@ public class DATC_A
{ {
TestCaseBuilder setup = new TestCaseBuilder(StandardEmpty); TestCaseBuilder setup = new TestCaseBuilder(StandardEmpty);
// Order should fail.
Assert.That( Assert.That(
() => () =>
{ {
@ -41,6 +43,7 @@ public class DATC_A
{ {
TestCaseBuilder setup = new TestCaseBuilder(StandardEmpty); TestCaseBuilder setup = new TestCaseBuilder(StandardEmpty);
// Order should fail.
Assert.That( Assert.That(
() => () =>
{ {
@ -57,9 +60,9 @@ public class DATC_A
setup["Germany"] setup["Germany"]
.Fleet("Kiel").MovesTo("Kiel").GetReference(out var order); .Fleet("Kiel").MovesTo("Kiel").GetReference(out var order);
// Program should not crash.
setup.ValidateOrders(MovementPhaseAdjudicator.Instance); setup.ValidateOrders(MovementPhaseAdjudicator.Instance);
Assert.That(order, Is.Invalid(ValidationReason.DestinationMatchesOrigin));
Assert.That(order.Validation, Is.Invalid(ValidationReason.DestinationMatchesOrigin));
} }
[Test] [Test]
@ -72,15 +75,20 @@ public class DATC_A
.Army("Yorkshire").MovesTo("Yorkshire").GetReference(out var orderYor) .Army("Yorkshire").MovesTo("Yorkshire").GetReference(out var orderYor)
.Army("Liverpool").Supports.Army("Yorkshire").MoveTo("Yorkshire") .Army("Liverpool").Supports.Army("Yorkshire").MoveTo("Yorkshire")
["Germany"] ["Germany"]
.Fleet("London").MovesTo("Yorkshire") .Fleet("London").MovesTo("Yorkshire").GetReference(out var orderLon)
.Army("Wales").Supports.Fleet("London").MoveTo("Yorkshire"); .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); 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] [Test]
@ -91,9 +99,9 @@ public class DATC_A
["Germany"] ["Germany"]
.Fleet("London", powerName: "England").MovesTo("North Sea").GetReference(out var order); .Fleet("London", powerName: "England").MovesTo("North Sea").GetReference(out var order);
// Order should fail.
setup.ValidateOrders(MovementPhaseAdjudicator.Instance); setup.ValidateOrders(MovementPhaseAdjudicator.Instance);
Assert.That(order, Is.Invalid(ValidationReason.InvalidUnitForPower));
Assert.That(order.Validation, Is.Invalid(ValidationReason.InvalidUnitForPower));
} }
[Test] [Test]
@ -105,9 +113,9 @@ public class DATC_A
.Fleet("London").MovesTo("Belgium") .Fleet("London").MovesTo("Belgium")
.Fleet("North Sea").Convoys.Army("London").To("Belgium").GetReference(out var order); .Fleet("North Sea").Convoys.Army("London").To("Belgium").GetReference(out var order);
// Move from London to Belgium should fail.
setup.ValidateOrders(MovementPhaseAdjudicator.Instance); setup.ValidateOrders(MovementPhaseAdjudicator.Instance);
Assert.That(order, Is.Invalid(ValidationReason.InvalidOrderTypeForUnit));
Assert.That(order.Validation, Is.Invalid(ValidationReason.InvalidOrderTypeForUnit));
} }
[Test] [Test]
@ -122,15 +130,12 @@ public class DATC_A
.Fleet("Trieste").Supports.Fleet("Trieste").Hold().GetReference(out var orderTri); .Fleet("Trieste").Supports.Fleet("Trieste").Hold().GetReference(out var orderTri);
setup.ValidateOrders(MovementPhaseAdjudicator.Instance); 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. // 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] [Test]
@ -141,9 +146,9 @@ public class DATC_A
["Italy"] ["Italy"]
.Fleet("Rome").MovesTo("Venice").GetReference(out var order); .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); setup.ValidateOrders(MovementPhaseAdjudicator.Instance);
Assert.That(order, Is.Invalid(ValidationReason.UnreachableDestination));
Assert.That(order.Validation, Is.Invalid(ValidationReason.UnreachableDestination));
} }
[Test] [Test]
@ -160,12 +165,11 @@ public class DATC_A
setup.ValidateOrders(MovementPhaseAdjudicator.Instance); setup.ValidateOrders(MovementPhaseAdjudicator.Instance);
// The support of Rome is illegal, because Venice can not be reached from Rome by a fleet. // 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. // Venice is not dislodged.
setup.AdjudicateOrders(MovementPhaseAdjudicator.Instance); 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] [Test]
@ -179,15 +183,15 @@ public class DATC_A
.Army("Venice").MovesTo("Tyrolia").GetReference(out var orderVen); .Army("Venice").MovesTo("Tyrolia").GetReference(out var orderVen);
setup.ValidateOrders(MovementPhaseAdjudicator.Instance); 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. // 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] [Test]
@ -203,17 +207,17 @@ public class DATC_A
.Army("Venice").MovesTo("Tyrolia").GetReference(out var orderVen); .Army("Venice").MovesTo("Tyrolia").GetReference(out var orderVen);
var validations = setup.ValidateOrders(MovementPhaseAdjudicator.Instance); 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); var adjudications = setup.AdjudicateOrders(MovementPhaseAdjudicator.Instance);
// The three units bounce. // 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);
} }
} }

View File

@ -1,12 +1,25 @@
using MultiversalDiplomacy.Adjudicate; using MultiversalDiplomacy.Adjudicate;
using MultiversalDiplomacy.Adjudicate.Decision;
namespace MultiversalDiplomacyTests; namespace MultiversalDiplomacyTests;
public class Is : NUnit.Framework.Is public class Is : NUnit.Framework.Is
{ {
public static OrderValidationConstraint Valid public static OrderValidationConstraint Valid
=> new OrderValidationConstraint(true, ValidationReason.Valid); => new(true, ValidationReason.Valid);
public static OrderValidationConstraint Invalid(ValidationReason expected) 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);
} }

View File

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

View File

@ -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);
}
}

View File

@ -8,16 +8,21 @@ using NUnit.Framework;
namespace MultiversalDiplomacyTests; namespace MultiversalDiplomacyTests;
/// <summary> /// <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> /// </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> /// <summary>
/// The validation result for the order. Throws if validation has not occurred. /// 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 public List<AdjudicationDecision> Adjudications
{ {
get get
@ -76,15 +103,35 @@ public class OrderReference<OrderType> where OrderType : Order
IsDislodged dislodged => dislodged.Order == this.Order, IsDislodged dislodged => dislodged.Order == this.Order,
DoesMove moves => moves.Order == this.Order, DoesMove moves => moves.Order == this.Order,
GivesSupport supports => supports.Order == this.Order, GivesSupport supports => supports.Order == this.Order,
HasPath path => path.Order == this.Order,
AttackStrength attack => attack.Order == this.Order, AttackStrength attack => attack.Order == this.Order,
DefendStrength defend => defend.Order == this.Order, DefendStrength defend => defend.Order == this.Order,
PreventStrength prevent => prevent.Order == this.Order, PreventStrength prevent => prevent.Order == this.Order,
HoldStrength hold => this.Order is UnitOrder unitOrder
? hold.Province == unitOrder.Unit.Location.Province
: false,
_ => false, _ => false,
}).ToList(); }).ToList();
return adjudications; 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 public RetreatingUnit? Retreat
{ {
get get
@ -105,10 +152,23 @@ public class OrderReference<OrderType> where OrderType : Order
return null; 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) public OrderReference(TestCaseBuilder builder, OrderType order)
: base(builder, order)
{ {
this.Builder = builder;
this.Order = order; this.Order = order;
} }
} }

View File

@ -22,9 +22,16 @@ public class OrderValidationConstraint : Constraint
public override ConstraintResult ApplyTo<TActual>(TActual actual) 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); return new ConstraintResult(this, actual, success);
} }
} }