Now able to correctly predict customs handling and handling immediately after a reroute.

Fixed mapping of Cargo, adapted tests

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

@@ -132,16 +132,16 @@ public class SampleDataGenerator implements ServletContextListener {
 
   private static void loadCargoData(JdbcTemplate jdbcTemplate) {
     String cargoSql =
-      "insert into Cargo (id, tracking_id, spec_origin_id, spec_destination_id, spec_arrival_deadline, calculated_at) " +
-        "values (?, ?, ?, ?, ?, ?)";
+      "insert into Cargo (id, tracking_id, spec_origin_id, spec_destination_id, spec_arrival_deadline, last_update, routed_after_handling) " +
+        "values (?, ?, ?, ?, ?, ?, ?)";
 
     Object[][] cargoArgs = {
-      {1, "XYZ", 1, 2, ts(10), ts(100)},
-      {2, "ABC", 1, 5, ts(20), ts(100)},
-      {3, "ZYX", 2, 1, ts(30), ts(100)},
-      {4, "CBA", 5, 1, ts(40), ts(100)},
-      {5, "FGH", 3, 5, ts(50), ts(100)},  // Cargo origin differs from spec origin
-      {6, "JKL", 6, 4, ts(60), ts(100)}
+      {1, "XYZ", 1, 2, ts(10), ts(100), false},
+      {2, "ABC", 1, 5, ts(20), ts(100), false},
+      {3, "ZYX", 2, 1, ts(30), ts(100), false},
+      {4, "CBA", 5, 1, ts(40), ts(100), false},
+      {5, "FGH", 3, 5, ts(50), ts(100), false},
+      {6, "JKL", 6, 4, ts(60), ts(100), false}
     };
     executeUpdate(jdbcTemplate, cargoSql, cargoArgs);
   }

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

@@ -3,9 +3,11 @@ package se.citerus.dddsample.tracking.core.domain.model.cargo;
 import org.apache.commons.lang.Validate;
 import static se.citerus.dddsample.tracking.core.domain.model.cargo.RoutingStatus.NOT_ROUTED;
 import se.citerus.dddsample.tracking.core.domain.model.handling.HandlingEvent;
+import static se.citerus.dddsample.tracking.core.domain.model.handling.HandlingEvent.Type.UNLOAD;
 import se.citerus.dddsample.tracking.core.domain.model.location.CustomsZone;
 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.customsIn;
 import se.citerus.dddsample.tracking.core.domain.model.voyage.Voyage;
 import se.citerus.dddsample.tracking.core.domain.patterns.entity.EntitySupport;
 
@@ -94,7 +96,7 @@ public class Cargo extends EntitySupport<Cargo,TrackingId> {
    * @return Estimated time of arrival.
    */
   public Date estimatedTimeOfArrival() {
-    if (onTrack()) {
+    if (delivery.isOnRoute(itinerary, routeSpecification)) {
       return itinerary.estimatedTimeOfArrival();
     } else {
       return null;
@@ -105,31 +107,32 @@ public class Cargo extends EntitySupport<Cargo,TrackingId> {
    * @return Next expected activity.
    */
   public HandlingActivity nextExpectedActivity() {
-    if (onTrack()) {
-      if (delivery.isRoutedAfterHandling()) {
-        return itinerary.firstLeg().deriveLoadActivity();
+    if (!delivery.isOnRoute(itinerary, routeSpecification)) {
+      return null;
+    }
+
+    if (delivery.isRoutedAfterHandling()) {
+      return itinerary.firstLeg().deriveLoadActivity();
+    } else {
+      if (unloadedInCustomsClearancePoint()) {
+        return customsIn(customsClearancePoint());
       } else {
-        // Not yet able to determine when the next expected activity is non-pyhsical, i.e. customs
         return itinerary.activitySucceding(delivery.mostRecentPhysicalHandlingActivity());
       }
-    } else {
-      return null;
     }
   }
 
-  /**
-   * @return True if the cargo is assigned to a route and is following that route.
-   */
-  public boolean onTrack() {
-    return delivery.onTrack(itinerary, routeSpecification);
+  private boolean unloadedInCustomsClearancePoint() {
+    return mostRecentHandlingActivity() != null &&
+           mostRecentHandlingActivity().location().sameAs(customsClearancePoint()) &&
+           mostRecentHandlingActivity().type() == UNLOAD;
   }
 
   /**
    * @return True if cargo is misdirected.
    */
   public boolean isMisdirected() {
-    return delivery.hasBeenHandledAfterRouting() &&
-           !itinerary.isExpectedActivity(delivery.mostRecentPhysicalHandlingActivity());
+    return delivery.isMisdirected(itinerary);
   }
 
   /**
@@ -192,7 +195,6 @@ public class Cargo extends EntitySupport<Cargo,TrackingId> {
     return routeSpecification.destination().customsZone();
   }
 
-
   /**
    * @return Customs clearance point.
    */
@@ -245,13 +247,9 @@ public class Cargo extends EntitySupport<Cargo,TrackingId> {
     return succedsMostRecentActivity(newHandlingActivity);
   }
 
-  /*
-  * Problem: CUSTOMS går inte att matcha mot ett Leg, så varje annan händelse som
-  * är förväntad kommer att trilla ut som strictly prior.
-  */
   private boolean succedsMostRecentActivity(final HandlingActivity newHandlingActivity) {
     if (delivery.hasBeenHandledAfterRouting()) {
-      final HandlingActivity priorActivity = itinerary.strictlyPriorOf(mostRecentHandlingActivity(), newHandlingActivity);
+      final HandlingActivity priorActivity = itinerary.strictlyPriorOf(delivery.mostRecentPhysicalHandlingActivity(), newHandlingActivity);
       return !newHandlingActivity.sameValueAs(priorActivity);
     } else {
       return true;

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

@@ -3,7 +3,6 @@ package se.citerus.dddsample.tracking.core.domain.model.cargo;
 import org.apache.commons.lang.Validate;
 import static se.citerus.dddsample.tracking.core.domain.model.cargo.RoutingStatus.*;
 import static se.citerus.dddsample.tracking.core.domain.model.cargo.TransportStatus.ONBOARD_CARRIER;
-import static se.citerus.dddsample.tracking.core.domain.model.handling.HandlingEvent.Type.CUSTOMS;
 import static se.citerus.dddsample.tracking.core.domain.model.handling.HandlingEvent.Type.UNLOAD;
 import se.citerus.dddsample.tracking.core.domain.model.location.Location;
 import se.citerus.dddsample.tracking.core.domain.model.shared.HandlingActivity;
@@ -20,7 +19,7 @@ class Delivery extends ValueObjectSupport<Delivery> {
 
   private final HandlingActivity mostRecentHandlingActivity;
   private final HandlingActivity mostRecentPhysicalHandlingActivity;
-  private final Date calculatedAt;
+  private final Date lastUpdatedOn;
   private final boolean routedAfterHandling;
 
   /**
@@ -33,9 +32,9 @@ class Delivery extends ValueObjectSupport<Delivery> {
     Validate.notNull(newHandlingActivity, "Handling activity is required");
 
     if (newHandlingActivity.type().isPhysical()) {
-      return new Delivery(newHandlingActivity, newHandlingActivity, new Date(), false);
+      return new Delivery(newHandlingActivity, newHandlingActivity, false);
     } else {
-      return new Delivery(newHandlingActivity, mostRecentPhysicalHandlingActivity, new Date(), false);
+      return new Delivery(newHandlingActivity, mostRecentPhysicalHandlingActivity, false);
     }
   }
 
@@ -43,23 +42,23 @@ class Delivery extends ValueObjectSupport<Delivery> {
    * @return An up to date delivery
    */
   Delivery onRouting() {
-    return new Delivery(mostRecentHandlingActivity, mostRecentPhysicalHandlingActivity, calculatedAt, true);
+    return new Delivery(mostRecentHandlingActivity, mostRecentPhysicalHandlingActivity, true);
   }
 
   /**
    * @return Initial delivery, before any handling has taken place
    */
   static Delivery beforeHandling() {
-    return new Delivery(null, null, new Date(0L), false);
+    return new Delivery(null, null, false);
   }
 
-  Delivery(final HandlingActivity mostRecentHandlingActivity,
-           final HandlingActivity mostRecentPhysicalHandlingActivity,
-           final Date completionTime, boolean routedAfterHandling) {
+  private Delivery(final HandlingActivity mostRecentHandlingActivity,
+                   final HandlingActivity mostRecentPhysicalHandlingActivity,
+                   final boolean routedAfterHandling) {
     this.mostRecentHandlingActivity = mostRecentHandlingActivity;
     this.mostRecentPhysicalHandlingActivity = mostRecentPhysicalHandlingActivity;
-    this.calculatedAt = completionTime;
     this.routedAfterHandling = routedAfterHandling;
+    this.lastUpdatedOn = new Date();
   }
 
   HandlingActivity mostRecentHandlingActivity() {
@@ -81,7 +80,7 @@ class Delivery extends ValueObjectSupport<Delivery> {
    * @return Last known location of the cargo, or Location.UNKNOWN if the delivery history is empty.
    */
   Location lastKnownLocation() {
-    if (hasBeenHandledAfterRouting()) {
+    if (hasBeenHandled()) {
       return mostRecentHandlingActivity.location();
     } else {
       return Location.UNKNOWN;
@@ -100,7 +99,11 @@ class Delivery extends ValueObjectSupport<Delivery> {
   }
 
   boolean hasBeenHandledAfterRouting() {
-    return !routedAfterHandling && mostRecentHandlingActivity != null;
+    return hasBeenHandled() && !routedAfterHandling;
+  }
+
+  boolean hasBeenHandled() {
+    return mostRecentHandlingActivity != null;
   }
 
   /**
@@ -112,24 +115,11 @@ class Delivery extends ValueObjectSupport<Delivery> {
    * <li>A cargo that has received no handling events can not be misdirected.
    * </ul>
    *
-   * @return <code>true</code> if the cargo has been misdirected,
    * @param itinerary itinerary
-   * @param routeSpecification route specification
+   * @return <code>true</code> if the cargo has been misdirected,
    */
-  boolean isMisdirected(final Itinerary itinerary, final RouteSpecification routeSpecification) {
-    if (hasBeenHandledAfterRouting()) {
-      if (mostRecentHandlingActivity.type() == CUSTOMS) {
-        return !handledAtDestination(routeSpecification);
-      } else {
-        return !itinerary.isExpectedActivity(mostRecentHandlingActivity);
-      }
-    }
-
-    return false;
-  }
-
-  private boolean handledAtDestination(RouteSpecification routeSpecification) {
-    return routeSpecification.destination().sameAs(mostRecentHandlingActivity.location());
+  boolean isMisdirected(final Itinerary itinerary) {
+    return hasBeenHandledAfterRouting() && !itinerary.isExpectedActivity(mostRecentPhysicalHandlingActivity);
   }
 
   /**
@@ -162,8 +152,8 @@ class Delivery extends ValueObjectSupport<Delivery> {
   /**
    * @return When this delivery was calculated.
    */
-  Date lastTimestamp() {
-    return new Date(calculatedAt.getTime());
+  Date lastUpdatedOn() {
+    return new Date(lastUpdatedOn.getTime());
   }
 
   /**
@@ -171,8 +161,8 @@ class Delivery extends ValueObjectSupport<Delivery> {
    * @param itinerary itinerary
    * @param routeSpecification route specification
    */
-  boolean onTrack(final Itinerary itinerary, final RouteSpecification routeSpecification) {
-    return routingStatus(itinerary, routeSpecification) == ROUTED && !isMisdirected(itinerary, routeSpecification);
+  boolean isOnRoute(final Itinerary itinerary, final RouteSpecification routeSpecification) {
+    return routingStatus(itinerary, routeSpecification) == ROUTED && !isMisdirected(itinerary);
   }
 
   /**
@@ -184,7 +174,7 @@ class Delivery extends ValueObjectSupport<Delivery> {
 
   Delivery() {
     // Needed by Hibernate
-    calculatedAt = null;
+    lastUpdatedOn = null;
     mostRecentHandlingActivity = mostRecentPhysicalHandlingActivity = null;
     routedAfterHandling = false;
   }

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

@@ -169,7 +169,7 @@ public class Itinerary extends ValueObjectSupport<Itinerary> {
    */
   HandlingActivity activitySucceding(final HandlingActivity previousActivity) {
     if (previousActivity == null) {
-      return receivedIn(firstLeg().loadLocation());
+      return receiveIn(firstLeg().loadLocation());
     } else {
       return deriveFromMatchingLeg(previousActivity, legMatchOf(previousActivity).leg());
     }
@@ -253,7 +253,7 @@ public class Itinerary extends ValueObjectSupport<Itinerary> {
       return null;
     } else {
       if (handlingActivity.type() == LOAD) {
-        return unloadedOff(handlingActivity.voyage()).in(matchingLeg.unloadLocation());
+        return unloadOff(handlingActivity.voyage()).in(matchingLeg.unloadLocation());
       } else if (handlingActivity.type() == UNLOAD) {
         return deriveFromNextLeg(nextLeg(matchingLeg));
       } else {
@@ -265,7 +265,7 @@ public class Itinerary extends ValueObjectSupport<Itinerary> {
 
   private HandlingActivity deriveFromNextLeg(final Leg nextLeg) {
     if (nextLeg == null) {
-      return claimedIn(lastLeg().unloadLocation());
+      return claimIn(lastLeg().unloadLocation());
     } else {
       return nextLeg.deriveLoadActivity();
     }

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

@@ -5,8 +5,8 @@ import static se.citerus.dddsample.tracking.core.domain.model.handling.HandlingE
 import static se.citerus.dddsample.tracking.core.domain.model.handling.HandlingEvent.Type.UNLOAD;
 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.loadedOnto;
-import static se.citerus.dddsample.tracking.core.domain.model.shared.HandlingActivity.unloadedOff;
+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 se.citerus.dddsample.tracking.core.domain.model.voyage.Voyage;
 import se.citerus.dddsample.tracking.core.domain.patterns.valueobject.ValueObjectSupport;
 
@@ -88,7 +88,6 @@ public class Leg extends ValueObjectSupport<Leg> {
     return Leg.deriveLeg(voyage, loadLocation, unloadLocation);
   }
 
-
   /**
    *
    * @param handlingActivity handling activity
@@ -124,11 +123,11 @@ public class Leg extends ValueObjectSupport<Leg> {
   }
 
   HandlingActivity deriveLoadActivity() {
-    return loadedOnto(voyage).in(loadLocation);
+    return loadOnto(voyage).in(loadLocation);
   }
 
   HandlingActivity deriveUnloadActivity() {
-    return unloadedOff(voyage).in(unloadLocation);
+    return unloadOff(voyage).in(unloadLocation);
   }
 
   @Override

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

@@ -24,6 +24,7 @@ public enum TransportStatus implements ValueObject<TransportStatus> {
         return ONBOARD_CARRIER;
       case UNLOAD:
       case RECEIVE:
+      case CUSTOMS:
         return IN_PORT;
       case CLAIM:
         return CLAIMED;

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

@@ -14,7 +14,7 @@ import java.util.TimeZone;
 public final class Location extends EntitySupport<Location, UnLocode> {
 
   private final UnLocode unLocode;
-  private String name;
+  private final String name;
   private TimeZone timeZone;
   private CustomsZone customsZone;
 
@@ -87,6 +87,7 @@ public final class Location extends EntitySupport<Location, UnLocode> {
   Location() {
     // Needed by Hibernate
     unLocode = null;
+    name = null;
   }
 
 }

dddsample/tracking/core/src/main/java/se/citerus/dddsample/tracking/core/domain/model/shared/HandlingActivity.java

@@ -63,23 +63,23 @@ public class HandlingActivity extends ValueObjectSupport<HandlingActivity> {
 
   // DSL-like factory methods
 
-  public static InLocation loadedOnto(Voyage voyage) {
+  public static InLocation loadOnto(final Voyage voyage) {
     return new InLocation(LOAD, voyage);
   }
 
-  public static InLocation unloadedOff(Voyage voyage) {
+  public static InLocation unloadOff(final Voyage voyage) {
     return new InLocation(UNLOAD, voyage);
   }
 
-  public static HandlingActivity receivedIn(Location location) {
+  public static HandlingActivity receiveIn(final Location location) {
     return new HandlingActivity(RECEIVE, location);
   }
 
-  public static HandlingActivity claimedIn(Location location) {
+  public static HandlingActivity claimIn(final Location location) {
     return new HandlingActivity(CLAIM, location);
   }
 
-  public static HandlingActivity customsIn(Location location) {
+  public static HandlingActivity customsIn(final Location location) {
     return new HandlingActivity(CUSTOMS, location);
   }
 
@@ -87,12 +87,12 @@ public class HandlingActivity extends ValueObjectSupport<HandlingActivity> {
     private final HandlingEvent.Type type;
     private final Voyage voyage;
 
-    public InLocation(HandlingEvent.Type type, Voyage voyage) {
+    public InLocation(final HandlingEvent.Type type, final Voyage voyage) {
       this.type = type;
       this.voyage = voyage;
     }
 
-    public HandlingActivity in(Location location) {
+    public HandlingActivity in(final Location location) {
       return new HandlingActivity(type, location, voyage);
     }
   }

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

@@ -16,7 +16,8 @@
     </component>
 
     <component name="delivery" lazy="true">
-      <property name="calculatedAt" column="calculated_at" not-null="true"/>
+      <property name="routedAfterHandling" column="routed_after_handling" not-null="true"/>
+      <property name="lastUpdatedOn" column="last_update"/>
       <component name="mostRecentHandlingActivity">
         <many-to-one name="location" column="most_recent_location_id" foreign-key="most_recent_location_fk" cascade="none"/>
         <property name="type" column="most_recent_handling_event_type">
@@ -26,6 +27,15 @@
           </type>
         </property>
       </component>
+        <component name="mostRecentPhysicalHandlingActivity">
+          <many-to-one name="location" column="most_recent_physical_location_id" foreign-key="most_recent_physical_location_fk" cascade="none"/>
+          <property name="type" column="most_recent_physical_handling_event_type">
+            <type name="org.hibernate.type.EnumType">
+              <param name="enumClass">se.citerus.dddsample.tracking.core.domain.model.handling.HandlingEvent$Type</param>
+              <param name="type">12</param><!-- 12 is java.sql.Types.VARCHAR -->
+            </type>
+          </property>
+        </component>
     </component>
 
     <component name="routeSpecification">

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

@@ -10,6 +10,8 @@ import static se.citerus.dddsample.tracking.core.domain.model.handling.HandlingE
 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 se.citerus.dddsample.tracking.core.domain.model.voyage.Voyage;
 import se.citerus.dddsample.tracking.core.domain.model.voyage.VoyageNumber;
 
@@ -58,6 +60,10 @@ public class CargoTest extends TestCase {
     assertEquals(Voyage.NONE, cargo.currentVoyage());
   }
 
+  public void testEmptyCtor() {
+    new Cargo();
+  }
+
   public void testRoutingStatus() throws Exception {
     final Cargo cargo = new Cargo(new TrackingId("XYZ"), new RouteSpecification(STOCKHOLM, MELBOURNE, new Date()));
     final Itinerary good = new Itinerary(Leg.deriveLeg(northernRail, SEATTLE, NEWYORK));
@@ -83,20 +89,20 @@ public class CargoTest extends TestCase {
   public void testOutOrderHandling() throws Exception {
     Cargo cargo = setUpCargoWithItinerary(STOCKHOLM, HAMBURG, MELBOURNE);
 
-    cargo.handled(HandlingActivity.loadedOnto(crazyVoyage).in(STOCKHOLM));
+    cargo.handled(loadOnto(crazyVoyage).in(STOCKHOLM));
     assertThat(cargo.transportStatus(), is(ONBOARD_CARRIER));
     assertThat(cargo.lastKnownLocation(), is(STOCKHOLM));
 
-    cargo.handled(HandlingActivity.unloadedOff(crazyVoyage).in(HAMBURG));
+    cargo.handled(unloadOff(crazyVoyage).in(HAMBURG));
     assertThat(cargo.transportStatus(), is(IN_PORT));
     assertThat(cargo.lastKnownLocation(), is(HAMBURG));
 
-    cargo.handled(HandlingActivity.unloadedOff(crazyVoyage).in(MELBOURNE));
+    cargo.handled(unloadOff(crazyVoyage).in(MELBOURNE));
     assertThat(cargo.transportStatus(), is(IN_PORT));
     assertThat(cargo.lastKnownLocation(), is(MELBOURNE));
 
     // Out of order handling, does not affect state of cargo
-    cargo.handled(HandlingActivity.loadedOnto(crazyVoyage).in(HAMBURG));
+    cargo.handled(loadOnto(crazyVoyage).in(HAMBURG));
     assertThat(cargo.transportStatus(), is(IN_PORT));
     assertThat(cargo.lastKnownLocation(), is(MELBOURNE));
   }
@@ -171,6 +177,26 @@ public class CargoTest extends TestCase {
     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());
+
+    cargo.handled(loadOnto(crazyVoyage).in(HAMBURG));
+    assertThat(cargo.nextExpectedActivity(), is(unloadOff(crazyVoyage).in(MELBOURNE)));
+    assertFalse(cargo.isMisdirected());
+
+    cargo.handled(unloadOff(crazyVoyage).in(MELBOURNE));
+    assertThat(cargo.nextExpectedActivity(), is(customsIn(MELBOURNE)));
+    assertFalse(cargo.isMisdirected());
+
+    cargo.handled(customsIn(MELBOURNE));
+    assertThat(cargo.nextExpectedActivity(), is(claimIn(MELBOURNE)));
+    assertFalse(cargo.isMisdirected());*/
+  }
+
   private Cargo populateCargoReceivedStockholm() throws Exception {
     final Cargo cargo = setUpCargoWithItinerary(STOCKHOLM, HAMBURG, MELBOURNE);
     cargo.handled(new HandlingActivity(RECEIVE, STOCKHOLM));
@@ -257,6 +283,8 @@ public class CargoTest extends TestCase {
     final Cargo cargo = new Cargo(new TrackingId("XYZ"),
         new RouteSpecification(SHANGHAI, NEWYORK, new Date()));
 
+    assertThat(cargo.customsClearancePoint(), is(Location.UNKNOWN));
+
     //SHA-LGB-NYC
     cargo.assignToRoute(new Itinerary(
         Leg.deriveLeg(pacific, SHANGHAI, LONGBEACH),
@@ -301,8 +329,8 @@ public class CargoTest extends TestCase {
 
     Itinerary itinerary = new Itinerary(
         Arrays.asList(
-            new Leg(crazyVoyage, origin, midpoint, new Date(), new Date()),
-            new Leg(crazyVoyage, midpoint, destination, new Date(), new Date())
+            new Leg(crazyVoyage, origin, midpoint, new Date(1), new Date(2)),
+            new Leg(crazyVoyage, midpoint, destination, new Date(3), new Date(4))
         )
     );
 

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

@@ -12,7 +12,7 @@ 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.customsIn;
-import static se.citerus.dddsample.tracking.core.domain.model.shared.HandlingActivity.loadedOnto;
+import static se.citerus.dddsample.tracking.core.domain.model.shared.HandlingActivity.loadOnto;
 import static se.citerus.dddsample.tracking.core.domain.model.voyage.SampleVoyages.*;
 import se.citerus.dddsample.tracking.core.domain.model.voyage.Voyage;
 
@@ -39,7 +39,7 @@ public class DeliveryTest extends TestCase {
   public void testOnHandling() {
     Delivery delivery = Delivery.beforeHandling();
 
-    HandlingActivity load = loadedOnto(HONGKONG_TO_NEW_YORK).in(HONGKONG);
+    HandlingActivity load = loadOnto(HONGKONG_TO_NEW_YORK).in(HONGKONG);
     delivery = delivery.onHandling(load);
 
     assertThat(delivery.mostRecentHandlingActivity(), is(load));
@@ -51,7 +51,7 @@ public class DeliveryTest extends TestCase {
     assertThat(delivery.mostRecentHandlingActivity(), is(customs));
     assertThat(delivery.mostRecentPhysicalHandlingActivity(), is(load));
 
-    HandlingActivity loadAgain = loadedOnto(NEW_YORK_TO_DALLAS).in(NEWYORK);
+    HandlingActivity loadAgain = loadOnto(NEW_YORK_TO_DALLAS).in(NEWYORK);
     delivery = delivery.onHandling(loadAgain);
 
     assertThat(delivery.mostRecentHandlingActivity(), is(loadAgain));
@@ -61,11 +61,10 @@ public class DeliveryTest extends TestCase {
   public void testDerivedFromRouteSpecificationAndItinerary() throws Exception {
     assertEquals(ROUTED, delivery.routingStatus(itinerary, routeSpecification));
     assertEquals(Voyage.NONE, delivery.currentVoyage());
-    assertFalse(delivery.isMisdirected(itinerary, routeSpecification));
     assertFalse(delivery.onTheGroundAtDestination(routeSpecification));
     assertEquals(Location.UNKNOWN, delivery.lastKnownLocation());
     assertEquals(NOT_RECEIVED, delivery.transportStatus());
-    assertTrue(delivery.lastTimestamp().before(new Date()));
+    assertTrue(delivery.lastUpdatedOn().before(new Date()));
   }
 
   public void testUpdateOnHandlingHappyPath() {
@@ -80,14 +79,13 @@ public class DeliveryTest extends TestCase {
     assertEquals(IN_PORT, newDelivery.transportStatus());
 
     // Changed on handling and/or (re-)routing
-    assertFalse(newDelivery.isMisdirected(itinerary, routeSpecification));
     assertFalse(newDelivery.onTheGroundAtDestination(routeSpecification));
 
     // Changed on (re-)routing
     assertEquals(ROUTED, newDelivery.routingStatus(itinerary, routeSpecification));
 
     // Updated on every calculation
-    assertTrue(delivery.lastTimestamp().before(newDelivery.lastTimestamp()));
+    assertTrue(delivery.lastUpdatedOn().before(newDelivery.lastUpdatedOn()));
 
     // 2. Load
 
@@ -98,12 +96,11 @@ public class DeliveryTest extends TestCase {
     assertEquals(HANGZOU, newDelivery.lastKnownLocation());
     assertEquals(ONBOARD_CARRIER, newDelivery.transportStatus());
 
-    assertFalse(newDelivery.isMisdirected(itinerary, routeSpecification));
     assertFalse(newDelivery.onTheGroundAtDestination(routeSpecification));
 
     assertEquals(ROUTED, newDelivery.routingStatus(itinerary, routeSpecification));
 
-    assertTrue(delivery.lastTimestamp().before(newDelivery.lastTimestamp()));
+    assertTrue(delivery.lastUpdatedOn().before(newDelivery.lastUpdatedOn()));
 
     // Skipping intermediate load/unloads
 
@@ -116,12 +113,11 @@ public class DeliveryTest extends TestCase {
     assertEquals(STOCKHOLM, newDelivery.lastKnownLocation());
     assertEquals(IN_PORT, newDelivery.transportStatus());
 
-    assertFalse(newDelivery.isMisdirected(itinerary, routeSpecification));
     assertTrue(newDelivery.onTheGroundAtDestination(routeSpecification));
 
     assertEquals(ROUTED, newDelivery.routingStatus(itinerary, routeSpecification));
 
-    assertTrue(delivery.lastTimestamp().before(newDelivery.lastTimestamp()));
+    assertTrue(delivery.lastUpdatedOn().before(newDelivery.lastUpdatedOn()));
 
     // 4. Claim
 
@@ -132,12 +128,11 @@ public class DeliveryTest extends TestCase {
     assertEquals(STOCKHOLM, newDelivery.lastKnownLocation());
     assertEquals(CLAIMED, newDelivery.transportStatus());
 
-    assertFalse(newDelivery.isMisdirected(itinerary, routeSpecification));
     assertFalse(newDelivery.onTheGroundAtDestination(routeSpecification));
 
     assertEquals(ROUTED, newDelivery.routingStatus(itinerary, routeSpecification));
 
-    assertTrue(delivery.lastTimestamp().before(newDelivery.lastTimestamp()));
+    assertTrue(delivery.lastUpdatedOn().before(newDelivery.lastUpdatedOn()));
   }
 
   public void testUpdateOnHandlingWhenMisdirected() {
@@ -151,27 +146,21 @@ public class DeliveryTest extends TestCase {
 
     // Next handling activity is undefined. Need a new itinerary to know what to do.
 
-    assertTrue(newDelivery.isMisdirected(itinerary, routeSpecification));
     assertFalse(newDelivery.onTheGroundAtDestination(routeSpecification));
 
     assertEquals(ROUTED, newDelivery.routingStatus(itinerary, routeSpecification));
 
-    assertTrue(delivery.lastTimestamp().before(newDelivery.lastTimestamp()));
+    assertTrue(delivery.lastUpdatedOn().before(newDelivery.lastUpdatedOn()));
 
     // New route specification, old itinerary
     RouteSpecification newRouteSpecification = routeSpecification.withOrigin(HAMBURG);
     assertEquals(MISROUTED, newDelivery.routingStatus(itinerary, newRouteSpecification));
 
-    // TODO is it really misdirected at this point?
-    assertTrue(newDelivery.isMisdirected(itinerary, newRouteSpecification));
-
     Itinerary newItinerary = new Itinerary(
       Leg.deriveLeg(DALLAS_TO_HELSINKI, HAMBURG, STOCKHOLM)
     );
 
     assertEquals(ROUTED, newDelivery.routingStatus(newItinerary, newRouteSpecification));
-    // TODO is it really misdirected here?
-    assertTrue(newDelivery.isMisdirected(newItinerary, newRouteSpecification));
     assertEquals(IN_PORT, newDelivery.transportStatus());
   }
 

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

@@ -105,19 +105,19 @@ public class ItineraryTest extends TestCase {
     Leg rotterdamToGothenburg = Leg.deriveLeg(voyage, ROTTERDAM, GOTHENBURG);
     Itinerary itinerary = new Itinerary(shanghaiToRotterdam, rotterdamToGothenburg);
 
-    assertThat(itinerary.legMatchOf(receivedIn(SHANGHAI)).leg(), is(shanghaiToRotterdam));
-    assertThat(itinerary.legMatchOf(loadedOnto(voyage).in(SHANGHAI)).leg(), is(shanghaiToRotterdam));
-    assertThat(itinerary.legMatchOf(unloadedOff(voyage).in(ROTTERDAM)).leg(), is(shanghaiToRotterdam));
-    assertThat(itinerary.legMatchOf(claimedIn(GOTHENBURG)).leg(), is(rotterdamToGothenburg));
+    assertThat(itinerary.legMatchOf(receiveIn(SHANGHAI)).leg(), is(shanghaiToRotterdam));
+    assertThat(itinerary.legMatchOf(loadOnto(voyage).in(SHANGHAI)).leg(), is(shanghaiToRotterdam));
+    assertThat(itinerary.legMatchOf(unloadOff(voyage).in(ROTTERDAM)).leg(), is(shanghaiToRotterdam));
+    assertThat(itinerary.legMatchOf(claimIn(GOTHENBURG)).leg(), is(rotterdamToGothenburg));
 
-    assertNull(itinerary.legMatchOf(loadedOnto(wrongVoyage).in(SHANGHAI)).leg());
-    assertNull(itinerary.legMatchOf(loadedOnto(wrongVoyage).in(NEWYORK)).leg());
+    assertNull(itinerary.legMatchOf(loadOnto(wrongVoyage).in(SHANGHAI)).leg());
+    assertNull(itinerary.legMatchOf(loadOnto(wrongVoyage).in(NEWYORK)).leg());
 
-    assertNull(itinerary.legMatchOf(unloadedOff(wrongVoyage).in(ROTTERDAM)).leg());
-    assertNull(itinerary.legMatchOf(unloadedOff(wrongVoyage).in(NEWYORK)).leg());
+    assertNull(itinerary.legMatchOf(unloadOff(wrongVoyage).in(ROTTERDAM)).leg());
+    assertNull(itinerary.legMatchOf(unloadOff(wrongVoyage).in(NEWYORK)).leg());
 
-    assertNull(itinerary.legMatchOf(receivedIn(NEWYORK)).leg());
-    assertNull(itinerary.legMatchOf(claimedIn(NEWYORK)).leg());
+    assertNull(itinerary.legMatchOf(receiveIn(NEWYORK)).leg());
+    assertNull(itinerary.legMatchOf(claimIn(NEWYORK)).leg());
   }
 
   public void testNextLeg() {
@@ -139,9 +139,9 @@ public class ItineraryTest extends TestCase {
 
     Itinerary itinerary = new Itinerary(shanghaiToLongBeach, longBeachToNewYork, newYorkToRotterdam);
 
-    HandlingActivity notOnRoute = HandlingActivity.loadedOnto(pacific).in(STOCKHOLM);
-    HandlingActivity loadInShanghai = HandlingActivity.loadedOnto(pacific).in(SHANGHAI);
-    HandlingActivity unloadInLongbeach = HandlingActivity.unloadedOff(pacific).in(LONGBEACH);
+    HandlingActivity notOnRoute = HandlingActivity.loadOnto(pacific).in(STOCKHOLM);
+    HandlingActivity loadInShanghai = HandlingActivity.loadOnto(pacific).in(SHANGHAI);
+    HandlingActivity unloadInLongbeach = HandlingActivity.unloadOff(pacific).in(LONGBEACH);
 
     assertThat(itinerary.strictlyPriorOf(loadInShanghai, unloadInLongbeach), is(loadInShanghai));
     assertThat(itinerary.strictlyPriorOf(unloadInLongbeach, loadInShanghai), is(loadInShanghai));

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

@@ -6,8 +6,8 @@ import org.junit.Test;
 import static se.citerus.dddsample.tracking.core.application.util.DateTestUtil.toDate;
 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.loadedOnto;
-import static se.citerus.dddsample.tracking.core.domain.model.shared.HandlingActivity.unloadedOff;
+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.voyage.SampleVoyages.NEW_YORK_TO_DALLAS;
 import se.citerus.dddsample.tracking.core.domain.model.voyage.Voyage;
 
@@ -59,17 +59,17 @@ public class LegTest {
   public void matchActivity() {
     Leg newYorkToDallas = Leg.deriveLeg(voyage, NEWYORK, DALLAS);
 
-    assertTrue(newYorkToDallas.matchesActivity(loadedOnto(voyage).in(NEWYORK)));
-    assertTrue(newYorkToDallas.matchesActivity(unloadedOff(voyage).in(DALLAS)));
-    assertFalse(newYorkToDallas.matchesActivity(loadedOnto(voyage).in(DALLAS)));
-    assertFalse(newYorkToDallas.matchesActivity(unloadedOff(voyage).in(NEWYORK)));
+    assertTrue(newYorkToDallas.matchesActivity(loadOnto(voyage).in(NEWYORK)));
+    assertTrue(newYorkToDallas.matchesActivity(unloadOff(voyage).in(DALLAS)));
+    assertFalse(newYorkToDallas.matchesActivity(loadOnto(voyage).in(DALLAS)));
+    assertFalse(newYorkToDallas.matchesActivity(unloadOff(voyage).in(NEWYORK)));
   }
 
   @Test
   public void deriveActivities() {
     Leg newYorkToDallas = Leg.deriveLeg(voyage, NEWYORK, DALLAS);
     
-    assertThat(newYorkToDallas.deriveLoadActivity(), is(HandlingActivity.loadedOnto(voyage).in(NEWYORK)));
-    assertThat(newYorkToDallas.deriveUnloadActivity(), is(HandlingActivity.unloadedOff(voyage).in(DALLAS)));
+    assertThat(newYorkToDallas.deriveLoadActivity(), is(HandlingActivity.loadOnto(voyage).in(NEWYORK)));
+    assertThat(newYorkToDallas.deriveUnloadActivity(), is(HandlingActivity.unloadOff(voyage).in(DALLAS)));
   }
 }

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

@@ -36,9 +36,6 @@ public class CargoLifecycle {
 
 
 
-
-
-
     // Route: Hongkong - Long Beach - New York - Stockholm
     List<Itinerary> itineraries =
       routingService.fetchRoutesForSpecification(cargo.routeSpecification());
@@ -48,7 +45,7 @@ public class CargoLifecycle {
     // Routed
     assertThat(cargo.transportStatus(), is(NOT_RECEIVED));
     assertThat(cargo.routingStatus(), is(ROUTED));
-    assertThat(cargo.nextExpectedActivity(), is(receivedIn(HONGKONG)));
+    assertThat(cargo.nextExpectedActivity(), is(receiveIn(HONGKONG)));
     assertNotNull(cargo.estimatedTimeOfArrival());
 
 
@@ -58,8 +55,11 @@ public class CargoLifecycle {
 
 
 
+
+
+
     // Received
-    cargo.handled(receivedIn(HONGKONG));
+    cargo.handled(receiveIn(HONGKONG));
 
     assertThat(cargo.transportStatus(), is(IN_PORT));
     assertThat(cargo.lastKnownLocation(), is(HONGKONG));
@@ -74,13 +74,19 @@ public class CargoLifecycle {
 
 
 
+
+
+
+
+
+
     // Loaded
-    cargo.handled(loadedOnto(v100).in(HONGKONG));
+    cargo.handled(loadOnto(v100).in(HONGKONG));
 
     assertThat(cargo.currentVoyage(), is(v100));
     assertThat(cargo.lastKnownLocation(), is(HONGKONG));
     assertThat(cargo.transportStatus(), is(ONBOARD_CARRIER));
-    assertThat(cargo.nextExpectedActivity(), is(unloadedOff(v100).in(LONGBEACH)));
+    assertThat(cargo.nextExpectedActivity(), is(unloadOff(v100).in(LONGBEACH)));
     assertFalse(cargo.isMisdirected());
 
 
@@ -92,33 +98,24 @@ public class CargoLifecycle {
 
 
 
+
+
+
+
     // Unloaded
-    cargo.handled(unloadedOff(v100).in(LONGBEACH));
+    cargo.handled(unloadOff(v100).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(loadedOnto(v250).in(LONGBEACH)));
-
-
-
-
+    assertThat(cargo.nextExpectedActivity(), is(loadOnto(v250).in(LONGBEACH)));
 
 
 
 
 
-    /*
-    loadInLongBeach();
-    checkDeliveryAfterLoadInLongBeach();
 
-    unloadInNewYork();
-    checkDeliveryAfterUnloadInNewYork();
-
-    loadInNewYork();
-    checkDeliveryAfterLoadInNewYork();
-    */
 
 
 
@@ -129,7 +126,7 @@ public class CargoLifecycle {
 
 
     // Unloaded in Rotterdam, wasn't supposed to happen
-    cargo.handled(unloadedOff(v200).in(ROTTERDAM));
+    cargo.handled(unloadOff(v200).in(ROTTERDAM));
 
     // Misdirected
     assertTrue(cargo.isMisdirected());
@@ -145,19 +142,35 @@ public class CargoLifecycle {
 
 
 
+
+
+
     // Reroute: specify new route
+    RouteSpecification currentRouteSpec = cargo.routeSpecification();
     RouteSpecification newRouteSpec =
-      cargo.routeSpecification().withOrigin(cargo.lastKnownLocation());
+        currentRouteSpec.withOrigin(cargo.lastKnownLocation());
     cargo.specifyNewRoute(newRouteSpec);
+
     assertThat(cargo.routingStatus(), is(MISROUTED));
 
+
+
+
+
+
+
+
+
+
     // Assign to new route
-    List<Itinerary> available =
-      routingService.fetchRoutesForSpecification(newRouteSpec);
+    List<Itinerary> available = routingService.fetchRoutesForSpecification(newRouteSpec);
     Itinerary newItinerary = selectAppropriateRoute(available);
     cargo.assignToRoute(newItinerary);
+
     assertThat(cargo.routingStatus(), is(ROUTED));
-    assertThat(cargo.nextExpectedActivity(), is(loadedOnto(v300).in(ROTTERDAM)));
+    assertThat(cargo.nextExpectedActivity(), is(loadOnto(v300).in(ROTTERDAM)));
+
+
 
 
 
@@ -169,7 +182,7 @@ public class CargoLifecycle {
 
 
     // Loaded, back on track
-    cargo.handled(loadedOnto(v300).in(ROTTERDAM));
+    cargo.handled(loadOnto(v300).in(ROTTERDAM));
     assertFalse(cargo.isMisdirected());
     assertThat(cargo.lastKnownLocation(), is(ROTTERDAM));
     assertThat(cargo.transportStatus(), is(ONBOARD_CARRIER));
@@ -184,12 +197,9 @@ public class CargoLifecycle {
 
 
 
-    /*
-    checkDeliveryAfterUnloadInStockholm();
 
-    claimInStockholm();
-    checkDeliveryAfterClaimInStockholm();
-    */
+
+
   }
 
   private Itinerary selectAppropriateRoute(List<Itinerary> itineraries) {

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

@@ -13,7 +13,7 @@ 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.loadedOnto;
+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;
@@ -80,6 +80,9 @@ public class CargoLifecycleScenarioTest {
     unloadInStockholmOffOf(v200);
     checkDeliveryAfterUnloadInStockholm();
 
+    customsInStockholm();
+    checkDeliveryAfterCustomsInStockholm();
+    
     claimInStockholm();
     checkDeliveryAfterClaimInStockholm();
   }
@@ -174,11 +177,14 @@ public class CargoLifecycleScenarioTest {
     unloadInHamburg();
     checkDeliveryAfterUnloadInHamburg();
 
+    customsInHamburg();
+    checkDeliveryAfterCustomsInHamburg();
+
     loadInHamburg();
     checkDeliveryAfterLoadInHamburg();
 
     unloadInStockholmOffOf(v400);
-    checkDeliveryAfterUnloadInStockholm();
+    checkDeliveryAfterUnloadInStockholm2();
 
     claimInStockholm();
     checkDeliveryAfterClaimInStockholm();
@@ -297,7 +303,7 @@ public class CargoLifecycleScenarioTest {
     // New itinerary should satisfy new route
     assertThat(cargo.routingStatus(), is(ROUTED));
     assertFalse(cargo.isMisdirected());
-    assertThat(cargo.nextExpectedActivity(), is(loadedOnto(v300).in(TOKYO)));
+    assertThat(cargo.nextExpectedActivity(), is(loadOnto(v300).in(TOKYO)));
   }
 
   public void loadInTokyo() throws CannotCreateHandlingEventException {
@@ -325,10 +331,27 @@ public class CargoLifecycleScenarioTest {
     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);
   }
@@ -354,7 +377,31 @@ public class CargoLifecycleScenarioTest {
     assertThat(cargo.currentVoyage(), is(NONE));
     assertThat(cargo.lastKnownLocation(), is(STOCKHOLM));
     assertThat(cargo.transportStatus(), is(IN_PORT));
-    assertThat(cargo.nextExpectedActivity(), is(new HandlingActivity(CLAIM, STOCKHOLM)));
+    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());
   }
 
@@ -373,19 +420,20 @@ public class CargoLifecycleScenarioTest {
   }
 
   private void createHandlingEventAndUpdateAggregates(Date completionTime, Voyage voyage, Location location, HandlingEvent.Type type) throws CannotCreateHandlingEventException {
-    updateHandlingEventAggregate(completionTime, voyage, location, type);
-    updateCargoAggregate();
+    EventSequenceNumber eventSequenceNumber = updateHandlingEventAggregate(completionTime, voyage, location, type);
+    updateCargoAggregate(eventSequenceNumber);
   }
 
-  private void updateHandlingEventAggregate(Date completionTime, Voyage voyage, Location location, HandlingEvent.Type type) throws CannotCreateHandlingEventException {
+  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() {
+  private void updateCargoAggregate(EventSequenceNumber eventSequenceNumber) {
     Cargo cargo = cargoRepository.find(trackingId);
-    HandlingEvent handlingEvent = handlingEventRepository.mostRecentHandling(cargo);
+    HandlingEvent handlingEvent = handlingEventRepository.find(eventSequenceNumber);
     cargo.handled(handlingEvent.activity());
     cargoRepository.store(cargo);
   }