Changed persistence layer to point to the InMem repositories

Added test-context-persistence.xml to still be able to test hibernate repositories
Added HandlingEventService (first lab version...)
Added HandlingEvent- and Carrier-Repository.
Modified some equality operators to fit better with HandlingEventRepository (Maybe unneccessary after all, but it's working...)

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

 package se.citerus.dddsample.domain;
 
+import org.apache.commons.lang.builder.EqualsBuilder;
+import org.apache.commons.lang.builder.HashCodeBuilder;
 import org.apache.commons.lang.builder.ReflectionToStringBuilder;
 import org.apache.commons.lang.builder.ToStringStyle;
 
   public String toString() {
     return ReflectionToStringBuilder.toString(this, ToStringStyle.MULTI_LINE_STYLE);
   }
+
+  @Override
+  public boolean equals(Object obj) {
+    if (obj instanceof Cargo == false) {
+      return false;
+    }
+    if (this == obj) {
+      return true;
+    }
+    Cargo rhs = (Cargo) obj;
+    return new EqualsBuilder()
+      .append(trackingId, rhs.trackingId)
+      .append(origin, rhs.origin)
+      .append(finalDestination, rhs.finalDestination)
+      .isEquals();
+  }
+
+  @Override
+  public int hashCode() {
+    return new HashCodeBuilder(7, 39)
+    .append(trackingId)
+    .append(origin)
+    .append(finalDestination)
+    .toHashCode();
+  }
+  
+  
 }

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

 
 import javax.persistence.*;
 import java.util.Date;
+import java.util.HashSet;
+import java.util.Set;
 
 /**
  * HandlingEvent links the type of handling with a CarrierMovement.
   @Column(name = "time")
   private Date time;
 
+  @Transient /*TODO: Change to many-to-many if we decide on that approach*/
+  private Set<Cargo> cargos;
+  
   public enum Type {
     LOAD, UNLOAD, RECEIVE, CLAIM
   }
     this.time = time;
     this.type = type;
     this.carrierMovement = carrierMovement;
+    this.cargos = new HashSet<Cargo>();
   }
 
   public Type getType() {
     
     return location;
   }
+
+
+  /**
+   * Register a set of Cargos
+   * 
+   * @param cargos
+   */
+  public void register(Set<Cargo> cargosToRegister) {
+    this.cargos.addAll(cargosToRegister);
+  }
+  
+  public Set<Cargo> getRegisterdCargos(){
+    return cargos;
+  }
   
   
   @Override
 
   @Override
   public int hashCode() {
-    return HashCodeBuilder.reflectionHashCode(this, excludedFields);
+    return HashCodeBuilder.reflectionHashCode(this);
   }
 
   public int compareTo(HandlingEvent o) {
     return time.compareTo(o.getTime());
   }
+
+  public static Type parseType(String type) {
+    return Type.valueOf(type);
+  }
+
 }

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

   /**
    * The NULL Location object
    */
-  public static final Location NULL = new Location(Location.class.getName() + ".NULL");
+  public static final Location NULL = new Location("Unknown");
 
   @Id
   private Long id;

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

 
 public interface CargoRepository {
   Cargo find(TrackingId trackingId);
+  void save(Cargo cargo);
 }

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

     return (Cargo) sessionFactory.getCurrentSession().
             get(Cargo.class, trackingId);
   }
+
+  public void save(Cargo cargo) {
+    sessionFactory.getCurrentSession().saveOrUpdate(cargo);
+  }
 }

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

 package se.citerus.dddsample.repository;
 
-import java.text.DateFormat;
-import java.text.ParseException;
-import java.text.SimpleDateFormat;
-import java.util.Date;
 import java.util.HashMap;
 import java.util.Map;
 
 import org.springframework.dao.DataRetrievalFailureException;
 
 import se.citerus.dddsample.domain.Cargo;
-import se.citerus.dddsample.domain.CarrierMovement;
 import se.citerus.dddsample.domain.HandlingEvent;
 import se.citerus.dddsample.domain.Location;
 import se.citerus.dddsample.domain.TrackingId;
  */
 public class CargoRepositoryInMem implements CargoRepository {
   private Map<String, Cargo> cargoDb;
+  private HandlingEventRepository handlingEventRepository;
 
   public CargoRepositoryInMem() throws Exception {
     cargoDb = new HashMap<String, Cargo>();
-    setup();
   }
 
   public Cargo find(TrackingId trackingId) {
     
     return cargoDb.get(trackingId.getId());
   }
+  
+  public void save(Cargo cargo) {
+    //No need to save anything with InMem
+  }
 
-  private void setup() throws Exception {
+  /**
+   * 
+   * @throws Exception
+   */
+  public void init() throws Exception {
     String trackIdXYZ = "XYZ";
     final Cargo cargoXYZ = new Cargo(new TrackingId(trackIdXYZ), new Location("SESTO"), new Location("AUMEL"));
-    
-    cargoXYZ.handle(new HandlingEvent(getDate("2007-11-30"), HandlingEvent.Type.RECEIVE, null));
-
-    final CarrierMovement stockholmToHamburg = new CarrierMovement(new Location("SESTO"), new Location("DEHAM"));
-
-    cargoXYZ.handle(new HandlingEvent(getDate("2007-12-01"), HandlingEvent.Type.LOAD, stockholmToHamburg));
-    cargoXYZ.handle(new HandlingEvent(getDate("2007-12-02"), HandlingEvent.Type.UNLOAD, stockholmToHamburg));
-
-    final CarrierMovement hamburgToHongKong = new CarrierMovement(new Location("DEHAM"), new Location("CNHKG"));
-
-    cargoXYZ.handle(new HandlingEvent(getDate("2007-12-03"), HandlingEvent.Type.LOAD, hamburgToHongKong));
-    cargoXYZ.handle(new HandlingEvent(getDate("2007-12-05"), HandlingEvent.Type.UNLOAD, hamburgToHongKong));
-
     cargoDb.put(trackIdXYZ, cargoXYZ);
     
-    
     String trackIdZYX = "ZYX";
     final Cargo cargoZYX = new Cargo(new TrackingId(trackIdZYX), new Location("AUMEL"), new Location("SESTO"));
-    
-    cargoZYX.handle(new HandlingEvent(getDate("2007-12-09"), HandlingEvent.Type.RECEIVE, null));
-    
-    final CarrierMovement melbourneToTokyo = new CarrierMovement(new Location("AUMEL"), new Location("JPTOK"));
-
-    cargoZYX.handle(new HandlingEvent(getDate("2007-12-10"), HandlingEvent.Type.LOAD, melbourneToTokyo));
-    cargoZYX.handle(new HandlingEvent(getDate("2007-12-12"), HandlingEvent.Type.UNLOAD, melbourneToTokyo));
-
-    final CarrierMovement tokyoToLosAngeles = new CarrierMovement(new Location("JPTOK"), new Location("USLA"));
-
-    cargoZYX.handle(new HandlingEvent(getDate("2007-12-13"), HandlingEvent.Type.LOAD, tokyoToLosAngeles));
-
     cargoDb.put(trackIdZYX, cargoZYX);
     
     String trackIdABC = "ABC";
     final Cargo cargoABC = new Cargo(new TrackingId(trackIdABC), new Location("SESTO"), new Location("FIHEL"));
-    
-    cargoABC.handle(new HandlingEvent(getDate("2008-01-01"), HandlingEvent.Type.RECEIVE, null));
-
-    final CarrierMovement stockholmToHelsinki = new CarrierMovement(new Location("SESTO"), new Location("FIHEL"));
-
-    cargoABC.handle(new HandlingEvent(getDate("2008-01-02"), HandlingEvent.Type.LOAD, stockholmToHelsinki));
-    cargoABC.handle(new HandlingEvent(getDate("2008-01-03"), HandlingEvent.Type.UNLOAD, stockholmToHelsinki));
-    cargoABC.handle(new HandlingEvent(getDate("2008-01-05"), HandlingEvent.Type.CLAIM, null));
-    
     cargoDb.put(trackIdABC, cargoABC);
     
     String trackIdCBA = "CBA";
     final Cargo cargoCBA = new Cargo(new TrackingId(trackIdCBA), new Location("FIHEL"), new Location("SESTO"));
-    
-    cargoCBA.handle(new HandlingEvent(getDate("2008-01-10"), HandlingEvent.Type.RECEIVE, null));
-
-    
     cargoDb.put(trackIdCBA, cargoCBA);
+    
+    for (Cargo cargo : cargoDb.values()) {
+      for (HandlingEvent event : handlingEventRepository.findByTrackingId(cargo.trackingId())) {
+        cargo.handle(event);
+      }   
+    }
   }
 
-  /**
-   * Parse an ISO 8601 (YYYY-MM-DD) String to Date
-   * 
-   * @param isoFormat
-   *            String to parse.
-   * @return Created date instance.
-   * @throws ParseException
-   *             Thrown if parsing fails.
-   */
-  private Date getDate(String isoFormat) throws ParseException {
-    final DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
-    return dateFormat.parse(isoFormat);
+  public void setHandlingEventRepository(HandlingEventRepository handlingEventRepository) {
+    this.handlingEventRepository = handlingEventRepository;
   }
 }

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

+package se.citerus.dddsample.repository;
+
+import se.citerus.dddsample.domain.CarrierMovement;
+
+public interface CarrierRepository {
+
+  CarrierMovement find(String carrierId);
+
+}

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

+package se.citerus.dddsample.repository;
+
+import java.util.HashMap;
+
+import se.citerus.dddsample.domain.CarrierMovement;
+import se.citerus.dddsample.domain.Location;
+
+public class CarrierRepositoryInMem implements CarrierRepository {
+  private HashMap<String, CarrierMovement> carriers;
+
+  public CarrierRepositoryInMem() {
+    carriers = new HashMap<String, CarrierMovement>();
+    setup();
+  }
+
+  private void setup() {
+    final CarrierMovement stockholmToHamburg = new CarrierMovement(new Location("SESTO"), new Location("DEHAM"));
+    final CarrierMovement hamburgToHongKong = new CarrierMovement(new Location("DEHAM"), new Location("CNHKG"));
+    final CarrierMovement melbourneToTokyo = new CarrierMovement(new Location("AUMEL"), new Location("JPTOK"));
+    final CarrierMovement tokyoToLosAngeles = new CarrierMovement(new Location("JPTOK"), new Location("USLA"));
+    final CarrierMovement stockholmToHelsinki = new CarrierMovement(new Location("SESTO"), new Location("FIHEL"));
+    
+    carriers.put("SESTO_DEHAM", stockholmToHamburg);
+    carriers.put("DEHAM_CNHKG", hamburgToHongKong);
+    carriers.put("AUMEL_JPTOK", melbourneToTokyo);
+    carriers.put("JPTOK_USLA", tokyoToLosAngeles);
+    carriers.put("SESTO_FIHEL", stockholmToHelsinki);
+  }
+
+  public CarrierMovement find(String carrierId) {
+    return carriers.get(carrierId);
+  }
+  
+  
+
+}

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

+package se.citerus.dddsample.repository;
+
+import java.util.Set;
+
+import se.citerus.dddsample.domain.HandlingEvent;
+import se.citerus.dddsample.domain.TrackingId;
+
+public interface HandlingEventRepository {
+  HandlingEvent find(String handlingEventId);
+  void save(HandlingEvent event);
+  Set<HandlingEvent> findByTrackingId(final TrackingId trackingId);
+}

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

+package se.citerus.dddsample.repository;
+
+import java.text.DateFormat;
+import java.text.ParseException;
+import java.text.SimpleDateFormat;
+import java.util.Date;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Set;
+
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+
+import se.citerus.dddsample.domain.Cargo;
+import se.citerus.dddsample.domain.CarrierMovement;
+import se.citerus.dddsample.domain.HandlingEvent;
+import se.citerus.dddsample.domain.Location;
+import se.citerus.dddsample.domain.TrackingId;
+import se.citerus.dddsample.domain.HandlingEvent.Type;
+
+public class HandlingEventRepositoryInMem implements HandlingEventRepository{
+  private HashMap<String, HandlingEvent> eventDB;
+  private CarrierRepository carrierRepository;
+  
+  private final Log logger = LogFactory.getLog(getClass());
+
+  public HandlingEventRepositoryInMem() throws ParseException {
+    eventDB = new HashMap<String, HandlingEvent>();
+  }
+
+  /**
+   * Initilaze the in mem repository.
+   * 
+   * SpringIoC will call this init-method after the bean has bean created and properties has been set.
+   * 
+   * @throws ParseException
+   */
+  public void init() throws ParseException {
+    
+    // CargoXYZ
+    final Cargo cargoXYZ = new Cargo(new TrackingId("XYZ"), new Location("SESTO"), new Location("AUMEL"));
+    registerEvent(cargoXYZ, "2007-11-30", HandlingEvent.Type.RECEIVE, null);
+
+    final CarrierMovement stockholmToHamburg = carrierRepository.find("SESTO_DEHAM");
+    registerEvent(cargoXYZ, "2007-12-01", HandlingEvent.Type.LOAD, stockholmToHamburg);
+    registerEvent(cargoXYZ, "2007-12-02", HandlingEvent.Type.UNLOAD, stockholmToHamburg);
+    
+    final CarrierMovement hamburgToHongKong = carrierRepository.find("DEHAM_CNHKG");
+    registerEvent(cargoXYZ, "2007-12-03", HandlingEvent.Type.LOAD, hamburgToHongKong);
+    registerEvent(cargoXYZ, "2007-12-05", HandlingEvent.Type.UNLOAD, hamburgToHongKong);
+    
+    //CargoZYX
+    final Cargo cargoZYX = new Cargo(new TrackingId("ZYX"), new Location("AUMEL"), new Location("SESTO"));
+    registerEvent(cargoZYX, "2007-12-09", HandlingEvent.Type.RECEIVE, null);
+    
+    final CarrierMovement melbourneToTokyo = carrierRepository.find("AUMEL_JPTOK");
+    registerEvent(cargoZYX, "2007-12-10", HandlingEvent.Type.LOAD, melbourneToTokyo);
+    registerEvent(cargoZYX, "2007-12-12", HandlingEvent.Type.UNLOAD, melbourneToTokyo);
+    
+    final CarrierMovement tokyoToLosAngeles = carrierRepository.find("JPTOK_USLA");
+    registerEvent(cargoZYX, "2007-12-13", HandlingEvent.Type.LOAD, tokyoToLosAngeles);
+ 
+    //CargoABC
+    final Cargo cargoABC = new Cargo(new TrackingId("ABC"), new Location("SESTO"), new Location("FIHEL"));
+    registerEvent(cargoABC, "2008-01-01", HandlingEvent.Type.RECEIVE, null);
+    
+    final CarrierMovement stockholmToHelsinki = new CarrierMovement(new Location("SESTO"), new Location("FIHEL"));
+    registerEvent(cargoABC, "2008-01-02", HandlingEvent.Type.LOAD, stockholmToHelsinki);
+    registerEvent(cargoABC, "2008-01-03", HandlingEvent.Type.UNLOAD, stockholmToHelsinki);
+    registerEvent(cargoABC, "2008-01-05", HandlingEvent.Type.CLAIM, null);
+
+    //CargoCBA
+    final Cargo cargoCBA = new Cargo(new TrackingId("CBA"), new Location("FIHEL"), new Location("SESTO"));
+    registerEvent(cargoCBA, "2008-01-10", HandlingEvent.Type.RECEIVE, null);
+  }
+
+  
+  private void registerEvent(Cargo cargo, String date, Type type, CarrierMovement carrierMovement) throws ParseException{
+    HandlingEvent ev= new HandlingEvent(getDate(date), type, carrierMovement);
+    ev.register(toSet(cargo));
+    String id = cargo.trackingId() + "_" + type + "_" + date;
+    
+    logger.debug("Adding event " + id + "(" + ev + ")");
+    eventDB.put(id, ev);
+  }
+  
+  
+  private Set<Cargo> toSet(Cargo... cargoArgs) {
+    Set<Cargo> cargos = new HashSet<Cargo>();
+    for (Cargo cargo : cargoArgs) {
+      cargos.add(cargo);
+    }
+    
+    return cargos;
+  }
+
+  /**
+   * Parse an ISO 8601 (YYYY-MM-DD) String to Date
+   * 
+   * @param isoFormat
+   *            String to parse.
+   * @return Created date instance.
+   * @throws ParseException
+   *             Thrown if parsing fails.
+   */
+  private Date getDate(String isoFormat) throws ParseException {
+    final DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
+    return dateFormat.parse(isoFormat);
+  }
+  
+  public HandlingEvent find(String handlingEventId){
+    return eventDB.get(handlingEventId);
+  }
+
+  public void save(HandlingEvent event) {
+    // Mimmick saving to database
+    for (Cargo cargo : event.getRegisterdCargos()) {
+      cargo.handle(event);
+    }
+  }
+
+  @SuppressWarnings("unchecked")
+  public Set<HandlingEvent> findByTrackingId(final TrackingId trackingId) {
+    Set<HandlingEvent> events = new HashSet<HandlingEvent>();
+    for (HandlingEvent event : eventDB.values()) {
+      for (Cargo cargo : event.getRegisterdCargos()) {
+        if (cargo.trackingId().equals(trackingId)) {
+          events.add(event);
+          break;
+        }
+      }   
+    }
+    
+    logger.debug("findByTrackingId " + trackingId + " finds " + events);
+    
+    return events;
+  }
+
+  public void setCarrierRepository(CarrierRepository carrierRepository) {
+    this.carrierRepository = carrierRepository;
+  }
+}

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

+package se.citerus.dddsample.service;
+
+import java.util.Date;
+
+
+public interface HandlingEventService {
+
+  /**
+   * Regster an event with the EventHandling service
+   * 
+   * TODO: Fix javadoc when we know more about the relation between Cargo and HandlingEvent...
+   * 
+   * @param date
+   * @param type
+   * @param carrierId
+   * @param trackIds
+   */
+  public abstract void register(Date date, String type, String carrierId, String[] trackIds);
+
+}

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

+package se.citerus.dddsample.service;
+
+import java.util.Date;
+import java.util.HashSet;
+import java.util.Set;
+
+import org.apache.commons.lang.Validate;
+
+import se.citerus.dddsample.domain.Cargo;
+import se.citerus.dddsample.domain.CarrierMovement;
+import se.citerus.dddsample.domain.HandlingEvent;
+import se.citerus.dddsample.domain.TrackingId;
+import se.citerus.dddsample.repository.CargoRepository;
+import se.citerus.dddsample.repository.CarrierRepository;
+import se.citerus.dddsample.repository.HandlingEventRepository;
+
+public class HandlingEventServiceImpl implements HandlingEventService {
+  private CargoRepository cargoRepository;
+  private CarrierRepository carrierRepository;
+  private HandlingEventRepository handlingEventRepository;
+
+
+  public void register(Date date, String type, String carrierId, String[] trackingIds) {
+    HandlingEvent event = new HandlingEvent(date, HandlingEvent.parseType(type), findCarrier(carrierId));
+    Set<Cargo> cargos = findCargos(trackingIds);
+    event.register(cargos);
+    
+    handlingEventRepository.save(event);
+  }
+
+
+  private Set<Cargo> findCargos(String[] trackingIds) {
+    Set<Cargo> cargos = new HashSet<Cargo>();
+    
+    for (String trackingId : trackingIds) {
+      cargos.add(findCargo(trackingId));
+    }
+    
+    return cargos;
+  }
+
+
+  private Cargo findCargo(String trackingId) {
+    Cargo cargo = cargoRepository.find(new TrackingId(trackingId));
+    Validate.notNull(cargo, "Cargo is not found. Tracking ID=" + trackingId);
+    
+    return cargo;
+  }
+
+  private CarrierMovement findCarrier(String carrierId) {
+    if (carrierId == null){
+      return null;
+    }
+    CarrierMovement carrier = carrierRepository.find(carrierId);
+    Validate.notNull(carrier, "Carrier is not found: Carrier ID=" + carrierId);
+    
+    return carrier;
+  }
+
+  public void setCargoRepository(CargoRepository cargoRepository) {
+    this.cargoRepository = cargoRepository;
+  }
+
+  public void setCarrierRepository(CarrierRepository carrierRepository) {
+    this.carrierRepository = carrierRepository;
+  }
+
+  public void setHandlingEventRepository(HandlingEventRepository handlingEventRepository) {
+    this.handlingEventRepository = handlingEventRepository;
+  }
+
+
+
+}

dddsample/src/main/resources/context-persistence.xml

     <property name="sessionFactory" ref="sessionFactory"/>
   </bean>
 
-  <bean id="cargoRepository" class="se.citerus.dddsample.repository.CargoRepositoryHibernate">
-    <property name="sessionFactory" ref="sessionFactory"/>
+  <bean id="cargoRepository" class="se.citerus.dddsample.repository.CargoRepositoryInMem" init-method="init">
+    <property name="handlingEventRepository" ref="handlingEventRepository"/>
+  </bean>
+  
+  <bean id="handlingEventRepository" class="se.citerus.dddsample.repository.HandlingEventRepositoryInMem" init-method="init">
+    <property name="carrierRepository" ref="carrierRepository"/>
   </bean>
+  
+  <bean id="carrierRepository" class="se.citerus.dddsample.repository.CarrierRepositoryInMem" />
+  
+  <!--bean id="cargoRepository" class="se.citerus.dddsample.repository.CargoRepositoryHibernate">
+    <property name="sessionFactory" ref="sessionFactory"/>
+  </bean-->
 
 </beans>

dddsample/src/main/resources/context-service.xml

     <property name="cargoRepository" ref="cargoRepository"/>
   </bean>
 
+  <bean id="handlingEventService" class="se.citerus.dddsample.service.HandlingEventServiceImpl">
+    <property name="cargoRepository" ref="cargoRepository"/>
+    <property name="handlingEventRepository" ref="handlingEventRepository"/>
+    <property name="carrierRepository" ref="carrierRepository"/>
+  </bean>
 </beans>

dddsample/src/main/webapp/style.css

 /**************************************************************
    Custom div and span
  **************************************************************/
+#apptitle h1{
+  font-size: 1.6em;
+  margin-left: 200px;
+  margin-bottom: 10px;
+  border-bottom: 0px
+  
+}
+
 #container {
   text-align: left;
   width: 500px;

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

   }
 
   protected String[] getConfigLocations() {
-    return new String[]{"context-persistence.xml"};
+    return new String[]{"test-context-persistence.xml"};
   }
 
   protected void onSetUpInTransaction() throws Exception {

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

 
     assertFalse(cargo.atFinalDestiation());
   }
+  
+  public void testEquality() throws Exception {
+    Cargo c1 = new Cargo(new TrackingId("ABC"), new Location("A"), new Location("C"));
+    Cargo c2 = new Cargo(new TrackingId("CBA"), new Location("A"), new Location("C"));
+    Cargo c3 = new Cargo(new TrackingId("ABC"), new Location("A"), new Location("X"));
+    Cargo c4 = new Cargo(new TrackingId("ABC"), new Location("A"), new Location("C"));
+
+    assertTrue("TrackingID, origin and finalDestnation should be equal if Cargos are considered equal", c1.equals(c4));
+    assertFalse("Cargos are not equal when TrackingID differ", c1.equals(c2));
+    assertFalse("Cargos are not equal when Locations differ", c2.equals(c3));
+  }
 
   // TODO: Generate test data some better way
   private Cargo populateCargoReceivedStockholm() throws Exception {

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

 package se.citerus.dddsample.domain;
 
+import java.util.Calendar;
+import java.util.Date;
+import java.util.HashSet;
+import java.util.Set;
+
+import se.citerus.dddsample.domain.HandlingEvent.Type;
 import junit.framework.TestCase;
 
 public class HandlingEventTest extends TestCase {
 
     assertEquals(Location.NULL, ev.getLocation());
   }
+  
+  public void testParseType() throws Exception {
+    assertEquals(Type.CLAIM, HandlingEvent.parseType("CLAIM"));
+    assertEquals(Type.LOAD, HandlingEvent.parseType("LOAD"));
+    assertEquals(Type.UNLOAD, HandlingEvent.parseType("UNLOAD"));
+    assertEquals(Type.RECEIVE, HandlingEvent.parseType("RECEIVE"));
+  }
+  
+  public void testParseTypeIllegal() throws Exception {
+    try {
+      HandlingEvent.parseType("NOT_A_HANDLING_EVENT_TYPE");
+      assertTrue("Expected IllegaArgumentException to be thrown", false);
+    } catch (IllegalArgumentException e) {
+      // All's well
+    }
+  }
+  
+  public void testEquality() throws Exception {
+    Date date = Calendar.getInstance().getTime();
+    Location locationAAA = new Location("AAA");
+    Location locationBBB = new Location("BBB");
+    CarrierMovement cm = new CarrierMovement(locationAAA, locationBBB);
+    
+    Cargo cargo1 = new Cargo(new TrackingId("ABC"), new Location("A"), new Location("C"));
+    Cargo cargo2 = new Cargo(new TrackingId("CBA"), new Location("C"), new Location("A"));
+    Cargo cargo3 = new Cargo(new TrackingId("CBA"), new Location("C"), new Location("A")); //Identical to cargo2
+    
+    Set<Cargo> cargos1 = new HashSet<Cargo>();
+    cargos1.add(cargo1);
+    
+    Set<Cargo> cargos2 = new HashSet<Cargo>();
+    cargos2.add(cargo1);
+    cargos2.add(cargo2);
+    
+    Set<Cargo> cargos3 = new HashSet<Cargo>();
+    cargos3.add(cargo1);
+    cargos3.add(cargo3);
+    
+    
+    HandlingEvent ev1 = new HandlingEvent(date, HandlingEvent.Type.LOAD, cm);
+    ev1.register(cargos1);
+    
+    HandlingEvent ev2 = new HandlingEvent(date, HandlingEvent.Type.LOAD, cm);
+    ev2.register(cargos2);
+    
+    HandlingEvent ev3 = new HandlingEvent(date, HandlingEvent.Type.LOAD, cm);
+    ev3.register(cargos2);  
+    
+    assertFalse("HandlingEvents should not be considered equal if the Set of Cargo is not equal", ev1.equals(ev2));
+    assertTrue("HandlingEvents should be considered equal if the Set of Cargo is equal", ev2.equals(ev3));
+  }
 }

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

+package se.citerus.dddsample.service;
+
+import java.util.Calendar;
+import java.util.Date;
+import java.util.HashSet;
+import java.util.Set;
+
+import junit.framework.TestCase;
+import se.citerus.dddsample.domain.Cargo;
+import se.citerus.dddsample.domain.CarrierMovement;
+import se.citerus.dddsample.domain.HandlingEvent;
+import se.citerus.dddsample.domain.Location;
+import se.citerus.dddsample.domain.TrackingId;
+import se.citerus.dddsample.repository.CargoRepository;
+import se.citerus.dddsample.repository.CarrierRepository;
+import se.citerus.dddsample.repository.HandlingEventRepository;
+import static org.easymock.EasyMock.*;
+
+public class HandlingEventServiceTest extends TestCase {
+  private HandlingEventServiceImpl service;
+  private CargoRepository cargoRepository;
+  private CarrierRepository carrierRepository;
+  private HandlingEventRepository handlingEventRepository;
+  
+  private final Cargo cargoABC = new Cargo(new TrackingId("ABC"), new Location("ABCFROM"), new Location("ABCTO"));
+  private final Cargo cargoXYZ = new Cargo(new TrackingId("XYZ"), new Location("XYZFROM"), new Location("XYZTO"));
+  private final CarrierMovement cmAAA_BBB = new CarrierMovement(new Location("AAA"), new Location("BBB"));
+
+  protected void setUp() throws Exception{
+    service = new HandlingEventServiceImpl();
+    cargoRepository = createMock(CargoRepository.class);
+    carrierRepository = createMock(CarrierRepository.class);
+    handlingEventRepository = createMock(HandlingEventRepository.class);
+    
+    service.setCargoRepository(cargoRepository);
+    service.setCarrierRepository(carrierRepository);
+    service.setHandlingEventRepository(handlingEventRepository);
+  }
+
+  public void testRegisterEvent() throws Exception {
+    String carrierId = "AAA_BBB";
+    final String[] trackIds = { "ABC", "XYZ" };
+    Date date = Calendar.getInstance().getTime();
+    String type = "UNLOAD";
+    
+    expect(cargoRepository.find(new TrackingId("ABC"))).andReturn(cargoABC);
+    expect(cargoRepository.find(new TrackingId("XYZ"))).andReturn(cargoXYZ);
+    expect(carrierRepository.find("AAA_BBB")).andReturn(cmAAA_BBB);
+    
+    HandlingEvent event = new HandlingEvent(date, HandlingEvent.parseType(type), cmAAA_BBB);
+    Set<Cargo> cargos = new HashSet<Cargo>();
+    cargos.add(cargoABC);
+    cargos.add(cargoXYZ);
+    event.register(cargos);
+    
+    handlingEventRepository.save(event);
+    
+    replay(cargoRepository, carrierRepository, handlingEventRepository);
+    
+    service.register(date, type, carrierId, trackIds);
+    
+    verify(cargoRepository, carrierRepository, handlingEventRepository);
+  }
+  
+  public void testRegisterEventInvalidCarrier() throws Exception {
+    final String[] trackIds = { "ABC", "XYZ" };
+    Date date = Calendar.getInstance().getTime();
+    String type = "UNLOAD";
+    
+    expect(cargoRepository.find(new TrackingId("ABC"))).andReturn(cargoABC);
+    expect(cargoRepository.find(new TrackingId("XYZ"))).andReturn(cargoXYZ);
+    expect(carrierRepository.find("AAA_BBB")).andReturn(null);
+    
+    replay(cargoRepository, carrierRepository, handlingEventRepository);
+    
+    try {
+      service.register(date, type, "AAA_BBB", trackIds);
+      assertFalse(true);
+    } catch (IllegalArgumentException e) {
+      // Expected IllegalArgumentExecption
+    }
+  }
+  
+  public void testRegisterEventInvalidCargo() throws Exception {
+    final String[] trackIds = { "ABC", "XYZ" };
+    Date date = Calendar.getInstance().getTime();
+    String type = "UNLOAD";
+    
+    expect(cargoRepository.find(new TrackingId("ABC"))).andReturn(cargoABC);
+    expect(cargoRepository.find(new TrackingId("XYZ"))).andReturn(null);
+    expect(carrierRepository.find("AAA_BBB")).andReturn(cmAAA_BBB);
+    
+    replay(cargoRepository, carrierRepository, handlingEventRepository);
+    
+    try {
+      service.register(date, type, "AAA_BBB", trackIds);
+      assertFalse(true);
+    } catch (IllegalArgumentException e) {
+      // Expected IllegalArgumentExecption
+    }
+  }
+}

dddsample/src/test/resources/mock-context-persistence.xml

   <bean id="cargoRepository" class="org.easymock.EasyMock" factory-method="createMock">
     <constructor-arg value="se.citerus.dddsample.repository.CargoRepository"/>
   </bean>
-
+  
+  <bean id="handlingEventRepository" class="se.citerus.dddsample.repository.HandlingEventRepositoryInMem" init-method="init">
+    <property name="carrierRepository" ref="carrierRepository"/>
+  </bean>
+  
+  <bean id="carrierRepository" class="se.citerus.dddsample.repository.CarrierRepositoryInMem" />
 </beans>

dddsample/src/test/resources/test-context-persistence.xml

+<?xml version="1.0" encoding="UTF-8"?>
+
+<beans  xmlns="http://www.springframework.org/schema/beans"
+        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+        xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">
+
+  <bean class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
+    <property name="location" value="classpath:jdbc.properties"/>
+  </bean>
+
+  <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
+    <property name="url" value="${jdbc.url}"/>
+    <property name="driverClassName" value="${jdbc.driverClassName}"/>
+    <property name="username" value="${jdbc.username}"/>
+    <property name="password" value="${jdbc.password}"/>
+  </bean>
+
+  <bean id="sessionFactory" class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean">
+    <property name="dataSource" ref="dataSource"/>
+    <property name="annotatedClasses">
+      <list>
+        <value>se.citerus.dddsample.domain.Cargo</value>
+        <value>se.citerus.dddsample.domain.Location</value>
+        <value>se.citerus.dddsample.domain.DeliveryHistory</value>
+        <value>se.citerus.dddsample.domain.HandlingEvent</value>
+        <value>se.citerus.dddsample.domain.CarrierMovement</value>
+      </list>
+    </property>
+    <property name="hibernateProperties">
+      <props>
+        <!-- These are properties that are common for test and production -->
+        <prop key="hibernate.dialect">org.hibernate.dialect.HSQLDialect</prop>
+        <prop key="hibernate.cache.provider_class">org.hibernate.cache.EhCacheProvider</prop>
+      </props>
+    </property>
+  </bean>
+
+  <bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
+    <property name="sessionFactory" ref="sessionFactory"/>
+  </bean>
+
+  <!--  bean id="cargoRepository" class="se.citerus.dddsample.repository.CargoRepositoryInMem" / -->
+
+  <bean id="cargoRepository" class="se.citerus.dddsample.repository.CargoRepositoryHibernate">
+    <property name="sessionFactory" ref="sessionFactory"/>
+  </bean>
+
+</beans>