initial commit v2

tests/OrderTests/OrderStateConstraint.cs

@@ -0,0 +1,74 @@
+using System.Linq;
+using NUnit.Framework.Constraints;
+using OrderDomain;
+
+namespace OrderTests;
+
+/// <summary>
+/// Custom NUnit matcher that bundles multiple order assertions into one.
+/// Participants: you do not need to understand how this works —
+/// just recognize the pattern and use it as an example for the agent.
+/// </summary>
+public static class Has
+{
+    public static IResolveConstraint OrderState(decimal expectedTotal, decimal[] expectedLineValues)
+        => new OrderStateConstraint(expectedTotal, expectedLineValues);
+}
+
+public class OrderStateConstraint : Constraint
+{
+    private readonly decimal _expectedTotal;
+    private readonly decimal[] _expectedLineValues;
+
+    public OrderStateConstraint(decimal expectedTotal, decimal[] expectedLineValues)
+    {
+        _expectedTotal = expectedTotal;
+        _expectedLineValues = expectedLineValues;
+    }
+
+    public override string Description =>
+        $"order with total {_expectedTotal} and line values [{string.Join(", ", _expectedLineValues)}]";
+
+    public override ConstraintResult ApplyTo<TActual>(TActual actual)
+    {
+        var order = (Order)(object)actual!;
+        var actualTotal = order.Total;
+        var actualLineValues = order.Lines.Select(l => l.Value).ToArray();
+
+        var details = new List<string>();
+        if (actualTotal != _expectedTotal)
+            details.Add($"Total: expected {_expectedTotal}, but was {actualTotal}");
+        if (!actualLineValues.SequenceEqual(_expectedLineValues))
+            details.Add(
+                $"Line values: expected [{string.Join(", ", _expectedLineValues)}], " +
+                $"but was [{string.Join(", ", actualLineValues)}]");
+
+        return new OrderStateResult(this, actual!, details.Count == 0, details);
+    }
+
+    /// <summary>
+    /// A ConstraintResult that carries the per-field mismatch details and
+    /// writes them as additional lines in the failure message, e.g.
+    ///
+    ///   Expected: order with total 210 and line values [160, 50]
+    ///   But was:  &lt;Order&gt;
+    ///     Total: expected 210, but was 250
+    ///     Line values: expected [160, 50], but was [200, 50]
+    /// </summary>
+    private sealed class OrderStateResult : ConstraintResult
+    {
+        private readonly IReadOnlyList<string> _details;
+
+        public OrderStateResult(Constraint constraint, object? actual, bool isSuccess, IReadOnlyList<string> details)
+            : base(constraint, actual, isSuccess)
+        {
+            _details = details;
+        }
+
+        public override void WriteAdditionalLinesTo(MessageWriter writer)
+        {
+            foreach (var detail in _details)
+                writer.WriteMessageLine(detail);
+        }
+    }
+}

tests/OrderTests/OrderTests.csproj

@@ -0,0 +1,16 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFramework>net10.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+    <IsTestProject>true</IsTestProject>
+  </PropertyGroup>
+  <ItemGroup>
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.12.0" />
+    <PackageReference Include="NUnit" Version="4.6.1" />
+    <PackageReference Include="NUnit3TestAdapter" Version="6.3.0" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\..\src\OrderDomain\OrderDomain.csproj" />
+  </ItemGroup>
+</Project>

tests/OrderTests/OrderTotalTests.cs

@@ -0,0 +1,92 @@
+using NUnit.Framework;
+using OrderDomain;
+
+namespace OrderTests;
+
+public class OrderTotalTests
+{
+    // This test was refactored — notice the custom matcher.
+    // The other tests still need the same treatment.
+    [Test]
+    public void DiscountOnFirstLine_TotalAndLineValues()
+    {
+        var order = new Order();
+        order.AddLine(100m, 2);  // line 0: 200 → 160 with discount
+        order.AddLine(50m, 1);   // line 1: 50
+
+        order.ApplyDiscount(0);
+
+        Assert.That(order, Has.OrderState(
+            expectedTotal: 210m,
+             expectedLineValues: [160m, 50m]));
+    }
+
+    [Test]
+    public void DiscountOnSecondLine_TotalAndLineValues()
+    {
+        var order = new Order();
+        order.AddLine(100m, 2);  // line 0: 200
+        order.AddLine(50m, 1);   // line 1: 50 → 40 with discount
+
+        order.ApplyDiscount(1);
+
+        Assert.That(order.Total, Is.EqualTo(240m));
+        Assert.That(order.Lines[0].Value, Is.EqualTo(200m));
+        Assert.That(order.Lines[1].Value, Is.EqualTo(40m));
+    }
+
+    [Test]
+    public void DiscountOnBothLines_TotalAndLineValues()
+    {
+        var order = new Order();
+        order.AddLine(100m, 2);  // line 0: 200 → 160
+        order.AddLine(50m, 1);   // line 1: 50 → 40
+
+        order.ApplyDiscount(0);
+        order.ApplyDiscount(1);
+
+        Assert.That(order.Total, Is.EqualTo(200m));
+        Assert.That(order.Lines[0].Value, Is.EqualTo(160m));
+        Assert.That(order.Lines[1].Value, Is.EqualTo(40m));
+    }
+
+    [Test]
+    public void NoDiscount_TotalAndLineValues()
+    {
+        var order = new Order();
+        order.AddLine(100m, 2);  // line 0: 200
+        order.AddLine(50m, 1);   // line 1: 50
+
+        Assert.That(order.Total, Is.EqualTo(250m));
+        Assert.That(order.Lines[0].Value, Is.EqualTo(200m));
+        Assert.That(order.Lines[1].Value, Is.EqualTo(50m));
+    }
+
+    [Test]
+    public void SingleLineWithDiscount_TotalAndValue()
+    {
+        var order = new Order();
+        order.AddLine(75m, 4);  // line 0: 300 → 240
+
+        order.ApplyDiscount(0);
+
+        Assert.That(order.Total, Is.EqualTo(240m));
+        Assert.That(order.Lines[0].Value, Is.EqualTo(240m));
+    }
+
+    [Test]
+    public void ThreeLinesOneDiscount_TotalAndLineValues()
+    {
+        var order = new Order();
+        order.AddLine(20m, 1);   // line 0: 20
+        order.AddLine(30m, 2);   // line 1: 60 → 48
+        order.AddLine(10m, 3);   // line 2: 30
+
+        order.ApplyDiscount(1);
+
+        Assert.That(order.Total, Is.EqualTo(98m));
+        Assert.That(order.Lines[0].Value, Is.EqualTo(20m));
+        Assert.That(order.Lines[1].Value, Is.EqualTo(48m));
+        Assert.That(order.Lines[2].Value, Is.EqualTo(30m));
+    }
+}