Moved all aspects of the cargo delivery into the Delivery class

dddsample/src/main/java/se/citerus/dddsample/application/impl/CargoInspectionServiceImpl.java

@@ -42,11 +42,11 @@ public class CargoInspectionServiceImpl implements CargoInspectionService {
 
     cargo.deriveDeliveryProgress(handlingHistory);
 
-    if (cargo.isMisdirected()) {
+    if (cargo.delivery().isMisdirected()) {
       applicationEvents.cargoWasMisdirected(cargo);
     }
 
-    if (cargo.isUnloadedAtDestination()) {
+    if (cargo.delivery().isUnloadedAtDestination()) {
       applicationEvents.cargoHasArrived(cargo);
     }
 

dddsample/src/main/java/se/citerus/dddsample/application/util/SampleDataGenerator.java

@@ -132,16 +132,16 @@ public class SampleDataGenerator implements ServletContextListener {
 
   private static void loadCargoData(JdbcTemplate jdbcTemplate) {
     String cargoSql =
-      "insert into Cargo (id, tracking_id, origin_id, spec_origin_id, spec_destination_id, spec_arrival_deadline, transport_status, current_voyage_id, last_known_location_id, is_misdirected, routing_status) " +
-      "values (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)";
+      "insert into Cargo (id, tracking_id, origin_id, spec_origin_id, spec_destination_id, spec_arrival_deadline, transport_status, current_voyage_id, last_known_location_id, is_misdirected, routing_status, calculated_at, unloaded_at_dest) " +
+      "values (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)";
 
     Object[][] cargoArgs = {
-      {1, "XYZ", 1, 1, 2, ts(10), "IN_PORT", null, 1, false, "ROUTED"},
-      {2, "ABC", 1, 1, 5, ts(20), "IN_PORT", null, 1, false, "ROUTED"},
-      {3, "ZYX", 2, 2, 1, ts(30), "IN_PORT", null, 1, false, "NOT_ROUTED"},
-      {4, "CBA", 5, 5, 1, ts(40), "IN_PORT", null, 1, false, "MISROUTED"},
-      {5, "FGH", 1, 3, 5, ts(50), "IN_PORT", null, 1, false, "ROUTED"},  // Cargo origin differs from spec origin
-      {6, "JKL", 6, 6, 4, ts(60), "IN_PORT", null, 1, true, "ROUTED"}
+      {1, "XYZ", 1, 1, 2, ts(10), "IN_PORT", null, 1, false, "ROUTED", ts(100), false},
+      {2, "ABC", 1, 1, 5, ts(20), "IN_PORT", null, 1, false, "ROUTED", ts(100), false},
+      {3, "ZYX", 2, 2, 1, ts(30), "IN_PORT", null, 1, false, "NOT_ROUTED", ts(100), false},
+      {4, "CBA", 5, 5, 1, ts(40), "IN_PORT", null, 1, false, "MISROUTED", ts(100), false},
+      {5, "FGH", 1, 3, 5, ts(50), "IN_PORT", null, 1, false, "ROUTED", ts(100), false},  // Cargo origin differs from spec origin
+      {6, "JKL", 6, 6, 4, ts(60), "IN_PORT", null, 1, true, "ROUTED", ts(100), false}
     };
     executeUpdate(jdbcTemplate, cargoSql, cargoArgs);
   }
@@ -295,7 +295,7 @@ public class SampleDataGenerator implements ServletContextListener {
           throw new RuntimeException(e);
         }
 
-        HandlingHistory handlingHistory1 = handlingEventRepository.lookupHandlingHistoryOfCargo(trackingId);
+        HandlingHistory handlingHistory1 = handlingEventRepository.lookupHandlingHistoryOfCargo(trackingId1);
         jkl567.deriveDeliveryProgress(handlingHistory1);
 
         session.update(jkl567);

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

@@ -2,16 +2,11 @@ package se.citerus.dddsample.domain.model.cargo;
 
 import org.apache.commons.lang.Validate;
 import se.citerus.dddsample.domain.model.Entity;
-import static se.citerus.dddsample.domain.model.cargo.RoutingStatus.*;
 import se.citerus.dddsample.domain.model.handling.HandlingEvent;
-import static se.citerus.dddsample.domain.model.handling.HandlingEvent.Type.*;
 import se.citerus.dddsample.domain.model.handling.HandlingHistory;
 import se.citerus.dddsample.domain.model.location.Location;
 import se.citerus.dddsample.domain.shared.DomainObjectUtils;
 
-import java.util.Date;
-import java.util.Iterator;
-
 /**
  * A Cargo. This is the central class in the domain model,
  * and it is the root of the Cargo-Itinerary-Leg-Delivery-RouteSpecification aggregate.
@@ -32,11 +27,19 @@ import java.util.Iterator;
  * It may also happen that a cargo is accidentally misrouted, which should notify the proper
  * personnel and also trigger a re-routing procedure.
  *
+ * When a cargo is handled, the status of the delivery changes. Everything about the delivery
+ * of the cargo is contained in the Delivery value object, which is replaced whenever a cargo
+ * is handled by an asynchronous event triggered by the registration of the handling event.
+ *
+ * The delivery can also be affected by routing changes, i.e. when a the route specification
+ * changes, or the cargo is assigned to a new route. In that case, the delivery update is performed
+ * synchronously within the cargo aggregate.
+ *
  * The life cycle of a cargo ends when the cargo is claimed by the customer.
  *
  * The cargo aggregate, and the entre domain model, is built to solve the problem
  * of booking and tracking cargo. All important business rules for determining whether
- * or not a cargo is misrouted, what the current status of the cargo is (on board carrier,
+ * or not a cargo is misdirected, what the current status of the cargo is (on board carrier,
  * in port etc), are captured in this aggregate.
  *
  */
@@ -44,19 +47,12 @@ public class Cargo implements Entity<Cargo> {
 
   private TrackingId trackingId;
   private Location origin;
+  private RouteSpecification routeSpecification;
   private Itinerary itinerary;
   private Delivery delivery;
-  private RouteSpecification routeSpecification;
-  private RoutingStatus routingStatus;
-  private HandlingActivity nextExpectedActivity;
-  private boolean misdirected;
-  private Date eta;
-  
-  private static final Date ETA_UNKOWN = null;
-  private static final HandlingActivity NO_ACTIVITY = null;
 
   public Cargo(final TrackingId trackingId, final RouteSpecification routeSpecification) {
-    Validate.notNull(trackingId, "Tracking id is required");
+    Validate.notNull(trackingId, "Tracking ID is required");
     Validate.notNull(routeSpecification, "Route specification is required");
 
     this.trackingId = trackingId;
@@ -65,7 +61,7 @@ public class Cargo implements Entity<Cargo> {
     this.origin = routeSpecification.origin();
     this.routeSpecification = routeSpecification;
 
-    deriveDeliveryProgress(HandlingHistory.EMPTY);
+    this.delivery = Delivery.derivedFrom(this.routeSpecification, this.itinerary, HandlingHistory.EMPTY);
   }
 
   /**
@@ -74,7 +70,7 @@ public class Cargo implements Entity<Cargo> {
    * @return Tracking id.
    */
   public TrackingId trackingId() {
-    return this.trackingId;
+    return trackingId;
   }
 
   /**
@@ -88,7 +84,7 @@ public class Cargo implements Entity<Cargo> {
    * @return The delivery. Never null.
    */
   public Delivery delivery() {
-    return DomainObjectUtils.nullSafe(this.delivery, Delivery.EMPTY_DELIVERY);
+    return delivery;
   }
 
   /**
@@ -115,7 +111,7 @@ public class Cargo implements Entity<Cargo> {
 
     this.routeSpecification = routeSpecification;
     // Handling consistency within the Cargo aggregate synchronously
-    this.routingStatus = deriveRoutingStatus();
+    this.delivery = delivery.updateOnRouting(this.routeSpecification, this.itinerary);
   }
 
   /**
@@ -128,60 +124,7 @@ public class Cargo implements Entity<Cargo> {
 
     this.itinerary = itinerary;
     // Handling consistency within the Cargo aggregate synchronously
-    this.routingStatus = deriveRoutingStatus();
-    this.misdirected = deriveMisdirectionStatus();
-    this.nextExpectedActivity = deriveNextExpectedActivity();
-    this.eta = deriveEta();
-  }
-
-  /**
-   * Check if cargo is misdirected.
-   * <p/>
-   * <ul>
-   * <li>A cargo is misdirected if it is in a location that's not in the itinerary.
-   * <li>A cargo with no itinerary can not be misdirected.
-   * <li>A cargo that has received no handling events can not be misdirected.
-   * </ul>
-   *
-   * @return <code>true</code> if the cargo has been misdirected,
-   */
-  public boolean isMisdirected() {
-    return misdirected;
-  }
-
-  /**
-   * @return Routing status.
-   */
-  public RoutingStatus routingStatus() {
-    return routingStatus;
-  }
-
-  /**
-   * @return True if the cargo has been unloaded at the final destination.
-   */
-  public boolean isUnloadedAtDestination() {
-    final HandlingEvent lastEvent = delivery.lastEvent();
-    return lastEvent != null &&
-      UNLOAD.sameValueAs(lastEvent.type()) &&
-      routeSpecification.destination().sameIdentityAs(lastEvent.location());
-  }
-
-  /**
-   * @return estimated time of arrival
-   */
-  public Date estimatedTimeOfArrival() {
-    if (eta != ETA_UNKOWN) {
-      return new Date(eta.getTime());
-    } else {
-      return ETA_UNKOWN;
-    }
-  }
-
-  /**
-   * @return the next expected activity
-   */
-  public HandlingActivity nextExpectedActivity() {
-    return nextExpectedActivity;
+    this.delivery = delivery.updateOnRouting(this.routeSpecification, this.itinerary);
   }
 
   /**
@@ -202,102 +145,9 @@ public class Cargo implements Entity<Cargo> {
   public void deriveDeliveryProgress(final HandlingHistory handlingHistory) {
     // Delivery is a value object, so we can simply discard the old one
     // and replace it with a new
-    this.delivery = Delivery.derivedFrom(handlingHistory);
-    this.routingStatus = deriveRoutingStatus();
-    this.misdirected = deriveMisdirectionStatus();
-    this.eta = deriveEta();
-    this.nextExpectedActivity = deriveNextExpectedActivity();
+    this.delivery = Delivery.derivedFrom(routeSpecification(), itinerary(), handlingHistory);
   }
 
-  /**
-   *
-   * @return true if this cargo is misdirected.
-   */
-  private boolean deriveMisdirectionStatus() {
-    final HandlingEvent lastEvent = delivery().lastEvent();
-    if (lastEvent == null) {
-      return false;
-    } else {
-      return !itinerary().isExpected(lastEvent);
-    }
-  }
-
-  /**
-   * @return current routing status
-   */
-  private RoutingStatus deriveRoutingStatus() {
-    if (itinerary == null) {
-      return NOT_ROUTED;
-    } else {
-      if (routeSpecification.isSatisfiedBy(itinerary)) {
-        return ROUTED;
-      } else {
-        return MISROUTED;
-      }
-    }
-  }
-
-  /**
-   * @return estimated time of arrival, or null if unknown
-   */
-  private Date deriveEta() {
-    if (onTrack()) {
-      return itinerary().finalArrivalDate();
-    } else {
-      return ETA_UNKOWN;
-    }
-  }
-
-  private HandlingActivity deriveNextExpectedActivity() {
-    if (!onTrack()) return NO_ACTIVITY;
-
-    final HandlingEvent lastEvent = delivery().lastEvent();
-
-    if (lastEvent == null) return new HandlingActivity(RECEIVE, origin());
-
-    switch (lastEvent.type()) {
-
-      case LOAD:
-        for (Leg leg : itinerary().legs()) {
-          if (leg.loadLocation().sameIdentityAs(lastEvent.location())) {
-            return new HandlingActivity(UNLOAD, leg.unloadLocation(), leg.voyage());
-          }
-        }
-
-        return NO_ACTIVITY;
-
-      case UNLOAD:
-        for (Iterator<Leg> it = itinerary().legs().iterator(); it.hasNext();) {
-          final Leg leg = it.next();
-          if (leg.unloadLocation().sameIdentityAs(lastEvent.location())) {
-            if (it.hasNext()) {
-              final Leg nextLeg = it.next();
-              return new HandlingActivity(LOAD, nextLeg.loadLocation(), nextLeg.voyage());
-            } else {
-              return new HandlingActivity(CLAIM, leg.unloadLocation());
-            }
-          }
-        }
-
-        return NO_ACTIVITY;
-
-      case RECEIVE:
-        final Leg firstLeg = itinerary().legs().iterator().next();
-        return new HandlingActivity(LOAD, firstLeg.loadLocation(), firstLeg.voyage());
-
-      case CLAIM:
-      default:
-        return NO_ACTIVITY;
-    }
-  }
-
-  /**
-   * @return true if cargo is on track, i.e. routed and not misdirected
-   */
-  private boolean onTrack() {
-    return routingStatus.equals(ROUTED) && !misdirected;
-  }
-  
   @Override
   public boolean sameIdentityAs(final Cargo other) {
     return other != null && trackingId.sameValueAs(other.trackingId);

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

@@ -4,6 +4,7 @@ import org.apache.commons.lang.Validate;
 import org.apache.commons.lang.builder.EqualsBuilder;
 import org.apache.commons.lang.builder.HashCodeBuilder;
 import se.citerus.dddsample.domain.model.ValueObject;
+import static se.citerus.dddsample.domain.model.cargo.RoutingStatus.*;
 import static se.citerus.dddsample.domain.model.cargo.TransportStatus.*;
 import se.citerus.dddsample.domain.model.handling.HandlingEvent;
 import se.citerus.dddsample.domain.model.handling.HandlingHistory;
@@ -11,6 +12,9 @@ import se.citerus.dddsample.domain.model.location.Location;
 import se.citerus.dddsample.domain.model.voyage.Voyage;
 import se.citerus.dddsample.domain.shared.DomainObjectUtils;
 
+import java.util.Date;
+import java.util.Iterator;
+
 /**
  * The actual transportation of the cargo, as opposed to
  * the customer requirement (RouteSpecification) and the plan (Itinerary). 
@@ -18,15 +22,72 @@ import se.citerus.dddsample.domain.shared.DomainObjectUtils;
  */
 public class Delivery implements ValueObject<Delivery> {
 
-  public static final Delivery EMPTY_DELIVERY = Delivery.derivedFrom(HandlingHistory.EMPTY);
-
   private TransportStatus transportStatus;
   private Location lastKnownLocation;
   private Voyage currentVoyage;
+  private boolean misdirected;
+  private Date eta;
+  private HandlingActivity nextExpectedActivity;
+  private boolean isUnloadedAtDestination;
+  private RoutingStatus routingStatus;
+  private Date calculatedAt;
   private HandlingEvent lastEvent;
 
-  private Delivery(HandlingEvent lastEvent) {
+  private static final Date ETA_UNKOWN = null;
+  private static final HandlingActivity NO_ACTIVITY = null;
+
+  /**
+   * Creates a new delivery snapshot to reflect changes in routing, i.e.
+   * when the route specification or the itinerary has changed
+   * but no additional handling of the cargo has been performed.
+   *
+   * @param routeSpecification route specification
+   * @param itinerary itinerary
+   * @return An up to date delivery
+   */
+  Delivery updateOnRouting(RouteSpecification routeSpecification, Itinerary itinerary) {
+    Validate.notNull(routeSpecification, "Route specification is required");
+
+    return new Delivery(this.lastEvent, itinerary, routeSpecification);
+  }
+
+  /**
+   * Creates a new delivery snapshot based on the complete handling history of a cargo,
+   * as well as its route specification and itinerary.
+   *
+   * @param routeSpecification route specification
+   * @param itinerary itinerary
+   * @param handlingHistory delivery history
+   * @return An up to date delivery.
+   */
+  static Delivery derivedFrom(RouteSpecification routeSpecification, Itinerary itinerary, HandlingHistory handlingHistory) {
+    Validate.notNull(routeSpecification, "Route specification is required");
+    Validate.notNull(handlingHistory, "Delivery history is required");
+
+    final HandlingEvent lastEvent = handlingHistory.mostRecentlyCompletedEvent();
+
+    return new Delivery(lastEvent, itinerary, routeSpecification);
+  }
+
+  /**
+   * Internal constructor.
+   *
+   * @param lastEvent last event
+   * @param itinerary itinerary
+   * @param routeSpecification route specification
+   */
+  private Delivery(HandlingEvent lastEvent, Itinerary itinerary, RouteSpecification routeSpecification) {
+    this.calculatedAt = new Date();
     this.lastEvent = lastEvent;
+
+    this.misdirected = calculateMisdirectionStatus(itinerary);
+    this.routingStatus = calculateRoutingStatus(itinerary, routeSpecification);
+    this.transportStatus = calculateTransportStatus();
+    this.lastKnownLocation = calculateLastKnownLocation();
+    this.currentVoyage = calculateCurrentVoyage();
+    this.eta = calculateEta(itinerary);
+    this.nextExpectedActivity = calculateNextExpectedActivity(routeSpecification, itinerary);
+    this.isUnloadedAtDestination = calculateUnloadedAtDestination(routeSpecification);
   }
 
   /**
@@ -51,81 +112,197 @@ public class Delivery implements ValueObject<Delivery> {
   }
 
   /**
-   * @param handlingHistory delivery history
-   * @return An up to date Delivery derived from this collection of handling events.
+   * Check if cargo is misdirected.
+   * <p/>
+   * <ul>
+   * <li>A cargo is misdirected if it is in a location that's not in the itinerary.
+   * <li>A cargo with no itinerary can not be misdirected.
+   * <li>A cargo that has received no handling events can not be misdirected.
+   * </ul>
+   *
+   * @return <code>true</code> if the cargo has been misdirected,
    */
-  static Delivery derivedFrom(HandlingHistory handlingHistory) {
-    Validate.notNull(handlingHistory, "Delivery history is required");
-    
-    final Delivery delivery = new Delivery(
-      handlingHistory.mostRecentlyCompletedEvent()
-    );
-    delivery.calculateTransportStatus();
-    delivery.calculateLastKnownLocation();
-    delivery.calculateCurrentVoyage();
-    return delivery;
+  public boolean isMisdirected() {
+    return misdirected;
   }
 
   /**
-   * @return The last event of the delivery history, or null is history is empty.
+   * @return Estimated time of arrival
    */
-  HandlingEvent lastEvent() {
-    return lastEvent;
+  public Date estimatedTimeOfArrival() {
+    if (eta != ETA_UNKOWN) {
+      return new Date(eta.getTime());
+    } else {
+      return ETA_UNKOWN;
+    }
+  }
+
+  /**
+   * @return The next expected handling activity.
+   */
+  public HandlingActivity nextExpectedActivity() {
+    return nextExpectedActivity;
+  }
+
+  /**
+   * @return True if the cargo has been unloaded at the final destination.
+   */
+  public boolean isUnloadedAtDestination() {
+    return isUnloadedAtDestination;
   }
 
-  private void calculateTransportStatus() {
+  /**
+   * @return Routing status.
+   */
+  public RoutingStatus routingStatus() {
+    return routingStatus;
+  }
+
+  /**
+   * @return When this delivery was calculated.
+   */
+  public Date calculatedAt() {
+    return new Date(calculatedAt.getTime());
+  }
+
+  // TODO add currentCarrierMovement (?)
+
+
+  // --- Internal calculations below ---
+
+
+  private TransportStatus calculateTransportStatus() {
     if (lastEvent == null) {
-      transportStatus = NOT_RECEIVED;
-      return;
+      return NOT_RECEIVED;
     }
 
     switch (lastEvent.type()) {
       case LOAD:
-        transportStatus = ONBOARD_CARRIER;
-        break;
+        return ONBOARD_CARRIER;
       case UNLOAD:
       case RECEIVE:
       case CUSTOMS:
-        transportStatus = IN_PORT;
-        break;
+        return IN_PORT;
       case CLAIM:
-        transportStatus = CLAIMED;
-        break;
+        return CLAIMED;
       default:
-        transportStatus = UNKNOWN;
+        return UNKNOWN;
     }
   }
 
-  private void calculateLastKnownLocation() {
+  private Location calculateLastKnownLocation() {
     if (lastEvent != null) {
-      lastKnownLocation = lastEvent.location();
+      return lastEvent.location();
     } else {
-      lastKnownLocation = null;
+      return null;
     }
   }
 
-  // TODO add currentCarrierMovement (?)
-
-  private void calculateCurrentVoyage() {
+  private Voyage calculateCurrentVoyage() {
     if (transportStatus().equals(ONBOARD_CARRIER) && lastEvent != null) {
-      currentVoyage = lastEvent.voyage();
+      return lastEvent.voyage();
+    } else {
+      return null;
+    }
+  }
+
+  private boolean calculateMisdirectionStatus(Itinerary itinerary) {
+    if (lastEvent == null) {
+      return false;
+    } else {
+      return !itinerary.isExpected(lastEvent);
+    }
+  }
+
+  private Date calculateEta(Itinerary itinerary) {
+    if (onTrack()) {
+      return itinerary.finalArrivalDate();
+    } else {
+      return ETA_UNKOWN;
+    }
+  }
+
+  private HandlingActivity calculateNextExpectedActivity(RouteSpecification routeSpecification, Itinerary itinerary) {
+    if (!onTrack()) return NO_ACTIVITY;
+
+    if (lastEvent == null) return new HandlingActivity(HandlingEvent.Type.RECEIVE, routeSpecification.origin());
+
+    switch (lastEvent.type()) {
+
+      case LOAD:
+        for (Leg leg : itinerary.legs()) {
+          if (leg.loadLocation().sameIdentityAs(lastEvent.location())) {
+            return new HandlingActivity(HandlingEvent.Type.UNLOAD, leg.unloadLocation(), leg.voyage());
+          }
+        }
+
+        return NO_ACTIVITY;
+
+      case UNLOAD:
+        for (Iterator<Leg> it = itinerary.legs().iterator(); it.hasNext();) {
+          final Leg leg = it.next();
+          if (leg.unloadLocation().sameIdentityAs(lastEvent.location())) {
+            if (it.hasNext()) {
+              final Leg nextLeg = it.next();
+              return new HandlingActivity(HandlingEvent.Type.LOAD, nextLeg.loadLocation(), nextLeg.voyage());
+            } else {
+              return new HandlingActivity(HandlingEvent.Type.CLAIM, leg.unloadLocation());
+            }
+          }
+        }
+
+        return NO_ACTIVITY;
+
+      case RECEIVE:
+        final Leg firstLeg = itinerary.legs().iterator().next();
+        return new HandlingActivity(HandlingEvent.Type.LOAD, firstLeg.loadLocation(), firstLeg.voyage());
+
+      case CLAIM:
+      default:
+        return NO_ACTIVITY;
+    }
+  }
+
+  private RoutingStatus calculateRoutingStatus(Itinerary itinerary, RouteSpecification routeSpecification) {
+    if (itinerary == null) {
+      return NOT_ROUTED;
     } else {
-      currentVoyage = null;
+      if (routeSpecification.isSatisfiedBy(itinerary)) {
+        return ROUTED;
+      } else {
+        return MISROUTED;
+      }
     }
   }
 
+  private boolean calculateUnloadedAtDestination(RouteSpecification routeSpecification) {
+    return lastEvent != null &&
+      HandlingEvent.Type.UNLOAD.sameValueAs(lastEvent.type()) &&
+      routeSpecification.destination().sameIdentityAs(lastEvent.location());
+  }
+
+  private boolean onTrack() {
+    return routingStatus.equals(ROUTED) && !misdirected;
+  }
+
   @Override
-  public boolean sameValueAs(Delivery other) {
+  public boolean sameValueAs(final Delivery other) {
     return other != null && new EqualsBuilder().
       append(this.transportStatus, other.transportStatus).
       append(this.lastKnownLocation, other.lastKnownLocation).
       append(this.currentVoyage, other.currentVoyage).
+      append(this.misdirected, other.misdirected).
+      append(this.eta, other.eta).
+      append(this.nextExpectedActivity, other.nextExpectedActivity).
+      append(this.isUnloadedAtDestination, other.isUnloadedAtDestination).
+      append(this.routingStatus, other.routingStatus).
+      append(this.calculatedAt, other.calculatedAt).
       append(this.lastEvent, other.lastEvent).
       isEquals();
   }
 
   @Override
-  public boolean equals(Object o) {
+  public boolean equals(final Object o) {
     if (this == o) return true;
     if (o == null || getClass() != o.getClass()) return false;
 
@@ -140,6 +317,12 @@ public class Delivery implements ValueObject<Delivery> {
       append(transportStatus).
       append(lastKnownLocation).
       append(currentVoyage).
+      append(misdirected).
+      append(eta).
+      append(nextExpectedActivity).
+      append(isUnloadedAtDestination).
+      append(routingStatus).
+      append(calculatedAt).
       append(lastEvent).
       toHashCode();
   }
@@ -147,5 +330,4 @@ public class Delivery implements ValueObject<Delivery> {
   Delivery() {
     // Needed by Hibernate
   }
-
 }

dddsample/src/main/java/se/citerus/dddsample/interfaces/booking/facade/internal/assembler/CargoRoutingDTOAssembler.java

@@ -16,7 +16,7 @@ public class CargoRoutingDTOAssembler {
       cargo.origin().unLocode().idString(),
       cargo.routeSpecification().destination().unLocode().idString(),
       cargo.routeSpecification().arrivalDeadline(),
-      cargo.routingStatus().equals(RoutingStatus.MISROUTED));
+      cargo.delivery().routingStatus().sameValueAs(RoutingStatus.MISROUTED));
     for (Leg leg : cargo.itinerary().legs()) {
       dto.addLeg(
         leg.voyage().voyageNumber().idString(),

dddsample/src/main/java/se/citerus/dddsample/interfaces/tracking/CargoTrackingViewAdapter.java

@@ -104,14 +104,14 @@ public final class CargoTrackingViewAdapter {
   }
 
   public String getEta() {
-    Date eta = cargo.estimatedTimeOfArrival();
+    Date eta = cargo.delivery().estimatedTimeOfArrival();
 
     if (eta == null) return "?";
     else return new SimpleDateFormat(FORMAT).format(eta);
   }
 
   public String getNextExpectedActivity() {
-      HandlingActivity activity = cargo.nextExpectedActivity();
+      HandlingActivity activity = cargo.delivery().nextExpectedActivity();
       if (activity == null) {
         return "";
       }
@@ -135,7 +135,7 @@ public final class CargoTrackingViewAdapter {
    * @return True if cargo is misdirected.
    */
   public boolean isMisdirected() {
-    return cargo.isMisdirected();
+    return cargo.delivery().isMisdirected();
   }
 
   /**

dddsample/src/main/resources/se/citerus/dddsample/infrastructure/persistence/hibernate/Cargo.hbm.xml

@@ -13,32 +13,34 @@
 
     <many-to-one name="origin" column="origin_id" not-null="false" cascade="none" update="false" foreign-key="origin_fk"/>
 
-    <property name="misdirected" column="is_misdirected" not-null="true"/>
-    <property name="eta" column="eta" not-null="false"/>
-    
-    <property name="routingStatus" column="routing_status" not-null="true">
-      <type name="org.hibernate.type.EnumType">
-        <param name="enumClass">se.citerus.dddsample.domain.model.cargo.RoutingStatus</param>
-        <param name="type">12</param><!-- 12 is java.sql.Types.VARCHAR -->
-      </type>
-    </property>
+    <component name="trackingId" unique="true" update="false">
+      <property name="id" column="tracking_id"/>
+    </component>
+
+    <component name="delivery" lazy="true">
+      <property name="misdirected" column="is_misdirected" not-null="true"/>
+      <property name="eta" column="eta" not-null="false"/>
+      <property name="calculatedAt" column="calculated_at" not-null="true"/>
+      <property name="isUnloadedAtDestination" column="unloaded_at_dest" not-null="true"/>
 
-    <component name="nextExpectedActivity" update="true">
-      <many-to-one name="location" column="next_expected_location_id" foreign-key="next_expected_location_fk"/>
-      <property name="type" column="next_expected_handling_event_type">
+      <property name="routingStatus" column="routing_status" not-null="true">
         <type name="org.hibernate.type.EnumType">
-          <param name="enumClass">se.citerus.dddsample.domain.model.handling.HandlingEvent$Type</param>
+          <param name="enumClass">se.citerus.dddsample.domain.model.cargo.RoutingStatus</param>
           <param name="type">12</param><!-- 12 is java.sql.Types.VARCHAR -->
         </type>
       </property>
-      <many-to-one name="voyage" column="next_expected_voyage_id" foreign-key="next_expected_voyage_fk"/>
-    </component>
 
-    <component name="trackingId" unique="true" update="false">
-      <property name="id" column="tracking_id"/>
-    </component>
+      <component name="nextExpectedActivity" update="true">
+        <many-to-one name="location" column="next_expected_location_id" foreign-key="next_expected_location_fk" cascade="none"/>
+        <property name="type" column="next_expected_handling_event_type">
+          <type name="org.hibernate.type.EnumType">
+            <param name="enumClass">se.citerus.dddsample.domain.model.handling.HandlingEvent$Type</param>
+            <param name="type">12</param><!-- 12 is java.sql.Types.VARCHAR -->
+          </type>
+        </property>
+        <many-to-one name="voyage" column="next_expected_voyage_id" foreign-key="next_expected_voyage_fk" cascade="none"/>
+      </component>
 
-    <component name="delivery" lazy="true">
       <property name="transportStatus" column="transport_status" not-null="true">
         <type name="org.hibernate.type.EnumType">
           <param name="enumClass">se.citerus.dddsample.domain.model.cargo.TransportStatus</param>
@@ -57,6 +59,7 @@
     </component>
 
     <component name="itinerary">
+      <!-- cascade=all-delete-orphan would be better, but it doesn't seem to work inside a component -->
       <list name="legs" lazy="true" cascade="all">
         <key column="cargo_id" foreign-key="itinerary_fk"/>
         <index column="leg_index"/>

dddsample/src/main/resources/se/citerus/dddsample/infrastructure/persistence/hibernate/Voyage.hbm.xml

@@ -15,8 +15,8 @@
       <property name="number" column="voyage_number"/>
     </component>
 
-    <component name="schedule" lazy="false">
-      <list name="carrierMovements" lazy="false" cascade="all-delete-orphan">
+    <component name="schedule">
+      <list name="carrierMovements" cascade="all-delete-orphan">
         <key column="voyage_id" foreign-key="voyage_fk"/>
         <index column="cm_index"/>
         <one-to-many class="se.citerus.dddsample.domain.model.voyage.CarrierMovement"/>

dddsample/src/test/java/se/citerus/dddsample/domain/model/cargo/CargoTest.java

@@ -40,7 +40,7 @@ public class CargoTest extends TestCase {
 
     final Cargo cargo = new Cargo(trackingId, routeSpecification);
 
-    assertEquals(NOT_ROUTED, cargo.routingStatus());
+    assertEquals(NOT_ROUTED, cargo.delivery().routingStatus());
     assertEquals(NOT_RECEIVED, cargo.delivery().transportStatus());
     assertEquals(Location.UNKNOWN, cargo.delivery().lastKnownLocation());
     assertEquals(Voyage.NONE, cargo.delivery().currentVoyage());    
@@ -59,13 +59,13 @@ public class CargoTest extends TestCase {
 
     cargo.specifyNewRoute(acceptOnlyGood);
 
-    assertEquals(NOT_ROUTED, cargo.routingStatus());
+    assertEquals(NOT_ROUTED, cargo.delivery().routingStatus());
     
     cargo.assignToRoute(bad);
-    assertEquals(MISROUTED, cargo.routingStatus());
+    assertEquals(MISROUTED, cargo.delivery().routingStatus());
 
     cargo.assignToRoute(good);
-    assertEquals(ROUTED, cargo.routingStatus());
+    assertEquals(ROUTED, cargo.delivery().routingStatus());
   }
 
   public void testlastKnownLocationUnknownWhenNoEvents() throws Exception {
@@ -114,13 +114,13 @@ public class CargoTest extends TestCase {
 
   public void testIsUnloadedAtFinalDestination() throws Exception {
     Cargo cargo = setUpCargoWithItinerary(HANGZOU, TOKYO, NEWYORK);
-    assertFalse(cargo.isUnloadedAtDestination());
+    assertFalse(cargo.delivery().isUnloadedAtDestination());
 
     // Adding an event unrelated to unloading at final destination
     events.add(
       new HandlingEvent(cargo, new Date(10), new Date(), HandlingEvent.Type.RECEIVE, HANGZOU));
     cargo.deriveDeliveryProgress(new HandlingHistory(events));
-    assertFalse(cargo.isUnloadedAtDestination());
+    assertFalse(cargo.delivery().isUnloadedAtDestination());
 
     Voyage voyage = new Voyage.Builder(new VoyageNumber("0123"), HANGZOU).
       addMovement(NEWYORK, new Date(), new Date()).
@@ -130,19 +130,19 @@ public class CargoTest extends TestCase {
     events.add(
       new HandlingEvent(cargo, new Date(20), new Date(), HandlingEvent.Type.UNLOAD, TOKYO, voyage));
     cargo.deriveDeliveryProgress(new HandlingHistory(events));
-    assertFalse(cargo.isUnloadedAtDestination());
+    assertFalse(cargo.delivery().isUnloadedAtDestination());
 
     // Adding an event in the final destination, but not unload
     events.add(
       new HandlingEvent(cargo, new Date(30), new Date(), HandlingEvent.Type.CUSTOMS, NEWYORK));
     cargo.deriveDeliveryProgress(new HandlingHistory(events));
-    assertFalse(cargo.isUnloadedAtDestination());
+    assertFalse(cargo.delivery().isUnloadedAtDestination());
 
     // Finally, cargo is unloaded at final destination
     events.add(
       new HandlingEvent(cargo, new Date(40), new Date(), HandlingEvent.Type.UNLOAD, NEWYORK, voyage));
     cargo.deriveDeliveryProgress(new HandlingHistory(events));
-    assertTrue(cargo.isUnloadedAtDestination());
+    assertTrue(cargo.delivery().isUnloadedAtDestination());
   }
 
   // TODO: Generate test data some better way
@@ -224,12 +224,12 @@ public class CargoTest extends TestCase {
   public void testIsMisdirected() throws Exception {
     //A cargo with no itinerary is not misdirected
     Cargo cargo = new Cargo(new TrackingId("TRKID"), new RouteSpecification(SHANGHAI, GOTHENBURG, new Date()));
-    assertFalse(cargo.isMisdirected());
+    assertFalse(cargo.delivery().isMisdirected());
 
     cargo = setUpCargoWithItinerary(SHANGHAI, ROTTERDAM, GOTHENBURG);
 
     //A cargo with no handling events is not misdirected
-    assertFalse(cargo.isMisdirected());
+    assertFalse(cargo.delivery().isMisdirected());
 
     Collection<HandlingEvent> handlingEvents = new ArrayList<HandlingEvent>();
 
@@ -244,7 +244,7 @@ public class CargoTest extends TestCase {
 
     events.addAll(handlingEvents);
     cargo.deriveDeliveryProgress(new HandlingHistory(events));
-    assertFalse(cargo.isMisdirected());
+    assertFalse(cargo.delivery().isMisdirected());
 
     //Try a couple of failing ones
 
@@ -255,7 +255,7 @@ public class CargoTest extends TestCase {
     events.addAll(handlingEvents);
     cargo.deriveDeliveryProgress(new HandlingHistory(events));
 
-    assertTrue(cargo.isMisdirected());
+    assertTrue(cargo.delivery().isMisdirected());
 
 
     cargo = setUpCargoWithItinerary(SHANGHAI, ROTTERDAM, GOTHENBURG);
@@ -269,7 +269,7 @@ public class CargoTest extends TestCase {
     events.addAll(handlingEvents);
     cargo.deriveDeliveryProgress(new HandlingHistory(events));
 
-    assertTrue(cargo.isMisdirected());
+    assertTrue(cargo.delivery().isMisdirected());
 
 
     cargo = setUpCargoWithItinerary(SHANGHAI, ROTTERDAM, GOTHENBURG);
@@ -283,7 +283,7 @@ public class CargoTest extends TestCase {
     events.addAll(handlingEvents);
     cargo.deriveDeliveryProgress(new HandlingHistory(events));
 
-    assertTrue(cargo.isMisdirected());
+    assertTrue(cargo.delivery().isMisdirected());
   }
 
   private Cargo setUpCargoWithItinerary(Location origin, Location midpoint, Location destination) {

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

@@ -8,14 +8,14 @@ import se.citerus.dddsample.application.HandlingEventService;
 import se.citerus.dddsample.application.impl.BookingServiceImpl;
 import se.citerus.dddsample.application.impl.CargoInspectionServiceImpl;
 import se.citerus.dddsample.application.impl.HandlingEventServiceImpl;
+import static se.citerus.dddsample.application.util.DateTestUtil.toDate;
 import se.citerus.dddsample.domain.model.cargo.*;
 import static se.citerus.dddsample.domain.model.cargo.RoutingStatus.*;
 import static se.citerus.dddsample.domain.model.cargo.TransportStatus.*;
-import se.citerus.dddsample.domain.model.handling.HandlingEvent;
+import se.citerus.dddsample.domain.model.handling.CannotCreateHandlingEventException;
 import static se.citerus.dddsample.domain.model.handling.HandlingEvent.Type.*;
 import se.citerus.dddsample.domain.model.handling.HandlingEventFactory;
 import se.citerus.dddsample.domain.model.handling.HandlingEventRepository;
-import se.citerus.dddsample.domain.model.handling.HandlingHistory;
 import se.citerus.dddsample.domain.model.location.Location;
 import se.citerus.dddsample.domain.model.location.LocationRepository;
 import static se.citerus.dddsample.domain.model.location.SampleLocations.*;
@@ -27,10 +27,13 @@ import se.citerus.dddsample.domain.model.voyage.VoyageRepository;
 import se.citerus.dddsample.domain.service.RoutingService;
 import se.citerus.dddsample.infrastructure.messaging.stub.SynchronousApplicationEventsStub;
 import se.citerus.dddsample.infrastructure.persistence.inmemory.CargoRepositoryInMem;
+import se.citerus.dddsample.infrastructure.persistence.inmemory.HandlingEventRepositoryInMem;
 import se.citerus.dddsample.infrastructure.persistence.inmemory.LocationRepositoryInMem;
 import se.citerus.dddsample.infrastructure.persistence.inmemory.VoyageRepositoryInMem;
 
-import java.util.*;
+import java.util.Arrays;
+import java.util.Date;
+import java.util.List;
 
 public class CargoLifecycleScenarioTest extends TestCase {
 
@@ -85,7 +88,7 @@ public class CargoLifecycleScenarioTest extends TestCase {
        and it should arrive in no more than two weeks. */
     Location origin = HONGKONG;
     Location destination = STOCKHOLM;
-    Date arrivalDeadline = inTwoWeeks();
+    Date arrivalDeadline = toDate("2009-03-18");
 
     /* Use case 1: booking
 
@@ -105,10 +108,10 @@ public class CargoLifecycleScenarioTest extends TestCase {
     Cargo cargo = cargoRepository.find(trackingId);
     assertNotNull(cargo);
     assertEquals(NOT_RECEIVED, cargo.delivery().transportStatus());
-    assertEquals(NOT_ROUTED, cargo.routingStatus());
-    assertFalse(cargo.isMisdirected());
-    assertNull(cargo.estimatedTimeOfArrival());
-    assertNull(cargo.nextExpectedActivity());
+    assertEquals(NOT_ROUTED, cargo.delivery().routingStatus());
+    assertFalse(cargo.delivery().isMisdirected());
+    assertNull(cargo.delivery().estimatedTimeOfArrival());
+    assertNull(cargo.delivery().nextExpectedActivity());
 
     /* Use case 2: routing
 
@@ -123,9 +126,9 @@ public class CargoLifecycleScenarioTest extends TestCase {
     cargo.assignToRoute(itinerary);
 
     assertEquals(NOT_RECEIVED, cargo.delivery().transportStatus());
-    assertEquals(ROUTED, cargo.routingStatus());
-    assertNotNull(cargo.estimatedTimeOfArrival());
-    assertEquals(new HandlingActivity(RECEIVE, HONGKONG), cargo.nextExpectedActivity());
+    assertEquals(ROUTED, cargo.delivery().routingStatus());
+    assertNotNull(cargo.delivery().estimatedTimeOfArrival());
+    assertEquals(new HandlingActivity(RECEIVE, HONGKONG), cargo.delivery().nextExpectedActivity());
 
     /*
       Use case 3: handling
@@ -142,7 +145,7 @@ public class CargoLifecycleScenarioTest extends TestCase {
       Handling begins: cargo is received in Hongkong.
       */
     handlingEventService.registerHandlingEvent(
-      new Date(100), trackingId, null, HONGKONG.unLocode(), RECEIVE
+      toDate("2009-03-01"), trackingId, null, HONGKONG.unLocode(), RECEIVE
     );
 
     assertEquals(IN_PORT, cargo.delivery().transportStatus());
@@ -150,15 +153,15 @@ public class CargoLifecycleScenarioTest extends TestCase {
     
     // Next event: Load onto voyage CM003 in Hongkong
     handlingEventService.registerHandlingEvent(
-      new Date(200), trackingId, CM003.voyageNumber(), HONGKONG.unLocode(), LOAD
+      toDate("2009-03-03"), trackingId, CM003.voyageNumber(), HONGKONG.unLocode(), LOAD
     );
 
     // Check current state - should be ok
     assertEquals(CM003, cargo.delivery().currentVoyage());
     assertEquals(HONGKONG, cargo.delivery().lastKnownLocation());
     assertEquals(ONBOARD_CARRIER, cargo.delivery().transportStatus());
-    assertFalse(cargo.isMisdirected());
-    assertEquals(new HandlingActivity(UNLOAD, NEWYORK, CM003), cargo.nextExpectedActivity());
+    assertFalse(cargo.delivery().isMisdirected());
+    assertEquals(new HandlingActivity(UNLOAD, NEWYORK, CM003), cargo.delivery().nextExpectedActivity());
 
 
     /*
@@ -170,22 +173,26 @@ public class CargoLifecycleScenarioTest extends TestCase {
      */
     final VoyageNumber noSuchVoyageNumber = new VoyageNumber("XX000");
     final UnLocode noSuchUnLocode = new UnLocode("ZZZZZ");
-    handlingEventService.registerHandlingEvent(
-      new Date(300), trackingId, noSuchVoyageNumber, noSuchUnLocode, LOAD
-    );
+    try {
+      handlingEventService.registerHandlingEvent(
+      toDate("2009-03-05"), trackingId, noSuchVoyageNumber, noSuchUnLocode, LOAD
+      );
+      fail("Should not be able to register a handling event with invalid location and voyage");
+    } catch (CannotCreateHandlingEventException expected) {
+    }
 
 
     // Cargo is now (incorrectly) unloaded in Tokyo
     handlingEventService.registerHandlingEvent(
-      new Date(400), trackingId, CM003.voyageNumber(), TOKYO.unLocode(), UNLOAD
+      toDate("2009-03-05"), trackingId, CM003.voyageNumber(), TOKYO.unLocode(), UNLOAD
     );
 
     // Check current state - cargo is misdirected!
     assertEquals(NONE, cargo.delivery().currentVoyage());
     assertEquals(TOKYO, cargo.delivery().lastKnownLocation());
     assertEquals(IN_PORT, cargo.delivery().transportStatus());
-    assertTrue(cargo.isMisdirected());
-    assertNull(cargo.nextExpectedActivity());
+    assertTrue(cargo.delivery().isMisdirected());
+    assertNull(cargo.delivery().nextExpectedActivity());
 
 
     // -- Cargo needs to be rerouted --
@@ -196,8 +203,8 @@ public class CargoLifecycleScenarioTest extends TestCase {
     cargo.specifyNewRoute(fromTokyo);
 
     // The old itinerary does not satisfy the new specification
-    assertEquals(MISROUTED, cargo.routingStatus());
-    assertNull(cargo.nextExpectedActivity());
+    assertEquals(MISROUTED, cargo.delivery().routingStatus());
+    assertNull(cargo.delivery().nextExpectedActivity());
 
     // Repeat procedure of selecting one out of a number of possible routes satisfying the route spec
     List<Itinerary> newItineraries = bookingService.requestPossibleRoutesForCargo(cargo.trackingId());
@@ -205,7 +212,7 @@ public class CargoLifecycleScenarioTest extends TestCase {
     cargo.assignToRoute(newItinerary);
 
     // New itinerary should satisfy new route
-    assertEquals(ROUTED, cargo.routingStatus());
+    assertEquals(ROUTED, cargo.delivery().routingStatus());
 
     // TODO we can't handle the face that after a reroute, the cargo isn't misdirected anymore
     //assertFalse(cargo.isMisdirected());
@@ -217,65 +224,65 @@ public class CargoLifecycleScenarioTest extends TestCase {
 
     // Load in Tokyo
     handlingEventService.registerHandlingEvent(
-      new Date(500), trackingId, CM003.voyageNumber(), TOKYO.unLocode(), LOAD
+      toDate("2009-03-08"), trackingId, CM003.voyageNumber(), TOKYO.unLocode(), LOAD
     );
 
     // Check current state - should be ok
     assertEquals(CM003, cargo.delivery().currentVoyage());
     assertEquals(TOKYO, cargo.delivery().lastKnownLocation());
     assertEquals(ONBOARD_CARRIER, cargo.delivery().transportStatus());
-    assertFalse(cargo.isMisdirected());
-    assertEquals(new HandlingActivity(UNLOAD, HAMBURG, CM003), cargo.nextExpectedActivity());
+    assertFalse(cargo.delivery().isMisdirected());
+    assertEquals(new HandlingActivity(UNLOAD, HAMBURG, CM003), cargo.delivery().nextExpectedActivity());
 
     // Unload in Hamburg
     handlingEventService.registerHandlingEvent(
-      new Date(600), trackingId, CM003.voyageNumber(), HAMBURG.unLocode(), UNLOAD
+      toDate("2009-03-12"), trackingId, CM003.voyageNumber(), HAMBURG.unLocode(), UNLOAD
     );
 
     // Check current state - should be ok
     assertEquals(NONE, cargo.delivery().currentVoyage());
     assertEquals(HAMBURG, cargo.delivery().lastKnownLocation());
     assertEquals(IN_PORT, cargo.delivery().transportStatus());
-    assertFalse(cargo.isMisdirected());
-    assertEquals(new HandlingActivity(LOAD, HAMBURG, CM005), cargo.nextExpectedActivity());
+    assertFalse(cargo.delivery().isMisdirected());
+    assertEquals(new HandlingActivity(LOAD, HAMBURG, CM005), cargo.delivery().nextExpectedActivity());
 
 
     // Load in Hamburg
     handlingEventService.registerHandlingEvent(
-      new Date(700), trackingId, CM005.voyageNumber(), HAMBURG.unLocode(), LOAD
+      toDate("2009-03-14"), trackingId, CM005.voyageNumber(), HAMBURG.unLocode(), LOAD
     );
 
     // Check current state - should be ok
     assertEquals(CM005, cargo.delivery().currentVoyage());
     assertEquals(HAMBURG, cargo.delivery().lastKnownLocation());
     assertEquals(ONBOARD_CARRIER, cargo.delivery().transportStatus());
-    assertFalse(cargo.isMisdirected());
-    assertEquals(new HandlingActivity(UNLOAD, STOCKHOLM, CM005), cargo.nextExpectedActivity());
+    assertFalse(cargo.delivery().isMisdirected());
+    assertEquals(new HandlingActivity(UNLOAD, STOCKHOLM, CM005), cargo.delivery().nextExpectedActivity());
 
 
     // Unload in Stockholm
     handlingEventService.registerHandlingEvent(
-      new Date(800), trackingId, CM005.voyageNumber(), STOCKHOLM.unLocode(), UNLOAD
+      toDate("2009-03-15"), trackingId, CM005.voyageNumber(), STOCKHOLM.unLocode(), UNLOAD
     );
 
     // Check current state - should be ok
     assertEquals(NONE, cargo.delivery().currentVoyage());
     assertEquals(STOCKHOLM, cargo.delivery().lastKnownLocation());
     assertEquals(IN_PORT, cargo.delivery().transportStatus());
-    assertFalse(cargo.isMisdirected());
-    assertEquals(new HandlingActivity(CLAIM, STOCKHOLM), cargo.nextExpectedActivity());
+    assertFalse(cargo.delivery().isMisdirected());
+    assertEquals(new HandlingActivity(CLAIM, STOCKHOLM), cargo.delivery().nextExpectedActivity());
 
     // Finally, cargo is claimed in Stockholm. This ends the cargo lifecycle from our perspective.
     handlingEventService.registerHandlingEvent(
-      new Date(900), trackingId, null, STOCKHOLM.unLocode(), CLAIM
+      toDate("2009-03-16"), trackingId, null, STOCKHOLM.unLocode(), CLAIM
     );
 
     // Check current state - should be ok
     assertEquals(NONE, cargo.delivery().currentVoyage());
     assertEquals(STOCKHOLM, cargo.delivery().lastKnownLocation());
     assertEquals(CLAIMED, cargo.delivery().transportStatus());
-    assertFalse(cargo.isMisdirected());
-    assertNull(cargo.nextExpectedActivity());
+    assertFalse(cargo.delivery().isMisdirected());
+    assertNull(cargo.delivery().nextExpectedActivity());
   }
 
 
@@ -324,40 +331,20 @@ public class CargoLifecycleScenarioTest extends TestCase {
 
     applicationEvents = new SynchronousApplicationEventsStub();
 
-    // Stub
-    // TODO move functionality to in-mem impl
-    handlingEventRepository = new HandlingEventRepository() {
-      Map<TrackingId, List<HandlingEvent>> eventMap = new HashMap<TrackingId, List<HandlingEvent>>();
-
-      @Override
-      public void store(HandlingEvent event) {
-        final TrackingId trackingId = event.cargo().trackingId();
-        List<HandlingEvent> list = eventMap.get(trackingId);
-        if (list == null) {
-          list = new ArrayList<HandlingEvent>();
-          eventMap.put(trackingId, list);
-        }
-        list.add(event);
-      }
-
-      @Override
-      public HandlingHistory lookupHandlingHistoryOfCargo(TrackingId trackingId) {
-        return new HandlingHistory(eventMap.get(trackingId));
-      }
-    };
-
-    // In-memory implementations
+    // In-memory implementations of the repositories
+    handlingEventRepository = new HandlingEventRepositoryInMem();
     cargoRepository = new CargoRepositoryInMem();
     locationRepository = new LocationRepositoryInMem();
     voyageRepository = new VoyageRepositoryInMem();
 
     // Actual factories and application services, wired with stubbed or in-memory infrastructure
-    cargoInspectionService = new CargoInspectionServiceImpl(applicationEvents, cargoRepository, handlingEventRepository);
     handlingEventFactory = new HandlingEventFactory(cargoRepository, voyageRepository, locationRepository);
+
+    cargoInspectionService = new CargoInspectionServiceImpl(applicationEvents, cargoRepository, handlingEventRepository);
     handlingEventService = new HandlingEventServiceImpl(handlingEventRepository, applicationEvents, handlingEventFactory);
     bookingService = new BookingServiceImpl(cargoRepository, locationRepository, routingService);
 
-    // Stub
+    // Circular dependency when doing synchrounous calls
     ((SynchronousApplicationEventsStub) applicationEvents).setCargoInspectionService(cargoInspectionService);
   }