Use Mockito as mocking library instead of EasyMock

pom.xml

@@ -151,12 +151,6 @@
             <scope>test</scope>
         </dependency>
         <dependency>
-            <groupId>org.easymock</groupId>
-            <artifactId>easymock</artifactId>
-            <version>2.3</version>
-            <scope>test</scope>
-        </dependency>
-        <dependency>
             <groupId>org.assertj</groupId>
             <artifactId>assertj-core</artifactId>
             <scope>test</scope>

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

@@ -1,11 +1,18 @@
 package se.citerus.dddsample.application;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.easymock.EasyMock.createMock;
-import static org.easymock.EasyMock.expect;
-import static org.easymock.EasyMock.isA;
-import static org.easymock.EasyMock.replay;
-import static org.easymock.EasyMock.verify;
+import static org.mockito.Matchers.any;
+import static org.mockito.Matchers.isA;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+import static se.citerus.dddsample.domain.model.location.SampleLocations.CHICAGO;
+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.CHICAGO;
 import static se.citerus.dddsample.domain.model.location.SampleLocations.STOCKHOLM;
 
@@ -14,7 +21,6 @@ import java.util.Date;
 import org.junit.After;
 import org.junit.Before;
 import org.junit.Test;
-
 import se.citerus.dddsample.application.impl.BookingServiceImpl;
 import se.citerus.dddsample.domain.model.cargo.Cargo;
 import se.citerus.dddsample.domain.model.cargo.CargoRepository;
@@ -32,9 +38,9 @@ public class BookingServiceTest {
 
   @Before
   public void setUp() {
-    cargoRepository = createMock(CargoRepository.class);
-    locationRepository = createMock(LocationRepository.class);
-    routingService = createMock(RoutingService.class);
+    cargoRepository = mock(CargoRepository.class);
+    locationRepository = mock(LocationRepository.class);
+    routingService = mock(RoutingService.class);
     bookingService = new BookingServiceImpl(cargoRepository, locationRepository, routingService);
   }
 
@@ -44,13 +50,9 @@ public class BookingServiceTest {
     UnLocode fromUnlocode = new UnLocode("USCHI");
     UnLocode toUnlocode = new UnLocode("SESTO");
 
-    expect(cargoRepository.nextTrackingId()).andReturn(expectedTrackingId);
-    expect(locationRepository.find(fromUnlocode)).andReturn(CHICAGO);
-    expect(locationRepository.find(toUnlocode)).andReturn(STOCKHOLM);
-
-    cargoRepository.store(isA(Cargo.class));
-
-    replay(cargoRepository, locationRepository);
+    when(cargoRepository.nextTrackingId()).thenReturn(expectedTrackingId);
+    when(locationRepository.find(fromUnlocode)).thenReturn(CHICAGO);
+    when(locationRepository.find(toUnlocode)).thenReturn(STOCKHOLM);
 
     TrackingId trackingId = bookingService.bookNewCargo(fromUnlocode, toUnlocode, new Date());
     assertThat(trackingId).isEqualTo(expectedTrackingId);
@@ -58,6 +60,7 @@ public class BookingServiceTest {
 
   @After
   public void tearDown() {
-    verify(cargoRepository, locationRepository);
+    verify(cargoRepository, times(1)).store(isA(Cargo.class));
+    verify(locationRepository, times(2)).find(any(UnLocode.class));
   }
 }

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

@@ -1,10 +1,10 @@
 package se.citerus.dddsample.application;
 
-import static org.easymock.EasyMock.createMock;
-import static org.easymock.EasyMock.expect;
-import static org.easymock.EasyMock.isA;
-import static org.easymock.EasyMock.replay;
-import static org.easymock.EasyMock.verify;
+import static org.mockito.Matchers.isA;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
 import static se.citerus.dddsample.domain.model.location.SampleLocations.HAMBURG;
 import static se.citerus.dddsample.domain.model.location.SampleLocations.STOCKHOLM;
 import static se.citerus.dddsample.domain.model.location.SampleLocations.TOKYO;
@@ -39,11 +39,11 @@ public class HandlingEventServiceTest {
 
   @Before
   public void setUp() {
-    cargoRepository = createMock(CargoRepository.class);
-    voyageRepository = createMock(VoyageRepository.class);
-    handlingEventRepository = createMock(HandlingEventRepository.class);
-    locationRepository = createMock(LocationRepository.class);
-    applicationEvents = createMock(ApplicationEvents.class);
+    cargoRepository = mock(CargoRepository.class);
+    voyageRepository = mock(VoyageRepository.class);
+    handlingEventRepository = mock(HandlingEventRepository.class);
+    locationRepository = mock(LocationRepository.class);
+    applicationEvents = mock(ApplicationEvents.class);
 
     HandlingEventFactory handlingEventFactory = new HandlingEventFactory(cargoRepository, voyageRepository, locationRepository);
     service = new HandlingEventServiceImpl(handlingEventRepository, applicationEvents, handlingEventFactory);
@@ -51,18 +51,15 @@ public class HandlingEventServiceTest {
 
   @After
   public void tearDown() {
-    verify(cargoRepository, voyageRepository, handlingEventRepository, applicationEvents);
+    verify(handlingEventRepository, times(1)).store(isA(HandlingEvent.class));
+    verify(applicationEvents, times(1)).cargoWasHandled(isA(HandlingEvent.class));
   }
 
   @Test
   public void testRegisterEvent() throws Exception {
-    expect(cargoRepository.find(cargo.trackingId())).andReturn(cargo);
-    expect(voyageRepository.find(CM001.voyageNumber())).andReturn(CM001);
-    expect(locationRepository.find(STOCKHOLM.unLocode())).andReturn(STOCKHOLM);
-    handlingEventRepository.store(isA(HandlingEvent.class));
-    applicationEvents.cargoWasHandled(isA(HandlingEvent.class));
-
-    replay(cargoRepository, voyageRepository, handlingEventRepository, locationRepository, applicationEvents);
+    when(cargoRepository.find(cargo.trackingId())).thenReturn(cargo);
+    when(voyageRepository.find(CM001.voyageNumber())).thenReturn(CM001);
+    when(locationRepository.find(STOCKHOLM.unLocode())).thenReturn(STOCKHOLM);
 
     service.registerHandlingEvent(new Date(), cargo.trackingId(), CM001.voyageNumber(), STOCKHOLM.unLocode(), HandlingEvent.Type.LOAD);
   }

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

@@ -2,10 +2,8 @@ package se.citerus.dddsample.domain.model.handling;
 
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.fail;
-import static org.easymock.EasyMock.createMock;
-import static org.easymock.EasyMock.expect;
-import static org.easymock.EasyMock.replay;
-import static org.easymock.EasyMock.verify;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
 import static se.citerus.dddsample.domain.model.handling.HandlingEvent.Type;
 import static se.citerus.dddsample.domain.model.location.SampleLocations.HELSINKI;
 import static se.citerus.dddsample.domain.model.location.SampleLocations.STOCKHOLM;
@@ -14,7 +12,6 @@ import static se.citerus.dddsample.domain.model.voyage.SampleVoyages.CM001;
 
 import java.util.Date;
 
-import org.junit.After;
 import org.junit.Before;
 import org.junit.Test;
 
@@ -32,23 +29,21 @@ import se.citerus.dddsample.infrastructure.persistence.inmemory.VoyageRepository
 
 public class HandlingEventFactoryTest {
 
-  HandlingEventFactory factory;
-  CargoRepository cargoRepository;
-  VoyageRepository voyageRepository;
-  LocationRepository locationRepository;
-  TrackingId trackingId;
-  Cargo cargo;
+  private HandlingEventFactory factory;
+  private CargoRepository cargoRepository;
+  private VoyageRepository voyageRepository;
+  private LocationRepository locationRepository;
+  private TrackingId trackingId;
+  private Cargo cargo;
 
   @Before
   public void setUp() {
 
-    cargoRepository = createMock(CargoRepository.class);
+    cargoRepository = mock(CargoRepository.class);
     voyageRepository = new VoyageRepositoryInMem();
     locationRepository = new LocationRepositoryInMem();
     factory = new HandlingEventFactory(cargoRepository, voyageRepository, locationRepository);
 
-
-
     trackingId = new TrackingId("ABC");
     RouteSpecification routeSpecification = new RouteSpecification(TOKYO, HELSINKI, new Date());
     cargo = new Cargo(trackingId, routeSpecification);
@@ -56,9 +51,7 @@ public class HandlingEventFactoryTest {
 
   @Test
   public void testCreateHandlingEventWithCarrierMovement() throws Exception {
-    expect(cargoRepository.find(trackingId)).andReturn(cargo);
-
-    replay(cargoRepository);
+    when(cargoRepository.find(trackingId)).thenReturn(cargo);
 
     VoyageNumber voyageNumber = CM001.voyageNumber();
     UnLocode unLocode = STOCKHOLM.unLocode();
@@ -76,9 +69,7 @@ public class HandlingEventFactoryTest {
 
   @Test
   public void testCreateHandlingEventWithoutCarrierMovement() throws Exception {
-    expect(cargoRepository.find(trackingId)).andReturn(cargo);
-
-    replay(cargoRepository);
+    when(cargoRepository.find(trackingId)).thenReturn(cargo);
 
     UnLocode unLocode = STOCKHOLM.unLocode();
     HandlingEvent handlingEvent = factory.createHandlingEvent(
@@ -95,9 +86,7 @@ public class HandlingEventFactoryTest {
 
   @Test
   public void testCreateHandlingEventUnknownLocation() throws Exception {
-    expect(cargoRepository.find(trackingId)).andReturn(cargo);
-
-    replay(cargoRepository);
+    when(cargoRepository.find(trackingId)).thenReturn(cargo);
 
     UnLocode invalid = new UnLocode("NOEXT");
     try {
@@ -110,9 +99,7 @@ public class HandlingEventFactoryTest {
 
   @Test
   public void testCreateHandlingEventUnknownCarrierMovement() throws Exception {
-    expect(cargoRepository.find(trackingId)).andReturn(cargo);
-
-    replay(cargoRepository);
+    when(cargoRepository.find(trackingId)).thenReturn(cargo);
 
     try {
       VoyageNumber invalid = new VoyageNumber("XXX");
@@ -125,9 +112,7 @@ public class HandlingEventFactoryTest {
 
   @Test
   public void testCreateHandlingEventUnknownTrackingId() throws Exception {
-    expect(cargoRepository.find(trackingId)).andReturn(null);
-
-    replay(cargoRepository);
+    when(cargoRepository.find(trackingId)).thenReturn(null);
 
     try {
       factory.createHandlingEvent(
@@ -137,8 +122,4 @@ public class HandlingEventFactoryTest {
     } catch (UnknownCargoException expected) {}
   }
 
-  @After
-  public void tearDown() {
-    verify(cargoRepository);
-  }
 }

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

@@ -1,33 +1,11 @@
 package se.citerus.dddsample.infrastructure.routing;
 
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.easymock.EasyMock.createMock;
-import static org.easymock.EasyMock.expect;
-import static org.easymock.EasyMock.isA;
-import static org.easymock.EasyMock.replay;
-import static org.easymock.EasyMock.verify;
-import static se.citerus.dddsample.domain.model.location.SampleLocations.GOTHENBURG;
-import static se.citerus.dddsample.domain.model.location.SampleLocations.HELSINKI;
-import static se.citerus.dddsample.domain.model.location.SampleLocations.HONGKONG;
-import static se.citerus.dddsample.domain.model.location.SampleLocations.STOCKHOLM;
-import static se.citerus.dddsample.domain.model.location.SampleLocations.TOKYO;
-
-import java.util.Arrays;
-import java.util.Date;
-import java.util.List;
-
-import org.junit.Before;
-import org.junit.Test;
-
 import com.pathfinder.api.GraphTraversalService;
 import com.pathfinder.internal.GraphDAOStub;
 import com.pathfinder.internal.GraphTraversalServiceImpl;
-
-import se.citerus.dddsample.domain.model.cargo.Cargo;
-import se.citerus.dddsample.domain.model.cargo.Itinerary;
-import se.citerus.dddsample.domain.model.cargo.Leg;
-import se.citerus.dddsample.domain.model.cargo.RouteSpecification;
-import se.citerus.dddsample.domain.model.cargo.TrackingId;
+import org.junit.Before;
+import org.junit.Test;
+import se.citerus.dddsample.domain.model.cargo.*;
 import se.citerus.dddsample.domain.model.location.Location;
 import se.citerus.dddsample.domain.model.location.LocationRepository;
 import se.citerus.dddsample.domain.model.voyage.SampleVoyages;
@@ -35,6 +13,16 @@ import se.citerus.dddsample.domain.model.voyage.VoyageNumber;
 import se.citerus.dddsample.domain.model.voyage.VoyageRepository;
 import se.citerus.dddsample.infrastructure.persistence.inmemory.LocationRepositoryInMem;
 
+import java.util.Arrays;
+import java.util.Date;
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.Matchers.isA;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+import static se.citerus.dddsample.domain.model.location.SampleLocations.*;
+
 public class ExternalRoutingServiceTest {
 
   private ExternalRoutingService externalRoutingService;
@@ -46,7 +34,7 @@ public class ExternalRoutingServiceTest {
     LocationRepository locationRepository = new LocationRepositoryInMem();
     externalRoutingService.setLocationRepository(locationRepository);
 
-    voyageRepository = createMock(VoyageRepository.class);
+    voyageRepository = mock(VoyageRepository.class);
     externalRoutingService.setVoyageRepository(voyageRepository);
 
     GraphTraversalService graphTraversalService = new GraphTraversalServiceImpl(new GraphDAOStub() {
@@ -67,9 +55,7 @@ public class ExternalRoutingServiceTest {
     RouteSpecification routeSpecification = new RouteSpecification(HONGKONG, HELSINKI, new Date());
     Cargo cargo = new Cargo(trackingId, routeSpecification);
 
-    expect(voyageRepository.find(isA(VoyageNumber.class))).andStubReturn(SampleVoyages.CM002);
-    
-    replay(voyageRepository);
+    when(voyageRepository.find(isA(VoyageNumber.class))).thenReturn(SampleVoyages.CM002);
 
     List<Itinerary> candidates = externalRoutingService.fetchRoutesForSpecification(routeSpecification);
     assertThat(candidates).isNotNull();
@@ -91,8 +77,6 @@ public class ExternalRoutingServiceTest {
         assertThat(legs.get(i + 1).loadLocation()).isEqualTo(legs.get(i).unloadLocation());
       }
     }
-
-    verify(voyageRepository);
   }
 
 }

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

@@ -1,9 +1,8 @@
 package se.citerus.dddsample.interfaces.booking.facade.internal.assembler;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.easymock.EasyMock.createMock;
-import static org.easymock.EasyMock.expect;
-import static org.easymock.EasyMock.replay;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
 import static se.citerus.dddsample.domain.model.location.SampleLocations.CHICAGO;
 import static se.citerus.dddsample.domain.model.location.SampleLocations.HONGKONG;
 import static se.citerus.dddsample.domain.model.location.SampleLocations.MELBOURNE;
@@ -68,15 +67,13 @@ public class ItineraryCandidateDTOAssemblerTest {
     legs.add(new LegDTO("CM001", "AAAAA", "BBBBB", new Date(), new Date()));
     legs.add(new LegDTO("CM001", "BBBBB", "CCCCC", new Date(), new Date()));
 
-    final LocationRepository locationRepository = createMock(LocationRepository.class);
-    expect(locationRepository.find(new UnLocode("AAAAA"))).andReturn(HONGKONG);
-    expect(locationRepository.find(new UnLocode("BBBBB"))).andReturn(TOKYO).times(2);
-    expect(locationRepository.find(new UnLocode("CCCCC"))).andReturn(CHICAGO);
+    final LocationRepository locationRepository = mock(LocationRepository.class);
+    when(locationRepository.find(new UnLocode("AAAAA"))).thenReturn(HONGKONG);
+    when(locationRepository.find(new UnLocode("BBBBB"))).thenReturn(TOKYO);
+    when(locationRepository.find(new UnLocode("CCCCC"))).thenReturn(CHICAGO);
 
     final VoyageRepository voyageRepository = new VoyageRepositoryInMem();
 
-    replay(locationRepository);
-
 
     // Tested call
     final Itinerary itinerary = assembler.fromDTO(new RouteCandidateDTO(legs), voyageRepository, locationRepository);