feat: demonstrate a credit limit change flowing through the replica

The demo never exercised changeCreditLimit, so the claim that the replica is
enough to enforce business rules was only shown as a rejection. Add a fifth
step: the customer service comes back online, raises the credit limit, and the
order rejected in step 4 is accepted from the replicated state alone.

Add restart() to CustomerService so the outage can end, make CustomerReplica
use a LinkedHashMap like CustomerService for deterministic log order, cover the
new behaviour in CustomerServiceTest and OrderServiceTest, and refresh the
README demo section, its program output, and the PlantUML diagram.

Author: ylcn91

event-carried-state-transfer/README.md

@@ -172,7 +172,7 @@ public Order placeOrder(String customerId, BigDecimal amount) {
 
 6. **The demo**
 
-`App` registers a customer and changes the address, takes the customer service offline and places an order from the replica, publishes a stale event that the replica ignores, and finally shows the replica enforcing the credit limit.
+`App` registers a customer and changes the address, takes the customer service offline and places an order from the replica, publishes a stale event that the replica ignores, and shows the replica enforcing the credit limit. It then brings the customer service back and raises that limit: the new limit travels inside the event, and the order that was just rejected is accepted from the replica alone, without a single call back to the producer.
 
 ```java
 var bus = new EventBus();
@@ -188,6 +188,10 @@ var order = orderService.placeOrder("C-1", new BigDecimal("120.00")); // succeed
 
 bus.publish(new CustomerUpdatedEvent(99, Instant.now(), staleVersionOne)); // ignored
 tryToOrder(orderService, "C-1", new BigDecimal("900.00")); // rejected, above the replicated limit
+
+customerService.restart();
+customerService.changeCreditLimit("C-1", new BigDecimal("1500.00")); // the event carries the new limit
+tryToOrder(orderService, "C-1", new BigDecimal("900.00")); // accepted now, still only from the replica
 ```
 
 Program output:
@@ -217,6 +221,15 @@ INFO App -- Order service replica: C-1 version 2 at '42 Ocean Avenue, Porto' wit
 INFO App -- --- Step 4: the replica is enough to enforce business rules ---
 WARN App -- Order rejected: Amount 900.00 exceeds credit limit 500.00 of C-1
 WARN App -- Order rejected: Unknown customer C-2 in replica
+INFO App -- --- Step 5: a new credit limit travels in the event and unblocks the rejected order ---
+INFO CustomerService -- Customer service is back online
+INFO CustomerService -- Customer C-1 gets a credit limit of 1500.00
+INFO CustomerService -- Publishing event 3 with the full state of C-1 (version 3)
+INFO EventBus -- Publishing CustomerUpdatedEvent to 1 subscriber(s)
+INFO CustomerReplica -- Replica updated from event 3: C-1 is now at version 3 with address '42 Ocean Avenue, Porto' and limit 1500.00
+INFO App -- Order service replica: C-1 version 3 at '42 Ocean Avenue, Porto' with limit 1500.00
+INFO OrderService -- Accepted ORD-2 for C-1 (900.00) shipping to '42 Ocean Avenue, Porto' using replica version 3
+INFO App -- Order ORD-2 accepted
 ```
 
 ## Class Diagram

event-carried-state-transfer/etc/event-carried-state-transfer.urm.puml

@@ -44,6 +44,7 @@ package com.iluwatar.eventcarriedstatetransfer {
     + changeCreditLimit(customerId : String, newLimit : BigDecimal) : CustomerState
     + findCustomer(customerId : String) : Optional<CustomerState>
     + shutdown() : void
+    + restart() : void
     + isOnline() : boolean
   }
   class CustomerReplica {

event-carried-state-transfer/src/main/java/com/iluwatar/eventcarriedstatetransfer/App.java

@@ -41,8 +41,10 @@
  *
  * <p>The demo registers a customer and changes the address, showing the replica following each
  * event. It then takes the customer service offline and places an order anyway, purely from the
- * replica. A stale event is published to show that the replica ignores it, and finally an order
- * above the replicated credit limit is rejected.
+ * replica. A stale event is published to show that the replica ignores it, and an order above the
+ * replicated credit limit is rejected. Finally the customer service comes back and raises that
+ * credit limit: the new state travels in the event, and the order that was just rejected is
+ * accepted from the replica alone.
  */
 @Slf4j
 public class App {
@@ -86,6 +88,13 @@ public static void main(String[] args) {
     LOGGER.info("--- Step 4: the replica is enough to enforce business rules ---");
     tryToOrder(orderService, "C-1", new BigDecimal("900.00"));
     tryToOrder(orderService, "C-2", new BigDecimal("10.00"));
+
+    LOGGER.info(
+        "--- Step 5: a new credit limit travels in the event and unblocks the rejected order ---");
+    customerService.restart();
+    customerService.changeCreditLimit("C-1", new BigDecimal("1500.00"));
+    logReplica(orderService, "C-1");
+    tryToOrder(orderService, "C-1", new BigDecimal("900.00"));
   }
 
   /**

event-carried-state-transfer/src/main/java/com/iluwatar/eventcarriedstatetransfer/CustomerReplica.java

@@ -24,7 +24,7 @@
  */
 package com.iluwatar.eventcarriedstatetransfer;
 
-import java.util.HashMap;
+import java.util.LinkedHashMap;
 import java.util.Map;
 import java.util.Optional;
 import lombok.extern.slf4j.Slf4j;
@@ -41,7 +41,7 @@
 @Slf4j
 public class CustomerReplica {
 
-  private final Map<String, CustomerState> customers = new HashMap<>();
+  private final Map<String, CustomerState> customers = new LinkedHashMap<>();
 
   /**
    * Applies an event to the replica.

event-carried-state-transfer/src/main/java/com/iluwatar/eventcarriedstatetransfer/CustomerService.java

@@ -119,6 +119,12 @@ public void shutdown() {
     LOGGER.warn("Customer service is going offline");
   }
 
+  /** Ends the outage: direct queries are answered again. */
+  public void restart() {
+    online = true;
+    LOGGER.info("Customer service is back online");
+  }
+
   /** Whether direct queries are currently answered. */
   public boolean isOnline() {
     return online;

event-carried-state-transfer/src/test/java/com/iluwatar/eventcarriedstatetransfer/CustomerServiceTest.java

@@ -100,4 +100,15 @@ void refusesDirectLookupsWhenOffline() {
     var thrown = assertThrows(IllegalStateException.class, () -> service.findCustomer("C-1"));
     assertEquals("customer service is offline", thrown.getMessage());
   }
+
+  @Test
+  void answersDirectLookupsAgainAfterARestart() {
+    service.register("C-1", "Alice", "Lisbon", new BigDecimal("500.00"));
+    service.shutdown();
+
+    service.restart();
+
+    assertTrue(service.isOnline());
+    assertEquals("Alice", service.findCustomer("C-1").orElseThrow().name());
+  }
 }

event-carried-state-transfer/src/test/java/com/iluwatar/eventcarriedstatetransfer/OrderServiceTest.java

@@ -91,6 +91,21 @@ void rejectsOrdersAboveTheReplicatedCreditLimit() {
     assertTrue(thrown.getMessage().contains("exceeds credit limit"));
   }
 
+  @Test
+  void acceptsOrdersOnceARaisedCreditLimitHasBeenReplicated() {
+    customerService.register("C-1", "Alice", "Lisbon", new BigDecimal("500.00"));
+    assertThrows(
+        OrderRejectedException.class,
+        () -> orderService.placeOrder("C-1", new BigDecimal("900.00")));
+
+    customerService.changeCreditLimit("C-1", new BigDecimal("1500.00"));
+
+    var order = orderService.placeOrder("C-1", new BigDecimal("900.00"));
+    assertEquals(new BigDecimal("900.00"), order.amount());
+    assertEquals(
+        new BigDecimal("1500.00"), orderService.replica().find("C-1").orElseThrow().creditLimit());
+  }
+
   @Test
   void acceptsOrdersExactlyAtTheCreditLimitAndNumbersThemSequentially() {
     customerService.register("C-1", "Alice", "Lisbon", new BigDecimal("500.00"));