Further improvments of sample voyages and test environment.

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

   }
 
   private static void loadHandlingEventData(JdbcTemplate jdbcTemplate) {
+    String activitySql = "insert into HandlingActivity (id, handling_event_type, location_id, voyage_id) values (?, ?, ?, ?)";
+      Object[][] actvityArgs = {
+        {1, "RECEIVE", 1, null},
+        {2, "LOAD",    1, 1},
+        {3, "UNLOAD",  5, 1},
+        {4, "LOAD",    5, 1},
+        {5, "UNLOAD",  6, 1},
+        {6, "LOAD",    6, 1},
+        {7, "UNLOAD",  3, 1},
+        {8, "LOAD",    3, 1},
+        {9, "UNLOAD",  4, 1},
+        {10, "LOAD",    4, 1},
+        {11, "UNLOAD",  2, 1},
+        {12, "CLAIM",   2, null},
+
+        //ZYX (AUMEL - USCHI - DEHAM -)
+        {13, "RECEIVE", 2, null},
+        {14, "LOAD",    2, 2},
+        {15, "UNLOAD",  7, 2},
+        {16, "LOAD",    7, 2},
+        {17, "UNLOAD",  6, 2},
+        {18, "LOAD",    6, 2},
+
+        //ABC
+        {19, "CLAIM", 2, null},
+
+        //CBA
+        {20, "RECEIVE", 2, null},
+        {21, "LOAD",    2, 2},
+        {22, "UNLOAD",  7, 2},
+
+        //FGH
+        {23, "RECEIVE", 3, null},
+        {24, "LOAD",    3, 3},
+
+        // JKL
+        {25, "RECEIVE", 6, null},
+        {26, "LOAD",    6, 3},
+        {27, "UNLOAD",  5, 3}  // Unexpected event
+      };
+    executeUpdate(jdbcTemplate, activitySql, actvityArgs);
+
+
     String handlingEventSql =
-      "insert into HandlingEvent (sequence_number, completionTime, registrationTime, type, location_id, voyage_id, cargo_id, operator_code) " +
-        "values (?, ?, ?, ?, ?, ?, ?,?)";
+      "insert into HandlingEvent (sequence_number, completionTime, registrationTime, cargo_id, operator_code, activity_id) " +
+        "values (?, ?, ?, ?, ?, ?)";
 
     Object[][] handlingEventArgs = {
       //XYZ (SESTO-FIHEL-DEHAM-CNHKG-JPTOK-AUMEL)
-      {1, ts(0), ts((0)), "RECEIVE", 1, null, 1, null},
-      {2, ts((4)), ts((5)), "LOAD", 1, 1, 1, "AS34F"},
-      {3, ts((14)), ts((14)), "UNLOAD", 5, 1, 1, "AS34F"},
-      {4, ts((15)), ts((15)), "LOAD", 5, 1, 1, "AS34F"},
-      {5, ts((30)), ts((30)), "UNLOAD", 6, 1, 1, "AS34F"},
-      {6, ts((33)), ts((33)), "LOAD", 6, 1, 1, "AS34F"},
-      {7, ts((34)), ts((34)), "UNLOAD", 3, 1, 1, "AS34F"},
-      {8, ts((60)), ts((60)), "LOAD", 3, 1, 1, "AS34F"},
-      {9, ts((70)), ts((71)), "UNLOAD", 4, 1, 1, "AS34F"},
-      {10, ts((75)), ts((75)), "LOAD", 4, 1, 1, "AS34F"},
-      {11, ts((88)), ts((88)), "UNLOAD", 2, 1, 1, "AS34F"},
-      {12, ts((100)), ts((102)), "CLAIM", 2, null, 1, null},
+      {1, ts(0), ts((0)), 1, null, 1},
+      {2, ts((4)), ts((5)), 1, "AS34F", 2},
+      {3, ts((14)), ts((14)), 1, "AS34F", 3},
+      {4, ts((15)), ts((15)), 1, "AS34F", 4},
+      {5, ts((30)), ts((30)), 1, "AS34F", 5},
+      {6, ts((33)), ts((33)), 1, "AS34F", 6},
+      {7, ts((34)), ts((34)), 1, "AS34F", 7},
+      {8, ts((60)), ts((60)), 1, "AS34F", 8},
+      {9, ts((70)), ts((71)), 1, "AS34F", 9},
+      {10, ts((75)), ts((75)), 1, "AS34F", 10},
+      {11, ts((88)), ts((88)), 1, "AS34F", 11},
+      {12, ts((100)), ts((102)), 1, null, 12},
 
       //ZYX (AUMEL - USCHI - DEHAM -)
-      {13, ts((200)), ts((201)), "RECEIVE", 2, null, 3, null},
-      {14, ts((202)), ts((202)), "LOAD", 2, 2, 3, "AS34F"},
-      {15, ts((208)), ts((208)), "UNLOAD", 7, 2, 3, "AS34F"},
-      {16, ts((212)), ts((212)), "LOAD", 7, 2, 3, "AS34F"},
-      {17, ts((230)), ts((230)), "UNLOAD", 6, 2, 3, "AS34F"},
-      {18, ts((235)), ts((235)), "LOAD", 6, 2, 3, "AS34F"},
+      {13, ts((200)), ts((201)), 3, null, 13},
+      {14, ts((202)), ts((202)), 3, "AS34F", 14},
+      {15, ts((208)), ts((208)), 3, "AS34F", 15},
+      {16, ts((212)), ts((212)), 3, "AS34F", 16},
+      {17, ts((230)), ts((230)), 3, "AS34F", 17},
+      {18, ts((235)), ts((235)), 3, "AS34F", 18},
 
       //ABC
-      {19, ts((20)), ts((21)), "CLAIM", 2, null, 2, null},
+      {19, ts((20)), ts((21)), 2, null, 19},
 
       //CBA
-      {20, ts((0)), ts((1)), "RECEIVE", 2, null, 4, null},
-      {21, ts((10)), ts((11)), "LOAD", 2, 2, 4, "AS34F"},
-      {22, ts((20)), ts((21)), "UNLOAD", 7, 2, 4, "AS34F"},
+      {20, ts((0)), ts((1)), 4, null, 20},
+      {21, ts((10)), ts((11)), 4, "AS34F", 21},
+      {22, ts((20)), ts((21)), 4, "AS34F", 22},
 
       //FGH
-      {23, ts(100), ts(160), "RECEIVE", 3, null, 5, null},
-      {24, ts(150), ts(110), "LOAD", 3, 3, 5, "AS34F"},
+      {23, ts(100), ts(160), 5, null, 23},
+      {24, ts(150), ts(110), 5, "AS34F", 24},
 
       // JKL
-      {25, ts(200), ts(220), "RECEIVE", 6, null, 6, null},
-      {26, ts(300), ts(330), "LOAD", 6, 3, 6, "AS34F"},
-      {27, ts(400), ts(440), "UNLOAD", 5, 3, 6}  // Unexpected event
+      {25, ts(200), ts(220), 6, null, 25},
+      {26, ts(300), ts(330), 6, "AS34F", 26},
+      {27, ts(400), ts(440), 6, null, 27}  // Unexpected event
     };
     executeUpdate(jdbcTemplate, handlingEventSql, handlingEventArgs);
   }

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

 
     if (delivery.isRoutedAfterHandling()) {
       return itinerary.firstLeg().deriveLoadActivity();
-    } else {
-      if (unloadedInCustomsClearancePoint()) {
-        return customsIn(customsClearancePoint());
-      } else {
-        return itinerary.activitySucceding(delivery.mostRecentPhysicalHandlingActivity());
-      }
     }
+
+    if (unloadedInCustomsClearancePoint()) {
+      return customsIn(customsClearancePoint());
+    }
+
+    return itinerary.activitySucceding(delivery.mostRecentPhysicalHandlingActivity());
   }
 
   private boolean unloadedInCustomsClearancePoint() {
    * @return True if the cargo is ready to be claimed.
    */
   public boolean isReadyToClaim() {
-    return delivery.onTheGroundAtDestination(routeSpecification);
+    if (customsClearancePoint().sameAs(routeSpecification.destination())) {
+      return customsIn(customsClearancePoint()).sameValueAs(mostRecentHandlingActivity());
+    } else {
+      return delivery.onTheGroundAtDestination(routeSpecification);
+    }
   }
 
   /**

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

    */
   boolean onTheGroundAtDestination(final RouteSpecification routeSpecification) {
     return hasBeenHandledAfterRouting() &&
-           mostRecentHandlingActivity.type() == UNLOAD && 
+           mostRecentHandlingActivity.type() == UNLOAD &&
            routeSpecification.destination().sameAs(mostRecentHandlingActivity.location());
   }
 

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

 import static se.citerus.dddsample.tracking.core.domain.model.handling.HandlingEvent.Type.*;
 import se.citerus.dddsample.tracking.core.domain.model.location.Location;
 import se.citerus.dddsample.tracking.core.domain.model.shared.HandlingActivity;
-import static se.citerus.dddsample.tracking.core.domain.model.shared.HandlingActivity.*;
+import static se.citerus.dddsample.tracking.core.domain.model.shared.HandlingActivity.claimIn;
+import static se.citerus.dddsample.tracking.core.domain.model.shared.HandlingActivity.receiveIn;
 import se.citerus.dddsample.tracking.core.domain.model.voyage.Voyage;
 import se.citerus.dddsample.tracking.core.domain.patterns.valueobject.ValueObjectSupport;
 
 public class Itinerary extends ValueObjectSupport<Itinerary> {
 
   private final List<Leg> legs;
+  // Null object
+  static final Itinerary NONE = new Itinerary();
 
   /**
    * Constructor.
     Validate.notEmpty(legs);
     Validate.noNullElements(legs);
 
+    // TODO
+    // Validate that legs are in proper order, connected
     /*final Iterator<Leg> it = legs.iterator();
     Leg leg = it.next();
     while (it.hasNext()) {
       Validate.isTrue(lit.previous().unloadTime().before(lit.next().loadTime()));
     }*/
 
-    // TODO
-    // Validate that legs are in proper order, connected
-    // and that load/unload times are doable?
-
     this.legs = legs;
   }
 
       return null;
     } else {
       if (handlingActivity.type() == LOAD) {
-        return unloadOff(handlingActivity.voyage()).in(matchingLeg.unloadLocation());
+        return matchingLeg.deriveUnloadActivity();
       } else if (handlingActivity.type() == UNLOAD) {
         return deriveFromNextLeg(nextLeg(matchingLeg));
       } else {
 
   Itinerary() {
     // Needed by Hibernate
-    legs = null;
+    legs = Collections.emptyList();
   }
 
 }

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

   private final Date unloadTime;
 
   // TODO hide this, use factory only
-  public Leg(Voyage voyage, Location loadLocation, Location unloadLocation, Date loadTime, Date unloadTime) {
+  public Leg(final Voyage voyage, final Location loadLocation, final Location unloadLocation, final Date loadTime, final Date unloadTime) {
     Validate.notNull(voyage, "Voyage is required");
     Validate.notNull(loadLocation, "Load location is required");
     Validate.notNull(unloadLocation, "Unload location is required");
    * @param unloadLocation unload location
    * @return A leg on this voyage between the given locations.
    */
-  public static Leg deriveLeg(Voyage voyage, Location loadLocation, Location unloadLocation) {
+  public static Leg deriveLeg(final Voyage voyage, final Location loadLocation, final Location unloadLocation) {
+    // TODO enable this (or perhaps the requirement for load/unlaod time covers this?)
+    //voyage.locations().contains(loadLocation);
+    //voyage.locations().contains(unloadLocation);
+    Validate.notNull(voyage, "Voyage is required");
     return new Leg(voyage, loadLocation, unloadLocation, voyage.schedule().departureTimeAt(loadLocation), voyage.schedule().arrivalTimeAt(unloadLocation));
   }
 

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

 
   @Override
   public String toString() {
-    return origin + " to " + destination + " by " + arrivalDeadline;
+    return origin + " - " + destination + " by " + arrivalDeadline;
   }
 
   RouteSpecification() {

dddsample/tracking/core/src/main/java/se/citerus/dddsample/tracking/core/domain/model/location/CustomsZone.java

     Validate.notNull(code, "Code is required");
     Validate.isTrue(VALID_PATTERN.matcher(code).matches(), code + " is not a valid customs zone code (does not match pattern)");
     Validate.notNull(name, "Name is required");
+
     this.code = code.toUpperCase();
     this.name = name;
   }
    * following this route. Note that specific voyages, etc do not
    * matter, only the sequence of Locations.
    *
-   * @param route
-   * @return
+   * @param route a list of locations
+   * @return The first location on the route that is in this customs zone.
    */
   public Location entryPoint(final List<Location> route) {
     for (Location location : route) {
     return name;
   }
 
-  public boolean includes(final Location location) {
+  boolean includes(final Location location) {
     return this.sameAs(location.customsZone());
   }
 

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

 package se.citerus.dddsample.tracking.core.domain.model.voyage;
 
 import static se.citerus.dddsample.tracking.core.application.util.DateTestUtil.toDate;
-import se.citerus.dddsample.tracking.core.domain.model.location.Location;
 import static se.citerus.dddsample.tracking.core.domain.model.location.SampleLocations.*;
 
 import java.lang.reflect.Field;
-import java.util.*;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
 
 /**
  * Sample carrier movements, for test purposes.
     build();
 
   public final static Voyage pacific2 = new Voyage.Builder(new VoyageNumber("PAC2"), SHANGHAI).
+    addMovement(TOKYO, toDate("2009-03-04"), toDate("2009-03-05")).
     addMovement(LONGBEACH, toDate("2009-03-06"), toDate("2009-03-08")).
     addMovement(SEATTLE, toDate("2009-03-10"), toDate("2009-03-14")).
     addMovement(HANGZOU, toDate("2009-03-14"), toDate("2009-03-16")).
     addMovement(NEWYORK, toDate("2009-03-11"), toDate("2009-03-14")).
     build();
 
-  public final static Voyage continenal2 = new Voyage.Builder(new VoyageNumber("CNT2"), LONGBEACH).
+  public final static Voyage continental2 = new Voyage.Builder(new VoyageNumber("CNT2"), LONGBEACH).
     addMovement(DALLAS, toDate("2009-03-06"), toDate("2009-03-08")).
     addMovement(NEWYORK, toDate("2009-03-10"), toDate("2009-03-14")).
     build();
 
+  public final static Voyage continental3 = new Voyage.Builder(new VoyageNumber("CNT3"), SEATTLE).
+    addMovement(CHICAGO, toDate("2009-03-06"), toDate("2009-03-08")).
+    addMovement(NEWYORK, toDate("2009-03-10"), toDate("2009-03-14")).
+    build();
+
   public final static Voyage atlantic1 = new Voyage.Builder(new VoyageNumber("ATC1"), NEWYORK).
       addMovement(ROTTERDAM, toDate("2009-03-15"), toDate("2009-03-18")).
       addMovement(HAMBURG, toDate("2009-03-19"), toDate("2009-03-20")).
       build();
 
   public final static Voyage atlantic2 = new Voyage.Builder(new VoyageNumber("ATC2"), NEWYORK).
-      addMovement(ROTTERDAM, toDate("2009-03-17"), toDate("2009-03-20")).
+      addMovement(HAMBURG, toDate("2009-03-17"), toDate("2009-03-20")).
       addMovement(GOTHENBURG, toDate("2009-03-22"), toDate("2009-03-24")).
       addMovement(STOCKHOLM, toDate("2009-03-25"), toDate("2009-03-26")).
       addMovement(HELSINKI, toDate("2009-03-27"), toDate("2009-03-28")).
       addMovement(NEWYORK, toDate("2009-03-31"), toDate("2009-04-04")).
       build();
 
-
-  public final static Voyage v300 = new Voyage.Builder(new VoyageNumber("V300"), TOKYO).
-    addMovement(ROTTERDAM, toDate("2009-03-08"), toDate("2009-03-11")).
-    addMovement(HAMBURG, toDate("2009-03-11"), toDate("2009-03-12")).
-    addMovement(MELBOURNE, toDate("2009-03-14"), toDate("2009-03-18")).
-    addMovement(TOKYO, toDate("2009-03-19"), toDate("2009-03-21")).
-    build();
-
-  public final static Voyage v400 = new Voyage.Builder(new VoyageNumber("V400"), HAMBURG).
-    addMovement(STOCKHOLM, toDate("2009-03-14"), toDate("2009-03-15")).
-    addMovement(HELSINKI, toDate("2009-03-15"), toDate("2009-03-16")).
-    addMovement(HAMBURG, toDate("2009-03-20"), toDate("2009-03-22")).
-    build();
-
   /**
    * Voyage number 0100S (by ship)
    * <p/>
 
   private static final Map<VoyageNumber, Voyage> ALL = new HashMap<VoyageNumber, Voyage>();
 
-  static {
+    static {
     for (Field field : SampleVoyages.class.getDeclaredFields()) {
       if (field.getType().equals(Voyage.class)) {
         try {

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

 import se.citerus.dddsample.tracking.core.domain.model.location.Location;
 import static se.citerus.dddsample.tracking.core.domain.model.location.SampleLocations.*;
 import se.citerus.dddsample.tracking.core.domain.model.shared.HandlingActivity;
-import static se.citerus.dddsample.tracking.core.domain.model.shared.HandlingActivity.loadOnto;
-import static se.citerus.dddsample.tracking.core.domain.model.shared.HandlingActivity.unloadOff;
+import static se.citerus.dddsample.tracking.core.domain.model.shared.HandlingActivity.*;
+import static se.citerus.dddsample.tracking.core.domain.model.voyage.SampleVoyages.*;
 import se.citerus.dddsample.tracking.core.domain.model.voyage.Voyage;
 import se.citerus.dddsample.tracking.core.domain.model.voyage.VoyageNumber;
 
-import java.util.Arrays;
 import java.util.Date;
 
 public class CargoTest extends TestCase {
     assertFalse("Cargos are not equal when TrackingID differ", c1.equals(c2));
   }
 
-  public void testIsReadyToClaim() throws Exception {
-    Cargo cargo = setUpCargoWithItinerary(HANGZOU, TOKYO, NEWYORK);
+  public void testIsReadyToClaimWithDestinationDifferentFromCustomsClearancePoint() {
+    Cargo cargo = new Cargo(new TrackingId("CARGO1"), new RouteSpecification(HONGKONG, NEWYORK, toDate("2009-12-24")));
+    Itinerary itinerary = new Itinerary(
+      Leg.deriveLeg(pacific1, HONGKONG, LONGBEACH),
+      Leg.deriveLeg(continental2, LONGBEACH, NEWYORK)
+    );
+    cargo.assignToRoute(itinerary);
+    assertFalse(cargo.routeSpecification().destination().sameAs(cargo.customsClearancePoint()));
     assertFalse(cargo.isReadyToClaim());
 
-    // Adding an event unrelated to unloading at final destination
-    cargo.handled(new HandlingActivity(RECEIVE, HANGZOU));
+    cargo.handled(unloadOff(pacific1).in(LONGBEACH));
     assertFalse(cargo.isReadyToClaim());
 
-    Voyage voyage = new Voyage.Builder(new VoyageNumber("0123"), HANGZOU).
-        addMovement(NEWYORK, new Date(1), new Date(2)).
-        build();
-
-    // Adding an unload event, but not at the final destination
-    cargo.handled(new HandlingActivity(UNLOAD, TOKYO, voyage));
+    cargo.handled(loadOnto(continental2).in(LONGBEACH));
     assertFalse(cargo.isReadyToClaim());
-
-    // Adding an event in the final destination, but not unload
-    /*cargo.handled(new HandlingActivity(CUSTOMS, NEWYORK));
-    assertFalse(cargo.isReadyToClaim());
-    assertFalse(cargo.isMisdirected());*/
-
-    // Finally, cargo is unloaded at final destination
-    cargo.handled(new HandlingActivity(UNLOAD, NEWYORK, voyage));
+    
+    cargo.handled(unloadOff(continental2).in(NEWYORK));
     assertTrue(cargo.isReadyToClaim());
   }
 
-  public void testCustomsInMelbourne() throws Exception {
-    Cargo cargo = setUpCargoWithItinerary(STOCKHOLM, HAMBURG, MELBOURNE);
-    
-    /*cargo.handled(unloadOff(crazyVoyage).in(HAMBURG));
-    assertThat(cargo.nextExpectedActivity(), is(loadOnto(crazyVoyage).in(HAMBURG)));
-    assertFalse(cargo.isMisdirected());
+  public void testIsReadyToClaimWithDestinationSameAsCustomsClearancePoint() {
+    Cargo cargo = new Cargo(new TrackingId("CARGO1"), new RouteSpecification(SHANGHAI, SEATTLE, toDate("2009-12-24")));
+    Itinerary itinerary = new Itinerary(
+      Leg.deriveLeg(pacific2, SHANGHAI, SEATTLE)
+    );
+    cargo.assignToRoute(itinerary);
+    assertTrue(cargo.routeSpecification().destination().sameAs(cargo.customsClearancePoint()));
+    assertFalse(cargo.isReadyToClaim());
 
-    cargo.handled(loadOnto(crazyVoyage).in(HAMBURG));
-    assertThat(cargo.nextExpectedActivity(), is(unloadOff(crazyVoyage).in(MELBOURNE)));
-    assertFalse(cargo.isMisdirected());
+    cargo.handled(unloadOff(pacific2).in(SEATTLE));
+    assertFalse(cargo.isReadyToClaim());
 
-    cargo.handled(unloadOff(crazyVoyage).in(MELBOURNE));
-    assertThat(cargo.nextExpectedActivity(), is(customsIn(MELBOURNE)));
-    assertFalse(cargo.isMisdirected());
+    cargo.handled(customsIn(SEATTLE));
+    assertTrue(cargo.isReadyToClaim());
 
-    cargo.handled(customsIn(MELBOURNE));
-    assertThat(cargo.nextExpectedActivity(), is(claimIn(MELBOURNE)));
-    assertFalse(cargo.isMisdirected());*/
+    cargo.handled(claimIn(SEATTLE));
+    assertFalse(cargo.isReadyToClaim());
   }
 
   private Cargo populateCargoReceivedStockholm() throws Exception {
     return cargo;
   }
 
-  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()));
+  public void testIsMisdirectedHappyPath() throws Exception {
+    Cargo cargo = shanghaiSeattleChicagoOnPacific2AndContinental3();
+
+    //A cargo with no handling events is not misdirected
     assertFalse(cargo.isMisdirected());
 
-    cargo = setUpCargoWithItinerary(SHANGHAI, ROTTERDAM, GOTHENBURG);
+    cargo.handled(receiveIn(SHANGHAI));
+    assertFalse(cargo.isMisdirected());
 
-    //A cargo with no handling events is not misdirected
+    cargo.handled(loadOnto(pacific2).in(SHANGHAI));
     assertFalse(cargo.isMisdirected());
 
-    //Happy path
-    cargo.handled(new HandlingActivity(RECEIVE, SHANGHAI));
-    cargo.handled(new HandlingActivity(LOAD, SHANGHAI, crazyVoyage));
-    cargo.handled(new HandlingActivity(UNLOAD, ROTTERDAM, crazyVoyage));
-    cargo.handled(new HandlingActivity(LOAD, ROTTERDAM, crazyVoyage));
-    cargo.handled(new HandlingActivity(UNLOAD, GOTHENBURG, crazyVoyage));
-    cargo.handled(new HandlingActivity(CLAIM, GOTHENBURG));
-    cargo.handled(new HandlingActivity(CUSTOMS, GOTHENBURG));
+    cargo.handled(unloadOff(pacific2).in(SEATTLE));
     assertFalse(cargo.isMisdirected());
 
-    //Try a couple of failing ones
+    cargo.handled(customsIn(SEATTLE));
+    assertFalse(cargo.isMisdirected());
 
-    cargo = setUpCargoWithItinerary(SHANGHAI, ROTTERDAM, GOTHENBURG);
+    cargo.handled(loadOnto(continental3).in(SEATTLE));
+    assertFalse(cargo.isMisdirected());
+
+    cargo.handled(unloadOff(continental3).in(CHICAGO));
+    assertFalse(cargo.isMisdirected());
+
+    cargo.handled(claimIn(CHICAGO));
+    assertFalse(cargo.isMisdirected());
+  }
 
-    cargo.handled(new HandlingActivity(RECEIVE, HANGZOU));
+  public void testIsMisdirectedIncorrectReceive() throws Exception {
+    Cargo cargo = shanghaiSeattleChicagoOnPacific2AndContinental3();
+
+    cargo.handled(receiveIn(TOKYO));
     assertTrue(cargo.isMisdirected());
+  }
 
+  public void testIsMisdirectedLoadOntoWrongVoyage() throws Exception {
+    Cargo cargo = shanghaiSeattleChicagoOnPacific2AndContinental3();
 
-    cargo = setUpCargoWithItinerary(SHANGHAI, ROTTERDAM, GOTHENBURG);
+    cargo.handled(loadOnto(pacific1).in(HONGKONG));
+    assertTrue(cargo.isMisdirected());
+  }
 
-    cargo.handled(new HandlingActivity(RECEIVE, SHANGHAI));
-    cargo.handled(new HandlingActivity(LOAD, SHANGHAI, crazyVoyage));
-    cargo.handled(new HandlingActivity(UNLOAD, ROTTERDAM, crazyVoyage));
-    cargo.handled(new HandlingActivity(CLAIM, ROTTERDAM));
+  public void testIsMisdirectedUnloadInWrongLocation() throws Exception {
+    Cargo cargo = shanghaiSeattleChicagoOnPacific2AndContinental3();
 
+    cargo.handled(unloadOff(pacific2).in(TOKYO));
     assertTrue(cargo.isMisdirected());
   }
 
+  public void testIsMisdirectedCustomsInWrongLocation() throws Exception {
+    Cargo cargo = shanghaiSeattleChicagoOnPacific2AndContinental3();
+
+    cargo.handled(customsIn(CHICAGO));
+    assertTrue(cargo.isMisdirected());
+  }
+
+  public void testIsMisdirectedClaimedInWrongLocation() throws Exception {
+    Cargo cargo = shanghaiSeattleChicagoOnPacific2AndContinental3();
+
+    cargo.handled(claimIn(SEATTLE));
+    assertTrue(cargo.isMisdirected());
+  }
+
+  public void testIsMisdirectedAfterRerouting() throws Exception {
+    Cargo cargo = shanghaiSeattleChicagoOnPacific2AndContinental3();
+
+    cargo.handled(loadOnto(pacific2).in(SHANGHAI));
+    assertFalse(cargo.isMisdirected());
+
+    // Cargo destination is changed by customer mid-route
+    RouteSpecification newRouteSpec = cargo.routeSpecification().
+      withOrigin(cargo.lastKnownLocation()).
+      withDestination(NEWYORK);
+
+    cargo.specifyNewRoute(newRouteSpec);
+    // Misrouted, but not misdirected. Delivery is still accoring to plan (itinerary),
+    // but not according to desire (route specification).
+    assertFalse(cargo.isMisdirected());
+    assertTrue(cargo.routingStatus() == MISROUTED);
+
+    /**
+     * This is a perfect example of how LegMatch is a modelling breakthrough.
+     * It allows us to easily construct an itinerary that completes the remainder of the
+     * old itinerary and appends the new and different path.
+     */
+    Leg currentLeg = cargo.itinerary().legMatchOf(cargo.mostRecentHandlingActivity()).leg();
+    Itinerary newItinerary = new Itinerary(
+      currentLeg,
+      Leg.deriveLeg(continental3, SEATTLE, NEWYORK)
+    );
+    cargo.assignToRoute(newItinerary);
+    assertFalse(cargo.isMisdirected());
+
+    cargo.handled(unloadOff(pacific2).in(SEATTLE));
+    assertFalse(cargo.isMisdirected());
+
+    cargo.handled(loadOnto(continental3).in(SEATTLE));
+    assertFalse(cargo.isMisdirected());
+
+    cargo.handled(unloadOff(continental3).in(NEWYORK));
+    assertFalse(cargo.isMisdirected());
+  }
+
+  private Cargo shanghaiSeattleChicagoOnPacific2AndContinental3() {
+    Cargo cargo = new Cargo(new TrackingId("CARGO1"), new RouteSpecification(SHANGHAI, CHICAGO, toDate("2009-12-24")));
+
+    // A cargo with no itinerary is not misdirected
+    assertFalse(cargo.isMisdirected());
+
+    Itinerary itinerary = new Itinerary(
+        Leg.deriveLeg(pacific2, SHANGHAI, SEATTLE),
+        Leg.deriveLeg(continental3, SEATTLE, CHICAGO)
+    );
+    cargo.assignToRoute(itinerary);
+    return cargo;
+  }
+
   public void testCustomsClearancePoint() {
     //cargo destination NYC
     final Cargo cargo = new Cargo(new TrackingId("XYZ"),
     Cargo cargo = new Cargo(new TrackingId("CARGO1"), new RouteSpecification(origin, destination, new Date()));
 
     Itinerary itinerary = new Itinerary(
-        Arrays.asList(
-            new Leg(crazyVoyage, origin, midpoint, new Date(1), new Date(2)),
-            new Leg(crazyVoyage, midpoint, destination, new Date(3), new Date(4))
-        )
+        Leg.deriveLeg(crazyVoyage, origin, midpoint),
+        Leg.deriveLeg(crazyVoyage, midpoint, destination)
     );
 
     cargo.assignToRoute(itinerary);

dddsample/tracking/core/src/test/java/se/citerus/dddsample/tracking/core/domain/model/cargo/ItineraryTest.java

 import se.citerus.dddsample.tracking.core.domain.model.voyage.VoyageNumber;
 
 import java.util.ArrayList;
-import java.util.Arrays;
 import java.util.Date;
 import java.util.List;
 
   public void testIfCargoIsOnTrack() {
 
     Itinerary itinerary = new Itinerary(
-      Arrays.asList(
-        new Leg(voyage, SHANGHAI, ROTTERDAM, new Date(1), new Date(2)),
-        new Leg(voyage, ROTTERDAM, GOTHENBURG, new Date(3), new Date(4))
-      )
+        Leg.deriveLeg(voyage, SHANGHAI, ROTTERDAM),
+        Leg.deriveLeg(voyage, ROTTERDAM, GOTHENBURG)
     );
 
     // HandlingActivity.Load(cargo, RECEIVE, SHANGHAI, toDate("2009-05-03"))

dddsample/tracking/core/src/test/java/se/citerus/dddsample/tracking/core/domain/model/cargo/LegTest.java

 
   final Voyage voyage = NEW_YORK_TO_DALLAS;
 
-  @Test(expected = NullPointerException.class)
+  @Test(expected = IllegalArgumentException.class)
   public void testConstructor() throws Exception {
     Leg.deriveLeg(null, null, null);
   }

dddsample/tracking/core/src/test/java/se/citerus/dddsample/tracking/core/domain/model/cargo/RouteSpecificationTest.java

 import se.citerus.dddsample.tracking.core.domain.model.voyage.Voyage;
 import se.citerus.dddsample.tracking.core.domain.model.voyage.VoyageNumber;
 
-import java.util.Arrays;
-
 public class RouteSpecificationTest extends TestCase {
 
   final Voyage hongKongTokyoNewYork = new Voyage.Builder(
     addMovement(CHICAGO, toDate("2009-02-12"), toDate("2009-02-20")).
     build();
 
-  // TODO:
-  // it shouldn't be possible to create Legs that have load/unload locations
-  // and/or dates that don't match the voyage's carrier movements.
-  final Itinerary itinerary = new Itinerary(Arrays.asList(
-    new Leg(hongKongTokyoNewYork, HONGKONG, NEWYORK,
-      toDate("2009-02-01"), toDate("2009-02-10")),
-    new Leg(dallasNewYorkChicago, NEWYORK, CHICAGO,
-      toDate("2009-02-12"), toDate("2009-02-20")))
+  final Itinerary itinerary = new Itinerary(
+    Leg.deriveLeg(hongKongTokyoNewYork, HONGKONG, NEWYORK),
+    Leg.deriveLeg(dallasNewYorkChicago, NEWYORK, CHICAGO)
   );
 
   public void testIsSatisfiedBy_Success() {

dddsample/tracking/core/src/test/java/se/citerus/dddsample/tracking/core/domain/model/handling/HandlingEventTest.java

 
   public void testCurrentLocationLoadEvent() throws Exception {
 
-    HandlingEvent ev = new HandlingEvent(cargo, new Date(), new Date(), LOAD, CHICAGO, SampleVoyages.continenal2, new OperatorCode("ABCDE"));
+    HandlingEvent ev = new HandlingEvent(cargo, new Date(), new Date(), LOAD, CHICAGO, SampleVoyages.continental2, new OperatorCode("ABCDE"));
 
     assertEquals(CHICAGO, ev.location());
   }
 
   public void testCurrentLocationUnloadEvent() throws Exception {
-    HandlingEvent ev = new HandlingEvent(cargo, new Date(), new Date(), UNLOAD, HAMBURG, SampleVoyages.continenal2, new OperatorCode("ABCDE"));
+    HandlingEvent ev = new HandlingEvent(cargo, new Date(), new Date(), UNLOAD, HAMBURG, SampleVoyages.continental2, new OperatorCode("ABCDE"));
 
     assertEquals(HAMBURG, ev.location());
   }

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

 import static se.citerus.dddsample.tracking.core.domain.model.voyage.SampleVoyages.*;
 import static se.citerus.dddsample.tracking.core.domain.model.voyage.Voyage.NONE;
 import se.citerus.dddsample.tracking.core.domain.service.RoutingService;
+import se.citerus.dddsample.tracking.core.infrastructure.persistence.inmemory.TrackingIdFactoryInMem;
 
 import static java.util.Arrays.asList;
-import static java.util.Collections.emptyList;
+import java.util.Date;
 import java.util.List;
 
 public class CargoLifecycle {
 
   @Test
-  public void cargoIsMisdirectedAndRerouted() throws Exception {
+  public void cargoIsProperlyDelivered() 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)));
+    assertNotNull(cargo.estimatedTimeOfArrival());
+    assertThat(cargo.customsClearancePoint(), is(STOCKHOLM));
+
+    // 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());
+
+    // Unloaded
+    cargo.handled(unloadOff(pacific1).in(LONGBEACH));
+
+    assertFalse(cargo.isMisdirected());
+    assertThat(cargo.currentVoyage(), is(NONE));
+    assertThat(cargo.lastKnownLocation(), is(LONGBEACH));
+    assertThat(cargo.transportStatus(), is(IN_PORT));
+    assertThat(cargo.nextExpectedActivity(), is(loadOnto(continental1).in(LONGBEACH)));
+
+    cargo.handled(loadOnto(continental1).in(LONGBEACH));
+
+    assertFalse(cargo.isMisdirected());
+    assertThat(cargo.lastKnownLocation(), is(LONGBEACH));
+    assertThat(cargo.transportStatus(), is(ONBOARD_CARRIER));
+    assertThat(cargo.currentVoyage(), is(continental1));
+    assertThat(cargo.nextExpectedActivity(), is(unloadOff(continental1).in(NEWYORK)));
+
+    cargo.handled(unloadOff(continental1).in(NEWYORK));
+
+    assertFalse(cargo.isMisdirected());
+    assertThat(cargo.lastKnownLocation(), is(NEWYORK));
+    assertThat(cargo.transportStatus(), is(IN_PORT));
+    assertThat(cargo.currentVoyage(), is(NONE));
+    assertThat(cargo.nextExpectedActivity(), is(loadOnto(atlantic2).in(NEWYORK)));
+
+    cargo.handled(loadOnto(atlantic2).in(NEWYORK));
+
+    assertFalse(cargo.isMisdirected());
+    assertThat(cargo.lastKnownLocation(), is(NEWYORK));
+    assertThat(cargo.transportStatus(), is(ONBOARD_CARRIER));
+    assertThat(cargo.currentVoyage(), is(atlantic2));
+    assertThat(cargo.nextExpectedActivity(), is(unloadOff(atlantic2).in(STOCKHOLM)));
+
+    cargo.handled(unloadOff(atlantic2).in(STOCKHOLM));
+
+    assertFalse(cargo.isReadyToClaim());
+    assertFalse(cargo.isMisdirected());
+    assertThat(cargo.lastKnownLocation(), is(STOCKHOLM));
+    assertThat(cargo.transportStatus(), is(IN_PORT));
+    assertThat(cargo.currentVoyage(), is(NONE));
+    assertThat(cargo.nextExpectedActivity(), is(customsIn(STOCKHOLM)));
+
+    cargo.handled(customsIn(STOCKHOLM));
+
+    assertTrue(cargo.isReadyToClaim());
+    assertThat(cargo.nextExpectedActivity(), is(claimIn(STOCKHOLM)));
+
+    cargo.handled(claimIn(STOCKHOLM));
     
-    TrackingId trackingId = new TrackingId("ABC");
-    RouteSpecification routeSpecification =
-      new RouteSpecification(HONGKONG, STOCKHOLM, toDate("2009-03-18"));
-    Cargo cargo = new Cargo(trackingId, routeSpecification);
+    assertNull(cargo.nextExpectedActivity());
+  }
+
+  @Test
+  public void cargoIsMisdirectedAndRerouted() throws Exception {
+
+    Cargo cargo = setupCargoFromHongkongToStockholm();
 
     // Initial state, before routing
     assertThat(cargo.transportStatus(), is(NOT_RECEIVED));
     cargo.assignToRoute(newItinerary);
 
     assertThat(cargo.routingStatus(), is(ROUTED));
-    assertThat(cargo.nextExpectedActivity(), is(loadOnto(v300).in(ROTTERDAM)));
+    assertThat(cargo.nextExpectedActivity(), is(loadOnto(atlantic1).in(ROTTERDAM)));
 
 
 
 
 
     // Loaded, back on track
-    cargo.handled(loadOnto(v300).in(ROTTERDAM));
+    cargo.handled(loadOnto(atlantic1).in(ROTTERDAM));
     assertFalse(cargo.isMisdirected());
     assertThat(cargo.lastKnownLocation(), is(ROTTERDAM));
     assertThat(cargo.transportStatus(), is(ONBOARD_CARRIER));
 
   }
 
+  @Test
+  public void customerRequestsChangeOfDestination() 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)));
+    assertNotNull(cargo.estimatedTimeOfArrival());
+
+    // 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());
+
+    // Unloaded
+    cargo.handled(unloadOff(pacific1).in(LONGBEACH));
+
+    assertThat(cargo.currentVoyage(), is(NONE));
+    assertThat(cargo.lastKnownLocation(), is(LONGBEACH));
+    assertThat(cargo.transportStatus(), is(IN_PORT));
+    assertFalse(cargo.isMisdirected());
+    assertThat(cargo.nextExpectedActivity(), is(loadOnto(continental1).in(LONGBEACH)));
+
+    // Customer wants cargo to go to Rotterdam instead of Stockholm
+    RouteSpecification toRotterdam = cargo.routeSpecification().
+      withOrigin(cargo.lastKnownLocation()).
+      withDestination(ROTTERDAM);
+
+    cargo.specifyNewRoute(toRotterdam);
+
+    // Misrouted
+    assertThat(cargo.routingStatus(), is(MISROUTED));
+    assertFalse(cargo.isMisdirected());
+    assertThat(cargo.lastKnownLocation(), is(LONGBEACH));
+    assertThat(cargo.transportStatus(), is(IN_PORT));
+
+    // Assign to new route
+    List<Itinerary> available = routingService.fetchRoutesForSpecification(cargo.routeSpecification());
+    Itinerary newItinerary = selectAppropriateRoute(available);
+    cargo.assignToRoute(newItinerary);
+
+    assertThat(cargo.routingStatus(), is(ROUTED));
+    assertThat(cargo.nextExpectedActivity(), is(loadOnto(continental2).in(LONGBEACH)));
+
+    // Loaded, back on track
+    cargo.handled(loadOnto(continental2).in(LONGBEACH));
+    assertFalse(cargo.isMisdirected());
+    assertThat(cargo.lastKnownLocation(), is(LONGBEACH));
+    assertThat(cargo.transportStatus(), is(ONBOARD_CARRIER));
+    assertThat(cargo.nextExpectedActivity(), is(unloadOff(continental2).in(NEWYORK)));
+
+    // Fast forward a bit
+    cargo.handled(unloadOff(continental2).in(NEWYORK));
+    cargo.handled(loadOnto(atlantic1).in(NEWYORK));
+
+    // Cargo enters its destination customs zone
+    cargo.handled(unloadOff(atlantic1).in(ROTTERDAM));
+    assertThat(cargo.nextExpectedActivity(), is(customsIn(ROTTERDAM)));
+    cargo.handled(customsIn(ROTTERDAM));
+    assertThat(cargo.nextExpectedActivity(), is(claimIn(ROTTERDAM)));
+  }
+
+  private Cargo setupCargoFromHongkongToStockholm() {
+    TrackingId trackingId = trackingIdFactory.nextTrackingId();
+    Date arrivalDeadline = toDate("2009-04-10");
+    RouteSpecification routeSpecification = new RouteSpecification(HONGKONG, STOCKHOLM, arrivalDeadline);
+
+    return new Cargo(trackingId, routeSpecification);
+  }
+
+  // Stubbed out customer selection process
   private Itinerary selectAppropriateRoute(List<Itinerary> itineraries) {
     return itineraries.get(0);
   }
 
-  RoutingService routingService = new ScenarioStubRoutingService();
+  private final RoutingService routingService = new ScenarioStubRoutingService();
+
+  private final TrackingIdFactory trackingIdFactory = new TrackingIdFactoryInMem();
 
   private static class ScenarioStubRoutingService implements RoutingService {
 
-    private static final Itinerary itinerary1 = new Itinerary(asList(
-      new Leg(pacific1, HONGKONG, LONGBEACH, toDate("2009-03-03"), toDate("2009-03-09")),
-      new Leg(continental1, LONGBEACH, NEWYORK, toDate("2009-03-10"), toDate("2009-03-14")),
-      new Leg(pacific2, NEWYORK, STOCKHOLM, toDate("2009-03-07"), toDate("2009-03-11"))
-    ));
+    private static final Itinerary itinerary1 = new Itinerary(
+      Leg.deriveLeg(pacific1, HONGKONG, LONGBEACH),
+      Leg.deriveLeg(continental1, LONGBEACH, NEWYORK),
+      Leg.deriveLeg(atlantic2, NEWYORK, STOCKHOLM)
+    );
+
+    private static final Itinerary itinerary2 = new Itinerary(
+      Leg.deriveLeg(atlantic1, ROTTERDAM, HAMBURG),
+      Leg.deriveLeg(atlantic2, HAMBURG, STOCKHOLM)
+    );
 
-    private static final Itinerary itinerary2 = new Itinerary(asList(
-      new Leg(v300, ROTTERDAM, HAMBURG, toDate("2009-03-10"), toDate("2009-03-12")),
-      new Leg(v400, HAMBURG, STOCKHOLM, toDate("2009-03-14"), toDate("2009-03-15"))
-    ));
+    private static final Itinerary itinerary3 = new Itinerary(
+      Leg.deriveLeg(continental2, LONGBEACH, NEWYORK),
+      Leg.deriveLeg(atlantic1, NEWYORK, ROTTERDAM)
+    );
 
     public List<Itinerary> fetchRoutesForSpecification(RouteSpecification routeSpecification) {
       if (routeSpecification.origin().sameAs(HONGKONG)) {
       } else if (routeSpecification.origin().sameAs(ROTTERDAM)) {
         // Rotterdam - Hamburg - Stockholm, rerouting misdirected cargo from Rotterdam
         return asList(itinerary2);
+      } else if (routeSpecification.origin().sameAs(LONGBEACH)) {
+        // Customer requested change of destination
+        return asList(itinerary3);
       } else {
-        return emptyList();
+        throw new IllegalStateException("No stubbed data for " + routeSpecification);
       }
     }
 

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

-package se.citerus.dddsample.tracking.core.domain.scenario;
-
-import static org.hamcrest.core.Is.is;
-import static org.junit.Assert.*;
-import org.junit.Test;
-import static se.citerus.dddsample.tracking.core.application.util.DateTestUtil.toDate;
-import se.citerus.dddsample.tracking.core.domain.model.cargo.*;
-import static se.citerus.dddsample.tracking.core.domain.model.cargo.RoutingStatus.*;
-import static se.citerus.dddsample.tracking.core.domain.model.cargo.TransportStatus.*;
-import se.citerus.dddsample.tracking.core.domain.model.handling.*;
-import static se.citerus.dddsample.tracking.core.domain.model.handling.HandlingEvent.Type.*;
-import se.citerus.dddsample.tracking.core.domain.model.location.Location;
-import se.citerus.dddsample.tracking.core.domain.model.location.LocationRepository;
-import static se.citerus.dddsample.tracking.core.domain.model.location.SampleLocations.*;
-import se.citerus.dddsample.tracking.core.domain.model.shared.HandlingActivity;
-import static se.citerus.dddsample.tracking.core.domain.model.shared.HandlingActivity.*;
-import static se.citerus.dddsample.tracking.core.domain.model.voyage.SampleVoyages.*;
-import se.citerus.dddsample.tracking.core.domain.model.voyage.Voyage;
-import static se.citerus.dddsample.tracking.core.domain.model.voyage.Voyage.NONE;
-import se.citerus.dddsample.tracking.core.domain.model.voyage.VoyageNumber;
-import se.citerus.dddsample.tracking.core.domain.model.voyage.VoyageRepository;
-import se.citerus.dddsample.tracking.core.domain.service.RoutingService;
-import se.citerus.dddsample.tracking.core.infrastructure.persistence.inmemory.*;
-
-import java.util.Arrays;
-import java.util.Date;
-import java.util.List;
-
-public class CargoLifecycleScenarioTest {
-
-  /**
-   * Repository implementations are part of the infrastructure layer,
-   * which in this test is stubbed out by in-memory replacements.
-   */
-  HandlingEventRepository handlingEventRepository = new HandlingEventRepositoryInMem();
-  CargoRepository cargoRepository = new CargoRepositoryInMem();
-  LocationRepository locationRepository = new LocationRepositoryInMem();
-  VoyageRepository voyageRepository = new VoyageRepositoryInMem();
-
-  HandlingEventFactory handlingEventFactory = new HandlingEventFactory(cargoRepository, voyageRepository, locationRepository);
-  TrackingIdFactory trackingIdFactory = new TrackingIdFactoryInMem();
-
-  /**
-   * This is a domain service interface, whose implementation
-   * is part of the infrastructure layer (re mote call to external system).
-   * <p/>
-   * It is stubbed in this test.
-   */
-  RoutingService routingService = new ScenarioStubRoutingService();
-
-  TrackingId trackingId;
-
-  @Test
-  public void cargoIsCorrectlyDelivered() throws Exception {
-    bookCargoFromHongkongToStockholm();
-    checkDeliveryAfterBooking();
-
-    // Route: Hongkong - Long Beach - New York - Stockholm
-    routeCargoFromHongkongToStockholm();
-    checkDeliveryAfterRouting();
-
-    receiveInHongkong();
-    checkDeliveryAfterReceiveInHongkong();
-
-    loadInHongkong();
-    checkDeliveryAfterLoadInHongKong();
-
-    unloadInLongBeach();
-    checkDeliveryAfterUnloadInLongBeach();
-
-    loadInLongBeach();
-    checkDeliveryAfterLoadInLongBeach();
-
-    unloadInNewYork();
-    checkDeliveryAfterUnloadInNewYork();
-
-    loadInNewYork();
-    checkDeliveryAfterLoadInNewYork();
-
-    unloadInStockholmOffOf(pacific2);
-    checkDeliveryAfterUnloadInStockholm();
-
-    customsInStockholm();
-    checkDeliveryAfterCustomsInStockholm();
-    
-    claimInStockholm();
-    checkDeliveryAfterClaimInStockholm();
-  }
-
-  private void unloadInLongBeach() throws CannotCreateHandlingEventException {
-    createHandlingEventAndUpdateAggregates(toDate("2009-03-06"), pacific1, LONGBEACH, UNLOAD);
-  }
-
-  private void checkDeliveryAfterUnloadInLongBeach() {
-    Cargo cargo = cargoRepository.find(trackingId);
-
-    assertThat(cargo.currentVoyage(), is(NONE));
-    assertThat(cargo.lastKnownLocation(), is(LONGBEACH));
-    assertThat(cargo.transportStatus(), is(IN_PORT));
-    assertFalse(cargo.isMisdirected());
-    assertThat(cargo.nextExpectedActivity(), is(new HandlingActivity(LOAD, LONGBEACH, continental1)));
-  }
-
-  private void loadInLongBeach() throws CannotCreateHandlingEventException {
-    createHandlingEventAndUpdateAggregates(toDate("2009-03-07"), continental1, LONGBEACH, LOAD);
-  }
-
-  private void checkDeliveryAfterLoadInLongBeach() {
-    Cargo cargo = cargoRepository.find(trackingId);
-
-    assertThat(cargo.currentVoyage(), is(continental1));
-    assertThat(cargo.lastKnownLocation(), is(LONGBEACH));
-    assertThat(cargo.transportStatus(), is(ONBOARD_CARRIER));
-    assertFalse(cargo.isMisdirected());
-    assertThat(cargo.nextExpectedActivity(), is(new HandlingActivity(UNLOAD, NEWYORK, continental1)));
-  }
-
-  private void unloadInNewYork() throws CannotCreateHandlingEventException {
-    createHandlingEventAndUpdateAggregates(toDate("2009-03-08"), continental1, NEWYORK, UNLOAD);
-  }
-
-  private void checkDeliveryAfterUnloadInNewYork() {
-    Cargo cargo = cargoRepository.find(trackingId);
-
-    assertThat(cargo.currentVoyage(), is(NONE));
-    assertThat(cargo.lastKnownLocation(), is(NEWYORK));
-    assertThat(cargo.transportStatus(), is(IN_PORT));
-    assertThat(cargo.nextExpectedActivity(), is(new HandlingActivity(LOAD, NEWYORK, pacific2)));
-    assertFalse(cargo.isMisdirected());
-  }
-
-  private void loadInNewYork() throws CannotCreateHandlingEventException {
-    createHandlingEventAndUpdateAggregates(toDate("2009-03-10"), pacific2, NEWYORK, LOAD);
-  }
-
-  private void checkDeliveryAfterLoadInNewYork() {
-    Cargo cargo = cargoRepository.find(trackingId);
-
-    assertThat(cargo.currentVoyage(), is(pacific2));
-    assertThat(cargo.lastKnownLocation(), is(NEWYORK));
-    assertThat(cargo.transportStatus(), is(ONBOARD_CARRIER));
-    assertFalse(cargo.isMisdirected());
-    assertThat(cargo.nextExpectedActivity(), is(new HandlingActivity(UNLOAD, STOCKHOLM, pacific2)));
-  }
-
-  @Test
-  public void cargoIsMisdirectedAndRerouted() throws Exception {
-    bookCargoFromHongkongToStockholm();
-    checkDeliveryAfterBooking();
-
-
-    // Initial route: Hongkong - Long Beach - New York - Stockholm
-    routeCargoFromHongkongToStockholm();
-    checkDeliveryAfterRouting();
-
-    receiveInHongkong();
-    checkDeliveryAfterReceiveInHongkong();
-
-    loadInHongkong();
-    checkDeliveryAfterLoadInHongKong();
-
-    unloadInTokyo();
-    checkDeliveryAfterUnloadInTokyo();
-
-
-    // Reroute: Tokyo - Hamburg - Stockholm
-    specifyNewRouteFromTokyoToStockholm();
-    checkDeliveryAfterNewRouteSpecified();
-
-    assignToNewRouteFromTokyoToStockholm();
-    checkDeliveryAfterAssignedToNewRoute();
-
-
-    loadInTokyo();
-    checkDeliveryAfterLoadInTokyo();
-
-    unloadInHamburg();
-    checkDeliveryAfterUnloadInHamburg();
-
-    customsInHamburg();
-    checkDeliveryAfterCustomsInHamburg();
-
-    loadInHamburg();
-    checkDeliveryAfterLoadInHamburg();
-
-    unloadInStockholmOffOf(v400);
-    checkDeliveryAfterUnloadInStockholm2();
-
-    claimInStockholm();
-    checkDeliveryAfterClaimInStockholm();
-  }
-
-  private void bookCargoFromHongkongToStockholm() {
-    Date arrivalDeadline = toDate("2009-03-18");
-    final TrackingId trackingId1 = trackingIdFactory.nextTrackingId();
-    final RouteSpecification routeSpecification = new RouteSpecification(HONGKONG, STOCKHOLM, arrivalDeadline);
-
-    Cargo cargo = new Cargo(trackingId1, routeSpecification);
-    cargoRepository.store(cargo);
-
-    trackingId = cargo.trackingId();
-  }
-
-  private void routeCargoFromHongkongToStockholm() {
-    Cargo cargo = cargoRepository.find(trackingId);
-    List<Itinerary> itineraries = routingService.fetchRoutesForSpecification(cargo.routeSpecification());
-    Itinerary itinerary = itineraries.get(0);
-    cargo.assignToRoute(itinerary);
-    cargoRepository.store(cargo);
-  }
-
-  public void checkDeliveryAfterBooking() throws Exception {
-    Cargo cargo = cargoRepository.find(trackingId);
-
-    assertThat(cargo.transportStatus(), is(NOT_RECEIVED));
-    assertThat(cargo.routingStatus(), is(NOT_ROUTED));
-    assertFalse(cargo.isMisdirected());
-    assertNull(cargo.estimatedTimeOfArrival());
-    assertNull(cargo.nextExpectedActivity());
-  }
-
-  public void checkDeliveryAfterRouting() throws Exception {
-    Cargo cargo = cargoRepository.find(trackingId);
-
-    assertThat(cargo.transportStatus(), is(NOT_RECEIVED));
-    assertThat(cargo.routingStatus(), is(ROUTED));
-    assertThat(cargo.nextExpectedActivity(), is(new HandlingActivity(RECEIVE, HONGKONG)));
-    assertNotNull(cargo.estimatedTimeOfArrival());
-  }
-
-  public void receiveInHongkong() throws CannotCreateHandlingEventException {
-    createHandlingEventAndUpdateAggregates(toDate("2009-03-01"), null, HONGKONG, RECEIVE);
-  }
-
-  private void checkDeliveryAfterReceiveInHongkong() {
-    Cargo cargo = cargoRepository.find(trackingId);
-    assertThat(cargo.transportStatus(), is(IN_PORT));
-    assertThat(cargo.lastKnownLocation(), is(HONGKONG));
-  }
-
-  public void loadInHongkong() throws CannotCreateHandlingEventException {
-    createHandlingEventAndUpdateAggregates(toDate("2009-03-03"), pacific1, HONGKONG, LOAD);
-  }
-
-  private void checkDeliveryAfterLoadInHongKong() {
-    // Check current state - should be ok
-    Cargo cargo = cargoRepository.find(trackingId);
-
-    assertThat(cargo.currentVoyage(), is(pacific1));
-    assertThat(cargo.lastKnownLocation(), is(HONGKONG));
-    assertThat(cargo.transportStatus(), is(ONBOARD_CARRIER));
-    assertThat(cargo.nextExpectedActivity(), is(new HandlingActivity(UNLOAD, LONGBEACH, pacific1)));
-    assertFalse(cargo.isMisdirected());
-  }
-
-  public void unloadInTokyo() throws CannotCreateHandlingEventException {
-    // Cargo is now (incorrectly) unloaded in Tokyo
-    createHandlingEventAndUpdateAggregates(toDate("2009-03-05"), pacific1, TOKYO, UNLOAD);
-  }
-
-  private void checkDeliveryAfterUnloadInTokyo() {
-    Cargo cargo = cargoRepository.find(trackingId);
-    // Check current state - cargo is misdirected!
-    assertThat(cargo.currentVoyage(), is(NONE));
-    assertThat(cargo.lastKnownLocation(), is(TOKYO));
-    assertThat(cargo.transportStatus(), is(IN_PORT));
-    assertTrue(cargo.isMisdirected());
-    assertNull(cargo.nextExpectedActivity());
-  }
-
-  public void specifyNewRouteFromTokyoToStockholm() {
-    // TODO cleaner reroute from "earliest location from where the new route originates"
-    Cargo cargo = cargoRepository.find(trackingId);
-
-    // Specify a new route, this time from Tokyo (where it was incorrectly unloaded) to Stockholm
-    RouteSpecification fromTokyo = cargo.routeSpecification().withOrigin(TOKYO);
-    cargo.specifyNewRoute(fromTokyo);
-    cargoRepository.store(cargo);
-  }
-
-  public void checkDeliveryAfterNewRouteSpecified() {
-    Cargo cargo = cargoRepository.find(trackingId);
-
-    // The old itinerary does not satisfy the new specification
-    assertThat(cargo.routingStatus(), is(MISROUTED));
-    assertNull(cargo.nextExpectedActivity());
-  }
-
-  public void assignToNewRouteFromTokyoToStockholm() {
-    Cargo cargo = cargoRepository.find(trackingId);
-
-    // Repeat procedure of selecting one out of a number of possible routes satisfying the route spec
-    List<Itinerary> newItineraries = routingService.fetchRoutesForSpecification(cargo.routeSpecification());
-    Itinerary newItinerary = newItineraries.get(0);
-
-    cargo.assignToRoute(newItinerary);
-    cargoRepository.store(cargo);
-  }
-
-  public void checkDeliveryAfterAssignedToNewRoute() {
-    Cargo cargo = cargoRepository.find(trackingId);
-
-    // New itinerary should satisfy new route
-    assertThat(cargo.routingStatus(), is(ROUTED));
-    assertFalse(cargo.isMisdirected());
-    assertThat(cargo.nextExpectedActivity(), is(loadOnto(v300).in(TOKYO)));
-  }
-
-  public void loadInTokyo() throws CannotCreateHandlingEventException {
-    createHandlingEventAndUpdateAggregates(toDate("2009-03-08"), v300, TOKYO, LOAD);
-  }
-
-  private void checkDeliveryAfterLoadInTokyo() {
-    Cargo cargo = cargoRepository.find(trackingId);
-    // Check current state - should be ok
-    assertThat(cargo.currentVoyage(), is(v300));
-    assertThat(cargo.lastKnownLocation(), is(TOKYO));
-    assertThat(cargo.transportStatus(), is(ONBOARD_CARRIER));
-    assertThat(cargo.nextExpectedActivity(), is(new HandlingActivity(UNLOAD, HAMBURG, v300)));
-    assertFalse(cargo.isMisdirected());
-  }
-
-  public void unloadInHamburg() throws CannotCreateHandlingEventException {
-    createHandlingEventAndUpdateAggregates(toDate("2009-03-12"), v300, HAMBURG, UNLOAD);
-  }
-
-  private void checkDeliveryAfterUnloadInHamburg() {
-    Cargo cargo = cargoRepository.find(trackingId);
-    // Check current state - should be ok
-
-    assertThat(cargo.currentVoyage(), is(NONE));
-    assertThat(cargo.lastKnownLocation(), is(HAMBURG));
-    assertThat(cargo.transportStatus(), is(IN_PORT));
-    assertThat(cargo.nextExpectedActivity(), is(customsIn(HAMBURG)));
-    assertFalse(cargo.isMisdirected());
-  }
-
-  public void customsInHamburg() throws CannotCreateHandlingEventException {
-    createHandlingEventAndUpdateAggregates(toDate("2009-03-12"), null, HAMBURG, CUSTOMS);
-  }
-
-  private void checkDeliveryAfterCustomsInHamburg() {
-    Cargo cargo = cargoRepository.find(trackingId);
-    // Check current state - should be ok
-
-    assertThat(cargo.currentVoyage(), is(NONE));
-    assertThat(cargo.lastKnownLocation(), is(HAMBURG));
-    assertThat(cargo.transportStatus(), is(IN_PORT));
-    assertThat(cargo.mostRecentHandlingActivity(), is(customsIn(HAMBURG)));
-    assertThat(cargo.nextExpectedActivity(), is(new HandlingActivity(LOAD, HAMBURG, v400)));
-    assertFalse(cargo.isMisdirected());
-  }
-
-
-  public void loadInHamburg() throws CannotCreateHandlingEventException {
-    createHandlingEventAndUpdateAggregates(toDate("2009-03-14"), v400, HAMBURG, LOAD);
-  }
-
-  private void checkDeliveryAfterLoadInHamburg() {
-    Cargo cargo = cargoRepository.find(trackingId);
-    // Check current state - should be ok
-
-    assertThat(cargo.currentVoyage(), is(v400));
-    assertThat(cargo.lastKnownLocation(), is(HAMBURG));
-    assertThat(cargo.transportStatus(), is(ONBOARD_CARRIER));
-    assertThat(cargo.nextExpectedActivity(), is(new HandlingActivity(UNLOAD, STOCKHOLM, v400)));
-    assertFalse(cargo.isMisdirected());
-  }
-
-  public void unloadInStockholmOffOf(Voyage voyage) throws CannotCreateHandlingEventException {
-    createHandlingEventAndUpdateAggregates(toDate("2009-03-15"), voyage, STOCKHOLM, UNLOAD);
-  }
-
-  private void checkDeliveryAfterUnloadInStockholm() {
-    Cargo cargo = cargoRepository.find(trackingId);
-    // Check current state - should be ok
-    assertThat(cargo.currentVoyage(), is(NONE));
-    assertThat(cargo.lastKnownLocation(), is(STOCKHOLM));
-    assertThat(cargo.transportStatus(), is(IN_PORT));
-    assertThat(cargo.nextExpectedActivity(), is(customsIn(STOCKHOLM)));
-    assertFalse(cargo.isMisdirected());
-  }
-
-  private void checkDeliveryAfterUnloadInStockholm2() {
-    Cargo cargo = cargoRepository.find(trackingId);
-    // Check current state - should be ok
-    assertThat(cargo.currentVoyage(), is(NONE));
-    assertThat(cargo.lastKnownLocation(), is(STOCKHOLM));
-    assertThat(cargo.transportStatus(), is(IN_PORT));
-    assertThat(cargo.nextExpectedActivity(), is(claimIn(STOCKHOLM)));
-    assertFalse(cargo.isMisdirected());
-  }
-  
-  private void customsInStockholm() {
-    createHandlingEventAndUpdateAggregates(toDate("2009-03-16"), null, STOCKHOLM, CUSTOMS);
-  }
-  
-  private void checkDeliveryAfterCustomsInStockholm() {
-    Cargo cargo = cargoRepository.find(trackingId);
-    // Check current state - should be ok
-    assertThat(cargo.currentVoyage(), is(NONE));
-    assertThat(cargo.lastKnownLocation(), is(STOCKHOLM));
-    assertThat(cargo.transportStatus(), is(IN_PORT));
-    assertThat(cargo.nextExpectedActivity(), is(claimIn(STOCKHOLM)));
-    assertFalse(cargo.isMisdirected());
-  }
-
-  private void claimInStockholm() throws CannotCreateHandlingEventException {
-    createHandlingEventAndUpdateAggregates(toDate("2009-03-16"), null, STOCKHOLM, CLAIM);
-  }
-
-  private void checkDeliveryAfterClaimInStockholm() {
-    Cargo cargo = cargoRepository.find(trackingId);
-    // Check current state - should be ok
-    assertThat(cargo.currentVoyage(), is(NONE));
-    assertThat(cargo.lastKnownLocation(), is(STOCKHOLM));
-    assertThat(cargo.transportStatus(), is(CLAIMED));
-    assertFalse(cargo.isMisdirected());
-    assertNull(cargo.nextExpectedActivity());
-  }
-
-  private void createHandlingEventAndUpdateAggregates(Date completionTime, Voyage voyage, Location location, HandlingEvent.Type type) throws CannotCreateHandlingEventException {
-    EventSequenceNumber eventSequenceNumber = updateHandlingEventAggregate(completionTime, voyage, location, type);
-    updateCargoAggregate(eventSequenceNumber);
-  }
-
-  private EventSequenceNumber updateHandlingEventAggregate(Date completionTime, Voyage voyage, Location location, HandlingEvent.Type type) throws CannotCreateHandlingEventException {
-    VoyageNumber voyageNumber = voyage != null ? voyage.voyageNumber() : null;
-    HandlingEvent handlingEvent = handlingEventFactory.createHandlingEvent(completionTime, trackingId, voyageNumber, location.unLocode(), type, new OperatorCode("ABCDE"));
-    handlingEventRepository.store(handlingEvent);
-    return handlingEvent.sequenceNumber();
-  }
-
-  private void updateCargoAggregate(EventSequenceNumber eventSequenceNumber) {
-    Cargo cargo = cargoRepository.find(trackingId);
-    HandlingEvent handlingEvent = handlingEventRepository.find(eventSequenceNumber);
-    cargo.handled(handlingEvent.activity());
-    cargoRepository.store(cargo);
-  }
-
-  private static class ScenarioStubRoutingService implements RoutingService {
-
-    public List<Itinerary> fetchRoutesForSpecification(RouteSpecification routeSpecification) {
-      if (routeSpecification.origin().equals(HONGKONG)) {
-        // Hongkong - NYC - Chicago - Stockholm, initial routing
-        return Arrays.asList(
-          new Itinerary(Arrays.asList(
-            new Leg(pacific1, HONGKONG, LONGBEACH, toDate("2009-03-03"), toDate("2009-03-09")),
-            new Leg(continental1, LONGBEACH, NEWYORK, toDate("2009-03-10"), toDate("2009-03-14")),
-            new Leg(pacific2, NEWYORK, STOCKHOLM, toDate("2009-03-07"), toDate("2009-03-11"))
-          ))
-        );
-      } else {
-        // Tokyo - Hamburg - Stockholm, rerouting misdirected cargo from Tokyo
-        return Arrays.asList(
-          new Itinerary(Arrays.asList(
-            new Leg(v300, TOKYO, HAMBURG, toDate("2009-03-08"), toDate("2009-03-12")),
-            new Leg(v400, HAMBURG, STOCKHOLM, toDate("2009-03-14"), toDate("2009-03-15"))
-          ))
-        );
-      }
-    }
-
-  }
-
-}

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

 import se.citerus.dddsample.tracking.core.domain.model.location.LocationRepository;
 import static se.citerus.dddsample.tracking.core.domain.model.location.SampleLocations.*;
 import se.citerus.dddsample.tracking.core.domain.model.location.UnLocode;
-import se.citerus.dddsample.tracking.core.domain.model.voyage.SampleVoyages;
+import static se.citerus.dddsample.tracking.core.domain.model.voyage.SampleVoyages.atlantic2;
 import se.citerus.dddsample.tracking.core.domain.model.voyage.Voyage;
 import se.citerus.dddsample.tracking.core.domain.model.voyage.VoyageNumber;
 import se.citerus.dddsample.tracking.core.domain.model.voyage.VoyageRepository;
 
-import java.util.Arrays;
 import java.util.Date;
 import java.util.List;
 import java.util.Map;
     Cargo cargo = new Cargo(trackingId, new RouteSpecification(origin, destination, new Date()));
     cargoRepository.store(cargo);
 
-    cargo.assignToRoute(new Itinerary(Arrays.asList(
-      new Leg(
+    cargo.assignToRoute(new Itinerary(
+      Leg.deriveLeg(
         voyageRepository.find(new VoyageNumber("0101")),
         locationRepository.find(STOCKHOLM.unLocode()),
-        locationRepository.find(MELBOURNE.unLocode()),
-        new Date(), new Date())
-    )));
+        locationRepository.find(MELBOURNE.unLocode()))
+    ));
 
     flush();
 
     Long cargoId = getLongId(cargo);
     assertEquals(3, sjt.queryForInt("select count(*) from Leg where cargo_id = ?", cargoId));
 
-    Location legFrom = locationRepository.find(new UnLocode("FIHEL"));
-    Location legTo = locationRepository.find(new UnLocode("DEHAM"));
-    Itinerary newItinerary = new Itinerary(Arrays.asList(new Leg(SampleVoyages.continenal2, legFrom, legTo, new Date(), new Date())));
+    Location legFrom = locationRepository.find(new UnLocode("DEHAM"));
+    Location legTo = locationRepository.find(new UnLocode("FIHEL"));
+    Itinerary newItinerary = new Itinerary(
+        Leg.deriveLeg(atlantic2, legFrom, legTo)
+    );
 
     cargo.assignToRoute(newItinerary);
 

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

 package se.citerus.dddsample.tracking.core.infrastructure.persistence.hibernate;
 
 import static se.citerus.dddsample.tracking.core.application.util.DateTestUtil.toDate;
-
 import se.citerus.dddsample.tracking.core.domain.model.cargo.Cargo;
 import se.citerus.dddsample.tracking.core.domain.model.cargo.CargoRepository;
 import se.citerus.dddsample.tracking.core.domain.model.cargo.TrackingId;
 import se.citerus.dddsample.tracking.core.domain.model.handling.HandlingEventRepository;
 import se.citerus.dddsample.tracking.core.domain.model.location.Location;
 import se.citerus.dddsample.tracking.core.domain.model.location.LocationRepository;
-
 import static se.citerus.dddsample.tracking.core.domain.model.location.SampleLocations.MELBOURNE;
-
 import se.citerus.dddsample.tracking.core.domain.model.location.UnLocode;
-import se.citerus.dddsample.tracking.core.domain.model.shared.HandlingActivity;
+import static se.citerus.dddsample.tracking.core.domain.model.shared.HandlingActivity.claimIn;
 import se.citerus.dddsample.tracking.core.domain.model.voyage.VoyageRepository;
 
 import java.util.Date;
 
     flush();
 
-    Map<String, Object> result = sjt.queryForMap("select * from HandlingEvent where sequenceNumber = ?", event.sequenceNumber());
+    Map<String, Object> result = sjt.queryForMap("select * from HandlingEvent where sequence_number = ?", event.sequenceNumber());
     assertEquals(1L, result.get("CARGO_ID"));
     assertEquals(new Date(10), result.get("COMPLETIONTIME"));
-    assertEquals("CLAIM", result.get("TYPE"));
     // TODO: the rest of the columns
   }
 
     HandlingEvent handlingEvent = handlingEventRepository.mostRecentHandling(cargo);
     assertEquals(cargo, handlingEvent.cargo());
     assertEquals(toDate("2007-09-27", "05:00"), handlingEvent.completionTime());
-    assertEquals(new HandlingActivity(HandlingEvent.Type.CLAIM, MELBOURNE), handlingEvent.activity());
+
+    assertEquals(claimIn(MELBOURNE), handlingEvent.activity());
+    assertEquals(handlingEvent.activity(), claimIn(MELBOURNE));
   }
 
 }

dddsample/tracking/core/src/test/java/se/citerus/dddsample/tracking/core/interfaces/booking/facade/DTOAssemblerTest.java

 import se.citerus.dddsample.tracking.core.domain.model.location.Location;
 import se.citerus.dddsample.tracking.core.domain.model.location.LocationRepository;
 import static se.citerus.dddsample.tracking.core.domain.model.location.SampleLocations.*;
-
 import se.citerus.dddsample.tracking.core.domain.model.voyage.SampleVoyages;
 import se.citerus.dddsample.tracking.core.domain.model.voyage.VoyageRepository;
 import se.citerus.dddsample.tracking.core.infrastructure.persistence.inmemory.LocationRepositoryInMem;
   @Test
   public void fromRouteCandidateDTO() throws Exception {
     final List<LegDTO> legs = new ArrayList<LegDTO>();
-    legs.add(new LegDTO("CM003", "CNHKG", "USNYC", new Date(), new Date()));
-    legs.add(new LegDTO("CM004", "USNYC", "USCHI", new Date(), new Date()));
+    legs.add(new LegDTO("PAC1", "CNHKG", "USLBG", new Date(), new Date()));
+    legs.add(new LegDTO("CNT1", "USLBG", "USNYC", new Date(), new Date()));
 
     final LocationRepository locationRepository = new LocationRepositoryInMem();
     final VoyageRepository voyageRepository = new VoyageRepositoryInMem();
     final Leg leg1 = itinerary.legs().get(0);
     assertNotNull(leg1);
     assertEquals(HONGKONG, leg1.loadLocation());
-    assertEquals(NEWYORK, leg1.unloadLocation());
+    assertEquals(LONGBEACH, leg1.unloadLocation());
 
     final Leg leg2 = itinerary.legs().get(1);
     assertNotNull(leg2);
-    assertEquals(NEWYORK, leg2.loadLocation());
-    assertEquals(CHICAGO, leg2.unloadLocation());
+    assertEquals(LONGBEACH, leg2.loadLocation());
+    assertEquals(NEWYORK, leg2.unloadLocation());
   }
 
   @Test