Eliminated the need to keep track on "handled after routing".

Rerouting now works with complete, merged itineraries.

Scenario test is improved, using more realistic setup.

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

 import org.springframework.transaction.support.TransactionTemplate;
 import org.springframework.web.context.WebApplicationContext;
 import org.springframework.web.context.support.WebApplicationContextUtils;
-import static se.citerus.dddsample.tracking.core.application.util.DateTestUtil.toDate;
 import se.citerus.dddsample.tracking.core.domain.model.cargo.*;
 import se.citerus.dddsample.tracking.core.domain.model.handling.*;
 import se.citerus.dddsample.tracking.core.domain.model.location.Location;
 import se.citerus.dddsample.tracking.core.domain.model.location.LocationRepository;
 import se.citerus.dddsample.tracking.core.domain.model.location.SampleLocations;
-import static se.citerus.dddsample.tracking.core.domain.model.location.SampleLocations.*;
-import static se.citerus.dddsample.tracking.core.domain.model.voyage.SampleVoyages.*;
 import se.citerus.dddsample.tracking.core.domain.model.voyage.VoyageRepository;
 
 import javax.servlet.ServletContextEvent;
 import java.sql.Timestamp;
 import java.text.ParseException;
 import java.text.SimpleDateFormat;
-import static java.util.Arrays.asList;
 import java.util.Date;
 
+import static java.util.Arrays.asList;
+import static se.citerus.dddsample.tracking.core.application.util.DateTestUtil.toDate;
+import static se.citerus.dddsample.tracking.core.domain.model.location.SampleLocations.*;
+import static se.citerus.dddsample.tracking.core.domain.model.voyage.SampleVoyages.*;
+
 /**
  * Provides sample data.
  */
 
   private static void loadCargoData(JdbcTemplate jdbcTemplate) {
     String cargoSql =
-      "insert into Cargo (id, tracking_id, spec_origin_id, spec_destination_id, spec_arrival_deadline, last_update, routed_after_handling) " +
-        "values (?, ?, ?, ?, ?, ?, ?)";
+      "insert into Cargo (id, tracking_id, spec_origin_id, spec_destination_id, spec_arrival_deadline, last_update) " +
+        "values (?, ?, ?, ?, ?, ?)";
 
     Object[][] cargoArgs = {
-      {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}
+      {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)},
+      {6, "JKL", 6, 4, ts(60), ts(100)}
     };
     executeUpdate(jdbcTemplate, cargoSql, cargoArgs);
   }

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

 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;
 
 import java.util.Date;
 
+import static se.citerus.dddsample.tracking.core.domain.model.cargo.RoutingStatus.NOT_ROUTED;
+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.UNLOAD;
+import static se.citerus.dddsample.tracking.core.domain.model.shared.HandlingActivity.customsIn;
+
 /**
  * A Cargo. This is the central class in the domain model,
  * and it is the root of the Cargo-Itinerary-Leg-Delivery-RouteSpecification aggregate.
       return null;
     }
 
-    if (delivery.isRoutedAfterHandling()) {
-      return itinerary.firstLeg().deriveLoadActivity();
-    }
-
     if (unloadedInCustomsClearancePoint()) {
       return customsIn(customsClearancePoint());
     }
     return delivery.mostRecentHandlingActivity();
   }
 
+  public Location earliestReroutingLocation() {
+    if (isMisdirected()) {
+      if (transportStatus() == ONBOARD_CARRIER) {
+        return currentVoyage().nextArrivalLocation(lastKnownLocation());
+      } else {
+        return lastKnownLocation();
+      }
+    } else {
+      return itinerary.matchLeg(delivery.mostRecentPhysicalHandlingActivity()).leg().unloadLocation();
+    }
+  }
+
   /**
    * Updates all aspects of the cargo aggregate status
    * based on the current route specification, itinerary and handling of the cargo.
     }
   }
 
+  public Itinerary itineraryMergedWith(final Itinerary other) {
+    if (isMisdirected() && transportStatus() == ONBOARD_CARRIER) {
+      final Leg currentLeg = Leg.deriveLeg(
+        currentVoyage(), lastKnownLocation(), currentVoyage().nextArrivalLocation(lastKnownLocation())
+      );
+
+      return this.itinerary().
+        truncatedAfter(lastKnownLocation()).
+        withLeg(currentLeg).
+        appendBy(other);
+    } else {
+      return this.itinerary().
+        truncatedAfter(earliestReroutingLocation()).
+        appendBy(other);
+    }
+  }
+
   private boolean isSignificant(final HandlingActivity newHandlingActivity) {
     return succedsMostRecentActivity(newHandlingActivity);
   }
 
   private boolean succedsMostRecentActivity(final HandlingActivity newHandlingActivity) {
-    if (delivery.hasBeenHandledAfterRouting()) {
+    if (delivery.hasBeenHandled()) {
       final HandlingActivity priorActivity = itinerary.strictlyPriorOf(delivery.mostRecentPhysicalHandlingActivity(), newHandlingActivity);
       return !newHandlingActivity.sameValueAs(priorActivity);
     } else {

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

 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.UNLOAD;
 import se.citerus.dddsample.tracking.core.domain.model.location.Location;
 import se.citerus.dddsample.tracking.core.domain.model.shared.HandlingActivity;
 import se.citerus.dddsample.tracking.core.domain.model.voyage.Voyage;
 
 import java.util.Date;
 
+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.UNLOAD;
+
 /**
  * Everything about the delivery of the cargo, i.e. where the cargo is
  * right now, whether or not it's routed, misdirected and so on.
   private final HandlingActivity mostRecentHandlingActivity;
   private final HandlingActivity mostRecentPhysicalHandlingActivity;
   private final Date lastUpdatedOn;
-  private final boolean routedAfterHandling;
 
   /**
    * Derives a new delivery when a cargo has been handled.
     Validate.notNull(newHandlingActivity, "Handling activity is required");
 
     if (newHandlingActivity.type().isPhysical()) {
-      return new Delivery(newHandlingActivity, newHandlingActivity, false);
+      return new Delivery(newHandlingActivity, newHandlingActivity);
     } else {
-      return new Delivery(newHandlingActivity, mostRecentPhysicalHandlingActivity, false);
+      return new Delivery(newHandlingActivity, mostRecentPhysicalHandlingActivity);
     }
   }
 
    * @return An up to date delivery
    */
   Delivery onRouting() {
-    return new Delivery(mostRecentHandlingActivity, mostRecentPhysicalHandlingActivity, true);
+    return new Delivery(mostRecentHandlingActivity, mostRecentPhysicalHandlingActivity);
   }
 
   /**
    * @return Initial delivery, before any handling has taken place
    */
   static Delivery beforeHandling() {
-    return new Delivery(null, null, false);
+    return new Delivery(null, null);
   }
 
   private Delivery(final HandlingActivity mostRecentHandlingActivity,
-                   final HandlingActivity mostRecentPhysicalHandlingActivity,
-                   final boolean routedAfterHandling) {
+                   final HandlingActivity mostRecentPhysicalHandlingActivity) {
     this.mostRecentHandlingActivity = mostRecentHandlingActivity;
     this.mostRecentPhysicalHandlingActivity = mostRecentPhysicalHandlingActivity;
-    this.routedAfterHandling = routedAfterHandling;
     this.lastUpdatedOn = new Date();
   }
 
    * @return Current voyage.
    */
   Voyage currentVoyage() {
-    if (hasBeenHandledAfterRouting() && transportStatus() == ONBOARD_CARRIER) {
+    if (hasBeenHandled() && transportStatus() == ONBOARD_CARRIER) {
       return mostRecentHandlingActivity.voyage();
     } else {
       return Voyage.NONE;
   }
 
   /**
-   * @return True if the cargo has been handled at least once since it was last routed
-   */
-  boolean hasBeenHandledAfterRouting() {
-    return hasBeenHandled() && !routedAfterHandling;
-  }
-
-  /**
    * @return True if the cargo has been handled at least once
    */
   boolean hasBeenHandled() {
    * @return <code>true</code> if the cargo has been misdirected.
    */
   boolean isMisdirected(final Itinerary itinerary) {
-    return hasBeenHandledAfterRouting() && !itinerary.isExpectedActivity(mostRecentPhysicalHandlingActivity);
+    return hasBeenHandled() && !itinerary.isExpectedActivity(mostRecentPhysicalHandlingActivity);
   }
 
   /**
    * @param routeSpecification route specification
    */
   boolean onTheGroundAtDestination(final RouteSpecification routeSpecification) {
-    return hasBeenHandledAfterRouting() &&
+    return hasBeenHandled() &&
            mostRecentHandlingActivity.type() == UNLOAD &&
            routeSpecification.destination().sameAs(mostRecentHandlingActivity.location());
   }
     return routingStatus(itinerary, routeSpecification) == ROUTED && !isMisdirected(itinerary);
   }
 
-  /**
-   * @return True if cargo has been routed after the most recent handling activity took place.
-   */
-  boolean isRoutedAfterHandling() {
-    return routedAfterHandling;
-  }
-
   Delivery() {
     // Needed by Hibernate
     lastUpdatedOn = null;
     mostRecentHandlingActivity = mostRecentPhysicalHandlingActivity = null;
-    routedAfterHandling = false;
   }
 
 }

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

 public class Itinerary extends ValueObjectSupport<Itinerary> {
 
   private final List<Leg> legs;
-  // Null object
-  static final Itinerary NONE = new Itinerary();
 
   /**
    * Constructor.
     return legs.get(legs.size() - 1);
   }
 
+
+  Itinerary truncatedAfter(final Location location) {
+    final List<Leg> newLegs = new ArrayList<Leg>();
+
+    for (Leg leg : legs) {
+      if (leg.voyage().locations().contains(location)) {
+        newLegs.add(Leg.deriveLeg(leg.voyage(), leg.loadLocation(), location));
+        break;
+      } else {
+        newLegs.add(leg);
+        if (leg.unloadLocation().sameAs(location)) {
+          break;
+        }
+      }
+    }
+
+    return new Itinerary(newLegs);
+  }
+
+  Itinerary withLeg(final Leg leg) {
+    final List<Leg> newLegs = new ArrayList<Leg>(legs.size() + 1);
+    newLegs.add(leg);
+
+    return new Itinerary(newLegs);
+  }
+
+  Itinerary appendBy(final Itinerary other) {
+    final List<Leg> newLegs = new ArrayList<Leg>(this.legs.size() + other.legs.size());
+    newLegs.addAll(this.legs);
+    newLegs.addAll(other.legs);
+
+    return new Itinerary(newLegs);
+  }
+  
   private LegActivityMatch findLegMatchingActivity(final HandlingActivity handlingActivity) {
     for (Leg leg : legs) {
       if (leg.matchesActivity(handlingActivity)) {

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

 package se.citerus.dddsample.tracking.core.domain.model.cargo;
 
 import org.apache.commons.lang.Validate;
-import static se.citerus.dddsample.tracking.core.domain.model.handling.HandlingEvent.Type.LOAD;
-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.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;
 
+import java.util.ArrayList;
 import java.util.Date;
+import java.util.Iterator;
+import java.util.List;
+
+import static java.util.Collections.unmodifiableList;
+import static se.citerus.dddsample.tracking.core.domain.model.handling.HandlingEvent.Type.LOAD;
+import static se.citerus.dddsample.tracking.core.domain.model.handling.HandlingEvent.Type.UNLOAD;
+import static se.citerus.dddsample.tracking.core.domain.model.shared.HandlingActivity.loadOnto;
+import static se.citerus.dddsample.tracking.core.domain.model.shared.HandlingActivity.unloadOff;
 
 /**
  * An itinerary consists of one or more legs.
     return unloadOff(voyage).in(unloadLocation);
   }
 
+  public List<Location> intermediateLocations() {
+    final List<Location> locations = new ArrayList<Location>();
+    final Iterator<Location> it = voyage.locations().iterator();
+
+    Location location = it.next();
+    for (; it.hasNext() && !loadLocation.sameAs(location);) {}
+
+    location = it.next();
+    for (; it.hasNext() && !unloadLocation.sameAs(location);) {
+      locations.add(location);
+      location = it.next();
+    }
+
+    return unmodifiableList(locations);
+  }
+
   @Override
   public String toString() {
     return "Load in " + loadLocation + " at " + loadTime +

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

     return this.equals(other);
   }
 
-  public static TransportStatus derivedFrom(HandlingActivity handlingActivity) {
+  public static TransportStatus derivedFrom(final HandlingActivity handlingActivity) {
     if (handlingActivity == null) {
       return NOT_RECEIVED;
     }

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

 import java.util.Iterator;
 import java.util.List;
 
+import static java.util.Collections.unmodifiableList;
+
 /**
  * A Voyage.
  */
     voyageNumber = null;
   }
 
+  public Location nextArrivalLocation(final Location location) {
+    for (Iterator<CarrierMovement> it = schedule.carrierMovements().iterator(); it.hasNext();) {
+      CarrierMovement carrierMovement = it.next();
+      if (carrierMovement.arrivalLocation().sameAs(location)) {
+        return location;
+      } else if (carrierMovement.departureLocation().sameAs(location)) {
+        return it.next().arrivalLocation();
+      }
+    }
+
+    return Location.NONE;
+  }
+
+  public List<Location> locations() {
+    final List<Location> locations = new ArrayList<Location>();
+    final Iterator<CarrierMovement> it = schedule.carrierMovements().iterator();
+
+    for (; it.hasNext(); ) {
+      final CarrierMovement carrierMovement = it.next();
+      locations.add(carrierMovement.departureLocation());
+
+      if (!it.hasNext()) {
+        locations.add(carrierMovement.arrivalLocation());
+      }
+    }
+
+    return unmodifiableList(locations);
+  }
+
   /**
    * Builder pattern is used for incremental construction
    * of a Voyage aggregate. This serves as an aggregate factory.

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

     </component>
 
     <component name="delivery">
-      <property name="routedAfterHandling" column="routed_after_handling" not-null="true"/>
       <property name="lastUpdatedOn" column="last_update" not-null="true"/>
       <many-to-one name="mostRecentPhysicalHandlingActivity" column="most_recent_physical_act" not-null="false" update="false" cascade="all"/>
       <many-to-one name="mostRecentHandlingActivity" column="most_recent_act" not-null="false" update="false" cascade="all"/>

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

 import java.util.Date;
 import java.util.List;
 
+import static java.util.Arrays.asList;
 import static org.hamcrest.core.Is.is;
 import static org.hamcrest.core.IsEqual.equalTo;
 import static org.junit.Assert.assertThat;
     assertNull(itinerary.strictlyPriorOf(unloadInLongbeach, unloadInLongbeach));
   }
 
+  public void testTruncatedAfter() throws Exception {
+    Leg shanghaiToLongBeach = Leg.deriveLeg(pacific, SHANGHAI, LONGBEACH);
+    Leg longBeachToNewYork = Leg.deriveLeg(transcontinental, LONGBEACH, NEWYORK);
+    Leg newYorkToRotterdam = Leg.deriveLeg(atlantic, NEWYORK, ROTTERDAM);
+
+    Itinerary itinerary = new Itinerary(shanghaiToLongBeach, longBeachToNewYork, newYorkToRotterdam);
+
+    Itinerary toNewYork = itinerary.truncatedAfter(NEWYORK);
+    assertEquals(asList(shanghaiToLongBeach, longBeachToNewYork), toNewYork.legs());
+
+    Itinerary toChicago = itinerary.truncatedAfter(CHICAGO);
+    assertEquals(asList(shanghaiToLongBeach, Leg.deriveLeg(transcontinental, LONGBEACH, CHICAGO)), toChicago.legs());
+
+    Itinerary toRotterdam = itinerary.truncatedAfter(ROTTERDAM);
+    assertEquals(asList(shanghaiToLongBeach, longBeachToNewYork, Leg.deriveLeg(atlantic, NEWYORK, ROTTERDAM)), toRotterdam.legs());
+  }
+
   public void testCreateItinerary() throws Exception {
     try {
       new Itinerary(new ArrayList<Leg>());

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

 package se.citerus.dddsample.tracking.core.domain.model.cargo;
 
+import org.junit.Test;
+import se.citerus.dddsample.tracking.core.domain.model.shared.HandlingActivity;
+import se.citerus.dddsample.tracking.core.domain.model.voyage.SampleVoyages;
+import se.citerus.dddsample.tracking.core.domain.model.voyage.Voyage;
+
+import static java.util.Arrays.asList;
 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 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.voyage.SampleVoyages.NEW_YORK_TO_DALLAS;
-import se.citerus.dddsample.tracking.core.domain.model.voyage.Voyage;
 
 public class LegTest {
 
     assertThat(newYorkToDallas.deriveLoadActivity(), is(HandlingActivity.loadOnto(voyage).in(NEWYORK)));
     assertThat(newYorkToDallas.deriveUnloadActivity(), is(HandlingActivity.unloadOff(voyage).in(DALLAS)));
   }
+
+  @Test
+  public void intermediateLocations() throws Exception {
+    Leg leg = Leg.deriveLeg(SampleVoyages.HONGKONG_TO_NEW_YORK, HONGKONG, NEWYORK);
+    assertEquals(asList(HANGZOU, TOKYO, MELBOURNE), leg.intermediateLocations());
+  }
+
 }

dddsample/tracking/core/src/test/java/se/citerus/dddsample/tracking/core/domain/model/voyage/VoyageTest.java

 package se.citerus.dddsample.tracking.core.domain.model.voyage;
 
-import junit.framework.TestCase;
+import org.junit.Test;
 
-public class VoyageTest extends TestCase {
+import static java.util.Arrays.asList;
+import static org.junit.Assert.assertEquals;
+import static se.citerus.dddsample.tracking.core.domain.model.location.SampleLocations.*;
+import static se.citerus.dddsample.tracking.core.domain.model.voyage.SampleVoyages.HONGKONG_TO_NEW_YORK;
 
+public class VoyageTest {
 
-  public void testSchedule() {
-    /*Voyage transcontinental = new Voyage.Builder(new VoyageNumber("4567"),
-      LONGBEACH).
-      addMovement(CHICAGO, new Date(1), new Date(2)).
-      addMovement(NEWYORK, new Date(3), new Date(4)).
-      build();*/
+  @Test
+  public void locations() {
+    Voyage voyage = HONGKONG_TO_NEW_YORK;
+    assertEquals(asList(HONGKONG, HANGZOU, TOKYO, MELBOURNE, NEWYORK), voyage.locations());
   }
 
 }

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

 package se.citerus.dddsample.tracking.core.domain.scenario;
 
+import org.junit.Test;
+import se.citerus.dddsample.tracking.core.domain.model.cargo.*;
+import se.citerus.dddsample.tracking.core.domain.service.RoutingService;
+import se.citerus.dddsample.tracking.core.infrastructure.persistence.inmemory.TrackingIdFactoryInMem;
+
+import java.util.Date;
+import java.util.List;
+
+import static java.util.Arrays.asList;
 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 static se.citerus.dddsample.tracking.core.domain.model.location.SampleLocations.*;
 import static se.citerus.dddsample.tracking.core.domain.model.shared.HandlingActivity.*;
 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 java.util.Date;
-import java.util.List;
 
 public class CargoLifecycle {
 
     assertNull(cargo.estimatedTimeOfArrival());
     assertNull(cargo.nextExpectedActivity());
 
-
-
     // Route: Hongkong - Long Beach - New York - Stockholm
-    List<Itinerary> itineraries =
-      routingService.fetchRoutesForSpecification(cargo.routeSpecification());
+    List<Itinerary> itineraries = routingService.fetchRoutesForSpecification(cargo.routeSpecification());
     Itinerary itinerary = selectAppropriateRoute(itineraries);
     cargo.assignToRoute(itinerary);
 
     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.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)));
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-    // Unloaded in Rotterdam, wasn't supposed to happen
-    cargo.handled(unloadOff(pacific2).in(ROTTERDAM));
+    // Unloaded in Seattle, wasn't supposed to happen
+    cargo.handled(unloadOff(pacific1).in(SEATTLE));
 
     // Misdirected
     assertTrue(cargo.isMisdirected());
-    assertThat(cargo.lastKnownLocation(), is(ROTTERDAM));
+    assertThat(cargo.lastKnownLocation(), is(SEATTLE));
     assertThat(cargo.transportStatus(), is(IN_PORT));
-
-
-
-
-
-
-
-
-
-
-
-
+    assertNull(cargo.nextExpectedActivity());
+    assertNull(cargo.estimatedTimeOfArrival());
 
     // Reroute: specify new route
-    RouteSpecification currentRouteSpec = cargo.routeSpecification();
-    RouteSpecification newRouteSpec =
-        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(
+      cargo.routeSpecification().withOrigin(cargo.earliestReroutingLocation())
+    );
+
     Itinerary newItinerary = selectAppropriateRoute(available);
-    cargo.assignToRoute(newItinerary);
+    Itinerary mergedItinerary = cargo.itineraryMergedWith(newItinerary);
+    cargo.assignToRoute(mergedItinerary);
 
+    assertFalse(cargo.isMisdirected());
     assertThat(cargo.routingStatus(), is(ROUTED));
-    assertThat(cargo.nextExpectedActivity(), is(loadOnto(atlantic1).in(ROTTERDAM)));
-
-
-
-
-
-
-
-
-
-
-
+    assertThat(cargo.nextExpectedActivity(), is(loadOnto(continental3).in(SEATTLE)));
 
     // Loaded, back on track
-    cargo.handled(loadOnto(atlantic1).in(ROTTERDAM));
+    cargo.handled(loadOnto(continental3).in(SEATTLE));
     assertFalse(cargo.isMisdirected());
-    assertThat(cargo.lastKnownLocation(), is(ROTTERDAM));
+    assertThat(cargo.lastKnownLocation(), is(SEATTLE));
     assertThat(cargo.transportStatus(), is(ONBOARD_CARRIER));
 
-
-
-
-
-
-
-
-
-
-
-
-
-
+    // Etc
   }
 
   @Test
 
     // Customer wants cargo to go to Rotterdam instead of Stockholm
     RouteSpecification toRotterdam = cargo.routeSpecification().
-      withOrigin(cargo.lastKnownLocation()).
       withDestination(ROTTERDAM);
 
     cargo.specifyNewRoute(toRotterdam);
     // Assign to new route
     List<Itinerary> available = routingService.fetchRoutesForSpecification(cargo.routeSpecification());
     Itinerary newItinerary = selectAppropriateRoute(available);
-    cargo.assignToRoute(newItinerary);
+    Itinerary mergedItinerary = cargo.itineraryMergedWith(newItinerary);
+
+    cargo.assignToRoute(mergedItinerary);
 
     assertThat(cargo.routingStatus(), is(ROUTED));
     assertThat(cargo.nextExpectedActivity(), is(loadOnto(continental2).in(LONGBEACH)));
     );
 
     private static final Itinerary itinerary2 = new Itinerary(
-      Leg.deriveLeg(atlantic1, ROTTERDAM, HAMBURG),
-      Leg.deriveLeg(atlantic2, HAMBURG, STOCKHOLM)
+      Leg.deriveLeg(continental3, SEATTLE, NEWYORK),
+      Leg.deriveLeg(atlantic2, NEWYORK, STOCKHOLM)
     );
 
     private static final Itinerary itinerary3 = new Itinerary(
     );
 
     public List<Itinerary> fetchRoutesForSpecification(RouteSpecification routeSpecification) {
-      if (routeSpecification.origin().sameAs(HONGKONG)) {
+      if (routeSpecification.origin().sameAs(HONGKONG) && routeSpecification.destination().sameAs(STOCKHOLM)) {
         // Hongkong - Long Beach - New York - Stockholm, initial routing
         return asList(itinerary1);
-      } else if (routeSpecification.origin().sameAs(ROTTERDAM)) {
+      } else if (routeSpecification.origin().sameAs(SEATTLE) && routeSpecification.destination().sameAs(STOCKHOLM)) {
         // Rotterdam - Hamburg - Stockholm, rerouting misdirected cargo from Rotterdam
         return asList(itinerary2);
-      } else if (routeSpecification.origin().sameAs(LONGBEACH)) {
+      } else if (routeSpecification.origin().sameAs(HONGKONG) && routeSpecification.destination().sameAs(ROTTERDAM)) {
         // Customer requested change of destination
         return asList(itinerary3);
       } else {