tests/Db.Tests/AfterPersistenceTests.cs

@@ -0,0 +1,186 @@
+using Domain;
+using static TestData.ClientBuilder;
+using static TestData.OrderBuilder;
+
+namespace Db.Tests;
+
+/// <summary>The fake <see cref="DbContext"/> stores data-only records, never domain objects; Save maps state into rows (insert or refresh), the graph flattened to ids.</summary>
+public class AfterPersistenceTests
+{
+    [Fact]
+    public void Save_maps_domain_state_into_data_records()
+    {
+        var db = new DbContext();
+        var order = ValidOrder().WithDescription("one").WithTotal(150_00).Build();
+        var client = ValidClient().WithName("Acme").WithOrder(order).Build();
+
+        db.Save(client);
+        db.Save(order);
+
+        var clientRow = Assert.Single(db.Clients);
+        Assert.Equal(client.Id, clientRow.Id);
+        Assert.Equal("Acme", clientRow.Name);
+
+        var orderRow = Assert.Single(db.Orders);
+        Assert.Equal(order.Id, orderRow.Id);
+        Assert.Equal("one", orderRow.Description);
+        Assert.Equal(150_00, orderRow.TotalInCents);
+        Assert.Equal(client.Id, orderRow.ClientId);   // the graph is flattened to a key
+    }
+
+    [Fact]
+    public void An_order_without_client_stores_an_empty_client_id()
+    {
+        var db = new DbContext();
+        var order = ValidOrder().WithDescription("orphan").Build();
+
+        db.Save(order);
+
+        Assert.Equal(Guid.Empty, Assert.Single(db.Orders).ClientId);
+    }
+
+    [Fact]
+    public void Saving_again_refreshes_the_row_instead_of_duplicating_it()
+    {
+        var db = new DbContext();
+        var order = ValidOrder().WithDescription("one").WithTotal(150_00).Build();
+        var client = ValidClient().WithName("Acme").WithOrder(order).Build();
+        db.Save(client);
+        db.Save(order);
+
+        order.Description = "one (edited)";
+        order.TotalInCents = OrderMoney.From(99_00);
+        client.Name = "Acme GmbH";
+        db.Save(order);
+        db.Save(client);
+
+        // One row per saved object, refreshed with the *current* state:
+        var orderRow = Assert.Single(db.Orders);
+        Assert.Equal(order.Id, orderRow.Id);
+        Assert.Equal("one (edited)", orderRow.Description);
+        Assert.Equal(99_00, orderRow.TotalInCents);
+        Assert.Equal(client.Id, orderRow.ClientId);
+
+        var clientRow = Assert.Single(db.Clients);
+        Assert.Equal("Acme GmbH", clientRow.Name);
+    }
+
+    [Fact]
+    public void Rows_are_reachable_through_Set_and_Find()
+    {
+        var db = new DbContext();
+        var order = ValidOrder().WithDescription("one").WithTotal(150_00).Build();
+        var client = ValidClient().WithName("Acme").WithOrder(order).Build();
+        db.Save(client);
+        db.Save(order);
+
+        Assert.Single(db.Set<ClientData>());
+        Assert.Single(db.Set<OrderData>());
+
+        var found = db.Find<OrderData>(row => row.Description == "one");
+        Assert.Equal(order.Id, found!.Id);
+        Assert.Null(db.Find<OrderData>(row => row.Description == "no such order"));
+    }
+
+    // Read-back: LoadOrder / LoadClient reassemble domain objects from the stored rows.
+
+    [Fact]
+    public void Loading_an_order_restores_its_state_and_its_client()
+    {
+        var db = new DbContext();
+        var order = ValidOrder().WithDescription("one").WithTotal(150_00).Build();
+        var client = ValidClient().WithName("Acme").WithOrder(order).Build();
+        db.Save(client);
+        db.Save(order);
+
+        var loaded = db.LoadOrder(order.Id);
+
+        Assert.NotNull(loaded);
+        Assert.Equal(order.Id, loaded!.Id);
+        Assert.Equal("one", loaded.Description);
+        Assert.Equal(150_00, loaded.TotalInCents.Cents);
+
+        // The graph is reassembled: the loaded order knows its client again,
+        // and the client's collection holds the loaded order.
+        Assert.NotNull(loaded.Client);
+        Assert.Equal("Acme", loaded.Client!.Name);
+        Assert.Same(loaded, Assert.Single(loaded.Client.Orders));
+    }
+
+    [Fact]
+    public void Loading_a_client_restores_it_with_all_of_its_orders()
+    {
+        var db = new DbContext();
+        var first = ValidOrder().WithDescription("one").WithTotal(150_00).Build();
+        var second = ValidOrder().WithDescription("two").WithTotal(250_00).Build();
+        var client = ValidClient().WithName("Acme").WithOrder(first).WithOrder(second).Build();
+        db.Save(client);
+        db.Save(first);
+        db.Save(second);
+
+        var loaded = db.LoadClient(client.Id);
+
+        Assert.NotNull(loaded);
+        Assert.Equal("Acme", loaded!.Name);
+        Assert.Equal(2, loaded.Orders.Count);
+        Assert.All(loaded.Orders, o => Assert.Same(loaded, o.Client));
+    }
+
+    [Fact]
+    public void Loading_an_unknown_id_returns_null()
+    {
+        var db = new DbContext();
+
+        Assert.Null(db.LoadOrder(Guid.NewGuid()));
+        Assert.Null(db.LoadClient(Guid.NewGuid()));
+    }
+
+    // Tracking: explicit Save, distinct ids; a saved object keeps no reference to the context.
+    [Fact]
+    public void DbContext_saves_plain_domain_objects_and_tracks_them()
+    {
+        var db = new DbContext();
+        var order = ValidOrder().WithDescription("one").Build();
+        var client = ValidClient().WithName("Acme").WithOrder(order).Build();
+
+        Assert.Equal(Guid.Empty, client.Id);
+        db.Save(client);
+        db.Save(order);
+
+        Assert.NotEqual(Guid.Empty, client.Id);
+        Assert.NotEqual(Guid.Empty, order.Id);
+        Assert.NotEqual(client.Id, order.Id);
+        Assert.True(db.IsTracked(client));
+        Assert.True(db.IsTracked(order));
+        Assert.Equal(2, db.Tracked.Count);
+    }
+
+    [Fact]
+    public void Saving_twice_does_not_reassign_the_id()
+    {
+        var db = new DbContext();
+        var client = ValidClient().WithName("Acme").Build();
+        db.Save(client);
+        var id = client.Id;
+
+        db.Save(client);
+
+        Assert.Equal(id, client.Id);
+        Assert.Single(db.Tracked);
+    }
+
+    [Fact]
+    public void A_saved_domain_object_keeps_no_reference_to_the_context()
+    {
+        var db = new DbContext();
+        var client = ValidClient().WithName("Acme").Build();
+        db.Save(client);
+
+        // Saved (the id was assigned by the context) ...
+        Assert.NotEqual(Guid.Empty, client.Id);
+        Assert.True(db.IsTracked(client));
+
+        // No way back to the context through the domain object (see DomainStaysPlainTests): the only "receipt" is the plain Id value.
+        Assert.Equal(db.Tracked.Single(t => t.Id == client.Id).Id, client.Id);
+    }
+}