Added test for cargo loaded onto wrong voyage, fixed a few uncovered bugs.

dddsample/tracking/core/src/main/java/se/citerus/dddsample/tracking/core/domain/model/cargo/Cargo.java

@@ -120,12 +120,6 @@ public class Cargo extends EntitySupport<Cargo,TrackingId> {
     return itinerary.activitySucceding(delivery.mostRecentPhysicalHandlingActivity());
   }
 
-  private boolean unloadedInCustomsClearancePoint() {
-    return mostRecentHandlingActivity() != null &&
-           mostRecentHandlingActivity().location().sameAs(customsClearancePoint()) &&
-           mostRecentHandlingActivity().type() == UNLOAD;
-  }
-
   /**
    * @return True if cargo is misdirected.
    */
@@ -162,6 +156,29 @@ public class Cargo extends EntitySupport<Cargo,TrackingId> {
   }
 
   /**
+   * Updates all aspects of the cargo aggregate status
+   * based on the current route specification, itinerary and handling of the cargo.
+   * <p/>
+   * When either of those three changes, i.e. when a new route is specified for the cargo,
+   * the cargo is assigned to a route or when the cargo is handled, the status must be
+   * re-calculated.
+   * <p/>
+   * {@link RouteSpecification} and {@link Itinerary} are both inside the Cargo
+   * aggregate, so changes to them cause the status to be updated <b>synchronously</b>,
+   * but handling cause the status update to happen <b>asynchronously</b>
+   * since {@link HandlingEvent} is in a different aggregate.
+   *
+   * @param handlingActivity handling activity
+   */
+  public void handled(final HandlingActivity handlingActivity) {
+    Validate.notNull(handlingActivity, "Handling activity is required");
+
+    if (succedsMostRecentActivity(handlingActivity)) {
+      this.delivery = delivery.onHandling(handlingActivity);
+    }
+  }
+
+  /**
    * Specifies a new route for this cargo.
    *
    * @param routeSpecification route specification.
@@ -222,10 +239,15 @@ public class Cargo extends EntitySupport<Cargo,TrackingId> {
     return delivery.mostRecentHandlingActivity();
   }
 
+  /**
+   * @return The earliest rerouting location.
+   * If the cargo is in port, it's the current location.
+   * If it's onboard a carrier it's the next arrival location.
+   */
   public Location earliestReroutingLocation() {
     if (isMisdirected()) {
       if (transportStatus() == ONBOARD_CARRIER) {
-        return currentVoyage().nextArrivalLocation(lastKnownLocation());
+        return currentVoyage().arrivalLocationAfterDepartureFrom(lastKnownLocation());
       } else {
         return lastKnownLocation();
       }
@@ -235,32 +257,14 @@ public class Cargo extends EntitySupport<Cargo,TrackingId> {
   }
 
   /**
-   * Updates all aspects of the cargo aggregate status
-   * based on the current route specification, itinerary and handling of the cargo.
-   * <p/>
-   * When either of those three changes, i.e. when a new route is specified for the cargo,
-   * the cargo is assigned to a route or when the cargo is handled, the status must be
-   * re-calculated.
-   * <p/>
-   * {@link RouteSpecification} and {@link Itinerary} are both inside the Cargo
-   * aggregate, so changes to them cause the status to be updated <b>synchronously</b>,
-   * but handling cause the status update to happen <b>asynchronously</b>
-   * since {@link HandlingEvent} is in a different aggregate.
-   *
-   * @param handlingActivity handling activity
+   * @param other itinerary
+   * @return An merge between the current itinerary and the provided itinerary
+   * that describes a continuous route even if the cargo is currently misdirected.
    */
-  public void handled(final HandlingActivity handlingActivity) {
-    Validate.notNull(handlingActivity, "Handling activity is required");
-
-    if (isSignificant(handlingActivity)) {
-      this.delivery = delivery.onHandling(handlingActivity);
-    }
-  }
-
   public Itinerary itineraryMergedWith(final Itinerary other) {
     if (isMisdirected() && transportStatus() == ONBOARD_CARRIER) {
       final Leg currentLeg = Leg.deriveLeg(
-        currentVoyage(), lastKnownLocation(), currentVoyage().nextArrivalLocation(lastKnownLocation())
+        currentVoyage(), lastKnownLocation(), currentVoyage().arrivalLocationAfterDepartureFrom(lastKnownLocation())
       );
 
       return this.itinerary().
@@ -274,10 +278,6 @@ public class Cargo extends EntitySupport<Cargo,TrackingId> {
     }
   }
 
-  private boolean isSignificant(final HandlingActivity newHandlingActivity) {
-    return succedsMostRecentActivity(newHandlingActivity);
-  }
-
   private boolean succedsMostRecentActivity(final HandlingActivity newHandlingActivity) {
     if (delivery.hasBeenHandled()) {
       final HandlingActivity priorActivity = itinerary.strictlyPriorOf(delivery.mostRecentPhysicalHandlingActivity(), newHandlingActivity);
@@ -287,6 +287,12 @@ public class Cargo extends EntitySupport<Cargo,TrackingId> {
     }
   }
 
+  private boolean unloadedInCustomsClearancePoint() {
+    return mostRecentHandlingActivity() != null &&
+           mostRecentHandlingActivity().location().sameAs(customsClearancePoint()) &&
+           mostRecentHandlingActivity().type() == UNLOAD;
+  }
+
   @Override
   public String toString() {
     return trackingId + " (" + routeSpecification + ")";

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

@@ -259,6 +259,7 @@ public class Itinerary extends ValueObjectSupport<Itinerary> {
 
   Itinerary withLeg(final Leg leg) {
     final List<Leg> newLegs = new ArrayList<Leg>(legs.size() + 1);
+    newLegs.addAll(legs);
     newLegs.add(leg);
 
     return new Itinerary(newLegs);

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

@@ -67,23 +67,11 @@ public class Voyage extends EntitySupport<Voyage,VoyageNumber> {
     this.schedule = new Schedule(carrierMovements);
   }
 
-  @Override
-  public String toString() {
-    return voyageNumber.stringValue();
-  }
-
-  Voyage() {
-    // Needed by Hibernate
-    voyageNumber = null;
-  }
 
-  public Location nextArrivalLocation(final Location location) {
-    for (Iterator<CarrierMovement> it = schedule.carrierMovements().iterator(); it.hasNext();) {
-      CarrierMovement carrierMovement = it.next();
-      if (carrierMovement.arrivalLocation().sameAs(location)) {
-        return location;
-      } else if (carrierMovement.departureLocation().sameAs(location)) {
-        return it.next().arrivalLocation();
+  public Location arrivalLocationAfterDepartureFrom(final Location departureLocation) {
+    for (CarrierMovement carrierMovement : schedule.carrierMovements()) {
+      if (carrierMovement.departureLocation().sameAs(departureLocation)) {
+        return carrierMovement.arrivalLocation();
       }
     }
 
@@ -105,6 +93,16 @@ public class Voyage extends EntitySupport<Voyage,VoyageNumber> {
 
     return unmodifiableList(locations);
   }
+  
+  @Override
+  public String toString() {
+    return voyageNumber.stringValue();
+  }
+
+  Voyage() {
+    // Needed by Hibernate
+    voyageNumber = null;
+  }
 
   /**
    * Builder pattern is used for incremental construction

dddsample/tracking/core/src/test/java/se/citerus/dddsample/tracking/core/domain/scenario/CargoLifecycle.java

@@ -114,6 +114,8 @@ public class CargoLifecycle {
     assertNull(cargo.nextExpectedActivity());
   }
 
+  // TODO misdirected cargo, loaded onto wrong voyage
+                                                      
   @Test
   public void cargoIsMisdirectedAndRerouted() throws Exception {
 
@@ -187,6 +189,88 @@ public class CargoLifecycle {
   }
 
   @Test
+  public void cargoIsLoadedOntoWrongVoyage() throws Exception {
+
+    Cargo cargo = setupCargoFromHongkongToStockholm();
+
+    // Initial state, before routing
+    assertThat(cargo.transportStatus(), is(NOT_RECEIVED));
+    assertThat(cargo.routingStatus(), is(NOT_ROUTED));
+    assertFalse(cargo.isMisdirected());
+    assertNull(cargo.estimatedTimeOfArrival());
+    assertNull(cargo.nextExpectedActivity());
+
+    // Route: Hongkong - Long Beach - New York - Stockholm
+    List<Itinerary> itineraries = routingService.fetchRoutesForSpecification(cargo.routeSpecification());
+    Itinerary itinerary = selectAppropriateRoute(itineraries);
+    cargo.assignToRoute(itinerary);
+
+    // Routed
+    assertThat(cargo.transportStatus(), is(NOT_RECEIVED));
+    assertThat(cargo.routingStatus(), is(ROUTED));
+    assertThat(cargo.nextExpectedActivity(), is(receiveIn(HONGKONG)));
+    assertThat(cargo.estimatedTimeOfArrival(), is(toDate("2009-03-26")));
+
+    // Received
+    cargo.handled(receiveIn(HONGKONG));
+
+    assertThat(cargo.transportStatus(), is(IN_PORT));
+    assertThat(cargo.lastKnownLocation(), is(HONGKONG));
+
+    // Loaded
+    cargo.handled(loadOnto(pacific1).in(HONGKONG));
+
+    assertThat(cargo.currentVoyage(), is(pacific1));
+    assertThat(cargo.lastKnownLocation(), is(HONGKONG));
+    assertThat(cargo.transportStatus(), is(ONBOARD_CARRIER));
+    assertThat(cargo.nextExpectedActivity(), is(unloadOff(pacific1).in(LONGBEACH)));
+    assertFalse(cargo.isMisdirected());
+
+    // Unload
+    cargo.handled(unloadOff(pacific1).in(LONGBEACH));
+    assertFalse(cargo.isMisdirected());
+    assertThat(cargo.lastKnownLocation(), is(LONGBEACH));
+    assertThat(cargo.transportStatus(), is(IN_PORT));
+    assertThat(cargo.nextExpectedActivity(), is(loadOnto(continental1).in(LONGBEACH)));
+
+    // Load onto wrong voyage
+    cargo.handled(loadOnto(pacific2).in(LONGBEACH));
+    assertTrue(cargo.isMisdirected());
+    assertThat(cargo.transportStatus(), is(ONBOARD_CARRIER));
+    assertNull(cargo.nextExpectedActivity());
+    assertNull(cargo.estimatedTimeOfArrival());
+
+    // Reroute: specify new route
+
+    assertThat(cargo.earliestReroutingLocation(), is(SEATTLE));
+
+    // Assign to new route
+    List<Itinerary> available = routingService.fetchRoutesForSpecification(
+      cargo.routeSpecification().withOrigin(cargo.earliestReroutingLocation())
+    );
+
+    Itinerary newItinerary = selectAppropriateRoute(available);
+
+    Itinerary mergedItinerary = cargo.itineraryMergedWith(newItinerary);
+    cargo.assignToRoute(mergedItinerary);
+
+    // No longer misdirected
+    assertFalse(cargo.isMisdirected());
+    assertThat(cargo.routingStatus(), is(ROUTED));
+    assertThat(cargo.nextExpectedActivity(), is(unloadOff(pacific2).in(SEATTLE)));
+
+    // Loaded
+    cargo.handled(unloadOff(pacific2).in(SEATTLE));
+
+    assertFalse(cargo.isMisdirected());
+    assertThat(cargo.lastKnownLocation(), is(SEATTLE));
+    assertThat(cargo.transportStatus(), is(IN_PORT));
+
+    // Etc
+  }
+
+
+  @Test
   public void customerRequestsChangeOfDestination() throws Exception {
     Cargo cargo = setupCargoFromHongkongToStockholm();