Exercise baseline

tests/Web.Tests/DtoMapperTests.cs

@@ -0,0 +1,163 @@
+using Domain;
+using static TestData.ClientBuilder;
+using static TestData.OrderBuilder;
+
+namespace Web.Tests;
+
+/// <summary>The hand-written <see cref="DtoMappers"/> map both ways, never mutate their input, and round-trip losslessly; domain objects come from the test-data builders, DTO initializers stay literal.</summary>
+public class DtoMapperTests
+{
+    // (1) Mappers map all scalar fields, in both directions.
+    [Fact]
+    public void ToClientDto_maps_all_scalar_fields()
+    {
+        var id = Guid.NewGuid();
+        var client = ValidClient().WithId(id).WithName("Acme").Build();
+
+        var dto = DtoMappers.ToClientDto(client);
+
+        Assert.Equal(id, dto.Id);
+        Assert.Equal("Acme", dto.Name);
+    }
+
+    [Fact]
+    public void ToOrderDto_maps_all_scalar_fields()
+    {
+        var id = Guid.NewGuid();
+        var order = ValidOrder().WithId(id).WithDescription("one").WithTotal(150_00).Build();
+
+        var dto = DtoMappers.ToOrderDto(order);
+
+        Assert.Equal(id, dto.Id);
+        Assert.Equal("one", dto.Description);
+        Assert.Equal(150_00, dto.TotalInCents);
+    }
+
+    [Fact]
+    public void FromClientDto_maps_all_scalar_fields()
+    {
+        var id = Guid.NewGuid();
+        var dto = new ClientDto { Id = id, Name = "Acme" };
+
+        var client = DtoMappers.FromClientDto(dto);
+
+        Assert.Equal(id, client.Id);
+        Assert.Equal("Acme", client.Name);
+    }
+
+    [Fact]
+    public void FromOrderDto_maps_all_scalar_fields()
+    {
+        var id = Guid.NewGuid();
+        var dto = new OrderDto { Id = id, Description = "one", TotalInCents = 150_00 };
+
+        var order = DtoMappers.FromOrderDto(dto);
+
+        Assert.Equal(id, order.Id);
+        Assert.Equal("one", order.Description);
+        Assert.Equal(150_00, order.TotalInCents);
+    }
+
+    // (2) Mappers map the relations, and the back-references stay consistent.
+    [Fact]
+    public void ToClientDto_maps_orders_and_keeps_the_back_reference_consistent()
+    {
+        var order = ValidOrder().WithDescription("one").Build();
+        var client = ValidClient().WithName("Acme").WithOrder(order).Build();
+
+        var dto = DtoMappers.ToClientDto(client);
+        var orderDto = Assert.Single(dto.Orders);
+
+        // The order is mapped with the client's data:
+        Assert.Equal(order.Id, orderDto.Id);
+        Assert.Equal(order.Description, orderDto.Description);
+
+        // The back-reference cycle is resolved to the SAME dto reference:
+        Assert.Same(dto, orderDto.ClientDto);
+    }
+
+    [Fact]
+    public void FromClientDto_wires_the_order_client_back_reference()
+    {
+        var orderDto = new OrderDto { Description = "one" };
+        var dto = new ClientDto { Name = "Acme", Orders = new[] { orderDto } };
+
+        var client = DtoMappers.FromClientDto(dto);
+        var order = Assert.Single(client.Orders);
+
+        Assert.Equal(orderDto.Description, order.Description);
+        // Navigation fix-up: the reconstructed order points at the client:
+        Assert.Same(client, order.Client);
+    }
+
+    // (3) Round-trips preserve all state (compared by values, not reference).
+    [Fact]
+    public void Domain_round_trip_preserves_all_state()
+    {
+        var order = ValidOrder().WithId(Guid.NewGuid()).WithDescription("one").WithTotal(150_00).Build();
+        var client = ValidClient().WithId(Guid.NewGuid()).WithName("Acme").WithOrder(order).Build();
+
+        var roundTrip = DtoMappers.FromClientDto(DtoMappers.ToClientDto(client));
+
+        Assert.Equal(client.Id, roundTrip.Id);
+        Assert.Equal(client.Name, roundTrip.Name);
+        var roundTripOrder = Assert.Single(roundTrip.Orders);
+        Assert.Equal(order.Id, roundTripOrder.Id);
+        Assert.Equal(order.Description, roundTripOrder.Description);
+        Assert.Equal(order.TotalInCents, roundTripOrder.TotalInCents);
+        // The back-reference is still consistent on the reconstructed graph:
+        Assert.Same(roundTrip, roundTripOrder.Client);
+    }
+
+    [Fact]
+    public void Dto_round_trip_preserves_all_state()
+    {
+        var order = ValidOrder().WithId(Guid.NewGuid()).WithDescription("one").WithTotal(150_00).Build();
+        var client = ValidClient().WithId(Guid.NewGuid()).WithName("Acme").WithOrder(order).Build();
+        var dto = DtoMappers.ToClientDto(client);
+        var dtoOrder = dto.Orders[0];
+
+        var roundTrip = DtoMappers.ToClientDto(DtoMappers.FromClientDto(dto));
+
+        Assert.Equal(dto.Id, roundTrip.Id);
+        Assert.Equal(dto.Name, roundTrip.Name);
+        var roundTripOrder = Assert.Single(roundTrip.Orders);
+        Assert.Equal(dtoOrder.Id, roundTripOrder.Id);
+        Assert.Equal(dtoOrder.Description, roundTripOrder.Description);
+        Assert.Equal(dtoOrder.TotalInCents, roundTripOrder.TotalInCents);
+        Assert.Same(roundTrip, roundTripOrder.ClientDto);
+    }
+
+    // (4) Mappers do not mutate their inputs (snapshot fields, map, compare).
+    [Fact]
+    public void ToClientDto_does_not_mutate_the_domain()
+    {
+        var order = ValidOrder().WithId(Guid.NewGuid()).WithDescription("one").Build();
+        var client = ValidClient().WithId(Guid.NewGuid()).WithName("Acme").WithOrder(order).Build();
+        var ordersCount = client.Orders.Count;
+
+        DtoMappers.ToClientDto(client);
+        DtoMappers.ToOrderDto(order);
+
+        Assert.Equal("Acme", client.Name);
+        Assert.Equal(ordersCount, client.Orders.Count);
+        Assert.Same(client, order.Client);          // back-reference untouched
+        Assert.Equal("one", order.Description);
+    }
+
+    [Fact]
+    public void FromClientDto_does_not_mutate_the_dto()
+    {
+        var orderDto = new OrderDto { Description = "one" };
+        var dto = new ClientDto { Id = Guid.NewGuid(), Name = "Acme", Orders = new[] { orderDto } };
+
+        DtoMappers.FromClientDto(dto);
+        DtoMappers.FromOrderDto(orderDto);
+
+        Assert.Equal("Acme", dto.Name);
+        Assert.Same(orderDto, Assert.Single(dto.Orders));   // collection untouched
+        Assert.Null(orderDto.ClientDto);                   // back-reference untouched
+        Assert.Equal("one", orderDto.Description);
+    }
+
+}

tests/Web.Tests/Web.Tests.csproj

@@ -0,0 +1,30 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net10.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+    <IsPackable>false</IsPackable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="coverlet.collector" Version="6.0.4" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.14.1" />
+    <PackageReference Include="xunit" Version="2.9.3" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="3.1.4" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <Using Include="Xunit" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <!-- Domain is referenced explicitly because these tests use domain
+         types directly (it also flows in transitively through Web).
+         Deliberately NO reference to Db — mirroring the Web layer. -->
+    <ProjectReference Include="..\..\src\Domain\Domain.csproj" />
+    <ProjectReference Include="..\..\src\Web\Web.csproj" />
+    <ProjectReference Include="..\TestData\TestData.csproj" />
+  </ItemGroup>
+
+</Project>

tests/Web.Tests/WebAppTests.cs

@@ -0,0 +1,61 @@
+using Domain;
+using System.Reflection;
+using static TestData.ClientBuilder;
+using static TestData.OrderBuilder;
+
+namespace Web.Tests;
+
+/// <summary>The WebApp consumes only DTOs; persistence types are excluded at compile time (no Web → Db project reference).</summary>
+public class WebAppTests
+{
+    // The WebApp's public API references no domain type (reflection).
+    private static readonly Type[] BannedTypes = [typeof(Client), typeof(Order)];
+
+    private static IEnumerable<Type> TypeAndArguments(Type t)
+    {
+        yield return t;
+        if (t.IsGenericType)
+            foreach (var arg in t.GetGenericArguments())
+                foreach (var nested in TypeAndArguments(arg))
+                    yield return nested;
+        if (t.IsArray && t.GetElementType() is { } elem)
+            foreach (var nested in TypeAndArguments(elem))
+                yield return nested;
+    }
+
+    [Fact]
+    public void WebApp_public_api_references_no_domain_types()
+    {
+        var app = typeof(WebApp);
+        var banned = BannedTypes.ToList();
+
+        foreach (var m in app.GetMethods(BindingFlags.Public | BindingFlags.Instance | BindingFlags.Static))
+        {
+            var signature = m.GetParameters()
+                .Select(p => p.ParameterType)
+                .Append(m.ReturnType)
+                .ToList();
+            foreach (var t in signature.SelectMany(TypeAndArguments))
+                Assert.False(banned.Contains(t),
+                    $"WebApp.{m.Name}({string.Join(", ", signature)}) references banned type {t}");
+        }
+
+        foreach (var p in app.GetProperties(BindingFlags.Public | BindingFlags.Instance | BindingFlags.Static))
+            foreach (var t in TypeAndArguments(p.PropertyType))
+                Assert.False(banned.Contains(t),
+                    $"WebApp.{p.Name} references banned type {t}");
+    }
+
+    [Fact]
+    public void WebApp_consumes_dtos()
+    {
+        var app = new WebApp();
+        var order = ValidOrder().WithId(Guid.NewGuid()).WithDescription("order one").WithTotal(150_00).Build();
+        var client = ValidClient().WithId(Guid.NewGuid()).WithName("Acme").WithOrder(order).Build();
+
+        var view = app.ShowClient(DtoMappers.ToClientDto(client));
+
+        Assert.Contains("Acme", view);
+        Assert.Contains("order one", view);
+    }
+}