Added assertions to HandlingHistory that ensures that it refers to a unique cargo, and that a Cargo can't derive its delivery progress from a handling history of another cargo. There are also two descriptive static factory methods for the different possibilities of creating a HandlingHistory.

HandlingEventRepository now looks up handling events from Cargo instead of TrackingId.

Fixed a problem with Hibernate lazy proxies not being initialised when reading a field.

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

@@ -38,7 +38,7 @@ public class CargoInspectionServiceImpl implements CargoInspectionService {
       return;
     }
 
-    final HandlingHistory handlingHistory = handlingEventRepository.lookupHandlingHistoryOfCargo(trackingId);
+    final HandlingHistory handlingHistory = handlingEventRepository.lookupHandlingHistoryOfCargo(cargo);
 
     cargo.deriveDeliveryProgress(handlingHistory);
 

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

@@ -202,7 +202,6 @@ public class SampleDataGenerator implements ServletContextListener {
   }
 
   public static void loadHibernateData(TransactionTemplate tt, final SessionFactory sf, final HandlingEventFactory handlingEventFactory, final HandlingEventRepository handlingEventRepository) {
-    System.out.println("*** Loading Hibernate data ***");
     tt.execute(new TransactionCallbackWithoutResult() {
       @Override
       protected void doInTransactionWithoutResult(TransactionStatus status) {
@@ -250,7 +249,7 @@ public class SampleDataGenerator implements ServletContextListener {
           throw new RuntimeException(e);
         }
 
-        HandlingHistory handlingHistory = handlingEventRepository.lookupHandlingHistoryOfCargo(trackingId);
+        HandlingHistory handlingHistory = handlingEventRepository.lookupHandlingHistoryOfCargo(abc123);
         abc123.deriveDeliveryProgress(handlingHistory);
 
         session.update(abc123);
@@ -295,7 +294,7 @@ public class SampleDataGenerator implements ServletContextListener {
           throw new RuntimeException(e);
         }
 
-        HandlingHistory handlingHistory1 = handlingEventRepository.lookupHandlingHistoryOfCargo(trackingId1);
+        HandlingHistory handlingHistory1 = handlingEventRepository.lookupHandlingHistoryOfCargo(jkl567);
         jkl567.deriveDeliveryProgress(handlingHistory1);
 
         session.update(jkl567);

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

@@ -62,7 +62,7 @@ public class Cargo implements Entity<Cargo> {
     this.routeSpecification = routeSpecification;
 
     this.delivery = Delivery.derivedFrom(
-      this.routeSpecification, this.itinerary, HandlingHistory.EMPTY
+      this.routeSpecification, this.itinerary, HandlingHistory.emptyForCargo(this)
     );
   }
 
@@ -145,7 +145,9 @@ public class Cargo implements Entity<Cargo> {
    * @param handlingHistory handling history
    */
   public void deriveDeliveryProgress(final HandlingHistory handlingHistory) {
-    // TODO filter events on cargo (must be same as this cargo)
+    Validate.isTrue(this.sameIdentityAs(handlingHistory.cargo()),
+      "Handling history must refer to this cargo, " + this + ". " +
+      "Given handlig history refers to cargo " + handlingHistory.cargo());
 
     // Delivery is a value object, so we can simply discard the old one
     // and replace it with a new
@@ -154,7 +156,7 @@ public class Cargo implements Entity<Cargo> {
 
   @Override
   public boolean sameIdentityAs(final Cargo other) {
-    return other != null && trackingId.sameValueAs(other.trackingId);
+    return other != null && trackingId().sameValueAs(other.trackingId());
   }
 
   /**
@@ -176,12 +178,12 @@ public class Cargo implements Entity<Cargo> {
    */
   @Override
   public int hashCode() {
-    return trackingId.hashCode();
+    return trackingId().hashCode();
   }
 
   @Override
   public String toString() {
-    return trackingId.toString();
+    return trackingId().toString();
   }
 
   Cargo() {

dddsample/src/main/java/se/citerus/dddsample/domain/model/handling/HandlingEventRepository.java

@@ -1,6 +1,6 @@
 package se.citerus.dddsample.domain.model.handling;
 
-import se.citerus.dddsample.domain.model.cargo.TrackingId;
+import se.citerus.dddsample.domain.model.cargo.Cargo;
 
 /**
  * Handling event repository.
@@ -16,9 +16,9 @@ public interface HandlingEventRepository {
 
 
   /**
-   * @param trackingId cargo tracking id
+   * @param cargo cargo
    * @return The handling history of this cargo
    */
-  HandlingHistory lookupHandlingHistoryOfCargo(TrackingId trackingId);
+  HandlingHistory lookupHandlingHistoryOfCargo(Cargo cargo);
 
 }

dddsample/src/main/java/se/citerus/dddsample/domain/model/handling/HandlingHistory.java

@@ -1,6 +1,7 @@
 package se.citerus.dddsample.domain.model.handling;
 
 import org.apache.commons.lang.Validate;
+import se.citerus.dddsample.domain.model.cargo.Cargo;
 import se.citerus.dddsample.domain.shared.ValueObject;
 
 import java.util.*;
@@ -13,15 +14,45 @@ import static java.util.Collections.sort;
 public class HandlingHistory implements ValueObject<HandlingHistory> {
 
   private final List<HandlingEvent> handlingEvents;
+  private final Cargo cargo;
 
-  public static final HandlingHistory EMPTY = new HandlingHistory(Collections.<HandlingEvent>emptyList());
+  public static HandlingHistory emptyForCargo(final Cargo cargo) {
+    return new HandlingHistory(cargo);
+  }
+
+  public static HandlingHistory fromEvents(final Collection<HandlingEvent> handlingEvents) {
+    return new HandlingHistory(handlingEvents);
+  }
+
+  private HandlingHistory(final Cargo cargo) {
+    Validate.notNull(cargo, "Cargo is required");
+    this.cargo = cargo;
+    handlingEvents = Collections.emptyList();
+  }
 
-  public HandlingHistory(Collection<HandlingEvent> handlingEvents) {
-    Validate.notNull(handlingEvents, "Handling events are required");
+  private HandlingHistory(final Collection<HandlingEvent> handlingEvents) {
+    Validate.notEmpty(handlingEvents, "Handling events are required");
 
+    this.cargo = uniqueCargo(handlingEvents);
     this.handlingEvents = new ArrayList<HandlingEvent>(handlingEvents);
   }
 
+  private Cargo uniqueCargo(final Collection<HandlingEvent> handlingEvents) {
+    final Iterator<HandlingEvent> it = handlingEvents.iterator();
+    final Cargo firstCargo = it.next().cargo();
+    Validate.notNull(firstCargo, "Cargo is required");
+
+    while (it.hasNext()) {
+      final Cargo nextCargo = it.next().cargo();
+      Validate.isTrue(firstCargo.sameIdentityAs(nextCargo),
+        "A handling history can only contain handling events for a unique cargo. " +
+        "First event is for cargo " + firstCargo + ", also discovered cargo " + nextCargo
+      );
+    }
+
+    return firstCargo;
+  }
+
   /**
    * @return A distinct list (no duplicate registrations) of handling events, ordered by completion time.
    */
@@ -34,7 +65,7 @@ public class HandlingHistory implements ValueObject<HandlingHistory> {
   }
 
   /**
-   * @return Most recently completed event, or null if the delivery history is empty.
+   * @return Most recently completed event, or null if the handling history is empty.
    */
   public HandlingEvent mostRecentlyCompletedEvent() {
     final List<HandlingEvent> distinctEvents = distinctEventsByCompletionTime();
@@ -45,6 +76,13 @@ public class HandlingHistory implements ValueObject<HandlingHistory> {
     }
   }
 
+  /**
+   * @return The cargo to which this handling history refers.
+   */
+  public Cargo cargo() {
+    return cargo;
+  }
+
   @Override
   public boolean sameValueAs(HandlingHistory other) {
     return other != null && this.handlingEvents.equals(other.handlingEvents);
@@ -70,5 +108,4 @@ public class HandlingHistory implements ValueObject<HandlingHistory> {
         return he1.completionTime().compareTo(he2.completionTime());
       }
     };
-
 }

dddsample/src/main/java/se/citerus/dddsample/infrastructure/persistence/hibernate/HandlingEventRepositoryHibernate.java

@@ -1,11 +1,13 @@
 package se.citerus.dddsample.infrastructure.persistence.hibernate;
 
 import org.springframework.stereotype.Repository;
-import se.citerus.dddsample.domain.model.cargo.TrackingId;
+import se.citerus.dddsample.domain.model.cargo.Cargo;
 import se.citerus.dddsample.domain.model.handling.HandlingEvent;
 import se.citerus.dddsample.domain.model.handling.HandlingEventRepository;
 import se.citerus.dddsample.domain.model.handling.HandlingHistory;
 
+import java.util.List;
+
 /**
  * Hibernate implementation of HandlingEventRepository.
  *
@@ -19,12 +21,17 @@ public class HandlingEventRepositoryHibernate extends HibernateRepository implem
   }
 
   @Override
-  public HandlingHistory lookupHandlingHistoryOfCargo(final TrackingId trackingId) {
-    return new HandlingHistory(getSession().createQuery(
-            "from HandlingEvent where cargo.trackingId = :tid").
-            setParameter("tid", trackingId).
-            list()
-    );
+  public HandlingHistory lookupHandlingHistoryOfCargo(final Cargo cargo) {
+    final List handlingEvents = getSession().createQuery(
+      "from HandlingEvent where cargo.trackingId = :tid").
+      setParameter("tid", cargo.trackingId()).
+      list();
+
+    if (handlingEvents.isEmpty()) {
+      return HandlingHistory.emptyForCargo(cargo);
+    } else {
+      return HandlingHistory.fromEvents(handlingEvents);
+    }
   }
 
 }

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

@@ -56,7 +56,7 @@ public final class CargoTrackingController extends SimpleFormController {
     if (cargo != null) {
       final MessageSource messageSource = getApplicationContext();
       final Locale locale = RequestContextUtils.getLocale(request);
-      final List<HandlingEvent> handlingEvents = handlingEventRepository.lookupHandlingHistoryOfCargo(trackingId).distinctEventsByCompletionTime();
+      final List<HandlingEvent> handlingEvents = handlingEventRepository.lookupHandlingHistoryOfCargo(cargo).distinctEventsByCompletionTime();
       model.put("cargo", new CargoTrackingViewAdapter(cargo, messageSource, locale, handlingEvents));
     } else {
       errors.rejectValue("trackingId", "cargo.unknown_id", new Object[]{trackCommand.getTrackingId()}, "Unknown tracking id");

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

@@ -1,7 +1,7 @@
 package se.citerus.dddsample.domain.model.cargo;
 
 import junit.framework.TestCase;
-import se.citerus.dddsample.application.util.DateTestUtil;
+import static se.citerus.dddsample.application.util.DateTestUtil.toDate;
 import static se.citerus.dddsample.domain.model.cargo.RoutingStatus.*;
 import static se.citerus.dddsample.domain.model.cargo.TransportStatus.NOT_RECEIVED;
 import se.citerus.dddsample.domain.model.handling.HandlingEvent;
@@ -11,9 +11,6 @@ import static se.citerus.dddsample.domain.model.location.SampleLocations.*;
 import se.citerus.dddsample.domain.model.voyage.Voyage;
 import se.citerus.dddsample.domain.model.voyage.VoyageNumber;
 
-import java.text.DateFormat;
-import java.text.ParseException;
-import java.text.SimpleDateFormat;
 import java.util.*;
 
 public class CargoTest extends TestCase {
@@ -33,7 +30,7 @@ public class CargoTest extends TestCase {
 
   public void testConstruction() throws Exception {
     final TrackingId trackingId = new TrackingId("XYZ");
-    final Date arrivalDeadline = DateTestUtil.toDate("2009-03-13");
+    final Date arrivalDeadline = toDate("2009-03-13");
     final RouteSpecification routeSpecification = new RouteSpecification(
       STOCKHOLM, MELBOURNE, arrivalDeadline
     );
@@ -119,7 +116,7 @@ public class CargoTest extends TestCase {
     // 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));
+    cargo.deriveDeliveryProgress(HandlingHistory.fromEvents(events));
     assertFalse(cargo.delivery().isUnloadedAtDestination());
 
     Voyage voyage = new Voyage.Builder(new VoyageNumber("0123"), HANGZOU).
@@ -129,29 +126,49 @@ public class CargoTest extends TestCase {
     // Adding an unload event, but not at the final destination
     events.add(
       new HandlingEvent(cargo, new Date(20), new Date(), HandlingEvent.Type.UNLOAD, TOKYO, voyage));
-    cargo.deriveDeliveryProgress(new HandlingHistory(events));
+    cargo.deriveDeliveryProgress(HandlingHistory.fromEvents(events));
     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));
+    cargo.deriveDeliveryProgress(HandlingHistory.fromEvents(events));
     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));
+    cargo.deriveDeliveryProgress(HandlingHistory.fromEvents(events));
     assertTrue(cargo.delivery().isUnloadedAtDestination());
   }
 
+  public void testDeriveDeliveryFromHandlingHistory() throws Exception {
+    RouteSpecification sharedRouteSpec = new RouteSpecification(SHANGHAI, GOTHENBURG, toDate("2009-04-01"));
+    Cargo cargo1 = new Cargo(new TrackingId("ABC"), sharedRouteSpec);
+    Cargo cargo2 = new Cargo(new TrackingId("DEF"), sharedRouteSpec);
+    assertFalse(cargo1.sameIdentityAs(cargo2));
+    
+    HandlingHistory handlingHistoryOfCargo1 = HandlingHistory.fromEvents(Arrays.asList(
+      new HandlingEvent(cargo1, toDate("2009-03-10"), toDate("2009-03-12"), HandlingEvent.Type.RECEIVE, HANGZOU)
+    ));
+
+    // This is ok
+    cargo1.deriveDeliveryProgress(handlingHistoryOfCargo1);
+
+    try {
+      cargo2.deriveDeliveryProgress(handlingHistoryOfCargo1);
+      fail("A cargo should not be able to derive its delivery progress from a handling history of a different cargo");
+    } catch (IllegalArgumentException expected) {
+    }
+  }
+
   // TODO: Generate test data some better way
   private Cargo populateCargoReceivedStockholm() throws Exception {
     final Cargo cargo = new Cargo(new TrackingId("XYZ"), new RouteSpecification(STOCKHOLM, MELBOURNE, new Date()));
 
-    HandlingEvent he = new HandlingEvent(cargo, getDate("2007-12-01"), new Date(), HandlingEvent.Type.RECEIVE, STOCKHOLM);
+    HandlingEvent he = new HandlingEvent(cargo, toDate("2007-12-01"), new Date(), HandlingEvent.Type.RECEIVE, STOCKHOLM);
     events.add(he);
-    cargo.deriveDeliveryProgress(new HandlingHistory(events));
+    cargo.deriveDeliveryProgress(HandlingHistory.fromEvents(events));
 
     return cargo;
   }
@@ -159,8 +176,8 @@ public class CargoTest extends TestCase {
   private Cargo populateCargoClaimedMelbourne() throws Exception {
     final Cargo cargo = populateCargoOffMelbourne();
 
-    events.add(new HandlingEvent(cargo, getDate("2007-12-09"), new Date(), HandlingEvent.Type.CLAIM, MELBOURNE));
-    cargo.deriveDeliveryProgress(new HandlingHistory(events));
+    events.add(new HandlingEvent(cargo, toDate("2007-12-09"), new Date(), HandlingEvent.Type.CLAIM, MELBOURNE));
+    cargo.deriveDeliveryProgress(HandlingHistory.fromEvents(events));
 
     return cargo;
   }
@@ -169,55 +186,55 @@ public class CargoTest extends TestCase {
     final Cargo cargo = new Cargo(new TrackingId("XYZ"), new RouteSpecification(STOCKHOLM, MELBOURNE, new Date()));
 
 
-    events.add(new HandlingEvent(cargo, getDate("2007-12-01"), new Date(), HandlingEvent.Type.LOAD, STOCKHOLM, voyage));
-    events.add(new HandlingEvent(cargo, getDate("2007-12-02"), new Date(), HandlingEvent.Type.UNLOAD, HAMBURG, voyage));
+    events.add(new HandlingEvent(cargo, toDate("2007-12-01"), new Date(), HandlingEvent.Type.LOAD, STOCKHOLM, voyage));
+    events.add(new HandlingEvent(cargo, toDate("2007-12-02"), new Date(), HandlingEvent.Type.UNLOAD, HAMBURG, voyage));
 
-    events.add(new HandlingEvent(cargo, getDate("2007-12-03"), new Date(), HandlingEvent.Type.LOAD, HAMBURG, voyage));
-    events.add(new HandlingEvent(cargo, getDate("2007-12-04"), new Date(), HandlingEvent.Type.UNLOAD, HONGKONG, voyage));
+    events.add(new HandlingEvent(cargo, toDate("2007-12-03"), new Date(), HandlingEvent.Type.LOAD, HAMBURG, voyage));
+    events.add(new HandlingEvent(cargo, toDate("2007-12-04"), new Date(), HandlingEvent.Type.UNLOAD, HONGKONG, voyage));
 
-    cargo.deriveDeliveryProgress(new HandlingHistory(events));
+    cargo.deriveDeliveryProgress(HandlingHistory.fromEvents(events));
     return cargo;
   }
 
   private Cargo populateCargoOnHamburg() throws Exception {
     final Cargo cargo = new Cargo(new TrackingId("XYZ"), new RouteSpecification(STOCKHOLM, MELBOURNE, new Date()));
 
-    events.add(new HandlingEvent(cargo, getDate("2007-12-01"), new Date(), HandlingEvent.Type.LOAD, STOCKHOLM, voyage));
-    events.add(new HandlingEvent(cargo, getDate("2007-12-02"), new Date(), HandlingEvent.Type.UNLOAD, HAMBURG, voyage));
-    events.add(new HandlingEvent(cargo, getDate("2007-12-03"), new Date(), HandlingEvent.Type.LOAD, HAMBURG, voyage));
+    events.add(new HandlingEvent(cargo, toDate("2007-12-01"), new Date(), HandlingEvent.Type.LOAD, STOCKHOLM, voyage));
+    events.add(new HandlingEvent(cargo, toDate("2007-12-02"), new Date(), HandlingEvent.Type.UNLOAD, HAMBURG, voyage));
+    events.add(new HandlingEvent(cargo, toDate("2007-12-03"), new Date(), HandlingEvent.Type.LOAD, HAMBURG, voyage));
 
-    cargo.deriveDeliveryProgress(new HandlingHistory(events));
+    cargo.deriveDeliveryProgress(HandlingHistory.fromEvents(events));
     return cargo;
   }
 
   private Cargo populateCargoOffMelbourne() throws Exception {
     final Cargo cargo = new Cargo(new TrackingId("XYZ"), new RouteSpecification(STOCKHOLM, MELBOURNE, new Date()));
 
-    events.add(new HandlingEvent(cargo, getDate("2007-12-01"), new Date(), HandlingEvent.Type.LOAD, STOCKHOLM, voyage));
-    events.add(new HandlingEvent(cargo, getDate("2007-12-02"), new Date(), HandlingEvent.Type.UNLOAD, HAMBURG, voyage));
+    events.add(new HandlingEvent(cargo, toDate("2007-12-01"), new Date(), HandlingEvent.Type.LOAD, STOCKHOLM, voyage));
+    events.add(new HandlingEvent(cargo, toDate("2007-12-02"), new Date(), HandlingEvent.Type.UNLOAD, HAMBURG, voyage));
 
-    events.add(new HandlingEvent(cargo, getDate("2007-12-03"), new Date(), HandlingEvent.Type.LOAD, HAMBURG, voyage));
-    events.add(new HandlingEvent(cargo, getDate("2007-12-04"), new Date(), HandlingEvent.Type.UNLOAD, HONGKONG, voyage));
+    events.add(new HandlingEvent(cargo, toDate("2007-12-03"), new Date(), HandlingEvent.Type.LOAD, HAMBURG, voyage));
+    events.add(new HandlingEvent(cargo, toDate("2007-12-04"), new Date(), HandlingEvent.Type.UNLOAD, HONGKONG, voyage));
 
-    events.add(new HandlingEvent(cargo, getDate("2007-12-05"), new Date(), HandlingEvent.Type.LOAD, HONGKONG, voyage));
-    events.add(new HandlingEvent(cargo, getDate("2007-12-07"), new Date(), HandlingEvent.Type.UNLOAD, MELBOURNE, voyage));
+    events.add(new HandlingEvent(cargo, toDate("2007-12-05"), new Date(), HandlingEvent.Type.LOAD, HONGKONG, voyage));
+    events.add(new HandlingEvent(cargo, toDate("2007-12-07"), new Date(), HandlingEvent.Type.UNLOAD, MELBOURNE, voyage));
 
-    cargo.deriveDeliveryProgress(new HandlingHistory(events));
+    cargo.deriveDeliveryProgress(HandlingHistory.fromEvents(events));
     return cargo;
   }
 
   private Cargo populateCargoOnHongKong() throws Exception {
     final Cargo cargo = new Cargo(new TrackingId("XYZ"), new RouteSpecification(STOCKHOLM, MELBOURNE, new Date()));
 
-    events.add(new HandlingEvent(cargo, getDate("2007-12-01"), new Date(), HandlingEvent.Type.LOAD, STOCKHOLM, voyage));
-    events.add(new HandlingEvent(cargo, getDate("2007-12-02"), new Date(), HandlingEvent.Type.UNLOAD, HAMBURG, voyage));
+    events.add(new HandlingEvent(cargo, toDate("2007-12-01"), new Date(), HandlingEvent.Type.LOAD, STOCKHOLM, voyage));
+    events.add(new HandlingEvent(cargo, toDate("2007-12-02"), new Date(), HandlingEvent.Type.UNLOAD, HAMBURG, voyage));
 
-    events.add(new HandlingEvent(cargo, getDate("2007-12-03"), new Date(), HandlingEvent.Type.LOAD, HAMBURG, voyage));
-    events.add(new HandlingEvent(cargo, getDate("2007-12-04"), new Date(), HandlingEvent.Type.UNLOAD, HONGKONG, voyage));
+    events.add(new HandlingEvent(cargo, toDate("2007-12-03"), new Date(), HandlingEvent.Type.LOAD, HAMBURG, voyage));
+    events.add(new HandlingEvent(cargo, toDate("2007-12-04"), new Date(), HandlingEvent.Type.UNLOAD, HONGKONG, voyage));
 
-    events.add(new HandlingEvent(cargo, getDate("2007-12-05"), new Date(), HandlingEvent.Type.LOAD, HONGKONG, voyage));
+    events.add(new HandlingEvent(cargo, toDate("2007-12-05"), new Date(), HandlingEvent.Type.LOAD, HONGKONG, voyage));
 
-    cargo.deriveDeliveryProgress(new HandlingHistory(events));
+    cargo.deriveDeliveryProgress(HandlingHistory.fromEvents(events));
     return cargo;
   }
 
@@ -243,7 +260,7 @@ public class CargoTest extends TestCase {
     handlingEvents.add(new HandlingEvent(cargo, new Date(130), new Date(140), HandlingEvent.Type.CUSTOMS, GOTHENBURG));
 
     events.addAll(handlingEvents);
-    cargo.deriveDeliveryProgress(new HandlingHistory(events));
+    cargo.deriveDeliveryProgress(HandlingHistory.fromEvents(events));
     assertFalse(cargo.delivery().isMisdirected());
 
     //Try a couple of failing ones
@@ -253,7 +270,7 @@ public class CargoTest extends TestCase {
 
     handlingEvents.add(new HandlingEvent(cargo, new Date(), new Date(), HandlingEvent.Type.RECEIVE, HANGZOU));
     events.addAll(handlingEvents);
-    cargo.deriveDeliveryProgress(new HandlingHistory(events));
+    cargo.deriveDeliveryProgress(HandlingHistory.fromEvents(events));
 
     assertTrue(cargo.delivery().isMisdirected());
 
@@ -267,7 +284,7 @@ public class CargoTest extends TestCase {
     handlingEvents.add(new HandlingEvent(cargo, new Date(70), new Date(80), HandlingEvent.Type.LOAD, ROTTERDAM, voyage));
 
     events.addAll(handlingEvents);
-    cargo.deriveDeliveryProgress(new HandlingHistory(events));
+    cargo.deriveDeliveryProgress(HandlingHistory.fromEvents(events));
 
     assertTrue(cargo.delivery().isMisdirected());
 
@@ -281,7 +298,7 @@ public class CargoTest extends TestCase {
     handlingEvents.add(new HandlingEvent(cargo, new Date(), new Date(), HandlingEvent.Type.CLAIM, ROTTERDAM));
 
     events.addAll(handlingEvents);
-    cargo.deriveDeliveryProgress(new HandlingHistory(events));
+    cargo.deriveDeliveryProgress(HandlingHistory.fromEvents(events));
 
     assertTrue(cargo.delivery().isMisdirected());
   }
@@ -300,15 +317,4 @@ public class CargoTest extends TestCase {
     return cargo;
   }
 
-  /**
-   * Parse an ISO 8601 (YYYY-MM-DD) String to Date
-   *
-   * @param isoFormat String to parse.
-   * @return Created date instance.
-   * @throws ParseException Thrown if parsing fails.
-   */
-  private Date getDate(String isoFormat) throws ParseException {
-    final DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
-    return dateFormat.parse(isoFormat);
-  }
 }

dddsample/src/test/java/se/citerus/dddsample/domain/model/handling/HandlingHistoryTest.java

@@ -15,31 +15,54 @@ import java.util.Date;
 
 public class HandlingHistoryTest extends TestCase {
   Cargo cargo;
+  Cargo cargo2;
   Voyage voyage;
   HandlingEvent event1;
   HandlingEvent event1duplicate;
   HandlingEvent event2;
+  HandlingEvent eventOfCargo2;
   HandlingHistory handlingHistory;
 
   protected void setUp() throws Exception {
     cargo = new Cargo(new TrackingId("ABC"), new RouteSpecification(SHANGHAI, DALLAS, toDate("2009-04-01")));
+    cargo2 = new Cargo(new TrackingId("DEF"), new RouteSpecification(SHANGHAI, NEWYORK, toDate("2009-04-15")));
+    
     voyage = new Voyage.Builder(new VoyageNumber("X25"), HONGKONG).
       addMovement(SHANGHAI, new Date(), new Date()).
       addMovement(DALLAS, new Date(), new Date()).
       build();
-    event1 = new HandlingEvent(cargo, toDate("2009-03-05"), new Date(100), HandlingEvent.Type.LOAD, SHANGHAI, voyage);
-    event1duplicate = new HandlingEvent(cargo, toDate("2009-03-05"), new Date(200), HandlingEvent.Type.LOAD, SHANGHAI, voyage);
-    event2 = new HandlingEvent(cargo, toDate("2009-03-10"), new Date(150), HandlingEvent.Type.UNLOAD, DALLAS, voyage);
-
-    handlingHistory = new HandlingHistory(asList(event2, event1, event1duplicate));
+    event1 = new HandlingEvent(cargo, toDate("2009-03-05"), toDate("2009-03-05"), HandlingEvent.Type.LOAD, SHANGHAI, voyage);
+    event1duplicate = new HandlingEvent(cargo, toDate("2009-03-05"), toDate("2009-03-07"), HandlingEvent.Type.LOAD, SHANGHAI, voyage);
+    event2 = new HandlingEvent(cargo, toDate("2009-03-10"), toDate("2009-03-06"), HandlingEvent.Type.UNLOAD, DALLAS, voyage);
+    eventOfCargo2 = new HandlingEvent(cargo2, toDate("2009-03-11"), toDate("2009-03-08"), HandlingEvent.Type.LOAD, GOTHENBURG, voyage);
   }
 
   public void testDistinctEventsByCompletionTime() {
+    handlingHistory = HandlingHistory.fromEvents(asList(event2, event1, event1duplicate));
+    
     assertEquals(asList(event1, event2), handlingHistory.distinctEventsByCompletionTime());
   }
 
   public void testMostRecentlyCompletedEvent() {
+    handlingHistory = HandlingHistory.fromEvents(asList(event2, event1, event1duplicate));
+    
     assertEquals(event2, handlingHistory.mostRecentlyCompletedEvent());
   }
-  
+
+  public void testUniqueCargoOfEvents() {
+    try {
+      handlingHistory = HandlingHistory.fromEvents(asList(event1, event2, eventOfCargo2));
+      fail("A handling history should only accept handling events for a single unique cargo");
+    } catch (IllegalArgumentException expected) {
+    }
+  }
+
+  public void testCargo() {
+    handlingHistory = HandlingHistory.fromEvents(asList(event1, event2));
+    assertEquals(cargo, handlingHistory.cargo());
+
+    handlingHistory = HandlingHistory.fromEvents(asList(eventOfCargo2));
+    assertEquals(cargo2, handlingHistory.cargo());
+  }
+
 }

dddsample/src/test/java/se/citerus/dddsample/infrastructure/messaging/stub/SynchronousApplicationEventsStub.java

@@ -1,5 +1,7 @@
 package se.citerus.dddsample.infrastructure.messaging.stub;
 
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
 import se.citerus.dddsample.application.ApplicationEvents;
 import se.citerus.dddsample.application.CargoInspectionService;
 import se.citerus.dddsample.domain.model.cargo.Cargo;
@@ -9,6 +11,7 @@ import se.citerus.dddsample.interfaces.handling.HandlingEventRegistrationAttempt
 public class SynchronousApplicationEventsStub implements ApplicationEvents {
 
   CargoInspectionService cargoInspectionService;
+  private static final Log logger = LogFactory.getLog(SynchronousApplicationEventsStub.class);
 
   public void setCargoInspectionService(CargoInspectionService cargoInspectionService) {
     this.cargoInspectionService = cargoInspectionService;
@@ -16,22 +19,22 @@ public class SynchronousApplicationEventsStub implements ApplicationEvents {
 
   @Override
   public void cargoWasHandled(HandlingEvent event) {
-    System.out.println("EVENT: cargo was handled: " + event);
+    logger.debug("EVENT: cargo was handled: " + event);
     cargoInspectionService.inspectCargo(event.cargo().trackingId());
   }
 
   @Override
   public void cargoWasMisdirected(Cargo cargo) {
-    System.out.println("EVENT: cargo was misdirected");
+    logger.debug("EVENT: cargo was misdirected");
   }
 
   @Override
   public void cargoHasArrived(Cargo cargo) {
-    System.out.println("EVENT: cargo has arrived: " + cargo.trackingId().idString());
+    logger.debug("EVENT: cargo has arrived: " + cargo.trackingId().idString());
   }
 
   @Override
   public void receivedHandlingEventRegistrationAttempt(HandlingEventRegistrationAttempt attempt) {
-    System.out.println("EVENT: received handling event registration attempt");
+    logger.debug("EVENT: received handling event registration attempt");
   }
 }

dddsample/src/test/java/se/citerus/dddsample/infrastructure/persistence/hibernate/CargoRepositoryTest.java

@@ -46,7 +46,7 @@ public class CargoRepositoryTest extends AbstractRepositoryTest {
 
     assertNotNull(cargo.delivery());
 
-    final List<HandlingEvent> events = handlingEventRepository.lookupHandlingHistoryOfCargo(trackingId).distinctEventsByCompletionTime();
+    final List<HandlingEvent> events = handlingEventRepository.lookupHandlingHistoryOfCargo(cargo).distinctEventsByCompletionTime();
     assertEquals(2, events.size());
 
     HandlingEvent firstEvent = events.get(0);

dddsample/src/test/java/se/citerus/dddsample/infrastructure/persistence/hibernate/HandlingEventRepositoryTest.java

@@ -52,8 +52,8 @@ public class HandlingEventRepositoryTest extends AbstractRepositoryTest {
   }
 
   public void testFindEventsForCargo() throws Exception {
-    TrackingId trackingId = new TrackingId("XYZ");
-    List<HandlingEvent> handlingEvents = handlingEventRepository.lookupHandlingHistoryOfCargo(trackingId).distinctEventsByCompletionTime();
+    Cargo cargo = cargoRepository.find(new TrackingId("XYZ"));
+    List<HandlingEvent> handlingEvents = handlingEventRepository.lookupHandlingHistoryOfCargo(cargo).distinctEventsByCompletionTime();
     assertEquals(12, handlingEvents.size());
   }
 

dddsample/src/test/java/se/citerus/dddsample/infrastructure/persistence/inmemory/CargoRepositoryInMem.java

@@ -52,23 +52,19 @@ public class CargoRepositoryInMem implements CargoRepository {
 
   public void init() throws Exception {
     final TrackingId xyz = new TrackingId("XYZ");
-    final Cargo cargoXYZ = createCargoWithDeliveryHistory(
-      xyz, STOCKHOLM, MELBOURNE, handlingEventRepository.lookupHandlingHistoryOfCargo(xyz));
+    final Cargo cargoXYZ = createCargoWithDeliveryHistory(xyz, STOCKHOLM, MELBOURNE);
     cargoDb.put(xyz.idString(), cargoXYZ);
 
     final TrackingId zyx = new TrackingId("ZYX");
-    final Cargo cargoZYX = createCargoWithDeliveryHistory(
-      zyx, MELBOURNE, STOCKHOLM, handlingEventRepository.lookupHandlingHistoryOfCargo(zyx));
+    final Cargo cargoZYX = createCargoWithDeliveryHistory(zyx, MELBOURNE, STOCKHOLM);
     cargoDb.put(zyx.idString(), cargoZYX);
 
     final TrackingId abc = new TrackingId("ABC");
-    final Cargo cargoABC = createCargoWithDeliveryHistory(
-      abc, STOCKHOLM, HELSINKI, handlingEventRepository.lookupHandlingHistoryOfCargo(abc));
+    final Cargo cargoABC = createCargoWithDeliveryHistory(abc, STOCKHOLM, HELSINKI);
     cargoDb.put(abc.idString(), cargoABC);
 
     final TrackingId cba = new TrackingId("CBA");
-    final Cargo cargoCBA = createCargoWithDeliveryHistory(
-      cba, HELSINKI, STOCKHOLM, handlingEventRepository.lookupHandlingHistoryOfCargo(cba));
+    final Cargo cargoCBA = createCargoWithDeliveryHistory(cba, HELSINKI, STOCKHOLM);
     cargoDb.put(cba.idString(), cargoCBA);
   }
 
@@ -78,12 +74,11 @@ public class CargoRepositoryInMem implements CargoRepository {
 
   public static Cargo createCargoWithDeliveryHistory(TrackingId trackingId,
                                                      Location origin,
-                                                     Location destination,
-                                                     HandlingHistory handlingHistory) {
+                                                     Location destination) {
 
     final RouteSpecification routeSpecification = new RouteSpecification(origin, destination, new Date());
     final Cargo cargo = new Cargo(trackingId, routeSpecification);
-    cargo.deriveDeliveryProgress(handlingHistory);
+    cargo.deriveDeliveryProgress(HandlingHistory.emptyForCargo(cargo));
 
     return cargo;
   }

dddsample/src/test/java/se/citerus/dddsample/infrastructure/persistence/inmemory/HandlingEventRepositoryInMem.java

@@ -1,11 +1,15 @@
 package se.citerus.dddsample.infrastructure.persistence.inmemory;
 
+import se.citerus.dddsample.domain.model.cargo.Cargo;
 import se.citerus.dddsample.domain.model.cargo.TrackingId;
 import se.citerus.dddsample.domain.model.handling.HandlingEvent;
 import se.citerus.dddsample.domain.model.handling.HandlingEventRepository;
 import se.citerus.dddsample.domain.model.handling.HandlingHistory;
 
-import java.util.*;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
 
 public class HandlingEventRepositoryInMem implements HandlingEventRepository {
 
@@ -23,11 +27,14 @@ public class HandlingEventRepositoryInMem implements HandlingEventRepository {
   }
 
   @Override
-  public HandlingHistory lookupHandlingHistoryOfCargo(TrackingId trackingId) {
-    List<HandlingEvent> events = eventMap.get(trackingId);
-    if (events == null) events = Collections.emptyList();
-    
-    return new HandlingHistory(events);
+  public HandlingHistory lookupHandlingHistoryOfCargo(Cargo cargo) {
+    List<HandlingEvent> events = eventMap.get(cargo.trackingId());
+
+    if (events == null) {
+      return HandlingHistory.emptyForCargo(cargo);
+    } else {
+      return HandlingHistory.fromEvents(events);
+    }
   }
 
 }

dddsample/src/test/java/se/citerus/dddsample/infrastructure/routing/ExternalRoutingServiceTest.java

@@ -5,6 +5,7 @@ import com.pathfinder.internal.GraphDAO;
 import com.pathfinder.internal.GraphTraversalServiceImpl;
 import junit.framework.TestCase;
 import static org.easymock.EasyMock.*;
+import static se.citerus.dddsample.application.util.DateTestUtil.toDate;
 import se.citerus.dddsample.domain.model.cargo.*;
 import se.citerus.dddsample.domain.model.location.Location;
 import se.citerus.dddsample.domain.model.location.LocationRepository;
@@ -15,7 +16,6 @@ import se.citerus.dddsample.domain.model.voyage.VoyageRepository;
 import se.citerus.dddsample.infrastructure.persistence.inmemory.LocationRepositoryInMem;
 
 import java.util.Arrays;
-import java.util.Date;
 import java.util.List;
 
 public class ExternalRoutingServiceTest extends TestCase {
@@ -46,7 +46,7 @@ public class ExternalRoutingServiceTest extends TestCase {
 
   public void testCalculatePossibleRoutes() {
     TrackingId trackingId = new TrackingId("ABC");
-    RouteSpecification routeSpecification = new RouteSpecification(HONGKONG, HELSINKI, new Date());
+    RouteSpecification routeSpecification = new RouteSpecification(HONGKONG, HELSINKI, toDate("2009-04-01"));
     Cargo cargo = new Cargo(trackingId, routeSpecification);
 
     expect(voyageRepository.find(isA(VoyageNumber.class))).andStubReturn(SampleVoyages.CM002);

dddsample/src/test/java/se/citerus/dddsample/interfaces/tracking/CargoTrackingViewAdapterTest.java

@@ -24,7 +24,7 @@ public class CargoTrackingViewAdapterTest extends TestCase {
     events.add(new HandlingEvent(cargo, new Date(3), new Date(4), HandlingEvent.Type.LOAD, HANGZOU, CM001));
     events.add(new HandlingEvent(cargo, new Date(5), new Date(6), HandlingEvent.Type.UNLOAD, HELSINKI, CM001));
 
-    cargo.deriveDeliveryProgress(new HandlingHistory(events));
+    cargo.deriveDeliveryProgress(HandlingHistory.fromEvents(events));
 
     StaticApplicationContext applicationContext = new StaticApplicationContext();
     applicationContext.addMessage("cargo.status.IN_PORT", Locale.GERMAN, "In port {0}");