Convert JUnit assertions to AssertJ

 - We used "convert-junit-assertions-to-assertj.sh" script to launch the automatic conversion.
 - The auto conversion of  assertEquals(<List>, <List>) was wrong.
 - The auto conversion of  assertEquals(int, Integer.inValue()) was wrong.
 - assertThat(result.get("REGISTRATIONTIME")).isEqualTo(new Date(20)) in HandlingEventRepositoryTest.java (in the testSave method) throw an exception, because equals call isn't symmetric between java.util.Date and java.sql.Timestamp. AssertJ and Junit equality assertion doesn't call equals method in the same way. One invoke expected.equals(actual) and the other actual.equals(expected).

pom.xml

@@ -70,6 +70,7 @@
     <!-- Dependencies -->
     <spring.version>4.2.1.RELEASE</spring.version>
     <cxf.version>3.0.3</cxf.version>
+    <assertj.version>3.8.0</assertj.version>
     <!-- Plugin versions -->
     <maven-compiler-plugin.version>3.3</maven-compiler-plugin.version>
     <maven-jar-plugin.version>2.6</maven-jar-plugin.version>
@@ -141,6 +142,11 @@
       <scope>test</scope>
     </dependency>
     <dependency>
+      <groupId>org.assertj</groupId>
+      <artifactId>assertj-core</artifactId>
+      <version>${assertj.version}</version>
+    </dependency>
+    <dependency>
       <groupId>org.springframework</groupId>
       <artifactId>spring-webmvc</artifactId>
       <version>${spring.version}</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,51 @@ 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.get(0)).isSameAs(he2);
+    assertThat(orderEvents.get(1)).isSameAs(he4);
+    assertThat(orderEvents.get(2)).isSameAs(he1);
+    assertThat(orderEvents.get(3)).isSameAs(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);
+      assertThat(false).as("Expected IllegaArgumentException to be thrown").isTrue();
     } 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

@@ -1,7 +1,7 @@
 package se.citerus.dddsample.infrastructure.persistence.hibernate;
 
-import org.hibernate.SessionFactory;
 import org.hibernate.Session;
+import org.hibernate.SessionFactory;
 import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.RunWith;
@@ -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", "/context-domain.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

@@ -1,7 +1,7 @@
 package se.citerus.dddsample.infrastructure.persistence.hibernate;
 
-import org.hibernate.SessionFactory;
 import org.hibernate.Session;
+import org.hibernate.SessionFactory;
 import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.RunWith;
@@ -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", "/context-domain.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", "/context-domain.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

@@ -4,11 +4,9 @@ import com.pathfinder.api.GraphTraversalService;
 import com.pathfinder.internal.GraphDAO;
 import com.pathfinder.internal.GraphTraversalServiceImpl;
 import junit.framework.TestCase;
-import static org.easymock.EasyMock.*;
 import se.citerus.dddsample.domain.model.cargo.*;
 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.voyage.SampleVoyages;
 import se.citerus.dddsample.domain.model.voyage.VoyageNumber;
 import se.citerus.dddsample.domain.model.voyage.VoyageRepository;
@@ -18,6 +16,10 @@ 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.*;
+
 public class ExternalRoutingServiceTest extends TestCase {
 
   private ExternalRoutingService externalRoutingService;
@@ -54,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();
   }