Cleaner and clearer lifecycle scenario test. Now used only the domain layer.

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

@@ -1,31 +1,22 @@
 package se.citerus.dddsample.scenario;
 
-import junit.framework.TestCase;
-import se.citerus.dddsample.application.ApplicationEvents;
-import se.citerus.dddsample.application.BookingService;
-import se.citerus.dddsample.application.CargoInspectionService;
-import se.citerus.dddsample.application.HandlingEventService;
-import se.citerus.dddsample.application.impl.BookingServiceImpl;
-import se.citerus.dddsample.application.impl.CargoInspectionServiceImpl;
-import se.citerus.dddsample.application.impl.HandlingEventServiceImpl;
+import static org.junit.Assert.*;
+import org.junit.Test;
 import static se.citerus.dddsample.application.util.DateTestUtil.toDate;
 import se.citerus.dddsample.domain.model.cargo.*;
 import static se.citerus.dddsample.domain.model.cargo.RoutingStatus.*;
 import static se.citerus.dddsample.domain.model.cargo.TransportStatus.*;
-import se.citerus.dddsample.domain.model.handling.CannotCreateHandlingEventException;
+import se.citerus.dddsample.domain.model.handling.*;
 import static se.citerus.dddsample.domain.model.handling.HandlingEvent.Type.*;
-import se.citerus.dddsample.domain.model.handling.HandlingEventFactory;
-import se.citerus.dddsample.domain.model.handling.HandlingEventRepository;
 import se.citerus.dddsample.domain.model.location.Location;
 import se.citerus.dddsample.domain.model.location.LocationRepository;
 import static se.citerus.dddsample.domain.model.location.SampleLocations.*;
-import se.citerus.dddsample.domain.model.location.UnLocode;
 import static se.citerus.dddsample.domain.model.voyage.SampleVoyages.*;
+import se.citerus.dddsample.domain.model.voyage.Voyage;
 import static se.citerus.dddsample.domain.model.voyage.Voyage.NONE;
 import se.citerus.dddsample.domain.model.voyage.VoyageNumber;
 import se.citerus.dddsample.domain.model.voyage.VoyageRepository;
 import se.citerus.dddsample.domain.service.RoutingService;
-import se.citerus.dddsample.infrastructure.messaging.stub.SynchronousApplicationEventsStub;
 import se.citerus.dddsample.infrastructure.persistence.inmemory.CargoRepositoryInMem;
 import se.citerus.dddsample.infrastructure.persistence.inmemory.HandlingEventRepositoryInMem;
 import se.citerus.dddsample.infrastructure.persistence.inmemory.LocationRepositoryInMem;
@@ -35,44 +26,19 @@ import java.util.Arrays;
 import java.util.Date;
 import java.util.List;
 
-public class CargoLifecycleScenarioTest extends TestCase {
+public class CargoLifecycleScenarioTest {
 
   /**
    * Repository implementations are part of the infrastructure layer,
    * which in this test is stubbed out by in-memory replacements.
    */
-  HandlingEventRepository handlingEventRepository;
-  CargoRepository cargoRepository;
-  LocationRepository locationRepository;
-  VoyageRepository voyageRepository;
+  HandlingEventRepository handlingEventRepository = new HandlingEventRepositoryInMem();
+  CargoRepository cargoRepository = new CargoRepositoryInMem();
+  LocationRepository locationRepository = new LocationRepositoryInMem();
+  VoyageRepository voyageRepository = new VoyageRepositoryInMem();
 
-  /**
-   * This interface is part of the application layer,
-   * and defines a number of events that occur during
-   * aplication execution. It is used for message-driving
-   * and is implemented using JMS.
-   *
-   * In this test it is stubbed with synchronous calls.
-   */
-  ApplicationEvents applicationEvents;
-
-  /**
-   * These three components all belong to the application layer,
-   * and map against use cases of the application. The "real"
-   * implementations are used in this lifecycle test,
-   * but wired with stubbed infrastructure.
-   */
-  BookingService bookingService;
-  HandlingEventService handlingEventService;
-  CargoInspectionService cargoInspectionService;
-
-  /**
-   * This factory is part of the handling aggregate and belongs to
-   * the domain layer. Similar to the application layer components,
-   * the "real" implementation is used here too,
-   * wired with stubbed infrastructure.
-   */
-  HandlingEventFactory handlingEventFactory;
+  HandlingEventFactory handlingEventFactory = new HandlingEventFactory(cargoRepository, voyageRepository, locationRepository);
+  CargoFactory cargoFactory = new CargoFactory(cargoRepository, locationRepository);
 
   /**
    * This is a domain service interface, whose implementation
@@ -80,136 +46,212 @@ public class CargoLifecycleScenarioTest extends TestCase {
    *
    * It is stubbed in this test.
    */
-  RoutingService routingService;
+  RoutingService routingService = new ScenarioStubRoutingService();
+
+  TrackingId trackingId;
+
+  /* The tracking id can be used to lookup the cargo in the repository.
+
+     Important: The cargo, and thus the domain model, is responsible for determining
+     the status of the cargo, whether it is on the right track or not and so on.
+     This is core domain logic.
+
+     Tracking the cargo basically amounts to presenting information extracted from
+     the cargo aggregate in a suitable way. */
+  /* Test setup: A cargo should be shipped from Hongkong to Stockholm,
+     and it should arrive in no more than two weeks. */
+  /* Use case 2: routing
+
+     A number of possible routes for this cargo is requested and may be
+     presented to the customer in some way for him/her to choose from.
+     Selection could be affected by things like price and time of delivery,
+     but this test simply uses an arbitrary selection to mimic that process.
+
+     The cargo is then assigned to the selected route, described by an itinerary. */
+
+  /*
+    Use case 3: handling
+
+    A handling event registration attempt will be formed from parsing
+    the data coming in as a handling report either via
+    the web service interface or as an uploaded CSV file.
+
+    The handling event factory tries to create a HandlingEvent from the attempt,
+    and if the factory decides that this is a plausible handling event, it is stored.
+    If the attempt is invalid, for example if no cargo exists for the specfied tracking id,
+    the attempt is rejected.
+
+    Handling begins: cargo is received in Hongkong.
+    */
+
+  @Test
+  public void cargoIsMisdirectedAndRerouted() throws Exception {
+    bookCargoFromHongkongToStockholm();
+    checkDeliveryAfterBooking();
+
+
+    // Initial route: Hongkong - New York - Chicago - Stockholm
+    routeCargoFromHongkongToStockholm();
+    checkDeliveryAfterRouting();
+
+
+    receiveInHongkong();
+    checkDeliveryAfterReceiveInHongkong();
+
+    loadInHongkong();
+    checkDeliveryAfterLoadInHongKong();
+
+    unloadInTokyo();
+    checkDeliveryAfterUnloadInTokyo();
 
-  public void testCargoFromHongkongToStockholm() throws Exception {
-    /* Test setup: A cargo should be shipped from Hongkong to Stockholm,
-       and it should arrive in no more than two weeks. */
-    Location origin = HONGKONG;
-    Location destination = STOCKHOLM;
-    Date arrivalDeadline = toDate("2009-03-18");
 
-    /* Use case 1: booking
+    // Reroute: Tokyo - Hamburg - Stockholm
+    specifyNewRouteFromTokyoToStockholm();
+    checkDeliveryAfterNewRouteSpecified();
 
-       A new cargo is booked, and the unique tracking id is assigned to the cargo. */
-    TrackingId trackingId = bookingService.bookNewCargo(
-      origin.unLocode(), destination.unLocode(), arrivalDeadline
-    );
+    assignToNewRouteFromTokyoToStockholm();
+    checkDeliveryAfterAssignedToNewRoute();
 
-    /* The tracking id can be used to lookup the cargo in the repository.
 
-       Important: The cargo, and thus the domain model, is responsible for determining
-       the status of the cargo, whether it is on the right track or not and so on.
-       This is core domain logic.
+    loadInTokyo();
+    checkDeliveryAfterLoadInTokyo();
 
-       Tracking the cargo basically amounts to presenting information extracted from
-       the cargo aggregate in a suitable way. */
+    unloadInHamburg();
+    checkDeliveryAfterUnloadInHamburg();
+
+    loadInHamburg();
+    checkDeliveryAfterLoadInHamburg();
+
+    unloadInStockholm();
+    checkDeliveryAfterUnloadInStockholm();
+
+    claimInStockholm();
+    checkDeliveryAfterClaimInStockholm();
+  }
+
+  private void bookCargoFromHongkongToStockholm() {
+    Date arrivalDeadline = toDate("2009-03-18");
+    Cargo cargo = cargoFactory.newCargo(HONGKONG.unLocode(), STOCKHOLM.unLocode(), arrivalDeadline);
+    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);
+
     assertNotNull(cargo);
     assertEquals(NOT_RECEIVED, cargo.delivery().transportStatus());
     assertEquals(NOT_ROUTED, cargo.delivery().routingStatus());
     assertFalse(cargo.delivery().isMisdirected());
     assertNull(cargo.delivery().estimatedTimeOfArrival());
     assertNull(cargo.delivery().nextExpectedActivity());
+  }
 
-    /* Use case 2: routing
-
-       A number of possible routes for this cargo is requested and may be
-       presented to the customer in some way for him/her to choose from.
-       Selection could be affected by things like price and time of delivery,
-       but this test simply uses an arbitrary selection to mimic that process.
-
-       The cargo is then assigned to the selected route, described by an itinerary. */
-    List<Itinerary> itineraries = bookingService.requestPossibleRoutesForCargo(trackingId);
-    Itinerary itinerary = selectPreferedItinerary(itineraries);
-    cargo.assignToRoute(itinerary);
+  public void checkDeliveryAfterRouting() throws Exception {
+    Cargo cargo = cargoRepository.find(trackingId);
 
     assertEquals(NOT_RECEIVED, cargo.delivery().transportStatus());
     assertEquals(ROUTED, cargo.delivery().routingStatus());
     assertNotNull(cargo.delivery().estimatedTimeOfArrival());
     assertEquals(new HandlingActivity(RECEIVE, HONGKONG), cargo.delivery().nextExpectedActivity());
+  }
 
-    /*
-      Use case 3: handling
-
-      A handling event registration attempt will be formed from parsing
-      the data coming in as a handling report either via
-      the web service interface or as an uploaded CSV file.
-
-      The handling event factory tries to create a HandlingEvent from the attempt,
-      and if the factory decides that this is a plausible handling event, it is stored.
-      If the attempt is invalid, for example if no cargo exists for the specfied tracking id,
-      the attempt is rejected.
-
-      Handling begins: cargo is received in Hongkong.
-      */
-    handlingEventService.registerHandlingEvent(
-      toDate("2009-03-01"), trackingId, null, HONGKONG.unLocode(), RECEIVE
-    );
+  public void receiveInHongkong() throws CannotCreateHandlingEventException {
+    createHandlingEventAndUpdateAggregates(toDate("2009-03-01"), null, HONGKONG, RECEIVE);
+  }
 
+  private void checkDeliveryAfterReceiveInHongkong() {
+    Cargo cargo = cargoRepository.find(trackingId);
     assertEquals(IN_PORT, cargo.delivery().transportStatus());
     assertEquals(HONGKONG, cargo.delivery().lastKnownLocation());
-    
-    // Next event: Load onto voyage CM003 in Hongkong
-    handlingEventService.registerHandlingEvent(
-      toDate("2009-03-03"), trackingId, v100.voyageNumber(), HONGKONG.unLocode(), LOAD
-    );
+  }
+
+  public void loadInHongkong() throws CannotCreateHandlingEventException {
+    createHandlingEventAndUpdateAggregates(toDate("2009-03-03"), v100, HONGKONG, LOAD);
+  }
 
+  private void checkDeliveryAfterLoadInHongKong() {
     // Check current state - should be ok
+    Cargo cargo = cargoRepository.find(trackingId);
     assertEquals(v100, cargo.delivery().currentVoyage());
     assertEquals(HONGKONG, cargo.delivery().lastKnownLocation());
     assertEquals(ONBOARD_CARRIER, cargo.delivery().transportStatus());
     assertFalse(cargo.delivery().isMisdirected());
     assertEquals(new HandlingActivity(UNLOAD, NEWYORK, v100), cargo.delivery().nextExpectedActivity());
+  }
 
+  /*
+   Here's an attempt to register a handling event that's not valid
+   because there is no voyage with the specified voyage number,
+   and there's no location with the specified UN Locode either.
+
+   This attempt will be rejected and will not affect the cargo delivery in any way.
+ final VoyageNumber noSuchVoyageNumber = new VoyageNumber("XX000");
+ final UnLocode noSuchUnLocode = new UnLocode("ZZZZZ");
+ try {
+   handlingEventService.registerHandlingEvent(
+   toDate("2009-03-05"), trackingId, noSuchVoyageNumber, noSuchUnLocode, LOAD
+   );
+   fail("Should not be able to register a handling event with invalid location and voyage");
+ } catch (CannotCreateHandlingEventException expected) {
+ }
+  */
 
-    /*
-      Here's an attempt to register a handling event that's not valid
-      because there is no voyage with the specified voyage number,
-      and there's no location with the specified UN Locode either.
-
-      This attempt will be rejected and will not affect the cargo delivery in any way.
-     */
-    final VoyageNumber noSuchVoyageNumber = new VoyageNumber("XX000");
-    final UnLocode noSuchUnLocode = new UnLocode("ZZZZZ");
-    try {
-      handlingEventService.registerHandlingEvent(
-      toDate("2009-03-05"), trackingId, noSuchVoyageNumber, noSuchUnLocode, LOAD
-      );
-      fail("Should not be able to register a handling event with invalid location and voyage");
-    } catch (CannotCreateHandlingEventException expected) {
-    }
-
-
+  public void unloadInTokyo() throws CannotCreateHandlingEventException {
     // Cargo is now (incorrectly) unloaded in Tokyo
-    handlingEventService.registerHandlingEvent(
-      toDate("2009-03-05"), trackingId, v100.voyageNumber(), TOKYO.unLocode(), UNLOAD
-    );
+    createHandlingEventAndUpdateAggregates(toDate("2009-03-05"), v100, TOKYO, UNLOAD);
+  }
 
+  private void checkDeliveryAfterUnloadInTokyo() {
+    Cargo cargo = cargoRepository.find(trackingId);
     // Check current state - cargo is misdirected!
     assertEquals(NONE, cargo.delivery().currentVoyage());
     assertEquals(TOKYO, cargo.delivery().lastKnownLocation());
     assertEquals(IN_PORT, cargo.delivery().transportStatus());
     assertTrue(cargo.delivery().isMisdirected());
     assertNull(cargo.delivery().nextExpectedActivity());
+  }
 
-
-    // -- Cargo needs to be rerouted --
-
+  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 = new RouteSpecification(TOKYO, STOCKHOLM, arrivalDeadline);
+    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
     assertEquals(MISROUTED, cargo.delivery().routingStatus());
     assertNull(cargo.delivery().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 = bookingService.requestPossibleRoutesForCargo(cargo.trackingId());
-    Itinerary newItinerary = selectPreferedItinerary(newItineraries);
+    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
     assertEquals(ROUTED, cargo.delivery().routingStatus());
@@ -217,66 +259,71 @@ public class CargoLifecycleScenarioTest extends TestCase {
     // TODO we can't handle the face that after a reroute, the cargo isn't misdirected anymore
     //assertFalse(cargo.isMisdirected());
     //assertEquals(new HandlingActivity(LOAD, TOKYO), cargo.nextExpectedActivity());
+  }
 
+  public void loadInTokyo() throws CannotCreateHandlingEventException {
+    createHandlingEventAndUpdateAggregates(toDate("2009-03-08"), v300, TOKYO, LOAD);
+  }
 
-    // -- Cargo has been rerouted, shipping continues --
-
-
-    // Load in Tokyo
-    handlingEventService.registerHandlingEvent(
-      toDate("2009-03-08"), trackingId, v300.voyageNumber(), TOKYO.unLocode(), LOAD
-    );
-
+  private void checkDeliveryAfterLoadInTokyo() {
+    Cargo cargo = cargoRepository.find(trackingId);
     // Check current state - should be ok
     assertEquals(v300, cargo.delivery().currentVoyage());
     assertEquals(TOKYO, cargo.delivery().lastKnownLocation());
     assertEquals(ONBOARD_CARRIER, cargo.delivery().transportStatus());
     assertFalse(cargo.delivery().isMisdirected());
     assertEquals(new HandlingActivity(UNLOAD, HAMBURG, v300), cargo.delivery().nextExpectedActivity());
+  }
 
-    // Unload in Hamburg
-    handlingEventService.registerHandlingEvent(
-      toDate("2009-03-12"), trackingId, v300.voyageNumber(), HAMBURG.unLocode(), UNLOAD
-    );
+  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
     assertEquals(NONE, cargo.delivery().currentVoyage());
     assertEquals(HAMBURG, cargo.delivery().lastKnownLocation());
     assertEquals(IN_PORT, cargo.delivery().transportStatus());
     assertFalse(cargo.delivery().isMisdirected());
     assertEquals(new HandlingActivity(LOAD, HAMBURG, v400), cargo.delivery().nextExpectedActivity());
+  }
 
+  public void loadInHamburg() throws CannotCreateHandlingEventException {
+    createHandlingEventAndUpdateAggregates(toDate("2009-03-14"), v400, HAMBURG, LOAD);
+  }
 
-    // Load in Hamburg
-    handlingEventService.registerHandlingEvent(
-      toDate("2009-03-14"), trackingId, v400.voyageNumber(), HAMBURG.unLocode(), LOAD
-    );
-
+  private void checkDeliveryAfterLoadInHamburg() {
+    Cargo cargo = cargoRepository.find(trackingId);
     // Check current state - should be ok
     assertEquals(v400, cargo.delivery().currentVoyage());
     assertEquals(HAMBURG, cargo.delivery().lastKnownLocation());
     assertEquals(ONBOARD_CARRIER, cargo.delivery().transportStatus());
     assertFalse(cargo.delivery().isMisdirected());
     assertEquals(new HandlingActivity(UNLOAD, STOCKHOLM, v400), cargo.delivery().nextExpectedActivity());
+  }
 
+  public void unloadInStockholm() throws CannotCreateHandlingEventException {
+    createHandlingEventAndUpdateAggregates(toDate("2009-03-15"), v400, STOCKHOLM, UNLOAD);
+  }
 
-    // Unload in Stockholm
-    handlingEventService.registerHandlingEvent(
-      toDate("2009-03-15"), trackingId, v400.voyageNumber(), STOCKHOLM.unLocode(), UNLOAD
-    );
-
+  private void checkDeliveryAfterUnloadInStockholm() {
+    Cargo cargo = cargoRepository.find(trackingId);
     // Check current state - should be ok
     assertEquals(NONE, cargo.delivery().currentVoyage());
     assertEquals(STOCKHOLM, cargo.delivery().lastKnownLocation());
     assertEquals(IN_PORT, cargo.delivery().transportStatus());
     assertFalse(cargo.delivery().isMisdirected());
     assertEquals(new HandlingActivity(CLAIM, STOCKHOLM), cargo.delivery().nextExpectedActivity());
+  }
 
+  private void claimInStockholm() throws CannotCreateHandlingEventException {
     // Finally, cargo is claimed in Stockholm. This ends the cargo lifecycle from our perspective.
-    handlingEventService.registerHandlingEvent(
-      toDate("2009-03-16"), trackingId, null, STOCKHOLM.unLocode(), CLAIM
-    );
+    createHandlingEventAndUpdateAggregates(toDate("2009-03-16"), null, STOCKHOLM, CLAIM);
+  }
 
+  private void checkDeliveryAfterClaimInStockholm() {
+    Cargo cargo = cargoRepository.find(trackingId);
     // Check current state - should be ok
     assertEquals(NONE, cargo.delivery().currentVoyage());
     assertEquals(STOCKHOLM, cargo.delivery().lastKnownLocation());
@@ -285,57 +332,43 @@ public class CargoLifecycleScenarioTest extends TestCase {
     assertNull(cargo.delivery().nextExpectedActivity());
   }
 
+  private void createHandlingEventAndUpdateAggregates(Date completionTime, Voyage voyage, Location location, HandlingEvent.Type type) throws CannotCreateHandlingEventException {
+    VoyageNumber voyageNumber = voyage != null ? voyage.voyageNumber() : null;
+    HandlingEvent handlingEvent = handlingEventFactory.createHandlingEvent(new Date(), completionTime, trackingId, voyageNumber, location.unLocode(), type);
+    handlingEventRepository.store(handlingEvent);
+    updateCargoAggregate();
+  }
 
-  /*
-  * Utility stubs below.
-  */
-
-  private Itinerary selectPreferedItinerary(List<Itinerary> itineraries) {
-    return itineraries.get(0);
+  private void updateCargoAggregate() {
+    Cargo cargo = cargoRepository.find(trackingId);
+    HandlingHistory handlingHistory = handlingEventRepository.lookupHandlingHistoryOfCargo(cargo);
+    cargo.deriveDeliveryProgress(handlingHistory);
+    cargoRepository.store(cargo);
   }
 
-  protected void setUp() throws Exception {
-    routingService = new 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(v100, HONGKONG, NEWYORK, toDate("2009-03-03"), toDate("2009-03-09")),
-              new Leg(v200, NEWYORK, CHICAGO, toDate("2009-03-10"), toDate("2009-03-14")),
-              new Leg(v200, CHICAGO, 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"))
-            ))
-          );
-        }
+  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(v100, HONGKONG, NEWYORK, toDate("2009-03-03"), toDate("2009-03-09")),
+            new Leg(v200, NEWYORK, CHICAGO, toDate("2009-03-10"), toDate("2009-03-14")),
+            new Leg(v200, CHICAGO, 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"))
+          ))
+        );
       }
-    };
-
-
-    applicationEvents = new SynchronousApplicationEventsStub();
-
-    // In-memory implementations of the repositories
-    handlingEventRepository = new HandlingEventRepositoryInMem();
-    cargoRepository = new CargoRepositoryInMem();
-    locationRepository = new LocationRepositoryInMem();
-    voyageRepository = new VoyageRepositoryInMem();
-
-    // Actual factories and application services, wired with stubbed or in-memory infrastructure
-    handlingEventFactory = new HandlingEventFactory(cargoRepository, voyageRepository, locationRepository);
-
-    cargoInspectionService = new CargoInspectionServiceImpl(applicationEvents, cargoRepository, handlingEventRepository);
-    handlingEventService = new HandlingEventServiceImpl(handlingEventRepository, applicationEvents, handlingEventFactory);
-    bookingService = new BookingServiceImpl(cargoRepository, locationRepository, routingService);
+    }
 
-    // Circular dependency when doing synchrounous calls
-    ((SynchronousApplicationEventsStub) applicationEvents).setCargoInspectionService(cargoInspectionService);
   }
 
 }