Merged PR #16 "Convert JUnit assertions to AssertJ"

pom.xml

@@ -192,6 +192,11 @@
             <scope>test</scope>
         </dependency>
         <dependency>
+            <groupId>org.assertj</groupId>
+            <artifactId>assertj-core</artifactId>
+            <version>3.8.0</version>
+        </dependency>
+        <dependency>
             <groupId>org.seleniumhq.selenium</groupId>
             <artifactId>selenium-java</artifactId>
             <version>3.5.3</version>

src/test/java/se/citerus/dddsample/application/BookingServiceTest.java

@@ -1,19 +1,21 @@
 package se.citerus.dddsample.application;
 
 import junit.framework.TestCase;
-import static org.easymock.EasyMock.*;
 import se.citerus.dddsample.application.impl.BookingServiceImpl;
 import se.citerus.dddsample.domain.model.cargo.Cargo;
 import se.citerus.dddsample.domain.model.cargo.CargoRepository;
 import se.citerus.dddsample.domain.model.cargo.TrackingId;
 import se.citerus.dddsample.domain.model.location.LocationRepository;
-import static se.citerus.dddsample.domain.model.location.SampleLocations.CHICAGO;
-import static se.citerus.dddsample.domain.model.location.SampleLocations.STOCKHOLM;
 import se.citerus.dddsample.domain.model.location.UnLocode;
 import se.citerus.dddsample.domain.service.RoutingService;
 
 import java.util.Date;
 
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.easymock.EasyMock.*;
+import static se.citerus.dddsample.domain.model.location.SampleLocations.CHICAGO;
+import static se.citerus.dddsample.domain.model.location.SampleLocations.STOCKHOLM;
+
 public class BookingServiceTest extends TestCase {
 
   BookingServiceImpl bookingService;
@@ -42,7 +44,7 @@ public class BookingServiceTest extends TestCase {
     replay(cargoRepository, locationRepository);
 
     TrackingId trackingId = bookingService.bookNewCargo(fromUnlocode, toUnlocode, new Date());
-    assertEquals(expectedTrackingId, trackingId);
+    assertThat(trackingId).isEqualTo(expectedTrackingId);
   }
 
   protected void tearDown() throws Exception {

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

@@ -2,12 +2,9 @@ package se.citerus.dddsample.domain.model.cargo;
 
 import junit.framework.TestCase;
 import se.citerus.dddsample.application.util.DateTestUtil;
-import static se.citerus.dddsample.domain.model.cargo.RoutingStatus.*;
-import static se.citerus.dddsample.domain.model.cargo.TransportStatus.NOT_RECEIVED;
 import se.citerus.dddsample.domain.model.handling.HandlingEvent;
 import se.citerus.dddsample.domain.model.handling.HandlingHistory;
 import se.citerus.dddsample.domain.model.location.Location;
-import static se.citerus.dddsample.domain.model.location.SampleLocations.*;
 import se.citerus.dddsample.domain.model.voyage.Voyage;
 import se.citerus.dddsample.domain.model.voyage.VoyageNumber;
 
@@ -16,6 +13,11 @@ import java.text.ParseException;
 import java.text.SimpleDateFormat;
 import java.util.*;
 
+import static org.assertj.core.api.Assertions.assertThat;
+import static se.citerus.dddsample.domain.model.cargo.RoutingStatus.*;
+import static se.citerus.dddsample.domain.model.cargo.TransportStatus.NOT_RECEIVED;
+import static se.citerus.dddsample.domain.model.location.SampleLocations.*;
+
 public class CargoTest extends TestCase {
 
   private List<HandlingEvent> events;
@@ -40,10 +42,10 @@ public class CargoTest extends TestCase {
 
     final Cargo cargo = new Cargo(trackingId, routeSpecification);
 
-    assertEquals(NOT_ROUTED, cargo.delivery().routingStatus());
-    assertEquals(NOT_RECEIVED, cargo.delivery().transportStatus());
-    assertEquals(Location.UNKNOWN, cargo.delivery().lastKnownLocation());
-    assertEquals(Voyage.NONE, cargo.delivery().currentVoyage());    
+    assertThat(cargo.delivery().routingStatus()).isEqualTo(NOT_ROUTED);
+    assertThat(cargo.delivery().transportStatus()).isEqualTo(NOT_RECEIVED);
+    assertThat(cargo.delivery().lastKnownLocation()).isEqualTo(Location.UNKNOWN);
+    assertThat(cargo.delivery().currentVoyage()).isEqualTo(Voyage.NONE);    
   }
 
   public void testRoutingStatus() throws Exception {
@@ -59,43 +61,43 @@ public class CargoTest extends TestCase {
 
     cargo.specifyNewRoute(acceptOnlyGood);
 
-    assertEquals(NOT_ROUTED, cargo.delivery().routingStatus());
+    assertThat(cargo.delivery().routingStatus()).isEqualTo(NOT_ROUTED);
     
     cargo.assignToRoute(bad);
-    assertEquals(MISROUTED, cargo.delivery().routingStatus());
+    assertThat(cargo.delivery().routingStatus()).isEqualTo(MISROUTED);
 
     cargo.assignToRoute(good);
-    assertEquals(ROUTED, cargo.delivery().routingStatus());
+    assertThat(cargo.delivery().routingStatus()).isEqualTo(ROUTED);
   }
 
   public void testlastKnownLocationUnknownWhenNoEvents() throws Exception {
     Cargo cargo = new Cargo(new TrackingId("XYZ"), new RouteSpecification(STOCKHOLM, MELBOURNE, new Date()));
 
-    assertEquals(Location.UNKNOWN, cargo.delivery().lastKnownLocation());
+    assertThat(cargo.delivery().lastKnownLocation()).isEqualTo(Location.UNKNOWN);
   }
 
   public void testlastKnownLocationReceived() throws Exception {
     Cargo cargo = populateCargoReceivedStockholm();
 
-    assertEquals(STOCKHOLM, cargo.delivery().lastKnownLocation());
+    assertThat(cargo.delivery().lastKnownLocation()).isEqualTo(STOCKHOLM);
   }
 
   public void testlastKnownLocationClaimed() throws Exception {
     Cargo cargo = populateCargoClaimedMelbourne();
 
-    assertEquals(MELBOURNE, cargo.delivery().lastKnownLocation());
+    assertThat(cargo.delivery().lastKnownLocation()).isEqualTo(MELBOURNE);
   }
 
   public void testlastKnownLocationUnloaded() throws Exception {
     Cargo cargo = populateCargoOffHongKong();
 
-    assertEquals(HONGKONG, cargo.delivery().lastKnownLocation());
+    assertThat(cargo.delivery().lastKnownLocation()).isEqualTo(HONGKONG);
   }
 
   public void testlastKnownLocationloaded() throws Exception {
     Cargo cargo = populateCargoOnHamburg();
 
-    assertEquals(HAMBURG, cargo.delivery().lastKnownLocation());
+    assertThat(cargo.delivery().lastKnownLocation()).isEqualTo(HAMBURG);
   }
 
   public void testEquality() throws Exception {
@@ -106,21 +108,21 @@ public class CargoTest extends TestCase {
     Cargo c3 = new Cargo(new TrackingId("ABC"), spec2);
     Cargo c4 = new Cargo(new TrackingId("ABC"), spec1);
 
-    assertTrue("Cargos should be equal when TrackingIDs are equal", c1.equals(c4));
-    assertTrue("Cargos should be equal when TrackingIDs are equal", c1.equals(c3));
-    assertTrue("Cargos should be equal when TrackingIDs are equal", c3.equals(c4));
-    assertFalse("Cargos are not equal when TrackingID differ", c1.equals(c2));
+    assertThat(c1.equals(c4)).as("Cargos should be equal when TrackingIDs are equal").isTrue();
+    assertThat(c1.equals(c3)).as("Cargos should be equal when TrackingIDs are equal").isTrue();
+    assertThat(c3.equals(c4)).as("Cargos should be equal when TrackingIDs are equal").isTrue();
+    assertThat(c1.equals(c2)).as("Cargos are not equal when TrackingID differ").isFalse();
   }
 
   public void testIsUnloadedAtFinalDestination() throws Exception {
     Cargo cargo = setUpCargoWithItinerary(HANGZOU, TOKYO, NEWYORK);
-    assertFalse(cargo.delivery().isUnloadedAtDestination());
+    assertThat(cargo.delivery().isUnloadedAtDestination()).isFalse();
 
     // Adding an event unrelated to unloading at final destination
     events.add(
       new HandlingEvent(cargo, new Date(10), new Date(), HandlingEvent.Type.RECEIVE, HANGZOU));
     cargo.deriveDeliveryProgress(new HandlingHistory(events));
-    assertFalse(cargo.delivery().isUnloadedAtDestination());
+    assertThat(cargo.delivery().isUnloadedAtDestination()).isFalse();
 
     Voyage voyage = new Voyage.Builder(new VoyageNumber("0123"), HANGZOU).
       addMovement(NEWYORK, new Date(), new Date()).
@@ -130,19 +132,19 @@ public class CargoTest extends TestCase {
     events.add(
       new HandlingEvent(cargo, new Date(20), new Date(), HandlingEvent.Type.UNLOAD, TOKYO, voyage));
     cargo.deriveDeliveryProgress(new HandlingHistory(events));
-    assertFalse(cargo.delivery().isUnloadedAtDestination());
+    assertThat(cargo.delivery().isUnloadedAtDestination()).isFalse();
 
     // Adding an event in the final destination, but not unload
     events.add(
       new HandlingEvent(cargo, new Date(30), new Date(), HandlingEvent.Type.CUSTOMS, NEWYORK));
     cargo.deriveDeliveryProgress(new HandlingHistory(events));
-    assertFalse(cargo.delivery().isUnloadedAtDestination());
+    assertThat(cargo.delivery().isUnloadedAtDestination()).isFalse();
 
     // Finally, cargo is unloaded at final destination
     events.add(
       new HandlingEvent(cargo, new Date(40), new Date(), HandlingEvent.Type.UNLOAD, NEWYORK, voyage));
     cargo.deriveDeliveryProgress(new HandlingHistory(events));
-    assertTrue(cargo.delivery().isUnloadedAtDestination());
+    assertThat(cargo.delivery().isUnloadedAtDestination()).isTrue();
   }
 
   // TODO: Generate test data some better way
@@ -224,12 +226,12 @@ public class CargoTest extends TestCase {
   public void testIsMisdirected() throws Exception {
     //A cargo with no itinerary is not misdirected
     Cargo cargo = new Cargo(new TrackingId("TRKID"), new RouteSpecification(SHANGHAI, GOTHENBURG, new Date()));
-    assertFalse(cargo.delivery().isMisdirected());
+    assertThat(cargo.delivery().isMisdirected()).isFalse();
 
     cargo = setUpCargoWithItinerary(SHANGHAI, ROTTERDAM, GOTHENBURG);
 
     //A cargo with no handling events is not misdirected
-    assertFalse(cargo.delivery().isMisdirected());
+    assertThat(cargo.delivery().isMisdirected()).isFalse();
 
     Collection<HandlingEvent> handlingEvents = new ArrayList<HandlingEvent>();
 
@@ -244,7 +246,7 @@ public class CargoTest extends TestCase {
 
     events.addAll(handlingEvents);
     cargo.deriveDeliveryProgress(new HandlingHistory(events));
-    assertFalse(cargo.delivery().isMisdirected());
+    assertThat(cargo.delivery().isMisdirected()).isFalse();
 
     //Try a couple of failing ones
 
@@ -255,7 +257,7 @@ public class CargoTest extends TestCase {
     events.addAll(handlingEvents);
     cargo.deriveDeliveryProgress(new HandlingHistory(events));
 
-    assertTrue(cargo.delivery().isMisdirected());
+    assertThat(cargo.delivery().isMisdirected()).isTrue();
 
 
     cargo = setUpCargoWithItinerary(SHANGHAI, ROTTERDAM, GOTHENBURG);
@@ -269,7 +271,7 @@ public class CargoTest extends TestCase {
     events.addAll(handlingEvents);
     cargo.deriveDeliveryProgress(new HandlingHistory(events));
 
-    assertTrue(cargo.delivery().isMisdirected());
+    assertThat(cargo.delivery().isMisdirected()).isTrue();
 
 
     cargo = setUpCargoWithItinerary(SHANGHAI, ROTTERDAM, GOTHENBURG);
@@ -283,7 +285,7 @@ public class CargoTest extends TestCase {
     events.addAll(handlingEvents);
     cargo.deriveDeliveryProgress(new HandlingHistory(events));
 
-    assertTrue(cargo.delivery().isMisdirected());
+    assertThat(cargo.delivery().isMisdirected()).isTrue();
   }
 
   private Cargo setUpCargoWithItinerary(Location origin, Location midpoint, Location destination) {

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

@@ -1,17 +1,19 @@
 package se.citerus.dddsample.domain.model.cargo;
 
 import junit.framework.TestCase;
-import static se.citerus.dddsample.domain.model.location.SampleLocations.HONGKONG;
-import static se.citerus.dddsample.domain.model.location.SampleLocations.NEWYORK;
 
 import java.util.Date;
 
+import static org.assertj.core.api.Assertions.assertThat;
+import static se.citerus.dddsample.domain.model.location.SampleLocations.HONGKONG;
+import static se.citerus.dddsample.domain.model.location.SampleLocations.NEWYORK;
+
 public class DeliveryTest extends TestCase {
 
   private Cargo cargo = new Cargo(new TrackingId("XYZ"), new RouteSpecification(HONGKONG, NEWYORK, new Date()));
 
   public void testToSilenceWarnings() throws Exception {
-    assertTrue(true);
+    assertThat(true).isTrue();
   }
   
   /*
@@ -24,51 +26,48 @@ public class DeliveryTest extends TestCase {
     Delivery dh = new Delivery(Arrays.asList(he1, he2, he3, he4));
 
     List<HandlingEvent> orderEvents = dh.history();
-    assertEquals(4, orderEvents.size());
-    assertSame(he2, orderEvents.get(0));
-    assertSame(he4, orderEvents.get(1));
-    assertSame(he1, orderEvents.get(2));
-    assertSame(he3, orderEvents.get(3));
+    assertThat(orderEvents).hasSize(4);
+    assertThat(orderEvents).containsExactly(he2, he4, he1, he3);
   }
 
   public void testCargoStatusFromLastHandlingEvent() {
     Set<HandlingEvent> events = new HashSet<HandlingEvent>();
     Delivery delivery = new Delivery(events);
 
-    assertEquals(TransportStatus.NOT_RECEIVED, delivery.transportStatus());
+    assertThat(delivery.transportStatus()).isEqualTo(TransportStatus.NOT_RECEIVED);
 
     events.add(new HandlingEvent(cargo, new Date(10), new Date(11), HandlingEvent.Type.RECEIVE, HAMBURG));
     delivery = new Delivery(events);
-    assertEquals(TransportStatus.IN_PORT, delivery.transportStatus());
+    assertThat(delivery.transportStatus()).isEqualTo(TransportStatus.IN_PORT);
 
     events.add(new HandlingEvent(cargo, new Date(20), new Date(21), HandlingEvent.Type.LOAD, HAMBURG, CM005));
     delivery = new Delivery(events);
-    assertEquals(TransportStatus.ONBOARD_CARRIER, delivery.transportStatus());
+    assertThat(delivery.transportStatus()).isEqualTo(TransportStatus.ONBOARD_CARRIER);
 
     events.add(new HandlingEvent(cargo, new Date(30), new Date(31), HandlingEvent.Type.UNLOAD, HAMBURG, CM006));
     delivery = new Delivery(events);
-    assertEquals(TransportStatus.IN_PORT, delivery.transportStatus());
+    assertThat(delivery.transportStatus()).isEqualTo(TransportStatus.IN_PORT);
 
     events.add(new HandlingEvent(cargo, new Date(40), new Date(41), HandlingEvent.Type.CLAIM, HAMBURG));
     delivery = new Delivery(events);
-    assertEquals(TransportStatus.CLAIMED, delivery.transportStatus());
+    assertThat(delivery.transportStatus()).isEqualTo(TransportStatus.CLAIMED);
   }
 
   public void testLastKnownLocation() throws Exception {
     Set<HandlingEvent> events = new HashSet<HandlingEvent>();
     Delivery delivery = new Delivery(events);
 
-    assertEquals(Location.UNKNOWN, delivery.lastKnownLocation());
+    assertThat(delivery.lastKnownLocation()).isEqualTo(Location.UNKNOWN);
 
     events.add(new HandlingEvent(cargo, new Date(10), new Date(11), HandlingEvent.Type.RECEIVE, HAMBURG));
     delivery = new Delivery(events);
 
-    assertEquals(HAMBURG, delivery.lastKnownLocation());
+    assertThat(delivery.lastKnownLocation()).isEqualTo(HAMBURG);
 
     events.add(new HandlingEvent(cargo, new Date(20), new Date(21), HandlingEvent.Type.LOAD, HAMBURG, CM003));
     delivery = new Delivery(events);
 
-    assertEquals(HAMBURG, delivery.lastKnownLocation());
+    assertThat(delivery.lastKnownLocation()).isEqualTo(HAMBURG);
   }
   */
   

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

@@ -2,7 +2,6 @@ package se.citerus.dddsample.domain.model.cargo;
 
 import junit.framework.TestCase;
 import se.citerus.dddsample.domain.model.handling.HandlingEvent;
-import static se.citerus.dddsample.domain.model.location.SampleLocations.*;
 import se.citerus.dddsample.domain.model.voyage.CarrierMovement;
 import se.citerus.dddsample.domain.model.voyage.Voyage;
 import se.citerus.dddsample.domain.model.voyage.VoyageNumber;
@@ -12,6 +11,9 @@ import java.util.Arrays;
 import java.util.Date;
 import java.util.List;
 
+import static org.assertj.core.api.Assertions.assertThat;
+import static se.citerus.dddsample.domain.model.location.SampleLocations.*;
+
 public class ItineraryTest extends TestCase {
   private final CarrierMovement abc = new CarrierMovement(SHANGHAI, ROTTERDAM, new Date(), new Date());
   private final CarrierMovement def = new CarrierMovement(ROTTERDAM, GOTHENBURG, new Date(), new Date());
@@ -47,41 +49,41 @@ public class ItineraryTest extends TestCase {
 
     //Happy path
     HandlingEvent event = new HandlingEvent(cargo, new Date(), new Date(), HandlingEvent.Type.RECEIVE, SHANGHAI);
-    assertTrue(itinerary.isExpected(event));
+    assertThat(itinerary.isExpected(event)).isTrue();
 
     event = new HandlingEvent(cargo, new Date(), new Date(), HandlingEvent.Type.LOAD, SHANGHAI, voyage);
-    assertTrue(itinerary.isExpected(event));
+    assertThat(itinerary.isExpected(event)).isTrue();
 
     event = new HandlingEvent(cargo, new Date(), new Date(), HandlingEvent.Type.UNLOAD, ROTTERDAM, voyage);
-    assertTrue(itinerary.isExpected(event));
+    assertThat(itinerary.isExpected(event)).isTrue();
 
     event = new HandlingEvent(cargo, new Date(), new Date(), HandlingEvent.Type.LOAD, ROTTERDAM, voyage);
-    assertTrue(itinerary.isExpected(event));
+    assertThat(itinerary.isExpected(event)).isTrue();
 
     event = new HandlingEvent(cargo, new Date(), new Date(), HandlingEvent.Type.UNLOAD, GOTHENBURG, voyage);
-    assertTrue(itinerary.isExpected(event));
+    assertThat(itinerary.isExpected(event)).isTrue();
 
     event = new HandlingEvent(cargo, new Date(), new Date(), HandlingEvent.Type.CLAIM, GOTHENBURG);
-    assertTrue(itinerary.isExpected(event));
+    assertThat(itinerary.isExpected(event)).isTrue();
 
     //Customs event changes nothing
     event = new HandlingEvent(cargo, new Date(), new Date(), HandlingEvent.Type.CUSTOMS, GOTHENBURG);
-    assertTrue(itinerary.isExpected(event));
+    assertThat(itinerary.isExpected(event)).isTrue();
 
     //Received at the wrong location
     event = new HandlingEvent(cargo, new Date(), new Date(), HandlingEvent.Type.RECEIVE, HANGZOU);
-    assertFalse(itinerary.isExpected(event));
+    assertThat(itinerary.isExpected(event)).isFalse();
 
     //Loaded to onto the wrong ship, correct location
     event = new HandlingEvent(cargo, new Date(), new Date(), HandlingEvent.Type.LOAD, ROTTERDAM, wrongVoyage);
-    assertFalse(itinerary.isExpected(event));
+    assertThat(itinerary.isExpected(event)).isFalse();
 
     //Unloaded from the wrong ship in the wrong location
     event = new HandlingEvent(cargo, new Date(), new Date(), HandlingEvent.Type.UNLOAD, HELSINKI, wrongVoyage);
-    assertFalse(itinerary.isExpected(event));
+    assertThat(itinerary.isExpected(event)).isFalse();
 
     event = new HandlingEvent(cargo, new Date(), new Date(), HandlingEvent.Type.CLAIM, ROTTERDAM);
-    assertFalse(itinerary.isExpected(event));
+    assertThat(itinerary.isExpected(event)).isFalse();
 
   }
 

src/test/java/se/citerus/dddsample/domain/model/cargo/RouteSpecificationTest.java

@@ -1,13 +1,15 @@
 package se.citerus.dddsample.domain.model.cargo;
 
 import junit.framework.TestCase;
-import static se.citerus.dddsample.application.util.DateTestUtil.toDate;
-import static se.citerus.dddsample.domain.model.location.SampleLocations.*;
 import se.citerus.dddsample.domain.model.voyage.Voyage;
 import se.citerus.dddsample.domain.model.voyage.VoyageNumber;
 
 import java.util.Arrays;
 
+import static org.assertj.core.api.Assertions.assertThat;
+import static se.citerus.dddsample.application.util.DateTestUtil.toDate;
+import static se.citerus.dddsample.domain.model.location.SampleLocations.*;
+
 public class RouteSpecificationTest extends TestCase {
 
   final Voyage hongKongTokyoNewYork = new Voyage.Builder(
@@ -38,7 +40,7 @@ public class RouteSpecificationTest extends TestCase {
       HONGKONG, CHICAGO, toDate("2009-03-01")
     );
 
-    assertTrue(routeSpecification.isSatisfiedBy(itinerary));
+    assertThat(routeSpecification.isSatisfiedBy(itinerary)).isTrue();
   }
 
   public void testIsSatisfiedBy_WrongOrigin() {
@@ -46,7 +48,7 @@ public class RouteSpecificationTest extends TestCase {
       HANGZOU, CHICAGO, toDate("2009-03-01")
     );
 
-    assertFalse(routeSpecification.isSatisfiedBy(itinerary));
+    assertThat(routeSpecification.isSatisfiedBy(itinerary)).isFalse();
   }
 
   public void testIsSatisfiedBy_WrongDestination() {
@@ -54,7 +56,7 @@ public class RouteSpecificationTest extends TestCase {
       HONGKONG, DALLAS, toDate("2009-03-01")
     );
 
-    assertFalse(routeSpecification.isSatisfiedBy(itinerary));
+    assertThat(routeSpecification.isSatisfiedBy(itinerary)).isFalse();
   }
 
   public void testIsSatisfiedBy_MissedDeadline() {
@@ -62,7 +64,7 @@ public class RouteSpecificationTest extends TestCase {
       HONGKONG, CHICAGO, toDate("2009-02-15")
     );
 
-    assertFalse(routeSpecification.isSatisfiedBy(itinerary));
+    assertThat(routeSpecification.isSatisfiedBy(itinerary)).isFalse();
   }
 
 }

src/test/java/se/citerus/dddsample/domain/model/handling/HandlingEventFactoryTest.java

@@ -1,16 +1,12 @@
 package se.citerus.dddsample.domain.model.handling;
 
 import junit.framework.TestCase;
-import static org.easymock.EasyMock.*;
 import se.citerus.dddsample.domain.model.cargo.Cargo;
 import se.citerus.dddsample.domain.model.cargo.CargoRepository;
 import se.citerus.dddsample.domain.model.cargo.RouteSpecification;
 import se.citerus.dddsample.domain.model.cargo.TrackingId;
-import static se.citerus.dddsample.domain.model.handling.HandlingEvent.Type;
 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.CM001;
 import se.citerus.dddsample.domain.model.voyage.Voyage;
 import se.citerus.dddsample.domain.model.voyage.VoyageNumber;
 import se.citerus.dddsample.domain.model.voyage.VoyageRepository;
@@ -19,6 +15,12 @@ import se.citerus.dddsample.infrastructure.persistence.inmemory.VoyageRepository
 
 import java.util.Date;
 
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.easymock.EasyMock.*;
+import static se.citerus.dddsample.domain.model.handling.HandlingEvent.Type;
+import static se.citerus.dddsample.domain.model.location.SampleLocations.*;
+import static se.citerus.dddsample.domain.model.voyage.SampleVoyages.CM001;
+
 public class HandlingEventFactoryTest extends TestCase {
 
   HandlingEventFactory factory;
@@ -53,12 +55,12 @@ public class HandlingEventFactoryTest extends TestCase {
       new Date(), new Date(100), trackingId, voyageNumber, unLocode, Type.LOAD
     );
 
-    assertNotNull(handlingEvent);
-    assertEquals(STOCKHOLM, handlingEvent.location());
-    assertEquals(CM001, handlingEvent.voyage());
-    assertEquals(cargo, handlingEvent.cargo());
-    assertEquals(new Date(100), handlingEvent.completionTime());
-    assertTrue(handlingEvent.registrationTime().before(new Date(System.currentTimeMillis() + 1)));
+    assertThat(handlingEvent).isNotNull();
+    assertThat(handlingEvent.location()).isEqualTo(STOCKHOLM);
+    assertThat(handlingEvent.voyage()).isEqualTo(CM001);
+    assertThat(handlingEvent.cargo()).isEqualTo(cargo);
+    assertThat(handlingEvent.completionTime()).isEqualTo(new Date(100));
+    assertThat(handlingEvent.registrationTime().before(new Date(System.currentTimeMillis() + 1))).isTrue();
   }
 
   public void testCreateHandlingEventWithoutCarrierMovement() throws Exception {
@@ -71,12 +73,12 @@ public class HandlingEventFactoryTest extends TestCase {
       new Date(), new Date(100), trackingId, null, unLocode, Type.CLAIM
     );
 
-    assertNotNull(handlingEvent);
-    assertEquals(STOCKHOLM, handlingEvent.location());
-    assertEquals(Voyage.NONE, handlingEvent.voyage());
-    assertEquals(cargo, handlingEvent.cargo());
-    assertEquals(new Date(100), handlingEvent.completionTime());
-    assertTrue(handlingEvent.registrationTime().before(new Date(System.currentTimeMillis() + 1)));
+    assertThat(handlingEvent).isNotNull();
+    assertThat(handlingEvent.location()).isEqualTo(STOCKHOLM);
+    assertThat(handlingEvent.voyage()).isEqualTo(Voyage.NONE);
+    assertThat(handlingEvent.cargo()).isEqualTo(cargo);
+    assertThat(handlingEvent.completionTime()).isEqualTo(new Date(100));
+    assertThat(handlingEvent.registrationTime().before(new Date(System.currentTimeMillis() + 1))).isTrue();
   }
 
   public void testCreateHandlingEventUnknownLocation() throws Exception {

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

@@ -4,15 +4,17 @@ import junit.framework.TestCase;
 import se.citerus.dddsample.domain.model.cargo.Cargo;
 import se.citerus.dddsample.domain.model.cargo.RouteSpecification;
 import se.citerus.dddsample.domain.model.cargo.TrackingId;
+import se.citerus.dddsample.domain.model.voyage.SampleVoyages;
+
+import java.util.Date;
+
+import static java.util.Arrays.asList;
+import static org.assertj.core.api.Assertions.assertThat;
 import static se.citerus.dddsample.domain.model.handling.HandlingEvent.Type.*;
 import static se.citerus.dddsample.domain.model.location.SampleLocations.*;
-import se.citerus.dddsample.domain.model.voyage.SampleVoyages;
 import static se.citerus.dddsample.domain.model.voyage.SampleVoyages.CM003;
 import static se.citerus.dddsample.domain.model.voyage.SampleVoyages.CM004;
 
-import static java.util.Arrays.asList;
-import java.util.Date;
-
 public class HandlingEventTest extends TestCase {
   private Cargo cargo;
 
@@ -25,10 +27,10 @@ public class HandlingEventTest extends TestCase {
   public void testNewWithCarrierMovement() throws Exception {
 
     HandlingEvent e1 = new HandlingEvent(cargo, new Date(), new Date(), LOAD, HONGKONG, CM003);
-    assertEquals(HONGKONG, e1.location());
+    assertThat(e1.location()).isEqualTo(HONGKONG);
 
     HandlingEvent e2 = new HandlingEvent(cargo, new Date(), new Date(), UNLOAD, NEWYORK, CM003);
-    assertEquals(NEWYORK, e2.location());
+    assertThat(e2.location()).isEqualTo(NEWYORK);
 
       // These event types prohibit a carrier movement association
     for (HandlingEvent.Type type : asList(CLAIM, RECEIVE, CUSTOMS)) {
@@ -49,44 +51,44 @@ public class HandlingEventTest extends TestCase {
 
   public void testNewWithLocation() throws Exception {
     HandlingEvent e1 = new HandlingEvent(cargo, new Date(), new Date(), HandlingEvent.Type.CLAIM, HELSINKI);
-    assertEquals(HELSINKI, e1.location());
+    assertThat(e1.location()).isEqualTo(HELSINKI);
   }
 
   public void testCurrentLocationLoadEvent() throws Exception {
 
     HandlingEvent ev = new HandlingEvent(cargo, new Date(), new Date(), LOAD, CHICAGO, CM004);
     
-    assertEquals(CHICAGO, ev.location());
+    assertThat(ev.location()).isEqualTo(CHICAGO);
   }
   
   public void testCurrentLocationUnloadEvent() throws Exception {
     HandlingEvent ev = new HandlingEvent(cargo, new Date(), new Date(), UNLOAD, HAMBURG, CM004);
     
-    assertEquals(HAMBURG, ev.location());
+    assertThat(ev.location()).isEqualTo(HAMBURG);
   }
   
   public void testCurrentLocationReceivedEvent() throws Exception {
     HandlingEvent ev = new HandlingEvent(cargo, new Date(), new Date(), RECEIVE, CHICAGO);
 
-    assertEquals(CHICAGO, ev.location());
+    assertThat(ev.location()).isEqualTo(CHICAGO);
   }
   public void testCurrentLocationClaimedEvent() throws Exception {
     HandlingEvent ev = new HandlingEvent(cargo, new Date(), new Date(), CLAIM, CHICAGO);
 
-    assertEquals(CHICAGO, ev.location());
+    assertThat(ev.location()).isEqualTo(CHICAGO);
   }
   
   public void testParseType() throws Exception {
-    assertEquals(CLAIM, valueOf("CLAIM"));
-    assertEquals(LOAD, valueOf("LOAD"));
-    assertEquals(UNLOAD, valueOf("UNLOAD"));
-    assertEquals(RECEIVE, valueOf("RECEIVE"));
+    assertThat(valueOf("CLAIM")).isEqualTo(CLAIM);
+    assertThat(valueOf("LOAD")).isEqualTo(LOAD);
+    assertThat(valueOf("UNLOAD")).isEqualTo(UNLOAD);
+    assertThat(valueOf("RECEIVE")).isEqualTo(RECEIVE);
   }
   
   public void testParseTypeIllegal() throws Exception {
     try {
       valueOf("NOT_A_HANDLING_EVENT_TYPE");
-      assertTrue("Expected IllegaArgumentException to be thrown", false);
+      fail("Expected IllegaArgumentException to be thrown");
     } catch (IllegalArgumentException e) {
       // All's well
     }
@@ -100,13 +102,13 @@ public class HandlingEventTest extends TestCase {
     HandlingEvent ev2 = new HandlingEvent(cargo, timeOccured, timeRegistered, LOAD, CHICAGO, SampleVoyages.CM005);
 
     // Two handling events are not equal() even if all non-uuid fields are identical
-    assertTrue(ev1.equals(ev2));
-    assertTrue(ev2.equals(ev1));
+    assertThat(ev1.equals(ev2)).isTrue();
+    assertThat(ev2.equals(ev1)).isTrue();
 
-    assertTrue(ev1.equals(ev1));
+    assertThat(ev1.equals(ev1)).isTrue();
 
-    assertFalse(ev2.equals(null));
-    assertFalse(ev2.equals(new Object()));
+    assertThat(ev2.equals(null)).isFalse();
+    assertThat(ev2.equals(new Object())).isFalse();
   }
 
 }

src/test/java/se/citerus/dddsample/domain/model/handling/HandlingHistoryTest.java

@@ -1,17 +1,19 @@
 package se.citerus.dddsample.domain.model.handling;
 
 import junit.framework.TestCase;
-import static se.citerus.dddsample.application.util.DateTestUtil.toDate;
 import se.citerus.dddsample.domain.model.cargo.Cargo;
 import se.citerus.dddsample.domain.model.cargo.RouteSpecification;
 import se.citerus.dddsample.domain.model.cargo.TrackingId;
-import static se.citerus.dddsample.domain.model.location.SampleLocations.*;
 import se.citerus.dddsample.domain.model.voyage.Voyage;
 import se.citerus.dddsample.domain.model.voyage.VoyageNumber;
 
-import static java.util.Arrays.asList;
 import java.util.Date;
 
+import static java.util.Arrays.asList;
+import static org.assertj.core.api.Assertions.assertThat;
+import static se.citerus.dddsample.application.util.DateTestUtil.toDate;
+import static se.citerus.dddsample.domain.model.location.SampleLocations.*;
+
 
 public class HandlingHistoryTest extends TestCase {
   Cargo cargo;
@@ -35,11 +37,11 @@ public class HandlingHistoryTest extends TestCase {
   }
 
   public void testDistinctEventsByCompletionTime() {
-    assertEquals(asList(event1, event2), handlingHistory.distinctEventsByCompletionTime());
+    assertThat(handlingHistory.distinctEventsByCompletionTime()).isEqualTo(asList(event1, event2));
   }
 
   public void testMostRecentlyCompletedEvent() {
-    assertEquals(event2, handlingHistory.mostRecentlyCompletedEvent());
+    assertThat(handlingHistory.mostRecentlyCompletedEvent()).isEqualTo(event2);
   }
   
 }

src/test/java/se/citerus/dddsample/domain/model/location/LocationTest.java

@@ -2,26 +2,28 @@ package se.citerus.dddsample.domain.model.location;
 
 import junit.framework.TestCase;
 
+import static org.assertj.core.api.Assertions.assertThat;
+
 public class LocationTest extends TestCase {
 
   public void testEquals() {
     // Same UN locode - equal
-    assertTrue(new Location(new UnLocode("ATEST"),"test-name").
-        equals(new Location(new UnLocode("ATEST"),"test-name")));
+    assertThat(new Location(new UnLocode("ATEST"),"test-name").
+        equals(new Location(new UnLocode("ATEST"),"test-name"))).isTrue();
 
     // Different UN locodes - not equal
-    assertFalse(new Location(new UnLocode("ATEST"),"test-name").
-         equals(new Location(new UnLocode("TESTB"), "test-name")));
+    assertThat(new Location(new UnLocode("ATEST"),"test-name").
+         equals(new Location(new UnLocode("TESTB"), "test-name"))).isFalse();
 
     // Always equal to itself
     Location location = new Location(new UnLocode("ATEST"),"test-name");
-    assertTrue(location.equals(location));
+    assertThat(location.equals(location)).isTrue();
 
     // Never equal to null
-    assertFalse(location.equals(null));
+    assertThat(location.equals(null)).isFalse();
 
     // Special UNKNOWN location is equal to itself
-    assertTrue(Location.UNKNOWN.equals(Location.UNKNOWN));
+    assertThat(Location.UNKNOWN.equals(Location.UNKNOWN)).isTrue();
 
     try {
       new Location(null, null);

src/test/java/se/citerus/dddsample/domain/model/location/UnLocodeTest.java

@@ -2,6 +2,8 @@ package se.citerus.dddsample.domain.model.location;
 
 import junit.framework.TestCase;
 
+import static org.assertj.core.api.Assertions.assertThat;
+
 public class UnLocodeTest extends TestCase {
 
   public void testNew() throws Exception {
@@ -19,26 +21,26 @@ public class UnLocodeTest extends TestCase {
   }
 
   public void testIdString() throws Exception {
-    assertEquals("ABCDE", new UnLocode("AbcDe").idString());
+    assertThat(new UnLocode("AbcDe").idString()).isEqualTo("ABCDE");
   }
 
   public void testEquals() throws Exception {
     UnLocode allCaps = new UnLocode("ABCDE");
     UnLocode mixedCase = new UnLocode("aBcDe");
 
-    assertTrue(allCaps.equals(mixedCase));
-    assertTrue(mixedCase.equals(allCaps));
-    assertTrue(allCaps.equals(allCaps));
+    assertThat(allCaps.equals(mixedCase)).isTrue();
+    assertThat(mixedCase.equals(allCaps)).isTrue();
+    assertThat(allCaps.equals(allCaps)).isTrue();
 
-    assertFalse(allCaps.equals(null));
-    assertFalse(allCaps.equals(new UnLocode("FGHIJ")));
+    assertThat(allCaps.equals(null)).isFalse();
+    assertThat(allCaps.equals(new UnLocode("FGHIJ"))).isFalse();
   }
 
   public void testHashCode() throws Exception {
     UnLocode allCaps = new UnLocode("ABCDE");
     UnLocode mixedCase = new UnLocode("aBcDe");
 
-    assertEquals(allCaps.hashCode(), mixedCase.hashCode());  
+    assertThat(mixedCase.hashCode()).isEqualTo(allCaps.hashCode());  
   }
   
   private void assertValid(String unlocode) {

src/test/java/se/citerus/dddsample/domain/model/voyage/CarrierMovementTest.java

@@ -1,11 +1,13 @@
 package se.citerus.dddsample.domain.model.voyage;
 
 import junit.framework.TestCase;
-import static se.citerus.dddsample.domain.model.location.SampleLocations.HAMBURG;
-import static se.citerus.dddsample.domain.model.location.SampleLocations.STOCKHOLM;
 
 import java.util.Date;
 
+import static org.assertj.core.api.Assertions.assertThat;
+import static se.citerus.dddsample.domain.model.location.SampleLocations.HAMBURG;
+import static se.citerus.dddsample.domain.model.location.SampleLocations.STOCKHOLM;
+
 public class CarrierMovementTest extends TestCase {
 
   public void testConstructor() throws Exception {
@@ -29,17 +31,17 @@ public class CarrierMovementTest extends TestCase {
     CarrierMovement cm3 = new CarrierMovement(HAMBURG, STOCKHOLM, new Date(), new Date());
     CarrierMovement cm4 = new CarrierMovement(HAMBURG, STOCKHOLM, new Date(), new Date());
 
-    assertTrue(cm1.sameValueAs(cm2));
-    assertFalse(cm2.sameValueAs(cm3));
-    assertTrue(cm3.sameValueAs(cm4));
+    assertThat(cm1.sameValueAs(cm2)).isTrue();
+    assertThat(cm2.sameValueAs(cm3)).isFalse();
+    assertThat(cm3.sameValueAs(cm4)).isTrue();
     
-    assertTrue(cm1.equals(cm2));
-    assertFalse(cm2.equals(cm3));
-    assertTrue(cm3.equals(cm4));
+    assertThat(cm1.equals(cm2)).isTrue();
+    assertThat(cm2.equals(cm3)).isFalse();
+    assertThat(cm3.equals(cm4)).isTrue();
 
-    assertTrue(cm1.hashCode() == cm2.hashCode());
-    assertFalse(cm2.hashCode() == cm3.hashCode());
-    assertTrue(cm3.hashCode() == cm4.hashCode());
+    assertThat(cm1.hashCode() == cm2.hashCode()).isTrue();
+    assertThat(cm2.hashCode() == cm3.hashCode()).isFalse();
+    assertThat(cm3.hashCode() == cm4.hashCode()).isTrue();
   }
 
 }

src/test/java/se/citerus/dddsample/domain/shared/AndSpecificationTest.java

@@ -2,6 +2,8 @@ package se.citerus.dddsample.domain.shared;
 
 import junit.framework.TestCase;
 
+import static org.assertj.core.api.Assertions.assertThat;
+
 public class AndSpecificationTest extends TestCase {
 
   public void testAndIsSatisifedBy() throws Exception {
@@ -9,16 +11,16 @@ public class AndSpecificationTest extends TestCase {
     AlwaysFalseSpec falseSpec = new AlwaysFalseSpec();
 
     AndSpecification<Object> andSpecification = new AndSpecification<Object>(trueSpec, trueSpec);
-    assertTrue(andSpecification.isSatisfiedBy(new Object()));
+    assertThat(andSpecification.isSatisfiedBy(new Object())).isTrue();
 
     andSpecification = new AndSpecification<Object>(falseSpec, trueSpec);
-    assertFalse(andSpecification.isSatisfiedBy(new Object()));
+    assertThat(andSpecification.isSatisfiedBy(new Object())).isFalse();
 
     andSpecification = new AndSpecification<Object>(trueSpec, falseSpec);
-    assertFalse(andSpecification.isSatisfiedBy(new Object()));
+    assertThat(andSpecification.isSatisfiedBy(new Object())).isFalse();
 
     andSpecification = new AndSpecification<Object>(falseSpec, falseSpec);
-    assertFalse(andSpecification.isSatisfiedBy(new Object()));
+    assertThat(andSpecification.isSatisfiedBy(new Object())).isFalse();
 
   }
 }

src/test/java/se/citerus/dddsample/domain/shared/NotSpecificationTest.java

@@ -2,6 +2,8 @@ package se.citerus.dddsample.domain.shared;
 
 import junit.framework.TestCase;
 
+import static org.assertj.core.api.Assertions.assertThat;
+
 public class NotSpecificationTest extends TestCase {
 
   public void testAndIsSatisifedBy() throws Exception {
@@ -9,10 +11,10 @@ public class NotSpecificationTest extends TestCase {
     AlwaysFalseSpec falseSpec = new AlwaysFalseSpec();
 
     NotSpecification<Object> notSpecification = new NotSpecification<Object>(trueSpec);
-    assertFalse(notSpecification.isSatisfiedBy(new Object()));
+    assertThat(notSpecification.isSatisfiedBy(new Object())).isFalse();
 
     notSpecification = new NotSpecification<Object>(falseSpec);
-    assertTrue(notSpecification.isSatisfiedBy(new Object()));
+    assertThat(notSpecification.isSatisfiedBy(new Object())).isTrue();
 
   }
 }

src/test/java/se/citerus/dddsample/domain/shared/OrSpecificationTest.java

@@ -2,6 +2,8 @@ package se.citerus.dddsample.domain.shared;
 
 import junit.framework.TestCase;
 
+import static org.assertj.core.api.Assertions.assertThat;
+
 public class OrSpecificationTest extends TestCase {
 
   public void testAndIsSatisifedBy() throws Exception {
@@ -9,16 +11,16 @@ public class OrSpecificationTest extends TestCase {
     AlwaysFalseSpec falseSpec = new AlwaysFalseSpec();
 
     OrSpecification<Object> orSpecification = new OrSpecification<Object>(trueSpec, trueSpec);
-    assertTrue(orSpecification.isSatisfiedBy(new Object()));
+    assertThat(orSpecification.isSatisfiedBy(new Object())).isTrue();
 
     orSpecification = new OrSpecification<Object>(falseSpec, trueSpec);
-    assertTrue(orSpecification.isSatisfiedBy(new Object()));
+    assertThat(orSpecification.isSatisfiedBy(new Object())).isTrue();
 
     orSpecification = new OrSpecification<Object>(trueSpec, falseSpec);
-    assertTrue(orSpecification.isSatisfiedBy(new Object()));
+    assertThat(orSpecification.isSatisfiedBy(new Object())).isTrue();
 
     orSpecification = new OrSpecification<Object>(falseSpec, falseSpec);
-    assertFalse(orSpecification.isSatisfiedBy(new Object()));
+    assertThat(orSpecification.isSatisfiedBy(new Object())).isFalse();
 
   }
 }

src/test/java/se/citerus/dddsample/domain/shared/experimental/ValueObjectSupportTest.java

@@ -2,6 +2,8 @@ package se.citerus.dddsample.domain.shared.experimental;
 
 import junit.framework.TestCase;
 
+import static org.assertj.core.api.Assertions.assertThat;
+
 
 public class ValueObjectSupportTest extends TestCase {
 
@@ -10,13 +12,13 @@ public class ValueObjectSupportTest extends TestCase {
         final AValueObject vo2 = new AValueObject("A");
         final BValueObject vo3 = new BValueObject("A", 1);
 
-        assertEquals(vo1, vo2);
-        assertEquals(vo2, vo1);
-        assertFalse(vo2.equals(vo3));
-        assertFalse(vo3.equals(vo2));
+        assertThat(vo2).isEqualTo(vo1);
+        assertThat(vo1).isEqualTo(vo2);
+        assertThat(vo2.equals(vo3)).isFalse();
+        assertThat(vo3.equals(vo2)).isFalse();
 
-        assertTrue(vo1.sameValueAs(vo2));
-        assertFalse(vo2.sameValueAs(vo3));
+        assertThat(vo1.sameValueAs(vo2)).isTrue();
+        assertThat(vo2.sameValueAs(vo3)).isFalse();
     }
 
     class AValueObject extends ValueObjectSupport<AValueObject> {

src/test/java/se/citerus/dddsample/infrastructure/persistence/hibernate/CargoRepositoryTest.java

@@ -31,7 +31,7 @@ import java.util.Date;
 import java.util.List;
 import java.util.Map;
 
-import static org.junit.Assert.*;
+import static org.assertj.core.api.Assertions.assertThat;
 import static se.citerus.dddsample.domain.model.handling.HandlingEvent.Type.LOAD;
 import static se.citerus.dddsample.domain.model.handling.HandlingEvent.Type.RECEIVE;
 import static se.citerus.dddsample.domain.model.location.SampleLocations.*;
@@ -76,14 +76,14 @@ public class CargoRepositoryTest {
     public void testFindByCargoId() {
         final TrackingId trackingId = new TrackingId("FGH");
         final Cargo cargo = cargoRepository.find(trackingId);
-        assertEquals(STOCKHOLM, cargo.origin());
-        assertEquals(HONGKONG, cargo.routeSpecification().origin());
-        assertEquals(HELSINKI, cargo.routeSpecification().destination());
+        assertThat(cargo.origin()).isEqualTo(STOCKHOLM);
+        assertThat(cargo.routeSpecification().origin()).isEqualTo(HONGKONG);
+        assertThat(cargo.routeSpecification().destination()).isEqualTo(HELSINKI);
 
-        assertNotNull(cargo.delivery());
+        assertThat(cargo.delivery()).isNotNull();
 
         final List<HandlingEvent> events = handlingEventRepository.lookupHandlingHistoryOfCargo(trackingId).distinctEventsByCompletionTime();
-        assertEquals(2, events.size());
+        assertThat(events).hasSize(2);
 
         HandlingEvent firstEvent = events.get(0);
         assertHandlingEvent(cargo, firstEvent, RECEIVE, HONGKONG, 100, 160, Voyage.NONE);
@@ -100,7 +100,7 @@ public class CargoRepositoryTest {
         assertHandlingEvent(cargo, secondEvent, LOAD, HONGKONG, 150, 110, hongkongMelbourneTokyoAndBack);
 
         List<Leg> legs = cargo.itinerary().legs();
-        assertEquals(3, legs.size());
+        assertThat(legs).hasSize(3);
 
         Leg firstLeg = legs.get(0);
         assertLeg(firstLeg, "0101", HONGKONG, MELBOURNE);
@@ -113,28 +113,28 @@ public class CargoRepositoryTest {
     }
 
     private void assertHandlingEvent(Cargo cargo, HandlingEvent event, HandlingEvent.Type expectedEventType, Location expectedLocation, int completionTimeMs, int registrationTimeMs, Voyage voyage) {
-        assertEquals(expectedEventType, event.type());
-        assertEquals(expectedLocation, event.location());
+        assertThat(event.type()).isEqualTo(expectedEventType);
+        assertThat(event.location()).isEqualTo(expectedLocation);
 
         Date expectedCompletionTime = SampleDataGenerator.offset(completionTimeMs);
-        assertEquals(expectedCompletionTime, event.completionTime());
+        assertThat(event.completionTime()).isEqualTo(expectedCompletionTime);
 
         Date expectedRegistrationTime = SampleDataGenerator.offset(registrationTimeMs);
-        assertEquals(expectedRegistrationTime, event.registrationTime());
+        assertThat(event.registrationTime()).isEqualTo(expectedRegistrationTime);
 
-        assertEquals(voyage, event.voyage());
-        assertEquals(cargo, event.cargo());
+        assertThat(event.voyage()).isEqualTo(voyage);
+        assertThat(event.cargo()).isEqualTo(cargo);
     }
 
     @Test
     public void testFindByCargoIdUnknownId() {
-        assertNull(cargoRepository.find(new TrackingId("UNKNOWN")));
+        assertThat(cargoRepository.find(new TrackingId("UNKNOWN"))).isNull();
     }
 
     private void assertLeg(Leg firstLeg, String vn, Location expectedFrom, Location expectedTo) {
-        assertEquals(new VoyageNumber(vn), firstLeg.voyage().voyageNumber());
-        assertEquals(expectedFrom, firstLeg.loadLocation());
-        assertEquals(expectedTo, firstLeg.unloadLocation());
+        assertThat(firstLeg.voyage().voyageNumber()).isEqualTo(new VoyageNumber(vn));
+        assertThat(firstLeg.loadLocation()).isEqualTo(expectedFrom);
+        assertThat(firstLeg.unloadLocation()).isEqualTo(expectedTo);
     }
 
     @Test
@@ -159,25 +159,25 @@ public class CargoRepositoryTest {
         Map<String, Object> map = jdbcTemplate.queryForMap(
                 "select * from Cargo where tracking_id = ?", trackingId.idString());
 
-        assertEquals("AAA", map.get("TRACKING_ID"));
+        assertThat(map.get("TRACKING_ID")).isEqualTo("AAA");
 
         Long originId = getLongId(origin);
-        assertEquals(originId, map.get("SPEC_ORIGIN_ID"));
+        assertThat(map.get("SPEC_ORIGIN_ID")).isEqualTo(originId);
 
         Long destinationId = getLongId(destination);
-        assertEquals(destinationId, map.get("SPEC_DESTINATION_ID"));
+        assertThat(map.get("SPEC_DESTINATION_ID")).isEqualTo(destinationId);
 
         sessionFactory.getCurrentSession().clear();
 
         final Cargo loadedCargo = cargoRepository.find(trackingId);
-        assertEquals(1, loadedCargo.itinerary().legs().size());
+        assertThat(loadedCargo.itinerary().legs()).hasSize(1);
     }
 
     @Test
     public void testReplaceItinerary() {
         Cargo cargo = cargoRepository.find(new TrackingId("FGH"));
         Long cargoId = getLongId(cargo);
-        assertEquals(3, jdbcTemplate.queryForObject("select count(*) from Leg where cargo_id = ?", new Object[]{cargoId}, Integer.class).intValue());
+        assertThat(jdbcTemplate.queryForObject("select count(*) from Leg where cargo_id = ?", new Object[]{cargoId}, Integer.class).intValue()).isEqualTo(3);
 
         Location legFrom = locationRepository.find(new UnLocode("FIHEL"));
         Location legTo = locationRepository.find(new UnLocode("DEHAM"));
@@ -188,24 +188,24 @@ public class CargoRepositoryTest {
         cargoRepository.store(cargo);
         flush();
 
-        assertEquals(1, jdbcTemplate.queryForObject("select count(*) from Leg where cargo_id = ?", new Object[]{cargoId}, Integer.class).intValue());
+        assertThat(jdbcTemplate.queryForObject("select count(*) from Leg where cargo_id = ?", new Object[]{cargoId}, Integer.class).intValue()).isEqualTo(1);
     }
 
     @Test
     public void testFindAll() {
         List<Cargo> all = cargoRepository.findAll();
-        assertNotNull(all);
-        assertEquals(6, all.size());
+        assertThat(all).isNotNull();
+        assertThat(all).hasSize(6);
     }
 
     @Test
     public void testNextTrackingId() {
         TrackingId trackingId = cargoRepository.nextTrackingId();
-        assertNotNull(trackingId);
+        assertThat(trackingId).isNotNull();
 
         TrackingId trackingId2 = cargoRepository.nextTrackingId();
-        assertNotNull(trackingId2);
-        assertFalse(trackingId.equals(trackingId2));
+        assertThat(trackingId2).isNotNull();
+        assertThat(trackingId.equals(trackingId2)).isFalse();
     }
 
 

src/test/java/se/citerus/dddsample/infrastructure/persistence/hibernate/CarrierMovementRepositoryTest.java

@@ -19,8 +19,7 @@ import se.citerus.dddsample.domain.model.voyage.VoyageRepository;
 
 import javax.sql.DataSource;
 
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
+import static org.assertj.core.api.Assertions.assertThat;
 
 @RunWith(SpringJUnit4ClassRunner.class)
 @ContextConfiguration(value = {"/context-infrastructure-persistence.xml"})
@@ -51,13 +50,13 @@ public class CarrierMovementRepositoryTest {
     @Test
     public void testFind() throws Exception {
         Voyage voyage = voyageRepository.find(new VoyageNumber("0101"));
-        assertNotNull(voyage);
-        assertEquals("0101", voyage.voyageNumber().idString());
+        assertThat(voyage).isNotNull();
+        assertThat(voyage.voyageNumber().idString()).isEqualTo("0101");
     /* TODO adapt
-    assertEquals(STOCKHOLM, carrierMovement.departureLocation());
-    assertEquals(HELSINKI, carrierMovement.arrivalLocation());
-    assertEquals(DateTestUtil.toDate("2007-09-23", "02:00"), carrierMovement.departureTime());
-    assertEquals(DateTestUtil.toDate("2007-09-23", "03:00"), carrierMovement.arrivalTime());
+    assertThat(carrierMovement.departureLocation()).isEqualTo(STOCKHOLM);
+    assertThat(carrierMovement.arrivalLocation()).isEqualTo(HELSINKI);
+    assertThat(carrierMovement.departureTime()).isEqualTo(DateTestUtil.toDate("2007-09-23", "02:00"));
+    assertThat(carrierMovement.arrivalTime()).isEqualTo(DateTestUtil.toDate("2007-09-23", "03:00"));
     */
     }
 

src/test/java/se/citerus/dddsample/infrastructure/persistence/hibernate/HandlingEventRepositoryTest.java

@@ -25,11 +25,12 @@ import se.citerus.dddsample.domain.model.location.UnLocode;
 
 import javax.sql.DataSource;
 import java.lang.reflect.Field;
+import java.sql.Timestamp;
 import java.util.Date;
 import java.util.List;
 import java.util.Map;
 
-import static org.junit.Assert.assertEquals;
+import static org.assertj.core.api.Assertions.assertThat;
 
 @RunWith(SpringJUnit4ClassRunner.class)
 @ContextConfiguration(value = {"/context-infrastructure-persistence.xml"})
@@ -77,10 +78,13 @@ public class HandlingEventRepositoryTest {
         flush();
 
         Map<String, Object> result = jdbcTemplate.queryForMap("select * from HandlingEvent where id = ?", getLongId(event));
-        assertEquals(1L, result.get("CARGO_ID"));
-        assertEquals(new Date(10), result.get("COMPLETIONTIME"));
-        assertEquals(new Date(20), result.get("REGISTRATIONTIME"));
-        assertEquals("CLAIM", result.get("TYPE"));
+
+        assertThat(result.get("CARGO_ID")).isEqualTo(1L);
+        Date completionDate = new Date(((Timestamp) result.get("COMPLETIONTIME")).getTime()); // equals call is not symmetric between java.sql.Timestamp and java.util.Date, so we should convert Timestamp Date
+        assertThat(completionDate).isEqualTo(new Date(10));
+        Date registrationDate = new Date(((Timestamp) result.get("REGISTRATIONTIME")).getTime()); // equals call is not symmetric between java.sql.Timestamp and java.util.Date, so we should convert Timestamp Date
+        assertThat(registrationDate).isEqualTo(new Date(20));
+        assertThat(result.get("TYPE")).isEqualTo("CLAIM");
         // TODO: the rest of the columns
     }
 
@@ -107,7 +111,7 @@ public class HandlingEventRepositoryTest {
     public void testFindEventsForCargo() throws Exception {
         TrackingId trackingId = new TrackingId("XYZ");
         List<HandlingEvent> handlingEvents = handlingEventRepository.lookupHandlingHistoryOfCargo(trackingId).distinctEventsByCompletionTime();
-        assertEquals(12, handlingEvents.size());
+        assertThat(handlingEvents).hasSize(12);
     }
 
 }

src/test/java/se/citerus/dddsample/infrastructure/persistence/hibernate/LocationRepositoryTest.java

@@ -19,7 +19,7 @@ import se.citerus.dddsample.domain.model.location.UnLocode;
 import javax.sql.DataSource;
 import java.util.List;
 
-import static org.junit.Assert.*;
+import static org.assertj.core.api.Assertions.assertThat;
 
 @RunWith(SpringJUnit4ClassRunner.class)
 @ContextConfiguration(value = {"/context-infrastructure-persistence.xml"})
@@ -45,18 +45,18 @@ public class LocationRepositoryTest {
     public void testFind() throws Exception {
         final UnLocode melbourne = new UnLocode("AUMEL");
         Location location = locationRepository.find(melbourne);
-        assertNotNull(location);
-        assertEquals(melbourne, location.unLocode());
+        assertThat(location).isNotNull();
+        assertThat(location.unLocode()).isEqualTo(melbourne);
 
-        assertNull(locationRepository.find(new UnLocode("NOLOC")));
+        assertThat(locationRepository.find(new UnLocode("NOLOC"))).isNull();
     }
 
     @Test
     public void testFindAll() throws Exception {
         List<Location> allLocations = locationRepository.findAll();
 
-        assertNotNull(allLocations);
-        assertEquals(7, allLocations.size());
+        assertThat(allLocations).isNotNull();
+        assertThat(allLocations).hasSize(7);
     }
 
 }

src/test/java/se/citerus/dddsample/infrastructure/routing/ExternalRoutingServiceTest.java

@@ -16,6 +16,7 @@ import java.util.Arrays;
 import java.util.Date;
 import java.util.List;
 
+import static org.assertj.core.api.Assertions.assertThat;
 import static org.easymock.EasyMock.*;
 import static se.citerus.dddsample.domain.model.location.SampleLocations.*;
 
@@ -33,7 +34,7 @@ public class ExternalRoutingServiceTest extends TestCase {
     externalRoutingService.setVoyageRepository(voyageRepository);
 
     GraphTraversalService graphTraversalService = new GraphTraversalServiceImpl(new GraphDAOStub() {
-      public List<String> listAllNodes() {
+      public List<String> listLocations() {
         return Arrays.asList(TOKYO.unLocode().idString(), STOCKHOLM.unLocode().idString(), GOTHENBURG.unLocode().idString());
       }
 
@@ -55,23 +56,23 @@ public class ExternalRoutingServiceTest extends TestCase {
     replay(voyageRepository);
 
     List<Itinerary> candidates = externalRoutingService.fetchRoutesForSpecification(routeSpecification);
-    assertNotNull(candidates);
+    assertThat(candidates).isNotNull();
 
     for (Itinerary itinerary : candidates) {
       List<Leg> legs = itinerary.legs();
-      assertNotNull(legs);
-      assertFalse(legs.isEmpty());
+      assertThat(legs).isNotNull();
+      assertThat(legs.isEmpty()).isFalse();
 
       // Cargo origin and start of first leg should match
-      assertEquals(cargo.origin(), legs.get(0).loadLocation());
+      assertThat(legs.get(0).loadLocation()).isEqualTo(cargo.origin());
 
       // Cargo final destination and last leg stop should match
       Location lastLegStop = legs.get(legs.size() - 1).unloadLocation();
-      assertEquals(cargo.routeSpecification().destination(), lastLegStop);
+      assertThat(lastLegStop).isEqualTo(cargo.routeSpecification().destination());
 
       for (int i = 0; i < legs.size() - 1; i++) {
         // Assert that all legs are connected
-        assertEquals(legs.get(i).unloadLocation(), legs.get(i + 1).loadLocation());
+        assertThat(legs.get(i + 1).loadLocation()).isEqualTo(legs.get(i).unloadLocation());
       }
     }
 

src/test/java/se/citerus/dddsample/interfaces/booking/facade/internal/assembler/CargoRoutingDTOAssemblerTest.java

@@ -3,14 +3,16 @@ package se.citerus.dddsample.interfaces.booking.facade.internal.assembler;
 import junit.framework.TestCase;
 import se.citerus.dddsample.domain.model.cargo.*;
 import se.citerus.dddsample.domain.model.location.Location;
-import static se.citerus.dddsample.domain.model.location.SampleLocations.*;
-import static se.citerus.dddsample.domain.model.voyage.SampleVoyages.CM001;
 import se.citerus.dddsample.interfaces.booking.facade.dto.CargoRoutingDTO;
 import se.citerus.dddsample.interfaces.booking.facade.dto.LegDTO;
 
 import java.util.Arrays;
 import java.util.Date;
 
+import static org.assertj.core.api.Assertions.assertThat;
+import static se.citerus.dddsample.domain.model.location.SampleLocations.*;
+import static se.citerus.dddsample.domain.model.voyage.SampleVoyages.CM001;
+
 public class CargoRoutingDTOAssemblerTest extends TestCase {
 
   public void testToDTO() throws Exception {
@@ -31,17 +33,17 @@ public class CargoRoutingDTOAssemblerTest extends TestCase {
 
     final CargoRoutingDTO dto = assembler.toDTO(cargo);
 
-    assertEquals(2, dto.getLegs().size());
+    assertThat(dto.getLegs()).hasSize(2);
 
     LegDTO legDTO = dto.getLegs().get(0);
-    assertEquals("CM001", legDTO.getVoyageNumber());
-    assertEquals("SESTO", legDTO.getFrom());
-    assertEquals("CNSHA", legDTO.getTo());
+    assertThat(legDTO.getVoyageNumber()).isEqualTo("CM001");
+    assertThat(legDTO.getFrom()).isEqualTo("SESTO");
+    assertThat(legDTO.getTo()).isEqualTo("CNSHA");
 
     legDTO = dto.getLegs().get(1);
-    assertEquals("CM001", legDTO.getVoyageNumber());
-    assertEquals("NLRTM", legDTO.getFrom());
-    assertEquals("AUMEL", legDTO.getTo());
+    assertThat(legDTO.getVoyageNumber()).isEqualTo("CM001");
+    assertThat(legDTO.getFrom()).isEqualTo("NLRTM");
+    assertThat(legDTO.getTo()).isEqualTo("AUMEL");
   }
 
   public void testToDTO_NoItinerary() throws Exception {
@@ -50,9 +52,9 @@ public class CargoRoutingDTOAssemblerTest extends TestCase {
     final Cargo cargo = new Cargo(new TrackingId("XYZ"), new RouteSpecification(STOCKHOLM, MELBOURNE, new Date()));
     final CargoRoutingDTO dto = assembler.toDTO(cargo);
 
-    assertEquals("XYZ", dto.getTrackingId());
-    assertEquals("SESTO", dto.getOrigin());
-    assertEquals("AUMEL", dto.getFinalDestination());
-    assertTrue(dto.getLegs().isEmpty());
+    assertThat(dto.getTrackingId()).isEqualTo("XYZ");
+    assertThat(dto.getOrigin()).isEqualTo("SESTO");
+    assertThat(dto.getFinalDestination()).isEqualTo("AUMEL");
+    assertThat(dto.getLegs().isEmpty()).isTrue();
   }
 }

src/test/java/se/citerus/dddsample/interfaces/booking/facade/internal/assembler/ItineraryCandidateDTOAssemblerTest.java

@@ -1,14 +1,11 @@
 package se.citerus.dddsample.interfaces.booking.facade.internal.assembler;
 
 import junit.framework.TestCase;
-import static org.easymock.EasyMock.*;
 import se.citerus.dddsample.domain.model.cargo.Itinerary;
 import se.citerus.dddsample.domain.model.cargo.Leg;
 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.CM001;
 import se.citerus.dddsample.domain.model.voyage.VoyageRepository;
 import se.citerus.dddsample.infrastructure.persistence.inmemory.VoyageRepositoryInMem;
 import se.citerus.dddsample.interfaces.booking.facade.dto.LegDTO;
@@ -19,6 +16,11 @@ import java.util.Arrays;
 import java.util.Date;
 import java.util.List;
 
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.easymock.EasyMock.*;
+import static se.citerus.dddsample.domain.model.location.SampleLocations.*;
+import static se.citerus.dddsample.domain.model.voyage.SampleVoyages.CM001;
+
 public class ItineraryCandidateDTOAssemblerTest extends TestCase {
 
   public void testToDTO() throws Exception {
@@ -36,16 +38,16 @@ public class ItineraryCandidateDTOAssemblerTest extends TestCase {
 
     final RouteCandidateDTO dto = assembler.toDTO(itinerary);
 
-    assertEquals(2, dto.getLegs().size());
+    assertThat(dto.getLegs()).hasSize(2);
     LegDTO legDTO = dto.getLegs().get(0);
-    assertEquals("CM001", legDTO.getVoyageNumber());
-    assertEquals("SESTO", legDTO.getFrom());
-    assertEquals("CNSHA", legDTO.getTo());
+    assertThat(legDTO.getVoyageNumber()).isEqualTo("CM001");
+    assertThat(legDTO.getFrom()).isEqualTo("SESTO");
+    assertThat(legDTO.getTo()).isEqualTo("CNSHA");
 
     legDTO = dto.getLegs().get(1);
-    assertEquals("CM001", legDTO.getVoyageNumber());
-    assertEquals("NLRTM", legDTO.getFrom());
-    assertEquals("AUMEL", legDTO.getTo());
+    assertThat(legDTO.getVoyageNumber()).isEqualTo("CM001");
+    assertThat(legDTO.getFrom()).isEqualTo("NLRTM");
+    assertThat(legDTO.getTo()).isEqualTo("AUMEL");
   }
 
   public void testFromDTO() throws Exception {
@@ -69,18 +71,18 @@ public class ItineraryCandidateDTOAssemblerTest extends TestCase {
     final Itinerary itinerary = assembler.fromDTO(new RouteCandidateDTO(legs), voyageRepository, locationRepository);
 
     
-    assertNotNull(itinerary);
-    assertNotNull(itinerary.legs());
-    assertEquals(2, itinerary.legs().size());
+    assertThat(itinerary).isNotNull();
+    assertThat(itinerary.legs()).isNotNull();
+    assertThat(itinerary.legs()).hasSize(2);
 
     final Leg leg1 = itinerary.legs().get(0);
-    assertNotNull(leg1);
-    assertEquals(HONGKONG, leg1.loadLocation());
-    assertEquals(TOKYO, leg1.unloadLocation());
+    assertThat(leg1).isNotNull();
+    assertThat(leg1.loadLocation()).isEqualTo(HONGKONG);
+    assertThat(leg1.unloadLocation()).isEqualTo(TOKYO);
 
     final Leg leg2 = itinerary.legs().get(1);
-    assertNotNull(leg2);
-    assertEquals(TOKYO, leg2.loadLocation());
-    assertEquals(CHICAGO, leg2.unloadLocation());
+    assertThat(leg2).isNotNull();
+    assertThat(leg2.loadLocation()).isEqualTo(TOKYO);
+    assertThat(leg2.unloadLocation()).isEqualTo(CHICAGO);
   }
 }

src/test/java/se/citerus/dddsample/interfaces/booking/facade/internal/assembler/LocationDTOAssemblerTest.java

@@ -2,13 +2,15 @@ package se.citerus.dddsample.interfaces.booking.facade.internal.assembler;
 
 import junit.framework.TestCase;
 import se.citerus.dddsample.domain.model.location.Location;
-import static se.citerus.dddsample.domain.model.location.SampleLocations.HAMBURG;
-import static se.citerus.dddsample.domain.model.location.SampleLocations.STOCKHOLM;
 import se.citerus.dddsample.interfaces.booking.facade.dto.LocationDTO;
 
 import java.util.Arrays;
 import java.util.List;
 
+import static org.assertj.core.api.Assertions.assertThat;
+import static se.citerus.dddsample.domain.model.location.SampleLocations.HAMBURG;
+import static se.citerus.dddsample.domain.model.location.SampleLocations.STOCKHOLM;
+
 public class LocationDTOAssemblerTest extends TestCase {
 
   public void testToDTOList() {
@@ -17,15 +19,15 @@ public class LocationDTOAssemblerTest extends TestCase {
 
     final List<LocationDTO> dtos = assembler.toDTOList(locationList);
 
-    assertEquals(2, dtos.size());
+    assertThat(dtos).hasSize(2);
 
     LocationDTO dto = dtos.get(0);
-    assertEquals("SESTO", dto.getUnLocode());
-    assertEquals("Stockholm", dto.getName());
+    assertThat(dto.getUnLocode()).isEqualTo("SESTO");
+    assertThat(dto.getName()).isEqualTo("Stockholm");
 
     dto = dtos.get(1);
-    assertEquals("DEHAM", dto.getUnLocode());
-    assertEquals("Hamburg", dto.getName());
+    assertThat(dto.getUnLocode()).isEqualTo("DEHAM");
+    assertThat(dto.getName()).isEqualTo("Hamburg");
   }
 
 }

src/test/java/se/citerus/dddsample/interfaces/booking/web/ItinerarySelectionCommandTest.java

@@ -6,7 +6,7 @@ import org.springframework.web.bind.ServletRequestDataBinder;
 
 import java.util.List;
 
-import static org.junit.Assert.assertEquals;
+import static org.assertj.core.api.Assertions.assertThat;
 
 public class ItinerarySelectionCommandTest {
 
@@ -32,18 +32,18 @@ public class ItinerarySelectionCommandTest {
         binder.bind(request);
 
         List<RouteAssignmentCommand.LegCommand> legs = command.getLegs();
-        assertEquals(2, legs.size());
+        assertThat(legs).hasSize(2);
 
         RouteAssignmentCommand.LegCommand leg = legs.get(0);
-        assertEquals("CM01", leg.getVoyageNumber());
-        assertEquals("AAAAA", leg.getFromUnLocode());
-        assertEquals("BBBBB", leg.getToUnLocode());
+        assertThat(leg.getVoyageNumber()).isEqualTo("CM01");
+        assertThat(leg.getFromUnLocode()).isEqualTo("AAAAA");
+        assertThat(leg.getToUnLocode()).isEqualTo("BBBBB");
 
         leg = legs.get(1);
-        assertEquals("CM02", leg.getVoyageNumber());
-        assertEquals("CCCCC", leg.getFromUnLocode());
-        assertEquals("DDDDD", leg.getToUnLocode());
+        assertThat(leg.getVoyageNumber()).isEqualTo("CM02");
+        assertThat(leg.getFromUnLocode()).isEqualTo("CCCCC");
+        assertThat(leg.getToUnLocode()).isEqualTo("DDDDD");
 
-        assertEquals("XYZ", command.getTrackingId());
+        assertThat(command.getTrackingId()).isEqualTo("XYZ");
     }
 }

src/test/java/se/citerus/dddsample/interfaces/tracking/CargoTrackingControllerTest.java

@@ -17,7 +17,7 @@ import se.citerus.dddsample.infrastructure.persistence.inmemory.HandlingEventRep
 
 import java.util.Map;
 
-import static org.junit.Assert.assertEquals;
+import static org.assertj.core.api.Assertions.assertThat;
 import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post;
 
 
@@ -52,7 +52,7 @@ public class CargoTrackingControllerTest {
         String trackingId = "ABC";
         Map<String, Object> model = mockMvc.perform(post("/track").param("trackingId", trackingId)).andReturn().getModelAndView().getModel();
         CargoTrackingViewAdapter cargoTrackingViewAdapter = (CargoTrackingViewAdapter) model.get("cargo");
-        assertEquals(trackingId, cargoTrackingViewAdapter.getTrackingId());
+        assertThat(cargoTrackingViewAdapter.getTrackingId()).isEqualTo(trackingId);
     }
 
     @Test
@@ -61,9 +61,9 @@ public class CargoTrackingControllerTest {
         Map<String, Object> model = mockMvc.perform(post("/track").param("trackingId", trackingId)).andReturn().getModelAndView().getModel();
         Errors errors = (Errors) model.get(BindingResult.MODEL_KEY_PREFIX + "trackCommand");
         FieldError fe = errors.getFieldError("trackingId");
-        assertEquals("cargo.unknown_id", fe.getCode());
-        assertEquals(1, fe.getArguments().length);
-        assertEquals(trackingId, fe.getArguments()[0]);
+        assertThat(fe.getCode()).isEqualTo("cargo.unknown_id");
+        assertThat(fe.getArguments().length).isEqualTo(1);
+        assertThat(fe.getArguments()[0]).isEqualTo(trackingId);
     }
 
 }

src/test/java/se/citerus/dddsample/interfaces/tracking/CargoTrackingViewAdapterTest.java

@@ -7,12 +7,14 @@ import se.citerus.dddsample.domain.model.cargo.RouteSpecification;
 import se.citerus.dddsample.domain.model.cargo.TrackingId;
 import se.citerus.dddsample.domain.model.handling.HandlingEvent;
 import se.citerus.dddsample.domain.model.handling.HandlingHistory;
+
+import java.util.*;
+
+import static org.assertj.core.api.Assertions.assertThat;
 import static se.citerus.dddsample.domain.model.location.SampleLocations.HANGZOU;
 import static se.citerus.dddsample.domain.model.location.SampleLocations.HELSINKI;
 import static se.citerus.dddsample.domain.model.voyage.SampleVoyages.CM001;
 
-import java.util.*;
-
 public class CargoTrackingViewAdapterTest extends TestCase {
 
   public void testCreate() {
@@ -32,33 +34,33 @@ public class CargoTrackingViewAdapterTest extends TestCase {
 
     CargoTrackingViewAdapter adapter = new CargoTrackingViewAdapter(cargo, applicationContext, Locale.GERMAN, events, TimeZone.getTimeZone("Europe/Stockholm"));
 
-    assertEquals("XYZ", adapter.getTrackingId());
-    assertEquals("Hangzhou", adapter.getOrigin());
-    assertEquals("Helsinki", adapter.getDestination());
-    assertEquals("In port Helsinki", adapter.getStatusText());
+    assertThat(adapter.getTrackingId()).isEqualTo("XYZ");
+    assertThat(adapter.getOrigin()).isEqualTo("Hangzhou");
+    assertThat(adapter.getDestination()).isEqualTo("Helsinki");
+    assertThat(adapter.getStatusText()).isEqualTo("In port Helsinki");
 
     Iterator<CargoTrackingViewAdapter.HandlingEventViewAdapter> it = adapter.getEvents().iterator();
 
     CargoTrackingViewAdapter.HandlingEventViewAdapter event = it.next();
-    assertEquals("RECEIVE", event.getType());
-    assertEquals("Hangzhou", event.getLocation());
-    assertEquals("1970-01-01 01:00", event.getTime());
-    assertEquals("", event.getVoyageNumber());
-    assertTrue(event.isExpected());
+    assertThat(event.getType()).isEqualTo("RECEIVE");
+    assertThat(event.getLocation()).isEqualTo("Hangzhou");
+    assertThat(event.getTime()).isEqualTo("1970-01-01 01:00");
+    assertThat(event.getVoyageNumber()).isEqualTo("");
+    assertThat(event.isExpected()).isTrue();
 
     event = it.next();
-    assertEquals("LOAD", event.getType());
-    assertEquals("Hangzhou", event.getLocation());
-    assertEquals("1970-01-01 01:00", event.getTime());
-    assertEquals("CM001", event.getVoyageNumber());
-    assertTrue(event.isExpected());
+    assertThat(event.getType()).isEqualTo("LOAD");
+    assertThat(event.getLocation()).isEqualTo("Hangzhou");
+    assertThat(event.getTime()).isEqualTo("1970-01-01 01:00");
+    assertThat(event.getVoyageNumber()).isEqualTo("CM001");
+    assertThat(event.isExpected()).isTrue();
 
     event = it.next();
-    assertEquals("UNLOAD", event.getType());
-    assertEquals("Helsinki", event.getLocation());
-    assertEquals("1970-01-01 01:00", event.getTime());
-    assertEquals("CM001", event.getVoyageNumber());
-    assertTrue(event.isExpected());
+    assertThat(event.getType()).isEqualTo("UNLOAD");
+    assertThat(event.getLocation()).isEqualTo("Helsinki");
+    assertThat(event.getTime()).isEqualTo("1970-01-01 01:00");
+    assertThat(event.getVoyageNumber()).isEqualTo("CM001");
+    assertThat(event.isExpected()).isTrue();
   }
 
 }

src/test/java/se/citerus/dddsample/interfaces/tracking/TrackCommandValidatorTest.java

@@ -5,6 +5,8 @@ import org.springframework.validation.BeanPropertyBindingResult;
 import org.springframework.validation.BindingResult;
 import org.springframework.validation.FieldError;
 
+import static org.assertj.core.api.Assertions.assertThat;
+
 public class TrackCommandValidatorTest extends TestCase {
 
   TrackCommandValidator validator;
@@ -20,18 +22,18 @@ public class TrackCommandValidatorTest extends TestCase {
   public void testValidateIllegalId() throws Exception {
     validator.validate(command, errors);
 
-    assertEquals(1, errors.getErrorCount());
+    assertThat(errors.getErrorCount()).isEqualTo(1);
     FieldError error = errors.getFieldError("trackingId");
-    assertNotNull(error);
-    assertNull(error.getRejectedValue());
-    assertEquals("error.required", error.getCode());
+    assertThat(error).isNotNull();
+    assertThat(error.getRejectedValue()).isNull();
+    assertThat(error.getCode()).isEqualTo("error.required");
   }
     
   public void testValidateSuccess() throws Exception {
     command.setTrackingId("non-empty");
     validator.validate(command, errors);
 
-    assertFalse(errors.hasErrors());
+    assertThat(errors.hasErrors()).isFalse();
   }
 
 }

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

@@ -8,20 +8,13 @@ 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 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 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 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;
@@ -35,6 +28,15 @@ import java.util.Arrays;
 import java.util.Date;
 import java.util.List;
 
+import static org.assertj.core.api.Assertions.assertThat;
+import static se.citerus.dddsample.application.util.DateTestUtil.toDate;
+import static se.citerus.dddsample.domain.model.cargo.RoutingStatus.*;
+import static se.citerus.dddsample.domain.model.cargo.TransportStatus.*;
+import static se.citerus.dddsample.domain.model.handling.HandlingEvent.Type.*;
+import static se.citerus.dddsample.domain.model.location.SampleLocations.*;
+import static se.citerus.dddsample.domain.model.voyage.SampleVoyages.*;
+import static se.citerus.dddsample.domain.model.voyage.Voyage.NONE;
+
 public class CargoLifecycleScenarioTest extends TestCase {
 
   /**
@@ -105,12 +107,12 @@ public class CargoLifecycleScenarioTest extends TestCase {
        Tracking the cargo basically amounts to presenting information extracted from
        the cargo aggregate in a suitable way. */
     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());
+    assertThat(cargo).isNotNull();
+    assertThat(cargo.delivery().transportStatus()).isEqualTo(NOT_RECEIVED);
+    assertThat(cargo.delivery().routingStatus()).isEqualTo(NOT_ROUTED);
+    assertThat(cargo.delivery().isMisdirected()).isFalse();
+    assertThat(cargo.delivery().estimatedTimeOfArrival()).isNull();
+    assertThat(cargo.delivery().nextExpectedActivity()).isNull();
 
     /* Use case 2: routing
 
@@ -124,10 +126,10 @@ public class CargoLifecycleScenarioTest extends TestCase {
     Itinerary itinerary = selectPreferedItinerary(itineraries);
     cargo.assignToRoute(itinerary);
 
-    assertEquals(NOT_RECEIVED, cargo.delivery().transportStatus());
-    assertEquals(ROUTED, cargo.delivery().routingStatus());
-    assertNotNull(cargo.delivery().estimatedTimeOfArrival());
-    assertEquals(new HandlingActivity(RECEIVE, HONGKONG), cargo.delivery().nextExpectedActivity());
+    assertThat(cargo.delivery().transportStatus()).isEqualTo(NOT_RECEIVED);
+    assertThat(cargo.delivery().routingStatus()).isEqualTo(ROUTED);
+    assertThat(cargo.delivery().estimatedTimeOfArrival()).isNotNull();
+    assertThat(cargo.delivery().nextExpectedActivity()).isEqualTo(new HandlingActivity(RECEIVE, HONGKONG));
 
     /*
       Use case 3: handling
@@ -147,8 +149,8 @@ public class CargoLifecycleScenarioTest extends TestCase {
       toDate("2009-03-01"), trackingId, null, HONGKONG.unLocode(), RECEIVE
     );
 
-    assertEquals(IN_PORT, cargo.delivery().transportStatus());
-    assertEquals(HONGKONG, cargo.delivery().lastKnownLocation());
+    assertThat(cargo.delivery().transportStatus()).isEqualTo(IN_PORT);
+    assertThat(cargo.delivery().lastKnownLocation()).isEqualTo(HONGKONG);
     
     // Next event: Load onto voyage CM003 in Hongkong
     handlingEventService.registerHandlingEvent(
@@ -156,11 +158,11 @@ public class CargoLifecycleScenarioTest extends TestCase {
     );
 
     // Check current state - should be ok
-    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());
+    assertThat(cargo.delivery().currentVoyage()).isEqualTo(v100);
+    assertThat(cargo.delivery().lastKnownLocation()).isEqualTo(HONGKONG);
+    assertThat(cargo.delivery().transportStatus()).isEqualTo(ONBOARD_CARRIER);
+    assertThat(cargo.delivery().isMisdirected()).isFalse();
+    assertThat(cargo.delivery().nextExpectedActivity()).isEqualTo(new HandlingActivity(UNLOAD, NEWYORK, v100));
 
 
     /*
@@ -187,11 +189,11 @@ public class CargoLifecycleScenarioTest extends TestCase {
     );
 
     // 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());
+    assertThat(cargo.delivery().currentVoyage()).isEqualTo(NONE);
+    assertThat(cargo.delivery().lastKnownLocation()).isEqualTo(TOKYO);
+    assertThat(cargo.delivery().transportStatus()).isEqualTo(IN_PORT);
+    assertThat(cargo.delivery().isMisdirected()).isTrue();
+    assertThat(cargo.delivery().nextExpectedActivity()).isNull();
 
 
     // -- Cargo needs to be rerouted --
@@ -203,8 +205,8 @@ public class CargoLifecycleScenarioTest extends TestCase {
     cargo.specifyNewRoute(fromTokyo);
 
     // The old itinerary does not satisfy the new specification
-    assertEquals(MISROUTED, cargo.delivery().routingStatus());
-    assertNull(cargo.delivery().nextExpectedActivity());
+    assertThat(cargo.delivery().routingStatus()).isEqualTo(MISROUTED);
+    assertThat(cargo.delivery().nextExpectedActivity()).isNull();
 
     // Repeat procedure of selecting one out of a number of possible routes satisfying the route spec
     List<Itinerary> newItineraries = bookingService.requestPossibleRoutesForCargo(cargo.trackingId());
@@ -212,11 +214,11 @@ public class CargoLifecycleScenarioTest extends TestCase {
     cargo.assignToRoute(newItinerary);
 
     // New itinerary should satisfy new route
-    assertEquals(ROUTED, cargo.delivery().routingStatus());
+    assertThat(cargo.delivery().routingStatus()).isEqualTo(ROUTED);
 
     // 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());
+    //assertThat(cargo.isMisdirected()).isFalse();
+    //assertThat(, cargo.nextExpectedActivity()).isEqualTo(new HandlingActivity(LOAD, TOKYO));
 
 
     // -- Cargo has been rerouted, shipping continues --
@@ -228,11 +230,11 @@ public class CargoLifecycleScenarioTest extends TestCase {
     );
 
     // 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());
+    assertThat(cargo.delivery().currentVoyage()).isEqualTo(v300);
+    assertThat(cargo.delivery().lastKnownLocation()).isEqualTo(TOKYO);
+    assertThat(cargo.delivery().transportStatus()).isEqualTo(ONBOARD_CARRIER);
+    assertThat(cargo.delivery().isMisdirected()).isFalse();
+    assertThat(cargo.delivery().nextExpectedActivity()).isEqualTo(new HandlingActivity(UNLOAD, HAMBURG, v300));
 
     // Unload in Hamburg
     handlingEventService.registerHandlingEvent(
@@ -240,11 +242,11 @@ public class CargoLifecycleScenarioTest extends TestCase {
     );
 
     // 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());
+    assertThat(cargo.delivery().currentVoyage()).isEqualTo(NONE);
+    assertThat(cargo.delivery().lastKnownLocation()).isEqualTo(HAMBURG);
+    assertThat(cargo.delivery().transportStatus()).isEqualTo(IN_PORT);
+    assertThat(cargo.delivery().isMisdirected()).isFalse();
+    assertThat(cargo.delivery().nextExpectedActivity()).isEqualTo(new HandlingActivity(LOAD, HAMBURG, v400));
 
 
     // Load in Hamburg
@@ -253,11 +255,11 @@ public class CargoLifecycleScenarioTest extends TestCase {
     );
 
     // 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());
+    assertThat(cargo.delivery().currentVoyage()).isEqualTo(v400);
+    assertThat(cargo.delivery().lastKnownLocation()).isEqualTo(HAMBURG);
+    assertThat(cargo.delivery().transportStatus()).isEqualTo(ONBOARD_CARRIER);
+    assertThat(cargo.delivery().isMisdirected()).isFalse();
+    assertThat(cargo.delivery().nextExpectedActivity()).isEqualTo(new HandlingActivity(UNLOAD, STOCKHOLM, v400));
 
 
     // Unload in Stockholm
@@ -266,11 +268,11 @@ public class CargoLifecycleScenarioTest extends TestCase {
     );
 
     // 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());
+    assertThat(cargo.delivery().currentVoyage()).isEqualTo(NONE);
+    assertThat(cargo.delivery().lastKnownLocation()).isEqualTo(STOCKHOLM);
+    assertThat(cargo.delivery().transportStatus()).isEqualTo(IN_PORT);
+    assertThat(cargo.delivery().isMisdirected()).isFalse();
+    assertThat(cargo.delivery().nextExpectedActivity()).isEqualTo(new HandlingActivity(CLAIM, STOCKHOLM));
 
     // Finally, cargo is claimed in Stockholm. This ends the cargo lifecycle from our perspective.
     handlingEventService.registerHandlingEvent(
@@ -278,11 +280,11 @@ public class CargoLifecycleScenarioTest extends TestCase {
     );
 
     // Check current state - should be ok
-    assertEquals(NONE, cargo.delivery().currentVoyage());
-    assertEquals(STOCKHOLM, cargo.delivery().lastKnownLocation());
-    assertEquals(CLAIMED, cargo.delivery().transportStatus());
-    assertFalse(cargo.delivery().isMisdirected());
-    assertNull(cargo.delivery().nextExpectedActivity());
+    assertThat(cargo.delivery().currentVoyage()).isEqualTo(NONE);
+    assertThat(cargo.delivery().lastKnownLocation()).isEqualTo(STOCKHOLM);
+    assertThat(cargo.delivery().transportStatus()).isEqualTo(CLAIMED);
+    assertThat(cargo.delivery().isMisdirected()).isFalse();
+    assertThat(cargo.delivery().nextExpectedActivity()).isNull();
   }