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.
 - 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

     <!-- 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>
       <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

 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;
     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

 
 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;
 
 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;
 
     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 {
 
     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 {
     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()).
     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
   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>();
 
 
     events.addAll(handlingEvents);
     cargo.deriveDeliveryProgress(new HandlingHistory(events));
-    assertFalse(cargo.delivery().isMisdirected());
+    assertThat(cargo.delivery().isMisdirected()).isFalse();
 
     //Try a couple of failing ones
 
     events.addAll(handlingEvents);
     cargo.deriveDeliveryProgress(new HandlingHistory(events));
 
-    assertTrue(cargo.delivery().isMisdirected());
+    assertThat(cargo.delivery().isMisdirected()).isTrue();
 
 
     cargo = setUpCargoWithItinerary(SHANGHAI, ROTTERDAM, GOTHENBURG);
     events.addAll(handlingEvents);
     cargo.deriveDeliveryProgress(new HandlingHistory(events));
 
-    assertTrue(cargo.delivery().isMisdirected());
+    assertThat(cargo.delivery().isMisdirected()).isTrue();
 
 
     cargo = setUpCargoWithItinerary(SHANGHAI, ROTTERDAM, GOTHENBURG);
     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

 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();
   }
   
   /*
     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

 
 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;
 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());
 
     //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

 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(
       HONGKONG, CHICAGO, toDate("2009-03-01")
     );
 
-    assertTrue(routeSpecification.isSatisfiedBy(itinerary));
+    assertThat(routeSpecification.isSatisfiedBy(itinerary)).isTrue();
   }
 
   public void testIsSatisfiedBy_WrongOrigin() {
       HANGZOU, CHICAGO, toDate("2009-03-01")
     );
 
-    assertFalse(routeSpecification.isSatisfiedBy(itinerary));
+    assertThat(routeSpecification.isSatisfiedBy(itinerary)).isFalse();
   }
 
   public void testIsSatisfiedBy_WrongDestination() {
       HONGKONG, DALLAS, toDate("2009-03-01")
     );
 
-    assertFalse(routeSpecification.isSatisfiedBy(itinerary));
+    assertThat(routeSpecification.isSatisfiedBy(itinerary)).isFalse();
   }
 
   public void testIsSatisfiedBy_MissedDeadline() {
       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

 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;
 
 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;
       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 {
       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

 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;
 
   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)) {
 
   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
     }
     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

 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;
   }
 
   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

 
 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

 
 import junit.framework.TestCase;
 
+import static org.assertj.core.api.Assertions.assertThat;
+
 public class UnLocodeTest extends TestCase {
 
   public void testNew() throws Exception {
   }
 
   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

 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 {
     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

 
 import junit.framework.TestCase;
 
+import static org.assertj.core.api.Assertions.assertThat;
+
 public class AndSpecificationTest extends TestCase {
 
   public void testAndIsSatisifedBy() throws Exception {
     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

 
 import junit.framework.TestCase;
 
+import static org.assertj.core.api.Assertions.assertThat;
+
 public class NotSpecificationTest extends TestCase {
 
   public void testAndIsSatisifedBy() throws Exception {
     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

 
 import junit.framework.TestCase;
 
+import static org.assertj.core.api.Assertions.assertThat;
+
 public class OrSpecificationTest extends TestCase {
 
   public void testAndIsSatisifedBy() throws Exception {
     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

 
 import junit.framework.TestCase;
 
+import static org.assertj.core.api.Assertions.assertThat;
+
 
 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

 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;
 import java.util.List;
 import java.util.Map;
 
-import static org.junit.Assert.*;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.Assert.assertEquals;
 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.*;
     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);
         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);
     }
 
     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
         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);
+        //assertThat(Integer.class).intValue()).isEqualTo(3, jdbcTemplate.queryForObject("select count(*) from Leg where cargo_id = ?", new Object[]{cargoId});
         assertEquals(3, jdbcTemplate.queryForObject("select count(*) from Leg where cargo_id = ?", new Object[]{cargoId}, Integer.class).intValue());
 
         Location legFrom = locationRepository.find(new UnLocode("FIHEL"));
         cargoRepository.store(cargo);
         flush();
 
+        //assertThat(Integer.class).intValue()).isEqualTo(1, jdbcTemplate.queryForObject("select count(*) from Leg where cargo_id = ?", new Object[]{cargoId});
         assertEquals(1, jdbcTemplate.queryForObject("select count(*) from Leg where cargo_id = ?", new Object[]{cargoId}, Integer.class).intValue());
+
     }
 
     @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

 
 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"})
     @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

 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;
 
 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"})
         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
     }
 
     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

 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"})
     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

 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;
 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;
     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

 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 {
 
     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 {
     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

 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;
 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 {
 
     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 {
     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

 
 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() {
 
     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

 
 import java.util.List;
 
-import static org.junit.Assert.assertEquals;
+import static org.assertj.core.api.Assertions.assertThat;
 
 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

 
 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;
 
 
         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
         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

 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() {
 
     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

 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;
   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

 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;
 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 {
 
   /**
        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
 
     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
       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(
     );
 
     // 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));
 
 
     /*
     );
 
     // 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 --
     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());
     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 --
     );
 
     // 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(
     );
 
     // 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
     );
 
     // 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
     );
 
     // 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(
     );
 
     // 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();
   }