Replace EasyMock with Mockito Change-Id: I86f3487ad38360753afa8386bb23ee8e14e9e19a

diff --git a/BUCK b/BUCK
index e336c73..bd6696e 100644
--- a/BUCK
+++ b/BUCK

@@ -11,6 +11,7 @@
 
 TEST_DEPS = GERRIT_PLUGIN_API + GERRIT_TESTS + DEPS + [
   ':sync-index__plugin',
+  ':mockito',
 ]
 
 gerrit_plugin(
@@ -54,3 +55,30 @@
   license = 'Apache2.0',
   attach_source = False,
 )
+
+maven_jar(
+  name = 'mockito',
+  id = 'org.mockito:mockito-core:2.5.0',
+  sha1 = 'be28d46a52c7f2563580adeca350145e9ce916f8',
+  license = 'MIT',
+  deps = [
+    ':byte-buddy',
+    ':objenesis',
+  ],
+)
+
+maven_jar(
+  name = 'byte-buddy',
+  id = 'net.bytebuddy:byte-buddy:1.5.12',
+  sha1 = 'b1ba1d15f102b36ed43b826488114678d6d413da',
+  license = 'DO_NOT_DISTRIBUTE',
+  attach_source = False,
+)
+
+maven_jar(
+  name = 'objenesis',
+  id = 'org.objenesis:objenesis:2.4',
+  sha1 = '2916b6c96b50c5b3ec4452ed99401db745aabb27',
+  license = 'DO_NOT_DISTRIBUTE',
+  attach_source = False,
+)

diff --git a/src/test/java/com/ericsson/gerrit/plugins/syncindex/ConfigurationTest.java b/src/test/java/com/ericsson/gerrit/plugins/syncindex/ConfigurationTest.java
index fd39331..aab72d3 100644
--- a/src/test/java/com/ericsson/gerrit/plugins/syncindex/ConfigurationTest.java
+++ b/src/test/java/com/ericsson/gerrit/plugins/syncindex/ConfigurationTest.java

@@ -15,41 +15,46 @@
 package com.ericsson.gerrit.plugins.syncindex;
 
 import static com.google.common.truth.Truth.assertThat;
-import static org.easymock.EasyMock.expect;
-
-import org.easymock.EasyMockSupport;
-import org.junit.Before;
-import org.junit.Test;
+import static org.mockito.Mockito.when;
 
 import com.google.gerrit.server.config.PluginConfig;
 import com.google.gerrit.server.config.PluginConfigFactory;
 
-public class ConfigurationTest extends EasyMockSupport {
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnitRunner;
+
+@RunWith(MockitoJUnitRunner.class)
+public class ConfigurationTest {
   private static final String PASS = "fakePass";
   private static final String USER = "fakeUser";
   private static final String URL = "fakeUrl";
   private static final String EMPTY = "";
+  private static final boolean CUSTOM_VALUES = true;
+  private static final boolean DEFAULT_VALUES = false;
   private static final int TIMEOUT = 5000;
   private static final int MAX_TRIES = 5;
   private static final int RETRY_INTERVAL = 1000;
   private static final int THREAD_POOL_SIZE = 1;
 
+  @Mock
   private PluginConfigFactory cfgFactoryMock;
+  @Mock
   private PluginConfig configMock;
   private Configuration configuration;
-  private String pluginName = "sync-index";
+  private String pluginName = "sync-events";
 
   @Before
   public void setUp() throws Exception {
-    configMock = createNiceMock(PluginConfig.class);
-    cfgFactoryMock = createMock(PluginConfigFactory.class);
-    expect(cfgFactoryMock.getFromGerritConfig(pluginName, true))
-        .andStubReturn(configMock);
+    when(cfgFactoryMock.getFromGerritConfig(pluginName, true))
+        .thenReturn(configMock);
   }
 
   @Test
   public void testValuesPresentInGerritConfig() throws Exception {
-    buildMocks(true);
+    buildMocks(CUSTOM_VALUES);
     assertThat(configuration.getUrl()).isEqualTo(URL);
     assertThat(configuration.getUser()).isEqualTo(USER);
     assertThat(configuration.getPassword()).isEqualTo(PASS);
@@ -62,7 +67,7 @@
 
   @Test
   public void testValuesNotPresentInGerritConfig() throws Exception {
-    buildMocks(false);
+    buildMocks(DEFAULT_VALUES);
     assertThat(configuration.getUrl()).isEqualTo(EMPTY);
     assertThat(configuration.getUser()).isEqualTo(EMPTY);
     assertThat(configuration.getPassword()).isEqualTo(EMPTY);
@@ -75,28 +80,28 @@
 
   @Test
   public void testUrlTrailingSlashIsDropped() throws Exception {
-    expect(configMock.getString("url")).andReturn(URL + "/");
-    replayAll();
+    when(configMock.getString("url")).thenReturn(URL + "/");
+
     configuration = new Configuration(cfgFactoryMock, pluginName);
     assertThat(configuration).isNotNull();
     assertThat(configuration.getUrl()).isEqualTo(URL);
   }
 
   private void buildMocks(boolean values) {
-    expect(configMock.getString("url")).andReturn(values ? URL : null);
-    expect(configMock.getString("user")).andReturn(values ? USER : null);
-    expect(configMock.getString("password")).andReturn(values ? PASS : null);
-    expect(configMock.getInt("connectionTimeout", TIMEOUT))
-        .andReturn(values ? TIMEOUT : 0);
-    expect(configMock.getInt("socketTimeout", TIMEOUT))
-        .andReturn(values ? TIMEOUT : 0);
-    expect(configMock.getInt("maxTries", MAX_TRIES))
-        .andReturn(values ? MAX_TRIES : 0);
-    expect(configMock.getInt("retryInterval", RETRY_INTERVAL))
-        .andReturn(values ? RETRY_INTERVAL : 0);
-    expect(configMock.getInt("threadPoolSize", THREAD_POOL_SIZE))
-        .andReturn(values ? THREAD_POOL_SIZE : 0);
-    replayAll();
+    when(configMock.getString("url")).thenReturn(values ? URL : null);
+    when(configMock.getString("user")).thenReturn(values ? USER : null);
+    when(configMock.getString("password")).thenReturn(values ? PASS : null);
+    when(configMock.getInt("connectionTimeout", TIMEOUT))
+        .thenReturn(values ? TIMEOUT : 0);
+    when(configMock.getInt("socketTimeout", TIMEOUT))
+        .thenReturn(values ? TIMEOUT : 0);
+    when(configMock.getInt("maxTries", MAX_TRIES))
+        .thenReturn(values ? MAX_TRIES : 0);
+    when(configMock.getInt("retryInterval", RETRY_INTERVAL))
+        .thenReturn(values ? RETRY_INTERVAL : 0);
+    when(configMock.getInt("threadPoolSize", THREAD_POOL_SIZE))
+        .thenReturn(values ? THREAD_POOL_SIZE : 0);
+
     configuration = new Configuration(cfgFactoryMock, pluginName);
   }
 }

diff --git a/src/test/java/com/ericsson/gerrit/plugins/syncindex/ContextTest.java b/src/test/java/com/ericsson/gerrit/plugins/syncindex/ContextTest.java
index f43439e..a6898b5 100644
--- a/src/test/java/com/ericsson/gerrit/plugins/syncindex/ContextTest.java
+++ b/src/test/java/com/ericsson/gerrit/plugins/syncindex/ContextTest.java

@@ -16,10 +16,10 @@
 
 import static com.google.common.truth.Truth.assertThat;
 
-import org.easymock.EasyMockSupport;
+
 import org.junit.Test;
 
-public class ContextTest extends EasyMockSupport {
+public class ContextTest {
 
   @Test
   public void testInitialValueNotNull() throws Exception {

diff --git a/src/test/java/com/ericsson/gerrit/plugins/syncindex/HttpClientProviderTest.java b/src/test/java/com/ericsson/gerrit/plugins/syncindex/HttpClientProviderTest.java
index 48af47a..68577b8 100644
--- a/src/test/java/com/ericsson/gerrit/plugins/syncindex/HttpClientProviderTest.java
+++ b/src/test/java/com/ericsson/gerrit/plugins/syncindex/HttpClientProviderTest.java

@@ -15,7 +15,7 @@
 package com.ericsson.gerrit.plugins.syncindex;
 
 import static com.google.common.truth.Truth.assertThat;
-import static org.easymock.EasyMock.expect;
+import static org.mockito.Mockito.when;
 
 import com.google.gerrit.lifecycle.LifecycleModule;
 import com.google.inject.Guice;
@@ -23,27 +23,27 @@
 import com.google.inject.Scopes;
 
 import org.apache.http.impl.client.CloseableHttpClient;
-import org.easymock.EasyMockSupport;
 import org.junit.Before;
 import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnitRunner;
 
-public class HttpClientProviderTest extends EasyMockSupport {
+@RunWith(MockitoJUnitRunner.class)
+public class HttpClientProviderTest {
   private static final int TIME_INTERVAL = 1000;
   private static final String EMPTY = "";
 
+  @Mock
   private Configuration config;
 
   @Before
   public void setUp() throws Exception {
-    config = createNiceMock(Configuration.class);
-    expect(config.getUrl()).andReturn(EMPTY).anyTimes();
-    expect(config.getUser()).andReturn(EMPTY).anyTimes();
-    expect(config.getPassword()).andReturn(EMPTY).anyTimes();
-    expect(config.getMaxTries()).andReturn(1).anyTimes();
-    expect(config.getConnectionTimeout()).andReturn(TIME_INTERVAL).anyTimes();
-    expect(config.getSocketTimeout()).andReturn(TIME_INTERVAL).anyTimes();
-    expect(config.getRetryInterval()).andReturn(TIME_INTERVAL).anyTimes();
-    replayAll();
+    when(config.getUrl()).thenReturn(EMPTY);
+    when(config.getUser()).thenReturn(EMPTY);
+    when(config.getPassword()).thenReturn(EMPTY);
+    when(config.getConnectionTimeout()).thenReturn(TIME_INTERVAL);
+    when(config.getSocketTimeout()).thenReturn(TIME_INTERVAL);
   }
 
   @Test

diff --git a/src/test/java/com/ericsson/gerrit/plugins/syncindex/HttpSessionTest.java b/src/test/java/com/ericsson/gerrit/plugins/syncindex/HttpSessionTest.java
index 183f542..f83b499 100644
--- a/src/test/java/com/ericsson/gerrit/plugins/syncindex/HttpSessionTest.java
+++ b/src/test/java/com/ericsson/gerrit/plugins/syncindex/HttpSessionTest.java

@@ -15,26 +15,26 @@
 package com.ericsson.gerrit.plugins.syncindex;
 
 import static com.github.tomakehurst.wiremock.client.WireMock.aResponse;
-import static com.github.tomakehurst.wiremock.client.WireMock.post;
 import static com.github.tomakehurst.wiremock.client.WireMock.delete;
+import static com.github.tomakehurst.wiremock.client.WireMock.post;
 import static com.github.tomakehurst.wiremock.client.WireMock.urlEqualTo;
 import static com.google.common.truth.Truth.assertThat;
-import static org.easymock.EasyMock.expect;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
 
 import com.ericsson.gerrit.plugins.syncindex.IndexResponseHandler.IndexResult;
 import com.github.tomakehurst.wiremock.http.Fault;
 import com.github.tomakehurst.wiremock.junit.WireMockRule;
 import com.github.tomakehurst.wiremock.stubbing.Scenario;
 
-import org.apache.http.impl.client.CloseableHttpClient;
-import org.easymock.EasyMockSupport;
+
 import org.junit.Before;
 import org.junit.ClassRule;
 import org.junit.Test;
 
 import java.net.SocketTimeoutException;
 
-public class HttpSessionTest extends EasyMockSupport {
+public class HttpSessionTest {
   private static final int MAX_TRIES = 3;
   private static final int RETRY_INTERVAL = 250;
   private static final int TIMEOUT = 500;
@@ -51,8 +51,6 @@
   private static final String RETRY_AT_ERROR = "Retry at error";
   private static final String RETRY_AT_DELAY = "Retry at delay";
 
-  private Configuration cfg;
-  private CloseableHttpClient httpClient;
   private HttpSession httpSession;
 
   @ClassRule
@@ -61,18 +59,17 @@
   @Before
   public void setUp() throws Exception {
     String url = "http://localhost:" + wireMockRule.port();
-    cfg = createMock(Configuration.class);
-    expect(cfg.getUrl()).andReturn(url).anyTimes();
-    expect(cfg.getUser()).andReturn("user");
-    expect(cfg.getPassword()).andReturn("pass");
-    expect(cfg.getMaxTries()).andReturn(MAX_TRIES).anyTimes();
-    expect(cfg.getConnectionTimeout()).andReturn(TIMEOUT).anyTimes();
-    expect(cfg.getSocketTimeout()).andReturn(TIMEOUT).anyTimes();
-    expect(cfg.getRetryInterval()).andReturn(RETRY_INTERVAL).anyTimes();
-    replayAll();
-    httpClient = new HttpClientProvider(cfg).get();
-    httpSession = new HttpSession(httpClient, url);
+    Configuration cfg = mock(Configuration.class);
+    when(cfg.getUrl()).thenReturn(url);
+    when(cfg.getUser()).thenReturn("user");
+    when(cfg.getPassword()).thenReturn("pass");
+    when(cfg.getMaxTries()).thenReturn(MAX_TRIES);
+    when(cfg.getConnectionTimeout()).thenReturn(TIMEOUT);
+    when(cfg.getSocketTimeout()).thenReturn(TIMEOUT);
+    when(cfg.getRetryInterval()).thenReturn(RETRY_INTERVAL);
 
+    httpSession =
+        new HttpSession(new HttpClientProvider(cfg).get(), url);
     wireMockRule.resetRequests();
   }
 

diff --git a/src/test/java/com/ericsson/gerrit/plugins/syncindex/IndexEventHandlerTest.java b/src/test/java/com/ericsson/gerrit/plugins/syncindex/IndexEventHandlerTest.java
index 6489602..045aefa 100644
--- a/src/test/java/com/ericsson/gerrit/plugins/syncindex/IndexEventHandlerTest.java
+++ b/src/test/java/com/ericsson/gerrit/plugins/syncindex/IndexEventHandlerTest.java

@@ -15,34 +15,34 @@
 package com.ericsson.gerrit.plugins.syncindex;
 
 import static com.google.common.truth.Truth.assertThat;
-import static org.easymock.EasyMock.anyObject;
-import static org.easymock.EasyMock.expect;
-import static org.easymock.EasyMock.expectLastCall;
-import static org.easymock.EasyMock.reset;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyZeroInteractions;
 
 import com.google.common.util.concurrent.MoreExecutors;
 import com.google.gerrit.reviewdb.client.Change;
-import com.google.gerrit.server.query.change.ChangeData;
+import com.google.gerrit.server.git.WorkQueue.Executor;
 import com.google.gwtorm.client.KeyUtil;
 import com.google.gwtorm.server.StandardKeyEncoder;
 
 import com.ericsson.gerrit.plugins.syncindex.IndexEventHandler.SyncIndexTask;
 
-import org.easymock.EasyMockSupport;
 import org.junit.Before;
 import org.junit.BeforeClass;
 import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnitRunner;
 
-import java.util.concurrent.Executor;
-
-public class IndexEventHandlerTest extends EasyMockSupport {
+@RunWith(MockitoJUnitRunner.class)
+public class IndexEventHandlerTest {
   private static final String PLUGIN_NAME = "sync-index";
   private static final int CHANGE_ID = 1;
 
   private IndexEventHandler indexEventHandler;
-  private Executor poolMock;
-  private RestSession restClientMock;
-  private ChangeData cd;
+  @Mock
+  private RestSession restSessionMock;
   private Change.Id id;
 
   @BeforeClass
@@ -52,64 +52,50 @@
 
   @Before
   public void setUpMocks() {
-    cd = createNiceMock(ChangeData.class);
     id = Change.Id.parse(Integer.toString(CHANGE_ID));
-    expect(cd.getId()).andReturn(id).anyTimes();
-    poolMock = createMock(Executor.class);
-    poolMock.execute(anyObject(SyncIndexTask.class));
-    expectLastCall().andDelegateTo(MoreExecutors.directExecutor());
-    restClientMock = createMock(RestSession.class);
-    indexEventHandler =
-        new IndexEventHandler(poolMock, PLUGIN_NAME, restClientMock);
+    indexEventHandler = new IndexEventHandler(MoreExecutors.directExecutor(),
+        PLUGIN_NAME, restSessionMock);
   }
 
   @Test
   public void shouldIndexInRemoteOnChangeIndexedEvent() throws Exception {
-    expect(restClientMock.index(CHANGE_ID)).andReturn(true);
-    replayAll();
     indexEventHandler.onChangeIndexed(id.get());
-    verifyAll();
+    verify(restSessionMock).index(CHANGE_ID);
   }
 
   @Test
   public void shouldDeleteFromIndexInRemoteOnChangeDeletedEvent()
       throws Exception {
-    reset(cd);
-    expect(restClientMock.deleteFromIndex(CHANGE_ID)).andReturn(true);
-    replayAll();
     indexEventHandler.onChangeDeleted(id.get());
-    verifyAll();
+    verify(restSessionMock).deleteFromIndex(CHANGE_ID);
   }
 
   @Test
   public void shouldNotCallRemoteWhenEventIsForwarded() throws Exception {
-    reset(poolMock);
-    replayAll();
     Context.setForwardedEvent(true);
     indexEventHandler.onChangeIndexed(id.get());
     indexEventHandler.onChangeDeleted(id.get());
     Context.unsetForwardedEvent();
-    verifyAll();
+    verifyZeroInteractions(restSessionMock);
   }
 
   @Test
   public void duplicateEventOfAQueuedEventShouldGetDiscarded() {
-    reset(poolMock);
-    poolMock.execute(indexEventHandler.new SyncIndexTask(CHANGE_ID, false));
-    expectLastCall().once();
-    replayAll();
+    Executor poolMock = mock(Executor.class);
+    indexEventHandler =
+        new IndexEventHandler(poolMock, PLUGIN_NAME, restSessionMock);
     indexEventHandler.onChangeIndexed(id.get());
     indexEventHandler.onChangeIndexed(id.get());
-    verifyAll();
+    verify(poolMock, times(1))
+        .execute(indexEventHandler.new SyncIndexTask(CHANGE_ID, false));
   }
 
   @Test
   public void testSyncIndexTaskToString() throws Exception {
     SyncIndexTask syncIndexTask =
         indexEventHandler.new SyncIndexTask(CHANGE_ID, false);
-    assertThat(syncIndexTask.toString()).isEqualTo(
-        String.format("[%s] Index change %s in target instance", PLUGIN_NAME,
-            CHANGE_ID));
+    assertThat(syncIndexTask.toString()).isEqualTo(String.format(
+        "[%s] Index change %s in target instance", PLUGIN_NAME, CHANGE_ID));
   }
 
   @Test

diff --git a/src/test/java/com/ericsson/gerrit/plugins/syncindex/IndexResponseHandlerTest.java b/src/test/java/com/ericsson/gerrit/plugins/syncindex/IndexResponseHandlerTest.java
index 595cf7d..46488b7 100644
--- a/src/test/java/com/ericsson/gerrit/plugins/syncindex/IndexResponseHandlerTest.java
+++ b/src/test/java/com/ericsson/gerrit/plugins/syncindex/IndexResponseHandlerTest.java

@@ -15,20 +15,20 @@
 package com.ericsson.gerrit.plugins.syncindex;
 
 import static com.google.common.truth.Truth.assertThat;
-import static org.easymock.EasyMock.expect;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
 
 import com.ericsson.gerrit.plugins.syncindex.IndexResponseHandler.IndexResult;
 
 import org.apache.http.HttpResponse;
 import org.apache.http.StatusLine;
 import org.apache.http.entity.StringEntity;
-import org.easymock.EasyMockSupport;
 import org.junit.Before;
 import org.junit.Test;
 
 import java.io.UnsupportedEncodingException;
 
-public class IndexResponseHandlerTest extends EasyMockSupport {
+public class IndexResponseHandlerTest {
   private static final int ERROR = 400;
   private static final int OK = 204;
   private static final String EMPTY_ENTITY = "";
@@ -59,12 +59,11 @@
 
   private HttpResponse setupMocks(int httpCode, String entity)
       throws UnsupportedEncodingException {
-    StatusLine status = createNiceMock(StatusLine.class);
-    expect(status.getStatusCode()).andReturn(httpCode).anyTimes();
-    HttpResponse response = createNiceMock(HttpResponse.class);
-    expect(response.getStatusLine()).andReturn(status).anyTimes();
-    expect(response.getEntity()).andReturn(new StringEntity(entity)).anyTimes();
-    replayAll();
+    StatusLine status = mock(StatusLine.class);
+    when(status.getStatusCode()).thenReturn(httpCode);
+    HttpResponse response = mock(HttpResponse.class);
+    when(response.getStatusLine()).thenReturn(status);
+    when(response.getEntity()).thenReturn(new StringEntity(entity));
     return response;
   }
 }

diff --git a/src/test/java/com/ericsson/gerrit/plugins/syncindex/ModuleTest.java b/src/test/java/com/ericsson/gerrit/plugins/syncindex/ModuleTest.java
index bfc42b4..f997afa 100644
--- a/src/test/java/com/ericsson/gerrit/plugins/syncindex/ModuleTest.java
+++ b/src/test/java/com/ericsson/gerrit/plugins/syncindex/ModuleTest.java

@@ -15,19 +15,18 @@
 package com.ericsson.gerrit.plugins.syncindex;
 
 import static com.google.common.truth.Truth.assertThat;
-import static org.easymock.EasyMock.expect;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
 
-import org.easymock.EasyMockSupport;
 import org.junit.Test;
 
-public class ModuleTest extends EasyMockSupport {
+public class ModuleTest {
 
   @Test
   public void testSyncUrlProvider() {
-    Configuration configMock = createNiceMock(Configuration.class);
+    Configuration configMock = mock(Configuration.class);
     String expected = "someUrl";
-    expect(configMock.getUrl()).andReturn(expected);
-    replayAll();
+    when(configMock.getUrl()).thenReturn(expected);
     Module module = new Module();
     assertThat(module.syncUrl(configMock)).isEqualTo(expected);
   }

diff --git a/src/test/java/com/ericsson/gerrit/plugins/syncindex/RestSessionTest.java b/src/test/java/com/ericsson/gerrit/plugins/syncindex/RestSessionTest.java
index 31850c2..6f716c4 100644
--- a/src/test/java/com/ericsson/gerrit/plugins/syncindex/RestSessionTest.java
+++ b/src/test/java/com/ericsson/gerrit/plugins/syncindex/RestSessionTest.java

@@ -15,18 +15,19 @@
 package com.ericsson.gerrit.plugins.syncindex;
 
 import static com.google.common.truth.Truth.assertThat;
-import static org.easymock.EasyMock.expect;
+import static org.mockito.Mockito.doThrow;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
 
 import com.google.common.base.Joiner;
 
 import com.ericsson.gerrit.plugins.syncindex.IndexResponseHandler.IndexResult;
 
-import org.easymock.EasyMockSupport;
 import org.junit.Test;
 
 import java.io.IOException;
 
-public class RestSessionTest extends EasyMockSupport {
+public class RestSessionTest {
   private static final int CHANGE_NUMBER = 1;
   private static final String DELETE_OP = "delete";
   private static final String INDEX_OP = "index";
@@ -81,22 +82,21 @@
       String msg, boolean exception) throws Exception {
     String request =
         Joiner.on("/").join("/plugins", PLUGIN_NAME, INDEX_OP, CHANGE_NUMBER);
-    HttpSession httpSession = createNiceMock(HttpSession.class);
+    HttpSession httpSession = mock(HttpSession.class);
     if (exception) {
       if (operation.equals(INDEX_OP)) {
-        expect(httpSession.post(request)).andThrow(new IOException());
+        doThrow(new IOException()).when(httpSession).post(request);
       } else {
-        expect(httpSession.delete(request)).andThrow(new IOException());
+        doThrow(new IOException()).when(httpSession).delete(request);
       }
     } else {
       IndexResult result = new IndexResult(isOperationSuccessful, msg);
       if (operation.equals(INDEX_OP)) {
-        expect(httpSession.post(request)).andReturn(result);
+        when(httpSession.post(request)).thenReturn(result);
       } else {
-        expect(httpSession.delete(request)).andReturn(result);
+        when(httpSession.delete(request)).thenReturn(result);
       }
     }
     restClient = new RestSession(httpSession, PLUGIN_NAME);
-    replayAll();
   }
 }

diff --git a/src/test/java/com/ericsson/gerrit/plugins/syncindex/SyncIndexExecutorProviderTest.java b/src/test/java/com/ericsson/gerrit/plugins/syncindex/SyncIndexExecutorProviderTest.java
index 665b10a..a48dd9b 100644
--- a/src/test/java/com/ericsson/gerrit/plugins/syncindex/SyncIndexExecutorProviderTest.java
+++ b/src/test/java/com/ericsson/gerrit/plugins/syncindex/SyncIndexExecutorProviderTest.java

@@ -15,28 +15,32 @@
 package com.ericsson.gerrit.plugins.syncindex;
 
 import static com.google.common.truth.Truth.assertThat;
-import static org.easymock.EasyMock.expect;
-import static org.easymock.EasyMock.expectLastCall;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
 
 import com.google.gerrit.server.git.WorkQueue;
 
-import org.easymock.EasyMockSupport;
 import org.junit.Before;
 import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnitRunner;
 
-public class SyncIndexExecutorProviderTest extends EasyMockSupport {
+@RunWith(MockitoJUnitRunner.class)
+public class SyncIndexExecutorProviderTest {
+  @Mock
   private WorkQueue.Executor executorMock;
   private SyncIndexExecutorProvider syncIndexExecutorProvider;
 
   @Before
   public void setUp() throws Exception {
-    executorMock = createStrictMock(WorkQueue.Executor.class);
-    WorkQueue workQueueMock = createNiceMock(WorkQueue.class);
-    expect(workQueueMock.createQueue(4, "Sync remote index")).andReturn(
-        executorMock);
-    Configuration configMock = createStrictMock(Configuration.class);
-    expect(configMock.getThreadPoolSize()).andReturn(4);
-    replayAll();
+    executorMock = mock(WorkQueue.Executor.class);
+    WorkQueue workQueueMock = mock(WorkQueue.class);
+    when(workQueueMock.createQueue(4, "Sync remote index"))
+        .thenReturn(executorMock);
+    Configuration configMock = mock(Configuration.class);
+    when(configMock.getThreadPoolSize()).thenReturn(4);
     syncIndexExecutorProvider =
         new SyncIndexExecutorProvider(workQueueMock, configMock);
   }
@@ -48,17 +52,11 @@
 
   @Test
   public void testStop() throws Exception {
-    resetAll();
-    executorMock.shutdown();
-    expectLastCall().once();
-    executorMock.unregisterWorkQueue();
-    expectLastCall().once();
-    replayAll();
-
     syncIndexExecutorProvider.start();
     assertThat(syncIndexExecutorProvider.get()).isEqualTo(executorMock);
     syncIndexExecutorProvider.stop();
-    verifyAll();
+    verify(executorMock).shutdown();
+    verify(executorMock).unregisterWorkQueue();
     assertThat(syncIndexExecutorProvider.get()).isNull();
   }
 }

diff --git a/src/test/java/com/ericsson/gerrit/plugins/syncindex/SyncIndexRestApiServletTest.java b/src/test/java/com/ericsson/gerrit/plugins/syncindex/SyncIndexRestApiServletTest.java
index 3522e77..7e8ac83 100644
--- a/src/test/java/com/ericsson/gerrit/plugins/syncindex/SyncIndexRestApiServletTest.java
+++ b/src/test/java/com/ericsson/gerrit/plugins/syncindex/SyncIndexRestApiServletTest.java

@@ -14,9 +14,15 @@
 
 package com.ericsson.gerrit.plugins.syncindex;
 
+import static javax.servlet.http.HttpServletResponse.SC_CONFLICT;
 import static javax.servlet.http.HttpServletResponse.SC_NOT_FOUND;
-import static org.easymock.EasyMock.expect;
-import static org.easymock.EasyMock.expectLastCall;
+import static javax.servlet.http.HttpServletResponse.SC_NO_CONTENT;
+import static org.mockito.Mockito.doThrow;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyZeroInteractions;
+import static org.mockito.Mockito.when;
 
 import com.google.gerrit.common.TimeUtil;
 import com.google.gerrit.reviewdb.client.Change;
@@ -28,18 +34,20 @@
 import com.google.gwtorm.server.SchemaFactory;
 import com.google.gwtorm.server.StandardKeyEncoder;
 
-import org.easymock.EasyMockSupport;
 import org.junit.Before;
 import org.junit.BeforeClass;
 import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnitRunner;
 
 import java.io.IOException;
 
-import javax.servlet.ServletException;
 import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;
 
-public class SyncIndexRestApiServletTest extends EasyMockSupport {
+@RunWith(MockitoJUnitRunner.class)
+public class SyncIndexRestApiServletTest {
   private static final boolean CHANGE_EXISTS = true;
   private static final boolean CHANGE_DOES_NOT_EXIST = false;
   private static final boolean DO_NOT_THROW_IO_EXCEPTION = false;
@@ -48,12 +56,19 @@
   private static final boolean THROW_ORM_EXCEPTION = true;
   private static final String CHANGE_NUMBER = "1";
 
+  @Mock
   private ChangeIndexer indexer;
+  @Mock
   private SchemaFactory<ReviewDb> schemaFactory;
-  private SyncIndexRestApiServlet syncIndexRestApiServlet;
+  @Mock
+  private ReviewDb db;
+  @Mock
   private HttpServletRequest req;
+  @Mock
   private HttpServletResponse rsp;
   private Change.Id id;
+  private Change change;
+  private SyncIndexRestApiServlet syncIndexRestApiServlet;
 
   @BeforeClass
   public static void setup() {
@@ -61,62 +76,67 @@
   }
 
   @Before
-  @SuppressWarnings("unchecked")
   public void setUpMocks() {
-    indexer = createNiceMock(ChangeIndexer.class);
-    schemaFactory = createNiceMock(SchemaFactory.class);
-    req = createNiceMock(HttpServletRequest.class);
-    rsp = createNiceMock(HttpServletResponse.class);
     syncIndexRestApiServlet =
         new SyncIndexRestApiServlet(indexer, schemaFactory);
     id = Change.Id.parse(CHANGE_NUMBER);
-
-    expect(req.getPathInfo()).andReturn("/index/" + CHANGE_NUMBER);
+    when(req.getPathInfo()).thenReturn("/index/" + CHANGE_NUMBER);
+    change = new Change(null, id, null, null, TimeUtil.nowTs());
   }
 
   @Test
   public void changeIsIndexed() throws Exception {
     setupPostMocks(CHANGE_EXISTS);
-    verifyPost();
+    syncIndexRestApiServlet.doPost(req, rsp);
+    verify(indexer, times(1)).index(db, change);
+    verify(rsp).setStatus(SC_NO_CONTENT);
   }
 
   @Test
   public void changeToIndexDoNotExist() throws Exception {
     setupPostMocks(CHANGE_DOES_NOT_EXIST);
-    verifyPost();
+    syncIndexRestApiServlet.doPost(req, rsp);
+    verify(indexer, times(1)).delete(id);
+    verify(rsp).setStatus(SC_NO_CONTENT);
   }
 
   @Test
   public void schemaThrowsExceptionWhenLookingUpForChange() throws Exception {
     setupPostMocks(CHANGE_EXISTS, THROW_ORM_EXCEPTION);
-    verifyPost();
+    syncIndexRestApiServlet.doPost(req, rsp);
+    verify(rsp).sendError(SC_NOT_FOUND, "Error trying to find a change \n");
   }
 
   @Test
   public void indexerThrowsIOExceptionTryingToIndexChange() throws Exception {
     setupPostMocks(CHANGE_EXISTS, DO_NOT_THROW_ORM_EXCEPTION,
         THROW_IO_EXCEPTION);
-    verifyPost();
+    syncIndexRestApiServlet.doPost(req, rsp);
+    verify(rsp).sendError(SC_CONFLICT, "io-error");
   }
 
   @Test
   public void changeIsDeletedFromIndex() throws Exception {
-    setupDeleteMocks(DO_NOT_THROW_IO_EXCEPTION);
-    verifyDelete();
+    syncIndexRestApiServlet.doDelete(req, rsp);
+    verify(indexer, times(1)).delete(id);
+    verify(rsp).setStatus(SC_NO_CONTENT);
   }
 
   @Test
   public void indexerThrowsExceptionTryingToDeleteChange() throws Exception {
-    setupDeleteMocks(THROW_IO_EXCEPTION);
-    verifyDelete();
+    doThrow(new IOException("io-error")).when(indexer).delete(id);
+    syncIndexRestApiServlet.doDelete(req, rsp);
+    verify(rsp).sendError(SC_CONFLICT, "io-error");
   }
 
   @Test
   public void sendErrorThrowsIOException() throws Exception {
-    rsp.sendError(SC_NOT_FOUND, "Error trying to find a change \n");
-    expectLastCall().andThrow(new IOException("someError"));
+    doThrow(new IOException("someError")).when(rsp).sendError(SC_NOT_FOUND,
+        "Error trying to find a change \n");
     setupPostMocks(CHANGE_EXISTS, THROW_ORM_EXCEPTION);
-    verifyPost();
+    syncIndexRestApiServlet.doPost(req, rsp);
+    verify(rsp).sendError(SC_NOT_FOUND, "Error trying to find a change \n");
+    verifyZeroInteractions(indexer);
   }
 
   private void setupPostMocks(boolean changeExist) throws Exception {
@@ -132,46 +152,19 @@
   private void setupPostMocks(boolean changeExist, boolean ormException,
       boolean ioException) throws OrmException, IOException {
     if (ormException) {
-      expect(schemaFactory.open()).andThrow(new OrmException(""));
+      doThrow(new OrmException("")).when(schemaFactory).open();
     } else {
-      ReviewDb db = createNiceMock(ReviewDb.class);
-      expect(schemaFactory.open()).andReturn(db);
-      ChangeAccess ca = createNiceMock(ChangeAccess.class);
-      expect(db.changes()).andReturn(ca);
-
+      when(schemaFactory.open()).thenReturn(db);
+      ChangeAccess ca = mock(ChangeAccess.class);
+      when(db.changes()).thenReturn(ca);
       if (changeExist) {
-        Change change = new Change(null, id, null, null, TimeUtil.nowTs());
-        expect(ca.get(id)).andReturn(change);
-        indexer.index(db, change);
+        when(ca.get(id)).thenReturn(change);
         if (ioException) {
-          expectLastCall().andThrow(new IOException());
-        } else {
-          expectLastCall().once();
+          doThrow(new IOException("io-error")).when(indexer).index(db, change);
         }
       } else {
-        expect(ca.get(id)).andReturn(null);
+        when(ca.get(id)).thenReturn(null);
       }
     }
-    replayAll();
-  }
-
-  private void verifyPost() throws IOException, ServletException {
-    syncIndexRestApiServlet.doPost(req, rsp);
-    verifyAll();
-  }
-
-  private void setupDeleteMocks(boolean exception) throws IOException {
-    indexer.delete(id);
-    if (exception) {
-      expectLastCall().andThrow(new IOException());
-    } else {
-      expectLastCall().once();
-    }
-    replayAll();
-  }
-
-  private void verifyDelete() throws IOException, ServletException {
-    syncIndexRestApiServlet.doDelete(req, rsp);
-    verifyAll();
   }
 }