Modified DeliveryHistory to be immutable and filled with handling events at (Cargo) load time.

Implemented orphan delete of the old itinerary when a new itinerary is attached to a cargo.

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

@@ -24,7 +24,7 @@ public final class Cargo {
   private Location destination;
 
   @Transient
-  private final DeliveryHistory deliveryHistory = new DeliveryHistory();
+  private DeliveryHistory deliveryHistory = DeliveryHistory.EMPTY_DELIVERY_HISTORY;
 
   @ManyToOne(cascade = CascadeType.ALL)
   private Itinerary itinerary;
@@ -121,6 +121,18 @@ public final class Cargo {
     this.itinerary = itinerary;
   }
 
+  public void removeItinerary() {
+    this.itinerary = null;
+  }
+
+  /**
+   * @param deliveryHistory Cargo delivery history
+   */
+  public void setDeliveryHistory(final DeliveryHistory deliveryHistory) {
+    Validate.notNull(deliveryHistory);
+    this.deliveryHistory = deliveryHistory;
+  }
+
   /**
    * Check if cargo is misdirected.
    * <p/>
@@ -201,5 +213,4 @@ public final class Cargo {
   Cargo() {
     // Needed by Hibernate
   }
-
 }

dddsample/src/main/java/se/citerus/dddsample/domain/DeliveryHistory.java

@@ -11,25 +11,32 @@ import java.util.*;
  */
 public final class DeliveryHistory {
 
-  private final Set<HandlingEvent> events = new HashSet<HandlingEvent>();
+  private final Set<HandlingEvent> events;
+
+  public static final DeliveryHistory EMPTY_DELIVERY_HISTORY = new DeliveryHistory(Collections.EMPTY_SET);
+
+
+  public DeliveryHistory(final Collection<HandlingEvent> events) {
+    this.events = new HashSet<HandlingEvent>(events);
+  }
 
   /**
    * Adds all HandlingEvent to the delivery history.
    *
    * @param events events to add
-   */
   public void addAllEvents(final Collection<HandlingEvent> events) {
     this.events.addAll(events);
   }
+   */
 
   /**
    * Adds a HandlingEvent to the delivery history.
    *
    * @param event event to add.
-   */
   public void addEvent(final HandlingEvent event) {
     this.events.add(event);
   }
+   */
 
   /**
    * @return An <b>unmodifiable</b> list of handling events, ordered by the time the events occured.
@@ -110,8 +117,10 @@ public final class DeliveryHistory {
     return events.hashCode();
   }
 
+  /*
   DeliveryHistory() {
     // Needed by Hibernate
   }
+  */
 
 }

dddsample/src/main/java/se/citerus/dddsample/domain/HandlingEvent.java

@@ -131,6 +131,7 @@ public final class HandlingEvent {
     return this.cargo;
   }
 
+  @Override
   public boolean equals(final Object o) {
     if (this == o) return true;
     if (o == null || getClass() != o.getClass()) return false;

dddsample/src/main/java/se/citerus/dddsample/domain/Itinerary.java

@@ -21,7 +21,7 @@ public final class Itinerary {
   @JoinColumn(name = "itinerary_id")
   private List<Leg> legs = Collections.emptyList();
 
-  public static final Itinerary EMPTY_ITINERARY = new Itinerary();
+  static final Itinerary EMPTY_ITINERARY = new Itinerary();
 
   /**
    * Constructor.

dddsample/src/main/java/se/citerus/dddsample/repository/CargoRepository.java

@@ -1,6 +1,7 @@
 package se.citerus.dddsample.repository;
 
 import se.citerus.dddsample.domain.Cargo;
+import se.citerus.dddsample.domain.Itinerary;
 import se.citerus.dddsample.domain.TrackingId;
 
 import java.util.List;
@@ -25,7 +26,7 @@ public interface CargoRepository {
   /**
    * Saves given cargo.
    *
-   * @param cargo Cargo to save.
+   * @param cargo cargo to save
    */
   void save(Cargo cargo);
 
@@ -34,4 +35,10 @@ public interface CargoRepository {
    */
   TrackingId nextTrackingId();
 
+  /**
+   * Deletes an itinerary.
+   *
+   * @param itinerary itinerary to delete
+   */
+  void deleteItinerary(Itinerary itinerary);
 }

dddsample/src/main/java/se/citerus/dddsample/repository/CargoRepositoryHibernate.java

@@ -2,6 +2,8 @@ package se.citerus.dddsample.repository;
 
 import org.springframework.stereotype.Repository;
 import se.citerus.dddsample.domain.Cargo;
+import se.citerus.dddsample.domain.DeliveryHistory;
+import se.citerus.dddsample.domain.Itinerary;
 import se.citerus.dddsample.domain.TrackingId;
 
 import java.util.List;
@@ -26,10 +28,17 @@ public class CargoRepositoryHibernate extends HibernateRepository implements Car
     /*  There's no OR-mapped relation between the cargo delivery history and its handling events
         because the handling events are in a different aggregate.
 
+        TODO: investigate the following scenario to motivate this construction 
+        If we had to use pessimistic locking on cargo,
+        it might be cumbersome to map the relation between cargo and handling event,
+        since we want to be able to insert handling events regardless of locking status on cargo.
+
         If this extra database call were a problem, you might want to use a different model.
         For example, you could calculate the effect/status of the cargo and store it separate from the
         handling events. */
-    cargo.deliveryHistory().addAllEvents(handlingEventRepository.findEventsForCargo(tid));
+    DeliveryHistory deliveryHistory = new DeliveryHistory(handlingEventRepository.findEventsForCargo(tid));
+    cargo.setDeliveryHistory(deliveryHistory);
+
     return cargo;
   }
 
@@ -48,6 +57,13 @@ public class CargoRepositoryHibernate extends HibernateRepository implements Car
     );
   }
 
+  public void deleteItinerary(Itinerary itinerary) {
+    // Itinerary should be mapped to cascade deletes to all its legs
+    if (itinerary != null) {
+      getSession().delete(itinerary);
+    }
+  }
+
   public List<Cargo> findAll() {
     return getSession().createQuery("from Cargo").list();
   }

dddsample/src/main/java/se/citerus/dddsample/repository/CargoRepositoryInMem.java

@@ -2,6 +2,7 @@ package se.citerus.dddsample.repository;
 
 import org.springframework.dao.DataRetrievalFailureException;
 import se.citerus.dddsample.domain.Cargo;
+import se.citerus.dddsample.domain.Itinerary;
 import se.citerus.dddsample.domain.TrackingId;
 
 import java.util.HashMap;
@@ -46,6 +47,9 @@ public class CargoRepositoryInMem implements CargoRepository {
     return new TrackingId(UUID.randomUUID().toString());
   }
 
+  public void deleteItinerary(Itinerary itinerary) {
+  }
+
   public List<Cargo> findAll() {
     return null;  //To change body of implemented methods use File | Settings | File Templates.
   }

dddsample/src/main/java/se/citerus/dddsample/service/CargoServiceImpl.java

@@ -117,6 +117,7 @@ public final class CargoServiceImpl implements CargoService {
     Validate.notNull(trackingId);
     Validate.notNull(dto);
 
+    // TODO: findAndLock, to illustrate locking problem vs. HandlingEvent?
     final Cargo cargo = cargoRepository.find(trackingId);
     if (cargo == null) {
       throw new IllegalArgumentException("Can't assign itinerary to non-existing cargo " + trackingId);
@@ -125,10 +126,12 @@ public final class CargoServiceImpl implements CargoService {
     final ItineraryCandidateDTOAssembler itineraryCandidateDTOAssembler = new ItineraryCandidateDTOAssembler();
     final Itinerary newItinerary = itineraryCandidateDTOAssembler.fromDTO(dto, carrierMovementRepository, locationRepository);
 
-    /* TODO: delete orphaned itinerary
+    // Delete orphaned itinerary
     final Itinerary oldItinerary = cargo.itinerary();
     cargoRepository.deleteItinerary(oldItinerary);
-    */
+    cargo.removeItinerary();
+
+    // Assign the new itinerary to the cargo
     cargo.setItinerary(newItinerary);
     cargoRepository.save(cargo);
   }

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

@@ -6,18 +6,10 @@ import static se.citerus.dddsample.domain.SampleLocations.*;
 import java.text.DateFormat;
 import java.text.ParseException;
 import java.text.SimpleDateFormat;
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.Date;
+import java.util.*;
 
 public class CargoTest extends TestCase {
-
-  // TODO:
-  // it seems that events are not added to the system by cargo.deliveryHistory().addEvent(),
-  // but rather new HandlingEvents are stored and associated with its cargo. This test should
-  // work against the repositories or the service layer. The delivery history of a cargo should be
-  // read-only from the cargo end. // PeBa
-
+  private Set<HandlingEvent> events;
 
   public void testlastKnownLocationUnknownWhenNoEvents() throws Exception {
     Cargo cargo = new Cargo(new TrackingId("XYZ"), STOCKHOLM, MELBOURNE);
@@ -73,6 +65,10 @@ public class CargoTest extends TestCase {
     assertFalse("Cargos are not equal when TrackingID differ", c1.equals(c2));
   }
 
+  protected void setUp() throws Exception {
+    events = new HashSet<HandlingEvent>();
+  }
+
   public void testIsUnloadedAtFinalDestination() throws Exception {
     assertFalse(new Cargo().isUnloadedAtDestination());
 
@@ -80,25 +76,29 @@ public class CargoTest extends TestCase {
     assertFalse(cargo.isUnloadedAtDestination());
 
     // Adding an event unrelated to unloading at final destination
-    cargo.deliveryHistory().addEvent(
+    events.add(
       new HandlingEvent(cargo, new Date(), new Date(), HandlingEvent.Type.RECEIVE, HANGZOU, null));
+    cargo.setDeliveryHistory(new DeliveryHistory(events));
     assertFalse(cargo.isUnloadedAtDestination());
 
     CarrierMovement cm1 = new CarrierMovement(new CarrierMovementId("CM1"), HANGZOU, NEWYORK);
 
     // Adding an unload event, but not at the final destination
-    cargo.deliveryHistory().addEvent(
+    events.add(
       new HandlingEvent(cargo, new Date(), new Date(), HandlingEvent.Type.UNLOAD, TOKYO, cm1));
+    cargo.setDeliveryHistory(new DeliveryHistory(events));
     assertFalse(cargo.isUnloadedAtDestination());
 
     // Adding an event in the final destination, but not unload
-    cargo.deliveryHistory().addEvent(
+    events.add(
       new HandlingEvent(cargo, new Date(), new Date(), HandlingEvent.Type.CUSTOMS, NEWYORK, null));
+    cargo.setDeliveryHistory(new DeliveryHistory(events));
     assertFalse(cargo.isUnloadedAtDestination());
 
     // Finally, cargo is unloaded at final destination
-    cargo.deliveryHistory().addEvent(
+    events.add(
       new HandlingEvent(cargo, new Date(), new Date(), HandlingEvent.Type.UNLOAD, NEWYORK, cm1));
+    cargo.setDeliveryHistory(new DeliveryHistory(events));
     assertTrue(cargo.isUnloadedAtDestination());
   }
 
@@ -129,7 +129,8 @@ public class CargoTest extends TestCase {
     final Cargo cargo = new Cargo(new TrackingId("XYZ"), STOCKHOLM, MELBOURNE);
 
     HandlingEvent he = new HandlingEvent(cargo, getDate("2007-12-01"), new Date(), HandlingEvent.Type.RECEIVE, STOCKHOLM, null);
-    cargo.deliveryHistory().addEvent(he);
+    events.add(he);
+    cargo.setDeliveryHistory(new DeliveryHistory(events));
 
     return cargo;
   }
@@ -137,7 +138,8 @@ public class CargoTest extends TestCase {
   private Cargo populateCargoClaimedMelbourne() throws Exception {
     final Cargo cargo = populateCargoOffMelbourne();
 
-    cargo.deliveryHistory().addEvent(new HandlingEvent(cargo, getDate("2007-12-09"), new Date(), HandlingEvent.Type.CLAIM, MELBOURNE, null));
+    events.add(new HandlingEvent(cargo, getDate("2007-12-09"), new Date(), HandlingEvent.Type.CLAIM, MELBOURNE, null));
+    cargo.setDeliveryHistory(new DeliveryHistory(events));
 
     return cargo;
   }
@@ -148,15 +150,16 @@ public class CargoTest extends TestCase {
     final CarrierMovement stockholmToHamburg = new CarrierMovement(
        new CarrierMovementId("CAR_001"), STOCKHOLM, HAMBURG);
 
-    cargo.deliveryHistory().addEvent(new HandlingEvent(cargo, getDate("2007-12-01"), new Date(), HandlingEvent.Type.LOAD, STOCKHOLM, stockholmToHamburg));
-    cargo.deliveryHistory().addEvent(new HandlingEvent(cargo, getDate("2007-12-02"), new Date(), HandlingEvent.Type.UNLOAD, HAMBURG, stockholmToHamburg));
+    events.add(new HandlingEvent(cargo, getDate("2007-12-01"), new Date(), HandlingEvent.Type.LOAD, STOCKHOLM, stockholmToHamburg));
+    events.add(new HandlingEvent(cargo, getDate("2007-12-02"), new Date(), HandlingEvent.Type.UNLOAD, HAMBURG, stockholmToHamburg));
 
     final CarrierMovement hamburgToHongKong = new CarrierMovement(
        new CarrierMovementId("CAR_001"), HAMBURG, HONGKONG);
 
-    cargo.deliveryHistory().addEvent(new HandlingEvent(cargo, getDate("2007-12-03"), new Date(), HandlingEvent.Type.LOAD, HAMBURG, hamburgToHongKong));
-    cargo.deliveryHistory().addEvent(new HandlingEvent(cargo, getDate("2007-12-04"), new Date(), HandlingEvent.Type.UNLOAD, HONGKONG, hamburgToHongKong));
+    events.add(new HandlingEvent(cargo, getDate("2007-12-03"), new Date(), HandlingEvent.Type.LOAD, HAMBURG, hamburgToHongKong));
+    events.add(new HandlingEvent(cargo, getDate("2007-12-04"), new Date(), HandlingEvent.Type.UNLOAD, HONGKONG, hamburgToHongKong));
 
+    cargo.setDeliveryHistory(new DeliveryHistory(events));
     return cargo;
   }
 
@@ -166,14 +169,15 @@ public class CargoTest extends TestCase {
     final CarrierMovement stockholmToHamburg = new CarrierMovement(
        new CarrierMovementId("CAR_001"), STOCKHOLM, HAMBURG);
 
-    cargo.deliveryHistory().addEvent(new HandlingEvent(cargo, getDate("2007-12-01"), new Date(), HandlingEvent.Type.LOAD, STOCKHOLM, stockholmToHamburg));
-    cargo.deliveryHistory().addEvent(new HandlingEvent(cargo, getDate("2007-12-02"), new Date(), HandlingEvent.Type.UNLOAD, HAMBURG, stockholmToHamburg));
+    events.add(new HandlingEvent(cargo, getDate("2007-12-01"), new Date(), HandlingEvent.Type.LOAD, STOCKHOLM, stockholmToHamburg));
+    events.add(new HandlingEvent(cargo, getDate("2007-12-02"), new Date(), HandlingEvent.Type.UNLOAD, HAMBURG, stockholmToHamburg));
 
     final CarrierMovement hamburgToHongKong = new CarrierMovement(
        new CarrierMovementId("CAR_001"), HAMBURG, HONGKONG);
 
-    cargo.deliveryHistory().addEvent(new HandlingEvent(cargo, getDate("2007-12-03"), new Date(), HandlingEvent.Type.LOAD, HAMBURG, hamburgToHongKong));
+    events.add(new HandlingEvent(cargo, getDate("2007-12-03"), new Date(), HandlingEvent.Type.LOAD, HAMBURG, hamburgToHongKong));
 
+    cargo.setDeliveryHistory(new DeliveryHistory(events));
     return cargo;
   }
 
@@ -183,21 +187,22 @@ public class CargoTest extends TestCase {
     final CarrierMovement stockholmToHamburg = new CarrierMovement(
        new CarrierMovementId("CAR_001"), STOCKHOLM, HAMBURG);
 
-    cargo.deliveryHistory().addEvent(new HandlingEvent(cargo, getDate("2007-12-01"), new Date(), HandlingEvent.Type.LOAD, STOCKHOLM, stockholmToHamburg));
-    cargo.deliveryHistory().addEvent(new HandlingEvent(cargo, getDate("2007-12-02"), new Date(), HandlingEvent.Type.UNLOAD, HAMBURG, stockholmToHamburg));
+    events.add(new HandlingEvent(cargo, getDate("2007-12-01"), new Date(), HandlingEvent.Type.LOAD, STOCKHOLM, stockholmToHamburg));
+    events.add(new HandlingEvent(cargo, getDate("2007-12-02"), new Date(), HandlingEvent.Type.UNLOAD, HAMBURG, stockholmToHamburg));
 
     final CarrierMovement hamburgToHongKong = new CarrierMovement(
        new CarrierMovementId("CAR_001"), HAMBURG, HONGKONG);
 
-    cargo.deliveryHistory().addEvent(new HandlingEvent(cargo, getDate("2007-12-03"), new Date(), HandlingEvent.Type.LOAD, HAMBURG, hamburgToHongKong));
-    cargo.deliveryHistory().addEvent(new HandlingEvent(cargo, getDate("2007-12-04"), new Date(), HandlingEvent.Type.UNLOAD, HONGKONG, hamburgToHongKong));
+    events.add(new HandlingEvent(cargo, getDate("2007-12-03"), new Date(), HandlingEvent.Type.LOAD, HAMBURG, hamburgToHongKong));
+    events.add(new HandlingEvent(cargo, getDate("2007-12-04"), new Date(), HandlingEvent.Type.UNLOAD, HONGKONG, hamburgToHongKong));
 
     final CarrierMovement hongKongToMelbourne = new CarrierMovement(
        new CarrierMovementId("CAR_001"), HONGKONG, MELBOURNE);
 
-    cargo.deliveryHistory().addEvent(new HandlingEvent(cargo, getDate("2007-12-05"), new Date(), HandlingEvent.Type.LOAD, HONGKONG, hongKongToMelbourne));
-    cargo.deliveryHistory().addEvent(new HandlingEvent(cargo, getDate("2007-12-07"), new Date(), HandlingEvent.Type.UNLOAD, MELBOURNE, hongKongToMelbourne));
+    events.add(new HandlingEvent(cargo, getDate("2007-12-05"), new Date(), HandlingEvent.Type.LOAD, HONGKONG, hongKongToMelbourne));
+    events.add(new HandlingEvent(cargo, getDate("2007-12-07"), new Date(), HandlingEvent.Type.UNLOAD, MELBOURNE, hongKongToMelbourne));
 
+    cargo.setDeliveryHistory(new DeliveryHistory(events));
     return cargo;
   }
 
@@ -207,20 +212,21 @@ public class CargoTest extends TestCase {
     final CarrierMovement stockholmToHamburg = new CarrierMovement(
        new CarrierMovementId("CAR_001"), STOCKHOLM, HAMBURG);
 
-    cargo.deliveryHistory().addEvent(new HandlingEvent(cargo, getDate("2007-12-01"), new Date(), HandlingEvent.Type.LOAD, STOCKHOLM, stockholmToHamburg));
-    cargo.deliveryHistory().addEvent(new HandlingEvent(cargo, getDate("2007-12-02"), new Date(), HandlingEvent.Type.UNLOAD, HAMBURG, stockholmToHamburg));
+    events.add(new HandlingEvent(cargo, getDate("2007-12-01"), new Date(), HandlingEvent.Type.LOAD, STOCKHOLM, stockholmToHamburg));
+    events.add(new HandlingEvent(cargo, getDate("2007-12-02"), new Date(), HandlingEvent.Type.UNLOAD, HAMBURG, stockholmToHamburg));
 
     final CarrierMovement hamburgToHongKong = new CarrierMovement(
        new CarrierMovementId("CAR_001"), HAMBURG, HONGKONG);
 
-    cargo.deliveryHistory().addEvent(new HandlingEvent(cargo, getDate("2007-12-03"), new Date(), HandlingEvent.Type.LOAD, HAMBURG, hamburgToHongKong));
-    cargo.deliveryHistory().addEvent(new HandlingEvent(cargo, getDate("2007-12-04"), new Date(), HandlingEvent.Type.UNLOAD, HONGKONG, hamburgToHongKong));
+    events.add(new HandlingEvent(cargo, getDate("2007-12-03"), new Date(), HandlingEvent.Type.LOAD, HAMBURG, hamburgToHongKong));
+    events.add(new HandlingEvent(cargo, getDate("2007-12-04"), new Date(), HandlingEvent.Type.UNLOAD, HONGKONG, hamburgToHongKong));
 
     final CarrierMovement hongKongToMelbourne = new CarrierMovement(
        new CarrierMovementId("CAR_001"), HONGKONG, MELBOURNE);
 
-    cargo.deliveryHistory().addEvent(new HandlingEvent(cargo, getDate("2007-12-05"), new Date(), HandlingEvent.Type.LOAD, HONGKONG, hongKongToMelbourne));
+    events.add(new HandlingEvent(cargo, getDate("2007-12-05"), new Date(), HandlingEvent.Type.LOAD, HONGKONG, hongKongToMelbourne));
 
+    cargo.setDeliveryHistory(new DeliveryHistory(events));
     return cargo;
   }
 
@@ -249,7 +255,8 @@ public class CargoTest extends TestCase {
     handlingEvents.add(new HandlingEvent(cargo, new Date(110), new Date(120), HandlingEvent.Type.CLAIM, GOTHENBURG, null));
     handlingEvents.add(new HandlingEvent(cargo, new Date(130), new Date(140), HandlingEvent.Type.CUSTOMS, GOTHENBURG, null));
 
-    cargo.deliveryHistory().addAllEvents(handlingEvents);
+    events.addAll(handlingEvents);
+    cargo.setDeliveryHistory(new DeliveryHistory(events));
     assertFalse(cargo.isMisdirected());
 
     //Try a couple of failing ones
@@ -258,7 +265,8 @@ public class CargoTest extends TestCase {
     handlingEvents = new ArrayList<HandlingEvent>();
 
     handlingEvents.add(new HandlingEvent(cargo, new Date(), new Date(), HandlingEvent.Type.RECEIVE, HANGZOU, null));
-    cargo.deliveryHistory().addAllEvents(handlingEvents);
+    events.addAll(handlingEvents);
+    cargo.setDeliveryHistory(new DeliveryHistory(events));
     assertTrue(cargo.isMisdirected());
 
 
@@ -270,7 +278,8 @@ public class CargoTest extends TestCase {
     handlingEvents.add(new HandlingEvent(cargo, new Date(50), new Date(60), HandlingEvent.Type.UNLOAD, ROTTERDAM, abc));
     handlingEvents.add(new HandlingEvent(cargo, new Date(70), new Date(80), HandlingEvent.Type.LOAD, ROTTERDAM, ghi));
 
-    cargo.deliveryHistory().addAllEvents(handlingEvents);
+    events.addAll(handlingEvents);
+    cargo.setDeliveryHistory(new DeliveryHistory(events));
     assertTrue(cargo.isMisdirected());
 
 
@@ -282,7 +291,8 @@ public class CargoTest extends TestCase {
     handlingEvents.add(new HandlingEvent(cargo, new Date(50), new Date(60), HandlingEvent.Type.UNLOAD, ROTTERDAM, abc));
     handlingEvents.add(new HandlingEvent(cargo, new Date(), new Date(), HandlingEvent.Type.CLAIM, ROTTERDAM, null));
 
-    cargo.deliveryHistory().addAllEvents(handlingEvents);
+    events.addAll(handlingEvents);
+    cargo.setDeliveryHistory(new DeliveryHistory(events));
     assertTrue(cargo.isMisdirected());
   }
 

dddsample/src/test/java/se/citerus/dddsample/domain/DeliveryHistoryTest.java

@@ -5,17 +5,13 @@ import static se.citerus.dddsample.domain.SampleLocations.*;
 
 import java.text.DateFormat;
 import java.text.SimpleDateFormat;
-import java.util.Arrays;
-import java.util.Date;
-import java.util.List;
+import java.util.*;
 
 public class DeliveryHistoryTest extends TestCase {
 
   private Cargo cargo = new Cargo(new TrackingId("XYZ"), HONGKONG, NEWYORK);
 
   public void testEvensOrderedByTimeOccured() throws Exception {
-    DeliveryHistory dh = new DeliveryHistory();
-    assertTrue(dh.eventsOrderedByCompletionTime().isEmpty());
 
     DateFormat df = new SimpleDateFormat("yyyy-MM-dd");
     CarrierMovement carrierMovement = new CarrierMovement(new CarrierMovementId("CAR_001"), HONGKONG, NEWYORK);
@@ -23,7 +19,7 @@ public class DeliveryHistoryTest extends TestCase {
     HandlingEvent he2 = new HandlingEvent(cargo, df.parse("2010-01-01"), new Date(), HandlingEvent.Type.LOAD, NEWYORK, carrierMovement);
     HandlingEvent he3 = new HandlingEvent(cargo, df.parse("2010-01-04"), new Date(), HandlingEvent.Type.CLAIM, HONGKONG, null);
     HandlingEvent he4 = new HandlingEvent(cargo, df.parse("2010-01-02"), new Date(), HandlingEvent.Type.UNLOAD, HONGKONG, carrierMovement);
-    dh.addAllEvents(Arrays.asList(he1, he2, he3, he4));
+    DeliveryHistory dh = new DeliveryHistory(Arrays.asList(he1, he2, he3, he4));
 
     List<HandlingEvent> orderEvents = dh.eventsOrderedByCompletionTime();
     assertEquals(4, orderEvents.size());
@@ -34,34 +30,42 @@ public class DeliveryHistoryTest extends TestCase {
   }
 
   public void testCargoStatusFromLastHandlingEvent() {
-    DeliveryHistory deliveryHistory = new DeliveryHistory();
+    Set<HandlingEvent> events = new HashSet<HandlingEvent>();
+    DeliveryHistory deliveryHistory = new DeliveryHistory(events);
 
     assertEquals(StatusCode.NOT_RECEIVED, deliveryHistory.status());
 
-    deliveryHistory.addEvent(new HandlingEvent(cargo, new Date(10), new Date(11), HandlingEvent.Type.RECEIVE, HAMBURG, null));
+    events.add(new HandlingEvent(cargo, new Date(10), new Date(11), HandlingEvent.Type.RECEIVE, HAMBURG, null));
+    deliveryHistory = new DeliveryHistory(events);
     assertEquals(StatusCode.IN_PORT, deliveryHistory.status());
 
     CarrierMovement carrierMovement = new CarrierMovement(new CarrierMovementId("ABC"), HAMBURG, HAMBURG);
-    deliveryHistory.addEvent(new HandlingEvent(cargo, new Date(20), new Date(21), HandlingEvent.Type.LOAD, HAMBURG, carrierMovement));
+    events.add(new HandlingEvent(cargo, new Date(20), new Date(21), HandlingEvent.Type.LOAD, HAMBURG, carrierMovement));
+    deliveryHistory = new DeliveryHistory(events);
     assertEquals(StatusCode.ONBOARD_CARRIER, deliveryHistory.status());
 
-    deliveryHistory.addEvent(new HandlingEvent(cargo, new Date(30), new Date(31), HandlingEvent.Type.UNLOAD, HAMBURG, carrierMovement));
+    events.add(new HandlingEvent(cargo, new Date(30), new Date(31), HandlingEvent.Type.UNLOAD, HAMBURG, carrierMovement));
+    deliveryHistory = new DeliveryHistory(events);
     assertEquals(StatusCode.IN_PORT, deliveryHistory.status());
 
-    deliveryHistory.addEvent(new HandlingEvent(cargo, new Date(40), new Date(41), HandlingEvent.Type.CLAIM, HAMBURG, null));
+    events.add(new HandlingEvent(cargo, new Date(40), new Date(41), HandlingEvent.Type.CLAIM, HAMBURG, null));
+    deliveryHistory = new DeliveryHistory(events);
     assertEquals(StatusCode.CLAIMED, deliveryHistory.status());
   }
 
   public void testCurrentLocation() throws Exception {
-    DeliveryHistory deliveryHistory = new DeliveryHistory();
+    Set<HandlingEvent> events = new HashSet<HandlingEvent>();
+    DeliveryHistory deliveryHistory = new DeliveryHistory(events);
 
     assertNull(deliveryHistory.currentLocation());
 
-    deliveryHistory.addEvent(new HandlingEvent(cargo, new Date(10), new Date(11), HandlingEvent.Type.RECEIVE, HAMBURG, null));
+    events.add(new HandlingEvent(cargo, new Date(10), new Date(11), HandlingEvent.Type.RECEIVE, HAMBURG, null));
+    deliveryHistory = new DeliveryHistory(events);
     assertEquals(HAMBURG, deliveryHistory.currentLocation());
 
     CarrierMovement carrierMovement = new CarrierMovement(new CarrierMovementId("ABC"), HAMBURG, HAMBURG);
-    deliveryHistory.addEvent(new HandlingEvent(cargo, new Date(20), new Date(21), HandlingEvent.Type.LOAD, HAMBURG, carrierMovement));
+    events.add(new HandlingEvent(cargo, new Date(20), new Date(21), HandlingEvent.Type.LOAD, HAMBURG, carrierMovement));
+    deliveryHistory = new DeliveryHistory(events);
     assertNull(deliveryHistory.currentLocation());
   }
 

dddsample/src/test/java/se/citerus/dddsample/domain/TrackingScenarioTest.java

@@ -35,8 +35,7 @@ public class TrackingScenarioTest extends TestCase {
 
     final CarrierMovement hamburgToHongKong = new CarrierMovement(
             new CarrierMovementId("CAR_002"), HAMBURG, HONGKONG);
-    DeliveryHistory dh = new DeliveryHistory();
-    dh.addAllEvents(Arrays.asList(
+    DeliveryHistory dh = new DeliveryHistory(Arrays.asList(
             new HandlingEvent(cargo, getDate("2007-12-01"), new Date(), HandlingEvent.Type.LOAD, STOCKHOLM, stockholmToHamburg),
             new HandlingEvent(cargo, getDate("2007-12-02"), new Date(), HandlingEvent.Type.UNLOAD, HAMBURG, stockholmToHamburg),
             new HandlingEvent(cargo, getDate("2007-12-03"), new Date(), HandlingEvent.Type.LOAD, HAMBURG, hamburgToHongKong),

dddsample/src/test/java/se/citerus/dddsample/repository/AbstractRepositoryTest.java

@@ -1,12 +1,15 @@
 package se.citerus.dddsample.repository;
 
 import org.hibernate.SessionFactory;
+import org.hibernate.classic.Session;
 import org.springframework.jdbc.core.simple.SimpleJdbcTemplate;
 import org.springframework.orm.hibernate3.HibernateTransactionManager;
 import org.springframework.test.AbstractTransactionalDataSourceSpringContextTests;
 import org.springframework.transaction.support.TransactionTemplate;
 import se.citerus.dddsample.util.SampleDataGenerator;
 
+import java.lang.reflect.Field;
+
 public abstract class AbstractRepositoryTest extends AbstractTransactionalDataSourceSpringContextTests {
 
   SessionFactory sessionFactory;
@@ -41,4 +44,21 @@ public abstract class AbstractRepositoryTest extends AbstractTransactionalDataSo
     sjt = new SimpleJdbcTemplate(jdbcTemplate);
   }
 
+  protected Session getSession() {
+    return sessionFactory.getCurrentSession();
+  }
+
+  protected Long getLongId(Object o) {
+    if (getSession().contains(o)) {
+      return (Long) getSession().getIdentifier(o);
+    } else {
+      try {
+        Field id = o.getClass().getDeclaredField("id");
+        id.setAccessible(true);
+        return (Long) id.get(o);
+      } catch (Exception e) {
+        throw new RuntimeException(e);
+      }
+    }
+  }
 }

dddsample/src/test/java/se/citerus/dddsample/repository/CargoRepositoryTest.java

@@ -6,6 +6,7 @@ import static se.citerus.dddsample.domain.HandlingEvent.Type.RECEIVE;
 import static se.citerus.dddsample.domain.SampleLocations.*;
 import se.citerus.dddsample.util.SampleDataGenerator;
 
+import java.util.Arrays;
 import java.util.Date;
 import java.util.List;
 import java.util.Map;
@@ -93,10 +94,10 @@ public class CargoRepositoryTest extends AbstractRepositoryTest {
 
     assertEquals("AAA", map.get("TRACKING_ID"));
 
-    Long originId = (Long) sessionFactory.getCurrentSession().getIdentifier(origin);
+    Long originId = getLongId(origin);
     assertEquals(originId, map.get("ORIGIN_ID"));
 
-    Long destinationId = (Long) sessionFactory.getCurrentSession().getIdentifier(destination);
+    Long destinationId = getLongId(destination);
     assertEquals(destinationId, map.get("DESTINATION_ID"));
 
     assertNull(map.get("ITINERARY_ID"));
@@ -117,13 +118,13 @@ public class CargoRepositoryTest extends AbstractRepositoryTest {
     HandlingEvent event = new HandlingEvent(cargo, new Date(), new Date(), HandlingEvent.Type.RECEIVE, origin, null);
     assertFalse(cargo.deliveryHistory().eventsOrderedByCompletionTime().contains(event));
 
-    cargo.deliveryHistory().addEvent(event);
+    cargo.setDeliveryHistory(new DeliveryHistory(Arrays.asList(event)));
     assertTrue(cargo.deliveryHistory().eventsOrderedByCompletionTime().contains(event));
 
     // Save cargo, evict from session and then re-load it - should not pick up the added event,
     // as it was never cascade-saved
     cargoRepository.save(cargo);
-    sessionFactory.getCurrentSession().evict(cargo);
+    getSession().evict(cargo);
 
     cargo = cargoRepository.find(cargo.trackingId());
     assertFalse(cargo.deliveryHistory().eventsOrderedByCompletionTime().contains(event));
@@ -145,4 +146,19 @@ public class CargoRepositoryTest extends AbstractRepositoryTest {
     assertFalse(trackingId.equals(trackingId2));
   }
 
+  public void testDeleteItinerary() {
+    Cargo cargo = cargoRepository.find(new TrackingId("FGH"));
+    Itinerary itinerary = cargo.itinerary();
+
+    cargoRepository.deleteItinerary(itinerary);
+    cargo.removeItinerary();
+
+    flush();
+    
+    Long itineraryId = getLongId(itinerary);
+    assertEquals(0, sjt.queryForInt("select count(*) from Itinerary where id = ?", itineraryId));
+    assertEquals(0, sjt.queryForInt("select count(*) from Leg where itinerary_id = ?", itineraryId));
+    assertNull(sjt.queryForMap("select * from Cargo where tracking_id = 'FGH'").get("ITINERARY_ID"));
+  }
+
 }

dddsample/src/test/java/se/citerus/dddsample/service/CargoServiceTest.java

@@ -38,7 +38,8 @@ public class CargoServiceTest extends TestCase {
     HandlingEvent loaded = new HandlingEvent(cargo, new Date(12), new Date(25), HandlingEvent.Type.LOAD, STOCKHOLM, carrierMovement);
     HandlingEvent unloaded = new HandlingEvent(cargo, new Date(100), new Date(110), HandlingEvent.Type.UNLOAD, CHICAGO, carrierMovement);
     // Add out of order to verify ordering in DTO
-    cargo.deliveryHistory().addAllEvents(Arrays.asList(loaded, unloaded, claimed));
+    List<HandlingEvent> eventList = Arrays.asList(loaded, unloaded, claimed);
+    cargo.setDeliveryHistory(new DeliveryHistory(eventList));
 
     expect(cargoRepository.find(new TrackingId("XYZ"))).andReturn(cargo);