Expanded voyage rescheduling scenario test to include the case where a voyage is rescheduled so that the old itinerary is no longer maintainable, and modified the domain model to handle that case.

dddsample/src/main/java/se/citerus/dddsample/domain/model/cargo/Itinerary.java

@@ -131,7 +131,7 @@ public class Itinerary implements ValueObject<Itinerary> {
   /**
    * @return The first leg on the itinerary.
    */
-  Leg firstLeg() {
+  public Leg firstLeg() {
     if (isEmpty()) return null;
     return legs.get(0);
   }
@@ -139,7 +139,7 @@ public class Itinerary implements ValueObject<Itinerary> {
   /**
    * @return The last leg on the itinerary.
    */
-  Leg lastLeg() {
+  public Leg lastLeg() {
     if (isEmpty()) return null;
     return legs.get(legs.size() - 1);
   }
@@ -151,19 +151,30 @@ public class Itinerary implements ValueObject<Itinerary> {
   public Itinerary withRescheduledVoyage(final Voyage rescheduledVoyage) {
     final List<Leg> newLegsList = new ArrayList<Leg>(this.legs.size());
 
+    Leg lastAdded = null;
     for (Leg leg : this.legs) {
       if (leg.voyage().sameIdentityAs(rescheduledVoyage)) {
-        newLegsList.add(leg.withRescheduledVoyage(rescheduledVoyage));
+        Leg modifiedLeg = leg.withRescheduledVoyage(rescheduledVoyage);
+        // This truncates the itinerary if the voyage rescheduling makes
+        // it impossible to maintain the old unload-load chain.
+        if (lastAdded != null && modifiedLeg.loadTime().before(lastAdded.unloadTime())) {
+          break;
+        }
+        newLegsList.add(modifiedLeg);
       } else {
         newLegsList.add(leg);
       }
+      lastAdded = leg;
     }
 
     return new Itinerary(newLegsList);
   }
 
+  /**
+   * @return A list of all locations on this itinerary.
+   */
   public List<Location> locations() {
-    List<Location> result = new ArrayList<Location>();
+    final List<Location> result = new ArrayList<Location>();
     result.add(firstLeg().loadLocation());
     for (Leg leg : legs) {
       result.add(leg.unloadLocation());
@@ -172,6 +183,33 @@ public class Itinerary implements ValueObject<Itinerary> {
   }
 
   /**
+   * @param location a location
+   * @return Load time at this location, or null if the location isn't on this itinerary.
+   */
+  public Date loadTimeAt(final Location location) {
+    for (Leg leg : legs) {
+      if (leg.loadLocation().sameIdentityAs(location)) {
+        return leg.loadTime();
+      }
+    }
+    return null;
+  }
+
+  /**
+   * @param location a location
+   * @return Unload time at this location, or null if the location isn't on this itinerary.
+   */
+  public Date unloadTimeAt(final Location location) {
+    for (Leg leg : legs) {
+      if (leg.unloadLocation().sameIdentityAs(location)) {
+        return leg.unloadTime();
+      }
+    }
+    return null;
+  }
+
+
+  /**
    * @param other itinerary to compare
    * @return <code>true</code> if the legs in this and the other itinerary are all equal.
    */

dddsample/src/main/java/se/citerus/dddsample/domain/model/cargo/Leg.java

@@ -20,9 +20,14 @@ public class Leg implements ValueObject<Leg> {
   private Date loadTime;
   private Date unloadTime;
 
-  // TODO remove this ctor
+  // TODO hide this, use factory
   public Leg(Voyage voyage, Location loadLocation, Location unloadLocation, Date loadTime, Date unloadTime) {
-    Validate.noNullElements(new Object[]{voyage, loadLocation, unloadLocation, loadTime, unloadTime});
+    Validate.notNull(voyage, "Voyage is required");
+    Validate.notNull(loadLocation, "Load location is required");
+    Validate.notNull(unloadLocation, "Unload location is required");
+    Validate.isTrue(!loadLocation.sameIdentityAs(unloadLocation));
+    // TODO use a minimum time between unloading and loading?
+    Validate.isTrue(unloadTime.after(loadTime));
 
     this.voyage = voyage;
     this.loadLocation = loadLocation;
@@ -47,10 +52,6 @@ public class Leg implements ValueObject<Leg> {
    * @return A leg on this voyage between the given locations.
    */
   public static Leg deriveLeg(Voyage voyage, Location loadLocation, Location unloadLocation) {
-    Validate.notNull(voyage, "Voyage is required");
-    Validate.notNull(loadLocation, "Load location is required");
-    Validate.notNull(unloadLocation, "Unload location is required");
-    Validate.isTrue(!loadLocation.sameIdentityAs(unloadLocation));
     return new Leg(voyage, loadLocation, unloadLocation, voyage.schedule().departureTimeAt(loadLocation), voyage.schedule().arrivalTimeAt(unloadLocation));
   }
 

dddsample/src/main/java/se/citerus/dddsample/domain/model/voyage/Voyage.java

@@ -48,6 +48,8 @@ public class Voyage implements Entity<Voyage> {
    * @param newDepartureTime new departure time
    */
   public void departureRescheduled(final Location location, final Date newDepartureTime) {
+    // TODO Change departure/arrival by diffs instead of absolute times
+
     final int size = schedule.carrierMovements().size();
     final List<CarrierMovement> carrierMovements = new ArrayList<CarrierMovement>(size);
 

dddsample/src/test/java/se/citerus/dddsample/scenario/VoyageRescheduledScenarioTest.java

@@ -6,43 +6,96 @@
  */
 package se.citerus.dddsample.scenario;
 
-import junit.framework.TestCase;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.is;
+import org.junit.Before;
+import org.junit.Test;
 import static se.citerus.dddsample.application.util.DateTestUtil.toDate;
+import se.citerus.dddsample.domain.model.cargo.Cargo;
+import se.citerus.dddsample.domain.model.cargo.CargoFactory;
 import se.citerus.dddsample.domain.model.cargo.Itinerary;
 import se.citerus.dddsample.domain.model.cargo.Leg;
+import static se.citerus.dddsample.domain.model.cargo.RoutingStatus.MISROUTED;
+import static se.citerus.dddsample.domain.model.cargo.RoutingStatus.ROUTED;
 import static se.citerus.dddsample.domain.model.location.SampleLocations.*;
 import static se.citerus.dddsample.domain.model.voyage.SampleVoyages.*;
 import se.citerus.dddsample.domain.model.voyage.Voyage;
 import se.citerus.dddsample.domain.model.voyage.VoyageNumber;
+import se.citerus.dddsample.infrastructure.persistence.inmemory.CargoRepositoryInMem;
+import se.citerus.dddsample.infrastructure.persistence.inmemory.LocationRepositoryInMem;
 
 import java.util.Date;
 
-public class VoyageRescheduledScenarioTest extends TestCase {
+public class VoyageRescheduledScenarioTest {
 
-  public void testVoyageRescheduled() throws Exception {
-    // Creating new voyages to avoid rescheduling shared ones, breaking other tests
-    Voyage voyage1 = new Voyage(new VoyageNumber("V1"), HONGKONG_TO_NEW_YORK.schedule());
-    Voyage voyage2 = new Voyage(new VoyageNumber("V2"), NEW_YORK_TO_DALLAS.schedule());
-    Voyage voyage3 = new Voyage(new VoyageNumber("V3"), DALLAS_TO_HELSINKI.schedule());
+  Cargo cargo;
+  Voyage voyage1;
+  Voyage voyage2;
+  Voyage voyage3;
 
+  @Before
+  public void setupCargo() {
+    // Creating new voyages to avoid rescheduling shared ones, breaking other tests
+    voyage1 = new Voyage(new VoyageNumber("V1"), HONGKONG_TO_NEW_YORK.schedule());
+    voyage2 = new Voyage(new VoyageNumber("V2"), NEW_YORK_TO_DALLAS.schedule());
+    voyage3 = new Voyage(new VoyageNumber("V3"), DALLAS_TO_HELSINKI.schedule());
+    CargoFactory cargoFactory = new CargoFactory(new CargoRepositoryInMem(), new LocationRepositoryInMem());
+    cargo = cargoFactory.newCargo(HANGZOU.unLocode(), STOCKHOLM.unLocode(), toDate("2008-12-23"));
     Itinerary itinerary = new Itinerary(
       Leg.deriveLeg(voyage1, HANGZOU, NEWYORK),
       Leg.deriveLeg(voyage2, NEWYORK, DALLAS),
       Leg.deriveLeg(voyage3, DALLAS, STOCKHOLM)
     );
+    cargo.assignToRoute(itinerary);
+  }
+
+  @Test
+  public void voyageIsRescheduledWithMaintainableRoute() {
+    assertThat(cargo.delivery().routingStatus(), is(ROUTED));
 
     Date oldDepartureTime = toDate("2008-10-24", "07:00");
 
-    assertEquals(itinerary.legs().get(1).loadTime(), oldDepartureTime);
-    assertEquals(voyage2.schedule().carrierMovements().get(0).departureTime(), oldDepartureTime);
+    assertThat(voyage2.schedule().departureTimeAt(NEWYORK), is(oldDepartureTime));
+    assertThat(cargo.itinerary().loadTimeAt(NEWYORK), is(oldDepartureTime));
 
+    // Now voyage2 is rescheduled, the departure from NYC is delayed a few hours.
     Date newDepartureTime = toDate("2008-10-24", "18:00");
+    voyage2.departureRescheduled(NEWYORK, newDepartureTime);
+
+    // The schedule of voyage2 is updated
+    assertThat(voyage2.schedule().departureTimeAt(NEWYORK), is(newDepartureTime));
+    // ...but the cargo itinerary still has the old departure time
+    assertThat(cargo.itinerary().loadTimeAt(NEWYORK), is(oldDepartureTime));
 
+    // Generate a new itinerary from the old one and assign the cargo to this route
+    Itinerary newItinerary = cargo.itinerary().withRescheduledVoyage(voyage2);
+    cargo.assignToRoute(newItinerary);
+
+    // Now the cargo aggregate is updated to reflect the scheduling change!
+    assertThat(cargo.itinerary().loadTimeAt(NEWYORK), is(newDepartureTime));
+    assertThat(cargo.delivery().routingStatus(), is(ROUTED));
+  }
+
+  @Test
+  public void voyageIsRescheduledWithUnmaintainableRoute() {
+    assertThat(cargo.delivery().routingStatus(), is(ROUTED));
+
+    // Voyage1 arrives in NYC at 2008-10-23 23:10
+    // Now rescheduling the departure of voyage2 to BEFORE
+    // voyage1 arrives in NYC. This makes it impossible to
+    // keep the latter part of the old itinerary, and the new itinerary
+    // is therefore truncated after unload in NYC.
+
+    Date newDepartureTime = toDate("2008-10-23", "18:30");
     voyage2.departureRescheduled(NEWYORK, newDepartureTime);
-    Itinerary newItinerary = itinerary.withRescheduledVoyage(voyage2);
 
-    assertEquals(voyage2.schedule().carrierMovements().get(0).departureTime(), newDepartureTime);
-    assertEquals(newItinerary.legs().get(1).loadTime(), newDepartureTime);
+    // Only the part of the itinerary up to and including NYC is maintainable, the rest is truncated
+    Itinerary truncatedItinerary = cargo.itinerary().withRescheduledVoyage(voyage2);
+    assertThat(truncatedItinerary.lastLeg().unloadLocation(), is(NEWYORK));
+
+    // The cargo enters MISROUTED state
+    cargo.assignToRoute(truncatedItinerary);
+    assertThat(cargo.delivery().routingStatus(), is(MISROUTED));
   }
 
 }