diff --git a/BUCK b/BUCK
index 749b4c8..7b55bc0 100644
--- a/BUCK
+++ b/BUCK
@@ -1,5 +1,6 @@
 include_defs('//bucklets/gerrit_plugin.bucklet')
 include_defs('//bucklets/java_sources.bucklet')
+include_defs('//bucklets/maven_jar.bucklet')
 
 SOURCES = glob(['src/main/java/**/*.java'])
 RESOURCES = glob(['src/main/resources/**/*'])
@@ -9,6 +10,7 @@
 ]
 TEST_DEPS = GERRIT_PLUGIN_API + DEPS + GERRIT_TESTS + [
   ':events-log__plugin',
+  ':mockito',
 ]
 
 gerrit_plugin(
@@ -41,3 +43,30 @@
   name = 'events-log-sources',
   srcs = SOURCES + RESOURCES,
 )
+
+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/eventslog/EventHandlerTest.java b/src/test/java/com/ericsson/gerrit/plugins/eventslog/EventHandlerTest.java
index 8a1dbaa..68f1ea4 100644
--- a/src/test/java/com/ericsson/gerrit/plugins/eventslog/EventHandlerTest.java
+++ b/src/test/java/com/ericsson/gerrit/plugins/eventslog/EventHandlerTest.java
@@ -15,55 +15,50 @@
 package com.ericsson.gerrit.plugins.eventslog;
 
 import static com.google.common.truth.Truth.assertThat;
-import static org.easymock.EasyMock.expectLastCall;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyZeroInteractions;
 
-import com.google.gerrit.common.EventListener;
 import com.google.gerrit.server.events.ChangeEvent;
 import com.google.gerrit.server.events.Event;
 
-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;
 
 import java.util.concurrent.ScheduledThreadPoolExecutor;
 
+@RunWith(MockitoJUnitRunner.class)
 public class EventHandlerTest {
-  private EasyMockSupport easyMock = new EasyMockSupport();
+  @Mock
   private EventStore storeMock;
-  private EventListener listener;
-  private ScheduledThreadPoolExecutor poolMock;
+  private EventHandler eventHandler;
 
   @Before
   public void setUp() {
-    storeMock = easyMock.createMock(EventStore.class);
+    ScheduledThreadPoolExecutor poolMock = new PoolMock();
+    eventHandler = new EventHandler(storeMock, poolMock);
   }
 
   @Test
   public void passEventToStore() {
-    ChangeEvent eventMock = easyMock.createNiceMock(ChangeEvent.class);
-    easyMock.resetAll();
-    storeMock.storeEvent(eventMock);
-    expectLastCall().once();
-    easyMock.replayAll();
-    poolMock = new PoolMock(1);
-    listener = new EventHandler(storeMock, poolMock);
-    listener.onEvent(eventMock);
-    easyMock.verifyAll();
+    ChangeEvent eventMock = mock(ChangeEvent.class);
+    eventHandler.onEvent(eventMock);
+    verify(storeMock).storeEvent(eventMock);
   }
 
   @Test
   public void nonProjectEvent() {
-    poolMock = easyMock.createMock(ScheduledThreadPoolExecutor.class);
-    Event eventMock = easyMock.createMock(Event.class);
-    easyMock.replayAll();
-    listener = new EventHandler(storeMock, poolMock);
-    listener.onEvent(eventMock);
-    easyMock.verifyAll();
+    Event eventMock = mock(Event.class);
+    eventHandler.onEvent(eventMock);
+    verifyZeroInteractions(storeMock);
   }
 
   class PoolMock extends ScheduledThreadPoolExecutor {
-    PoolMock(int corePoolSize) {
-      super(corePoolSize);
+    PoolMock() {
+      super(1);
     }
     @Override
     public void execute(Runnable command) {
diff --git a/src/test/java/com/ericsson/gerrit/plugins/eventslog/EventsLogConfigTest.java b/src/test/java/com/ericsson/gerrit/plugins/eventslog/EventsLogConfigTest.java
index d6ae725..a767793 100644
--- a/src/test/java/com/ericsson/gerrit/plugins/eventslog/EventsLogConfigTest.java
+++ b/src/test/java/com/ericsson/gerrit/plugins/eventslog/EventsLogConfigTest.java
@@ -13,6 +13,7 @@
 // limitations under the License.
 
 package com.ericsson.gerrit.plugins.eventslog;
+
 import static com.ericsson.gerrit.plugins.eventslog.EventsLogConfig.CONFIG_CONN_TIME;
 import static com.ericsson.gerrit.plugins.eventslog.EventsLogConfig.CONFIG_COPY_LOCAL;
 import static com.ericsson.gerrit.plugins.eventslog.EventsLogConfig.CONFIG_DRIVER;
@@ -36,91 +37,108 @@
 import static com.ericsson.gerrit.plugins.eventslog.EventsLogConfig.DEFAULT_URL;
 import static com.ericsson.gerrit.plugins.eventslog.EventsLogConfig.DEFAULT_WAIT_TIME;
 import static com.google.common.truth.Truth.assertThat;
-import static org.easymock.EasyMock.expect;
+import static org.mockito.Mockito.when;
 
 import com.google.common.base.Joiner;
 import com.google.gerrit.server.config.PluginConfig;
 import com.google.gerrit.server.config.PluginConfigFactory;
 import com.google.gerrit.server.config.SitePaths;
 
-import org.easymock.EasyMock;
-import org.easymock.EasyMockSupport;
 import org.junit.Before;
 import org.junit.Rule;
 import org.junit.Test;
 import org.junit.rules.TemporaryFolder;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnitRunner;
 
 import java.io.IOException;
 import java.nio.file.Files;
 
+@RunWith(MockitoJUnitRunner.class)
 public class EventsLogConfigTest {
+  private static final String PLUGIN_NAME = "eventsLog";
+  private static final int CUSTOM_EVICT_IDLE_TIME = 10000;
+
   private SitePaths site;
   private EventsLogConfig config;
-  private PluginConfigFactory cfgFactoryMock;
-  private PluginConfig configMock;
-  private EasyMockSupport easyMock;
   private String defaultLocalStorePath;
   private String localStorePath;
-  private String [] urlOptions = new String[]{"a=b", "c=d"};
+  private String[] urlOptions = new String[] {"DB_CLOSE_DELAY=10"};
 
-  private static final int CUSTOM_EVICT_IDLE_TIME = 10000;
+  @Mock
+  private PluginConfigFactory cfgFactoryMock;
+  @Mock
+  private PluginConfig configMock;
 
   @Rule
   public TemporaryFolder gerrit_site = new TemporaryFolder();
 
   @Before
   public void setUp() throws IOException {
-    easyMock = new EasyMockSupport();
     site = new SitePaths(gerrit_site.getRoot().toPath());
     Files.createDirectories(site.etc_dir);
     defaultLocalStorePath = site.site_path.toString() + "/events-db/";
-    configMock = easyMock.createMock(PluginConfig.class);
-    cfgFactoryMock = easyMock.createMock(PluginConfigFactory.class);
-    expect(cfgFactoryMock.getFromGerritConfig(EasyMock.anyString(),
-        EasyMock.anyBoolean())).andStubReturn(configMock);
+    when(cfgFactoryMock.getFromGerritConfig(PLUGIN_NAME, true))
+        .thenReturn(configMock);
   }
 
   private void setUpDefaults() {
-    expect(configMock.getBoolean(CONFIG_COPY_LOCAL, DEFAULT_COPY_LOCAL)).andReturn(DEFAULT_COPY_LOCAL);
-    expect(configMock.getInt(CONFIG_MAX_AGE, DEFAULT_MAX_AGE)).andReturn(DEFAULT_MAX_AGE);
-    expect(configMock.getInt(CONFIG_MAX_TRIES, DEFAULT_MAX_TRIES)).andReturn(DEFAULT_MAX_TRIES);
-    expect(configMock.getInt(CONFIG_RETURN_LIMIT, DEFAULT_RETURN_LIMIT)).andReturn(DEFAULT_RETURN_LIMIT);
-    expect(configMock.getInt(CONFIG_CONN_TIME, DEFAULT_CONN_TIME)).andReturn(DEFAULT_CONN_TIME);
-    expect(configMock.getInt(CONFIG_WAIT_TIME, DEFAULT_WAIT_TIME)).andReturn(DEFAULT_WAIT_TIME);
-    expect(configMock.getString(CONFIG_DRIVER, DEFAULT_DRIVER)).andReturn(DEFAULT_DRIVER);
-    expect(configMock.getString(CONFIG_URL, DEFAULT_URL)).andReturn(DEFAULT_URL);
-    expect(configMock.getString(CONFIG_LOCAL_PATH, defaultLocalStorePath)).andReturn(defaultLocalStorePath);
-    expect(configMock.getStringList(CONFIG_URL_OPTIONS)).andReturn(new String[0]);
-    expect(configMock.getString(CONFIG_USERNAME)).andReturn(null);
-    expect(configMock.getString(CONFIG_PASSWORD)).andReturn(null);
-    expect(configMock.getInt(CONFIG_EVICT_IDLE_TIME, DEFAULT_EVICT_IDLE_TIME)).andReturn(DEFAULT_EVICT_IDLE_TIME);
-
-    easyMock.replayAll();
+    when(configMock.getBoolean(CONFIG_COPY_LOCAL, DEFAULT_COPY_LOCAL))
+        .thenReturn(DEFAULT_COPY_LOCAL);
+    when(configMock.getInt(CONFIG_MAX_AGE, DEFAULT_MAX_AGE))
+        .thenReturn(DEFAULT_MAX_AGE);
+    when(configMock.getInt(CONFIG_MAX_TRIES, DEFAULT_MAX_TRIES))
+        .thenReturn(DEFAULT_MAX_TRIES);
+    when(configMock.getInt(CONFIG_RETURN_LIMIT, DEFAULT_RETURN_LIMIT))
+        .thenReturn(DEFAULT_RETURN_LIMIT);
+    when(configMock.getInt(CONFIG_CONN_TIME, DEFAULT_CONN_TIME))
+        .thenReturn(DEFAULT_CONN_TIME);
+    when(configMock.getInt(CONFIG_WAIT_TIME, DEFAULT_WAIT_TIME))
+        .thenReturn(DEFAULT_WAIT_TIME);
+    when(configMock.getString(CONFIG_DRIVER, DEFAULT_DRIVER))
+        .thenReturn(DEFAULT_DRIVER);
+    when(configMock.getString(CONFIG_URL, DEFAULT_URL)).thenReturn(DEFAULT_URL);
+    when(configMock.getString(CONFIG_LOCAL_PATH, defaultLocalStorePath))
+        .thenReturn(defaultLocalStorePath);
+    when(configMock.getStringList(CONFIG_URL_OPTIONS))
+        .thenReturn(new String[] {});
+    when(configMock.getString(CONFIG_USERNAME)).thenReturn(null);
+    when(configMock.getString(CONFIG_PASSWORD)).thenReturn(null);
+    when(configMock.getInt(CONFIG_EVICT_IDLE_TIME, DEFAULT_EVICT_IDLE_TIME))
+        .thenReturn(DEFAULT_EVICT_IDLE_TIME);
   }
 
   private void setUpCustom() {
     localStorePath = "~/gerrit/events-db/";
-    expect(configMock.getBoolean(CONFIG_COPY_LOCAL, DEFAULT_COPY_LOCAL)).andReturn(true);
-    expect(configMock.getInt(CONFIG_MAX_AGE, DEFAULT_MAX_AGE)).andReturn(20);
-    expect(configMock.getInt(CONFIG_MAX_TRIES, DEFAULT_MAX_TRIES)).andReturn(5);
-    expect(configMock.getInt(CONFIG_RETURN_LIMIT, DEFAULT_RETURN_LIMIT)).andReturn(10000);
-    expect(configMock.getInt(CONFIG_CONN_TIME, DEFAULT_CONN_TIME)).andReturn(5000);
-    expect(configMock.getInt(CONFIG_WAIT_TIME, DEFAULT_WAIT_TIME)).andReturn(5000);
-    expect(configMock.getString(CONFIG_DRIVER, DEFAULT_DRIVER)).andReturn("org.h2.Driver2");
-    expect(configMock.getString(CONFIG_URL, DEFAULT_URL)).andReturn("jdbc:h2:~/gerrit/db");
-    expect(configMock.getString(CONFIG_LOCAL_PATH, defaultLocalStorePath)).andReturn(localStorePath);
-    expect(configMock.getStringList(CONFIG_URL_OPTIONS)).andReturn(urlOptions);
-    expect(configMock.getString(CONFIG_USERNAME)).andReturn("testUsername");
-    expect(configMock.getString(CONFIG_PASSWORD)).andReturn("testPassword");
-    expect(configMock.getInt(CONFIG_EVICT_IDLE_TIME, DEFAULT_EVICT_IDLE_TIME)).andReturn(CUSTOM_EVICT_IDLE_TIME);
+    when(configMock.getBoolean(CONFIG_COPY_LOCAL, DEFAULT_COPY_LOCAL))
+        .thenReturn(true);
+    when(configMock.getInt(CONFIG_MAX_AGE, DEFAULT_MAX_AGE)).thenReturn(20);
+    when(configMock.getInt(CONFIG_MAX_TRIES, DEFAULT_MAX_TRIES)).thenReturn(5);
+    when(configMock.getInt(CONFIG_RETURN_LIMIT, DEFAULT_RETURN_LIMIT))
+        .thenReturn(10000);
+    when(configMock.getInt(CONFIG_CONN_TIME, DEFAULT_CONN_TIME))
+        .thenReturn(5000);
+    when(configMock.getInt(CONFIG_WAIT_TIME, DEFAULT_WAIT_TIME))
+        .thenReturn(5000);
+    when(configMock.getString(CONFIG_DRIVER, DEFAULT_DRIVER))
+        .thenReturn("org.h2.Driver2");
+    when(configMock.getString(CONFIG_URL, DEFAULT_URL))
+        .thenReturn("jdbc:h2:~/gerrit/db");
+    when(configMock.getString(CONFIG_LOCAL_PATH, defaultLocalStorePath))
+        .thenReturn(localStorePath);
+    when(configMock.getStringList(CONFIG_URL_OPTIONS)).thenReturn(urlOptions);
+    when(configMock.getString(CONFIG_USERNAME)).thenReturn("testUsername");
+    when(configMock.getString(CONFIG_PASSWORD)).thenReturn("testPassword");
+    when(configMock.getInt(CONFIG_EVICT_IDLE_TIME, DEFAULT_EVICT_IDLE_TIME))
+        .thenReturn(CUSTOM_EVICT_IDLE_TIME);
 
-    easyMock.replayAll();
   }
 
   @Test
   public void shouldReturnDefaultsWhenMissingConfig() {
     setUpDefaults();
-    config = new EventsLogConfig(cfgFactoryMock, site, null);
+    config = new EventsLogConfig(cfgFactoryMock, site, PLUGIN_NAME);
     assertThat(config.getCopyLocal()).isFalse();
     assertThat(config.getMaxAge()).isEqualTo(30);
     assertThat(config.getMaxTries()).isEqualTo(3);
@@ -128,7 +146,8 @@
     assertThat(config.getConnectTime()).isEqualTo(1000);
     assertThat(config.getWaitTime()).isEqualTo(1000);
     assertThat(config.getLocalStoreDriver()).isEqualTo(DEFAULT_DRIVER);
-    assertThat(config.getLocalStorePath().toString() + "/").isEqualTo(defaultLocalStorePath);
+    assertThat(config.getLocalStorePath().toString() + "/")
+        .isEqualTo(defaultLocalStorePath);
     assertThat(config.getStoreDriver()).isEqualTo(DEFAULT_DRIVER);
     assertThat(config.getStoreUrl()).isEqualTo(DEFAULT_URL);
     assertThat(config.getUrlOptions()).isEmpty();
@@ -140,7 +159,7 @@
   @Test
   public void shouldReturnConfigValues() {
     setUpCustom();
-    config = new EventsLogConfig(cfgFactoryMock, site, null);
+    config = new EventsLogConfig(cfgFactoryMock, site, PLUGIN_NAME);
     assertThat(config.getCopyLocal()).isTrue();
     assertThat(config.getMaxAge()).isEqualTo(20);
     assertThat(config.getMaxTries()).isEqualTo(5);
@@ -148,10 +167,12 @@
     assertThat(config.getConnectTime()).isEqualTo(5000);
     assertThat(config.getWaitTime()).isEqualTo(5000);
     assertThat(config.getLocalStoreDriver()).isEqualTo(DEFAULT_DRIVER);
-    assertThat(config.getLocalStorePath().toString() + "/").isEqualTo(localStorePath);
+    assertThat(config.getLocalStorePath().toString() + "/")
+        .isEqualTo(localStorePath);
     assertThat(config.getStoreDriver()).isEqualTo("org.h2.Driver2");
     assertThat(config.getStoreUrl()).isEqualTo("jdbc:h2:~/gerrit/db");
-    assertThat(config.getUrlOptions()).isEqualTo(Joiner.on(";").join(urlOptions));
+    assertThat(config.getUrlOptions())
+        .isEqualTo(Joiner.on(";").join(urlOptions));
     assertThat(config.getStoreUsername()).isEqualTo("testUsername");
     assertThat(config.getStorePassword()).isEqualTo("testPassword");
     assertThat(config.getEvictIdleTime()).isEqualTo(CUSTOM_EVICT_IDLE_TIME);
diff --git a/src/test/java/com/ericsson/gerrit/plugins/eventslog/EventsLogIT.java b/src/test/java/com/ericsson/gerrit/plugins/eventslog/EventsLogIT.java
index 9bb2834..45391c0 100644
--- a/src/test/java/com/ericsson/gerrit/plugins/eventslog/EventsLogIT.java
+++ b/src/test/java/com/ericsson/gerrit/plugins/eventslog/EventsLogIT.java
@@ -16,23 +16,15 @@
 
 import static com.google.common.truth.Truth.assertThat;
 
+import com.google.gerrit.acceptance.GerritConfig;
 import com.google.gerrit.acceptance.PluginDaemonTest;
 
-import org.eclipse.jgit.errors.ConfigInvalidException;
 import org.junit.Test;
 
-import java.io.IOException;
-
 public class EventsLogIT extends PluginDaemonTest {
 
-  @Override
-  protected void beforeTestServerStarts() throws IOException,
-      ConfigInvalidException {
-    // otherwise default ~/db not deleted after => corrupted next test/run
-    setPluginConfigString("storeUrl", "jdbc:h2:" + testSite + "/db/");
-  }
-
   @Test
+  @GerritConfig(name = "plugin.events-log.storeUrl", value = "jdbc:h2:mem:db")
   public void getEventsShallBeConsistent() throws Exception {
     String events = "/plugins/events-log/events/?t1=1970-01-01;t2=2999-01-01";
     String change1 = "refs/changes/01/1/1";
diff --git a/src/test/java/com/ericsson/gerrit/plugins/eventslog/EventsRestApiServletTest.java b/src/test/java/com/ericsson/gerrit/plugins/eventslog/EventsRestApiServletTest.java
index 3af1bfa..1dcb53a 100644
--- a/src/test/java/com/ericsson/gerrit/plugins/eventslog/EventsRestApiServletTest.java
+++ b/src/test/java/com/ericsson/gerrit/plugins/eventslog/EventsRestApiServletTest.java
@@ -15,143 +15,112 @@
 package com.ericsson.gerrit.plugins.eventslog;
 
 import static com.google.common.truth.Truth.assertThat;
-import static org.easymock.EasyMock.newCapture;
-import static org.easymock.EasyMock.capture;
-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.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+import com.google.gerrit.server.CurrentUser;
+import com.google.inject.Provider;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Captor;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnitRunner;
 
 import java.io.PrintWriter;
 import java.util.ArrayList;
-import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 
 import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;
 
-import org.easymock.Capture;
-import org.easymock.EasyMock;
-import org.easymock.EasyMockSupport;
-import org.junit.Before;
-import org.junit.Test;
-
-import com.google.gerrit.server.CurrentUser;
-import com.google.inject.Provider;
-
-import com.ericsson.gerrit.plugins.eventslog.EventsRestApiServlet;
-import com.ericsson.gerrit.plugins.eventslog.EventStore;
-import com.ericsson.gerrit.plugins.eventslog.MalformedQueryException;
-import com.ericsson.gerrit.plugins.eventslog.QueryMaker;
-
+@RunWith(MockitoJUnitRunner.class)
 public class EventsRestApiServletTest {
-  private EasyMockSupport easyMock;
+  private static final String RANDOM_QUERY = "random query";
+
+  @Mock
   private EventStore storeMock;
+  @Mock
   private QueryMaker queryMakerMock;
+  @Mock
   private Provider<CurrentUser> userProviderMock;
+  @Mock
   private CurrentUser userMock;
+  @Mock
   private HttpServletRequest reqMock;
+  @Mock
   private HttpServletResponse rspMock;
+  @Captor
+  private ArgumentCaptor<Map<String, String>> captor;
+
   private EventsRestApiServlet eventServlet;
 
-  @SuppressWarnings("unchecked")
   @Before
   public void setUp() {
-    easyMock = new EasyMockSupport();
-    storeMock = easyMock.createNiceMock(EventStore.class);
-    queryMakerMock = easyMock.createNiceMock(QueryMaker.class);
-    userProviderMock = easyMock.createNiceMock(Provider.class);
-    userMock = easyMock.createNiceMock(CurrentUser.class);
-    reqMock = easyMock.createNiceMock(HttpServletRequest.class);
-    rspMock = easyMock.createNiceMock(HttpServletResponse.class);
-    easyMock.replayAll();
-    eventServlet = new EventsRestApiServlet(storeMock, queryMakerMock,
-        userProviderMock);
+    eventServlet =
+        new EventsRestApiServlet(storeMock, queryMakerMock, userProviderMock);
+
+    when(userProviderMock.get()).thenReturn(userMock);
+    when(userMock.isIdentifiedUser()).thenReturn(true);
   }
 
   @Test
   public void queryStringSplitting() throws Exception {
-    String queryStringMock = "a=1;b=2";
-    Map<String, String> paramMock = new HashMap<>();
-    paramMock.put("a", "1");
-    paramMock.put("b", "2");
-    Capture<Map<String, String>> catcher = newCapture();
-    easyMock.resetAll();
-    expect(userProviderMock.get()).andStubReturn(userMock);
-    expect(userMock.isIdentifiedUser()).andStubReturn(true);
-    expect(reqMock.getQueryString()).andStubReturn(queryStringMock);
-    expect(queryMakerMock.formQueryFromRequestParameters(capture(catcher)))
-      .andStubReturn("random query");
-    expect(storeMock.queryChangeEvents("random query")).andStubReturn(
-        new ArrayList<String>());
-    easyMock.replayAll();
+    when(reqMock.getQueryString()).thenReturn("a=1;b=2");
+    when(queryMakerMock.formQueryFromRequestParameters(captor.capture()))
+        .thenReturn(RANDOM_QUERY);
+    when(storeMock.queryChangeEvents(RANDOM_QUERY))
+        .thenReturn(new ArrayList<String>());
     eventServlet.doGet(reqMock, rspMock);
-    Map<String, String> capturedParam = catcher.getValue();
-    assertThat(paramMock).isEqualTo(capturedParam);
+    assertThat(ImmutableMap.of("a", "1", "b", "2"))
+        .isEqualTo(captor.getValue());
   }
 
   @Test
   public void badQueryString() throws Exception {
-    String queryStringMock = "a;b";
-    Capture<Map<String, String>> catcher = newCapture();
-    easyMock.resetAll();
-    expect(userProviderMock.get()).andStubReturn(userMock);
-    expect(userMock.isIdentifiedUser()).andStubReturn(true);
-    expect(reqMock.getQueryString()).andStubReturn(queryStringMock);
-    expect(queryMakerMock.formQueryFromRequestParameters(capture(catcher)))
-      .andStubReturn("random query");
-    expect(storeMock.queryChangeEvents("random query")).andStubReturn(
-        new ArrayList<String>());
-    easyMock.replayAll();
+    when(reqMock.getQueryString()).thenReturn("a;b");
+    when(queryMakerMock.formQueryFromRequestParameters(captor.capture()))
+        .thenReturn(RANDOM_QUERY);
+    when(storeMock.queryChangeEvents(RANDOM_QUERY))
+        .thenReturn(new ArrayList<String>());
     eventServlet.doGet(reqMock, rspMock);
-    Map<String, String> capturedParam = catcher.getValue();
-    assertThat(capturedParam).isEmpty();
+    assertThat(captor.getValue()).isEmpty();
   }
 
   @Test
   public void testUnAuthorizedCode() throws Exception {
-    easyMock.resetAll();
-    expect(userProviderMock.get()).andStubReturn(userMock);
-    expect(userMock.isIdentifiedUser()).andStubReturn(false);
-    rspMock.sendError(HttpServletResponse.SC_UNAUTHORIZED);
-    expectLastCall().once();
-    easyMock.replayAll();
+    when(userMock.isIdentifiedUser()).thenReturn(false);
     eventServlet.doGet(reqMock, rspMock);
-    easyMock.verifyAll();
+    verify(rspMock).sendError(HttpServletResponse.SC_UNAUTHORIZED);
   }
 
   @Test
   public void testBadRequestCode() throws Exception {
-    easyMock.resetAll();
-    expect(userProviderMock.get()).andStubReturn(userMock);
-    expect(userMock.isIdentifiedUser()).andStubReturn(true);
-    expect(queryMakerMock.formQueryFromRequestParameters(
-        EasyMock.<Map<String, String>> anyObject())).andStubThrow(
-            new MalformedQueryException());
-    rspMock.sendError(HttpServletResponse.SC_BAD_REQUEST);
-    expectLastCall().once();
-    easyMock.replayAll();
+    when(reqMock.getQueryString()).thenReturn("@@");
+    Map<String, String> emptyParams = ImmutableMap.of();
+    when(queryMakerMock.formQueryFromRequestParameters(emptyParams))
+        .thenThrow(new MalformedQueryException());
     eventServlet.doGet(reqMock, rspMock);
-    easyMock.verifyAll();
+    verify(rspMock).sendError(HttpServletResponse.SC_BAD_REQUEST);
   }
 
   @Test
   public void queryDatabaseAndWrite() throws Exception {
-    PrintWriter outMock = easyMock.createMock(PrintWriter.class);
-    List<String> listMock = new ArrayList<>();
-    listMock.add("event one");
-    listMock.add("event two");
-    easyMock.resetAll();
-    expect(userProviderMock.get()).andStubReturn(userMock);
-    expect(userMock.isIdentifiedUser()).andStubReturn(true);
-    expect(rspMock.getWriter()).andStubReturn(outMock);
-    expect(storeMock.queryChangeEvents(EasyMock.anyString())).andReturn(
-        listMock);
-    outMock.write(listMock.get(0) + "\n");
-    expectLastCall().once();
-    outMock.write(listMock.get(1) + "\n");
-    expectLastCall().once();
-    easyMock.replayAll();
+    when(reqMock.getQueryString()).thenReturn("@@");
+    PrintWriter outMock = mock(PrintWriter.class);
+    List<String> listMock = ImmutableList.of("event one", "event two");
+    when(rspMock.getWriter()).thenReturn(outMock);
+    when(queryMakerMock.formQueryFromRequestParameters(captor.capture()))
+        .thenReturn(RANDOM_QUERY);
+    when(storeMock.queryChangeEvents(RANDOM_QUERY)).thenReturn(listMock);
     eventServlet.doGet(reqMock, rspMock);
-    easyMock.verifyAll();
+    verify(outMock).write(listMock.get(0) + "\n");
+    verify(outMock).write(listMock.get(1) + "\n");
   }
 }
diff --git a/src/test/java/com/ericsson/gerrit/plugins/eventslog/sql/QueryMakerTest.java b/src/test/java/com/ericsson/gerrit/plugins/eventslog/sql/QueryMakerTest.java
index 9d606df..4094b23 100644
--- a/src/test/java/com/ericsson/gerrit/plugins/eventslog/sql/QueryMakerTest.java
+++ b/src/test/java/com/ericsson/gerrit/plugins/eventslog/sql/QueryMakerTest.java
@@ -15,106 +15,98 @@
 package com.ericsson.gerrit.plugins.eventslog.sql;
 
 import static com.google.common.truth.Truth.assertThat;
-import static org.easymock.EasyMock.expect;
+import static org.mockito.Mockito.when;
+
+import com.google.common.collect.ImmutableMap;
 
 import com.ericsson.gerrit.plugins.eventslog.EventsLogConfig;
 import com.ericsson.gerrit.plugins.eventslog.MalformedQueryException;
 import com.ericsson.gerrit.plugins.eventslog.QueryMaker;
-import com.ericsson.gerrit.plugins.eventslog.sql.SQLQueryMaker;
 
-import org.easymock.EasyMockSupport;
-import org.junit.BeforeClass;
+import org.junit.Before;
 import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnitRunner;
 
-import java.util.HashMap;
-import java.util.Map;
-
+@RunWith(MockitoJUnitRunner.class)
 public class QueryMakerTest {
-  private static QueryMaker queryMaker;
-  private static String defaultQuery;
+  private static final String T2 = "t2";
+  private static final String T1 = "t1";
+  private static final String OLD_DATE = "2013-10-10 10:00:00";
+  private static final String NEW_DATE = "2014-10-10 10:00:00";
 
-  @BeforeClass
-  public static void setUp() throws Exception {
-    EasyMockSupport easyMock = new EasyMockSupport();
-    EventsLogConfig cfgMock = easyMock.createMock(EventsLogConfig.class);
-    expect(cfgMock.getReturnLimit()).andReturn(10);
-    easyMock.replayAll();
+  private QueryMaker queryMaker;
+  private String defaultQuery;
+
+  @Mock
+  private EventsLogConfig cfgMock;
+
+  private String query;
+
+  @Before
+  public void setUp() throws Exception {
+    when(cfgMock.getReturnLimit()).thenReturn(10);
     queryMaker = new SQLQueryMaker(cfgMock);
     defaultQuery = queryMaker.getDefaultQuery();
   }
 
   @Test
-  public void returnDefaultforNullMap() throws Exception {
-    assertThat(queryMaker.formQueryFromRequestParameters(null)).isEqualTo(defaultQuery);
+  public void returnDefaultQueryforNullMap() throws Exception {
+    assertThat(queryMaker.formQueryFromRequestParameters(null))
+        .isEqualTo(defaultQuery);
   }
 
   @Test(expected = MalformedQueryException.class)
   public void badParameters() throws Exception {
-    Map<String, String> params = new HashMap<>();
-    params.put("t1", "bad format");
-    params.put("t2", "bad format");
-    queryMaker.formQueryFromRequestParameters(params);
+    queryMaker.formQueryFromRequestParameters(
+        ImmutableMap.of(T1, "13/13/32", T2, "14/10/10"));
   }
 
   @Test
   public void dateOneOnly() throws Exception {
-    Map<String, String> params = new HashMap<>();
-    String oldDate = "1990-10-10 10:00:00";
-    params.put("t1", oldDate);
-    String query = queryMaker.formQueryFromRequestParameters(params);
-    assertThat(query).contains(String.format("'%s' and ", oldDate));
+    query = queryMaker
+        .formQueryFromRequestParameters(ImmutableMap.of(T1, OLD_DATE));
+    assertThat(query).contains(String.format("'%s' and ", OLD_DATE));
   }
 
   @Test
   public void dateTwoOnly() throws Exception {
-    Map<String, String> params = new HashMap<>();
-    String oldDate = "1990-10-10 10:00:00";
-    params.put("t2", oldDate);
-    String query = queryMaker.formQueryFromRequestParameters(params);
-    assertThat(query).contains(String.format("'%s' and ", oldDate));
+    query = queryMaker
+        .formQueryFromRequestParameters(ImmutableMap.of(T2, OLD_DATE));
+    assertThat(query).contains(String.format("'%s' and ", OLD_DATE));
   }
 
   @Test(expected = MalformedQueryException.class)
   public void noDate() throws Exception {
-    Map<String, String> params = new HashMap<>();
-    queryMaker.formQueryFromRequestParameters(params);
+    queryMaker
+        .formQueryFromRequestParameters(ImmutableMap.<String, String> of());
   }
 
   @Test
   public void dateOrdering() throws Exception {
-    String query;
-    Map<String, String> params = new HashMap<>();
-    String olderDate = "2013-10-10 10:00:00";
-    String newerDate = "2014-10-10 10:00:00";
+    query = queryMaker.formQueryFromRequestParameters(
+        ImmutableMap.of(T1, OLD_DATE, T2, NEW_DATE));
+    assertThat(query)
+        .contains(String.format("'%s' and '%s'", OLD_DATE, NEW_DATE));
 
-    params.put("t1", olderDate);
-    params.put("t2", newerDate);
-    query = queryMaker.formQueryFromRequestParameters(params);
-    assertThat(query).contains(String.format("'%s' and '%s'",
-        olderDate, newerDate));
-
-    params.put("t1", newerDate);
-    params.put("t2", olderDate);
-    query = queryMaker.formQueryFromRequestParameters(params);
-    assertThat(query).contains(String.format("'%s' and '%s'",
-        olderDate, newerDate));
+    query = queryMaker.formQueryFromRequestParameters(
+        ImmutableMap.of(T1, NEW_DATE, T2, OLD_DATE));
+    assertThat(query)
+        .contains(String.format("'%s' and '%s'", OLD_DATE, NEW_DATE));
   }
 
   @Test
   public void bothDateTime() throws Exception {
-    Map<String, String> params = new HashMap<>();
-    params.put("t1", "2013-10-10 10:00:00");
-    params.put("t2", "2014-10-10 10:00:00");
-    String query = queryMaker.formQueryFromRequestParameters(params);
+    query = queryMaker.formQueryFromRequestParameters(
+        ImmutableMap.of(T1, OLD_DATE, T2, NEW_DATE));
     assertThat(query).isNotEqualTo(defaultQuery);
   }
 
   @Test
   public void onlyDateNoTime() throws Exception {
-    Map<String, String> params = new HashMap<>();
-    params.put("t1", "2013-10-10");
-    params.put("t2", "2014-10-10");
-    String query = queryMaker.formQueryFromRequestParameters(params);
+    String query = queryMaker.formQueryFromRequestParameters(
+        ImmutableMap.of(T1, "2013-10-10", T2, "2014-10-10"));
     assertThat(query).isNotEqualTo(defaultQuery);
   }
 }
diff --git a/src/test/java/com/ericsson/gerrit/plugins/eventslog/sql/SQLStoreTest.java b/src/test/java/com/ericsson/gerrit/plugins/eventslog/sql/SQLStoreTest.java
index d67ebd2..e506e26 100644
--- a/src/test/java/com/ericsson/gerrit/plugins/eventslog/sql/SQLStoreTest.java
+++ b/src/test/java/com/ericsson/gerrit/plugins/eventslog/sql/SQLStoreTest.java
@@ -16,10 +16,16 @@
 
 import static com.ericsson.gerrit.plugins.eventslog.sql.SQLTable.TABLE_NAME;
 import static com.google.common.truth.Truth.assertThat;
-import static org.easymock.EasyMock.expect;
-import static org.easymock.EasyMock.expectLastCall;
+import static org.mockito.ArgumentMatchers.any;
+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.when;
 
+import com.google.common.collect.ImmutableList;
 import com.google.gerrit.reviewdb.client.Project;
+import com.google.gerrit.reviewdb.client.Project.NameKey;
 import com.google.gerrit.server.CurrentUser;
 import com.google.gerrit.server.events.ProjectEvent;
 import com.google.gerrit.server.project.NoSuchProjectException;
@@ -30,16 +36,14 @@
 import com.ericsson.gerrit.plugins.eventslog.EventsLogConfig;
 import com.ericsson.gerrit.plugins.eventslog.MalformedQueryException;
 import com.ericsson.gerrit.plugins.eventslog.ServiceUnavailableException;
-import com.ericsson.gerrit.plugins.eventslog.sql.SQLClient;
-import com.ericsson.gerrit.plugins.eventslog.sql.SQLEntry;
-import com.ericsson.gerrit.plugins.eventslog.sql.SQLStore;
 
-import org.easymock.EasyMock;
-import org.easymock.EasyMockSupport;
 import org.junit.Before;
 import org.junit.Rule;
 import org.junit.Test;
 import org.junit.rules.TemporaryFolder;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnitRunner;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -50,52 +54,50 @@
 import java.sql.SQLException;
 import java.sql.Statement;
 import java.sql.Timestamp;
-import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.List;
 import java.util.concurrent.ScheduledFuture;
 import java.util.concurrent.ScheduledThreadPoolExecutor;
 import java.util.concurrent.TimeUnit;
 
+@RunWith(MockitoJUnitRunner.class)
 public class SQLStoreTest {
   private static final Logger log = LoggerFactory.getLogger(SQLStoreTest.class);
   private static final String TEST_URL = "jdbc:h2:mem:" + TABLE_NAME;
-  private static final String TEST_LOCAL_URL = "jdbc:h2:mem:test:";
+  private static final String TEST_LOCAL_URL = "jdbc:h2:mem:test";
   private static final String TEST_DRIVER = "org.h2.Driver";
-  private static final String TEST_OPTIONS = "DB_CLOSE_DELAY=-1;DATABASE_TO_UPPER=false";
+  private static final String TEST_OPTIONS =
+      "DB_CLOSE_DELAY=-1;DATABASE_TO_UPPER=false";
   private static final String TERM_CONN_MSG = "terminating connection";
   private static final String MSG = "message";
   private static final String GENERIC_QUERY = "SELECT * FROM " + TABLE_NAME;
+  private static final boolean PROJECT_VISIBLE_TO_USER = true;
+  private static final boolean PROJECT_NOT_VISIBLE_TO_USER = false;
 
-  private EasyMockSupport easyMock;
+  @Mock
   private ProjectControl.GenericFactory pcFactoryMock;
+  @Mock
   private Provider<CurrentUser> userProviderMock;
+  @Mock
   private EventsLogConfig cfgMock;
   private SQLClient eventsDb;
   private SQLClient localEventsDb;
   private SQLStore store;
   private ScheduledThreadPoolExecutor poolMock;
 
-  private String path = TEST_URL + ";" + TEST_OPTIONS;
-  private Connection conn;
   private Statement stat;
-  private List<SQLEntry> results;
 
   @Rule
   public TemporaryFolder testFolder = new TemporaryFolder();
 
-  @SuppressWarnings("unchecked")
   @Before
   public void setUp() throws SQLException {
-    conn = DriverManager.getConnection(path);
+    Connection conn =
+        DriverManager.getConnection(TEST_URL + ";" + TEST_OPTIONS);
     stat = conn.createStatement();
-    results = new ArrayList<>();
-    poolMock = new PoolMock(1);
-    easyMock = new EasyMockSupport();
-    pcFactoryMock = easyMock.createNiceMock(ProjectControl.GenericFactory.class);
-    userProviderMock = easyMock.createNiceMock(Provider.class);
-    cfgMock = easyMock.createNiceMock(EventsLogConfig.class);
-    expect(cfgMock.getMaxAge()).andReturn(5);
-    expect(cfgMock.getLocalStorePath()).andReturn(testFolder.getRoot().toPath()).atLeastOnce();
+    poolMock = new PoolMock();
+    when(cfgMock.getMaxAge()).thenReturn(5);
+    when(cfgMock.getLocalStorePath()).thenReturn(testFolder.getRoot().toPath());
   }
 
   public void tearDown() throws Exception {
@@ -106,76 +108,65 @@
   private void setUpClient() {
     eventsDb = new SQLClient(TEST_DRIVER, TEST_URL, TEST_OPTIONS);
     localEventsDb = new SQLClient(TEST_DRIVER, TEST_LOCAL_URL, TEST_OPTIONS);
-    store =
-        new SQLStore(pcFactoryMock, userProviderMock, cfgMock, eventsDb,
-            localEventsDb, poolMock);
+    store = new SQLStore(pcFactoryMock, userProviderMock, cfgMock, eventsDb,
+        localEventsDb, poolMock);
     store.start();
   }
 
-  private void setUpClientMock(boolean reset) throws SQLException {
-    eventsDb = easyMock.createNiceMock(SQLClient.class);
-    localEventsDb = easyMock.createNiceMock(SQLClient.class);
-    expect(localEventsDb.dbExists()).andReturn(true).anyTimes();
-    if (reset) {
-      easyMock.resetAll();
-    }
+  private void setUpClientMock() throws SQLException {
+    eventsDb = mock(SQLClient.class);
+    localEventsDb = mock(SQLClient.class);
+    when(localEventsDb.dbExists()).thenReturn(true);
   }
 
   @Test
   public void storeThenQueryVisible() throws Exception {
-    MockEvent mockEvent = new MockEvent();
-    ProjectControl pcMock = easyMock.createNiceMock(ProjectControl.class);
-    CurrentUser userMock = easyMock.createNiceMock(CurrentUser.class);
-    expect(userProviderMock.get()).andStubReturn(userMock);
-    expect(pcFactoryMock.controlFor(mockEvent.getProjectNameKey(), userMock))
-        .andStubReturn(pcMock);
-    expect(pcMock.isVisible()).andStubReturn(true);
-    easyMock.replayAll();
-    setUpClient();
+    MockEvent mockEvent = setUpMocks(PROJECT_VISIBLE_TO_USER);
     store.storeEvent(mockEvent);
     List<String> events = store.queryChangeEvents(GENERIC_QUERY);
-    Gson gson = new Gson();
-    String json = gson.toJson(mockEvent);
+    String json = new Gson().toJson(mockEvent);
     assertThat(events).containsExactly(json);
     tearDown();
   }
 
   @Test
   public void storeThenQueryNotVisible() throws Exception {
-    MockEvent mockEvent = new MockEvent();
-    ProjectControl pcMock = easyMock.createNiceMock(ProjectControl.class);
-    CurrentUser userMock = easyMock.createNiceMock(CurrentUser.class);
-    expect(userProviderMock.get()).andStubReturn(userMock);
-    expect(pcFactoryMock.controlFor(mockEvent.getProjectNameKey(), userMock))
-        .andStubReturn(pcMock);
-    expect(pcMock.isVisible()).andStubReturn(false);
-    easyMock.replayAll();
-    setUpClient();
+    MockEvent mockEvent = setUpMocks(PROJECT_NOT_VISIBLE_TO_USER);
     store.storeEvent(mockEvent);
     List<String> events = store.queryChangeEvents(GENERIC_QUERY);
     assertThat(events).isEmpty();
     tearDown();
   }
 
+  private MockEvent setUpMocks(boolean isVisible)
+      throws NoSuchProjectException, IOException {
+    MockEvent mockEvent = new MockEvent();
+    ProjectControl pcMock = mock(ProjectControl.class);
+    CurrentUser userMock = mock(CurrentUser.class);
+    when(userProviderMock.get()).thenReturn(userMock);
+    when(pcFactoryMock.controlFor(mockEvent.getProjectNameKey(), userMock))
+        .thenReturn(pcMock);
+    when(pcMock.isVisible()).thenReturn(isVisible);
+    setUpClient();
+    return mockEvent;
+  }
+
   @Test(expected = MalformedQueryException.class)
   public void throwBadRequestTriggerOnBadQuery() throws Exception {
-    easyMock.replayAll();
     setUpClient();
     String badQuery = "bad query";
     store.queryChangeEvents(badQuery);
-    easyMock.verifyAll();
   }
 
   @Test
   public void notReturnEventOfNonExistingProject() throws Exception {
     MockEvent mockEvent = new MockEvent();
-    Project.NameKey projectMock = easyMock.createMock(Project.NameKey.class);
-    expect(projectMock.get()).andStubReturn(" ");
-    expect(
-        pcFactoryMock.controlFor(EasyMock.anyObject(Project.NameKey.class),
-            EasyMock.anyObject(CurrentUser.class)))
-              .andThrow(new NoSuchProjectException(projectMock));
-    easyMock.replayAll();
+    Project.NameKey projectMock = mock(Project.NameKey.class);
+    CurrentUser userMock = mock(CurrentUser.class);
+    when(userProviderMock.get()).thenReturn(userMock);
+    NameKey projectNameKey = mockEvent.getProjectNameKey();
+    doThrow(new NoSuchProjectException(projectMock)).when(pcFactoryMock)
+        .controlFor(projectNameKey, userMock);
     setUpClient();
     store.storeEvent(mockEvent);
     List<String> events = store.queryChangeEvents(GENERIC_QUERY);
@@ -186,12 +177,11 @@
   @Test
   public void notReturnEventWithNoVisibilityInfo() throws Exception {
     MockEvent mockEvent = new MockEvent();
-    Project.NameKey projectMock = easyMock.createMock(Project.NameKey.class);
-    expect(projectMock.get()).andStubReturn(" ");
-    expect(
-        pcFactoryMock.controlFor(EasyMock.anyObject(Project.NameKey.class),
-            EasyMock.anyObject(CurrentUser.class))).andThrow(new IOException());
-    easyMock.replayAll();
+    CurrentUser userMock = mock(CurrentUser.class);
+    when(userProviderMock.get()).thenReturn(userMock);
+    NameKey projectNameKey = mockEvent.getProjectNameKey();
+    doThrow(new IOException()).when(pcFactoryMock).controlFor(projectNameKey,
+        userMock);
     setUpClient();
     store.storeEvent(mockEvent);
     List<String> events = store.queryChangeEvents(GENERIC_QUERY);
@@ -202,93 +192,78 @@
   @Test
   public void retryOnConnectException() throws Exception {
     MockEvent mockEvent = new MockEvent();
-    setUpClientMock(false);
-    EasyMock.reset(eventsDb, localEventsDb);
-    expect(cfgMock.getMaxTries()).andReturn(3).once();
-    eventsDb.storeEvent(mockEvent);
-    expectLastCall().andThrow(new SQLException(new ConnectException()))
-        .times(3);
-    expect(localEventsDb.getAll()).andStubReturn(results);
-    easyMock.replayAll();
-    store =
-        new SQLStore(pcFactoryMock, userProviderMock, cfgMock, eventsDb,
-            localEventsDb, poolMock);
+    when(cfgMock.getMaxTries()).thenReturn(3);
+    Throwable[] exceptions = new Throwable[3];
+    Arrays.fill(exceptions, new SQLException(new ConnectException()));
+    setUpClientMock();
+    doThrow(exceptions).doNothing().when(eventsDb).storeEvent(mockEvent);
+    doThrow(exceptions).doNothing().when(eventsDb).queryOne();
+    store = new SQLStore(pcFactoryMock, userProviderMock, cfgMock, eventsDb,
+        localEventsDb, poolMock);
     store.start();
-
     store.storeEvent(mockEvent);
-    easyMock.verifyAll();
+    verify(eventsDb, times(3)).storeEvent(mockEvent);
+    verify(localEventsDb).storeEvent(mockEvent);
   }
 
   @Test
   public void retryOnMessage() throws Exception {
     MockEvent mockEvent = new MockEvent();
-    setUpClientMock(false);
-    expect(cfgMock.getMaxTries()).andReturn(3).once();
-    eventsDb.storeEvent(mockEvent);
-    expectLastCall().andThrow(new SQLException(TERM_CONN_MSG)).times(3);
-    expect(localEventsDb.getAll()).andStubReturn(results);
-    easyMock.replayAll();
-    store =
-        new SQLStore(pcFactoryMock, userProviderMock, cfgMock, eventsDb,
-            localEventsDb, poolMock);
+    when(cfgMock.getMaxTries()).thenReturn(3);
+    Throwable[] exceptions = new Throwable[3];
+    Arrays.fill(exceptions, new SQLException(TERM_CONN_MSG));
+    setUpClientMock();
+    doThrow(exceptions).doNothing().when(eventsDb).storeEvent(mockEvent);
+    doThrow(exceptions).doNothing().when(eventsDb).queryOne();
+    store = new SQLStore(pcFactoryMock, userProviderMock, cfgMock, eventsDb,
+        localEventsDb, poolMock);
     store.start();
-
     store.storeEvent(mockEvent);
-    easyMock.verifyAll();
+    verify(eventsDb, times(3)).storeEvent(mockEvent);
+    verify(localEventsDb).storeEvent(mockEvent);
   }
 
   @Test
   public void noRetryOnMessage() throws Exception {
     MockEvent mockEvent = new MockEvent();
-    setUpClientMock(false);
-    expect(cfgMock.getMaxTries()).andReturn(3).once();
-    eventsDb.storeEvent(mockEvent);
-    expectLastCall().andThrow(new SQLException(MSG)).once();
-    expect(localEventsDb.getAll()).andReturn(results);
-    easyMock.replayAll();
-    store =
-        new SQLStore(pcFactoryMock, userProviderMock, cfgMock, eventsDb,
-            localEventsDb, poolMock);
+    when(cfgMock.getMaxTries()).thenReturn(3);
+    setUpClientMock();
+    doThrow(new SQLException(MSG)).when(eventsDb).storeEvent(mockEvent);
+    store = new SQLStore(pcFactoryMock, userProviderMock, cfgMock, eventsDb,
+        localEventsDb, poolMock);
     store.start();
-
     store.storeEvent(mockEvent);
-    easyMock.verifyAll();
+    verify(eventsDb, times(1)).storeEvent(mockEvent);
   }
 
   @Test
   public void noRetryOnZeroMaxTries() throws Exception {
     MockEvent mockEvent = new MockEvent();
-    setUpClientMock(false);
-    expect(cfgMock.getMaxTries()).andReturn(0).once();
-    eventsDb.storeEvent(mockEvent);
-    expectLastCall().andThrow(new SQLException(new ConnectException())).once();
-    expect(localEventsDb.getAll()).andStubReturn(results);
-    easyMock.replayAll();
-    store =
-        new SQLStore(pcFactoryMock, userProviderMock, cfgMock, eventsDb,
-            localEventsDb, poolMock);
+    when(cfgMock.getMaxTries()).thenReturn(0);
+    Throwable[] exceptions = new Throwable[3];
+    Arrays.fill(exceptions, new SQLException(new ConnectException()));
+    setUpClientMock();
+    doThrow(exceptions).doNothing().when(eventsDb).storeEvent(mockEvent);
+    doThrow(exceptions).doNothing().when(eventsDb).queryOne();
+    store = new SQLStore(pcFactoryMock, userProviderMock, cfgMock, eventsDb,
+        localEventsDb, poolMock);
     store.start();
-
     store.storeEvent(mockEvent);
-    easyMock.verifyAll();
+    verify(eventsDb, times(1)).storeEvent(mockEvent);
   }
 
-  @Test (expected = ServiceUnavailableException.class)
+  @Test(expected = ServiceUnavailableException.class)
   public void throwSQLExceptionIfNotOnline() throws Exception {
     MockEvent mockEvent = new MockEvent();
-    setUpClientMock(true);
-    eventsDb.createDBIfNotCreated();
-    expectLastCall().andThrow(new SQLException(new ConnectException())).once();
-    eventsDb.queryOne();
-    expectLastCall().andThrow(new SQLException());
-    easyMock.replayAll();
-    store =
-        new SQLStore(pcFactoryMock, userProviderMock, cfgMock, eventsDb,
-            localEventsDb, poolMock);
+    setUpClientMock();
+    doThrow(new SQLException(new ConnectException())).when(eventsDb)
+        .createDBIfNotCreated();
+    doThrow(new SQLException()).when(eventsDb).queryOne();
+    store = new SQLStore(pcFactoryMock, userProviderMock, cfgMock, eventsDb,
+        localEventsDb, poolMock);
     store.start();
     store.storeEvent(mockEvent);
     store.queryChangeEvents(GENERIC_QUERY);
-    easyMock.verifyAll();
   }
 
   @Test
@@ -297,26 +272,22 @@
     MockEvent mockEvent2 = new MockEvent("proj");
     MockEvent mockEvent3 = new MockEvent("unfound");
 
-    ProjectControl pc = easyMock.createNiceMock(ProjectControl.class);
-    NoSuchProjectException e =
-        easyMock.createNiceMock(NoSuchProjectException.class);
-    expect(
-        pcFactoryMock.controlFor(EasyMock.eq(mockEvent.getProjectNameKey()),
-            EasyMock.anyObject(CurrentUser.class))).andReturn(pc).once();
-    expect(
-        pcFactoryMock.controlFor(EasyMock.eq(mockEvent2.getProjectNameKey()),
-            EasyMock.anyObject(CurrentUser.class))).andReturn(pc).once();
-    expect(pc.isVisible()).andReturn(true).times(2);
-    expect(
-        pcFactoryMock.controlFor(EasyMock.eq(mockEvent3.getProjectNameKey()),
-            EasyMock.anyObject(CurrentUser.class))).andThrow(e);
-    easyMock.replayAll();
+    ProjectControl pc = mock(ProjectControl.class);
+    NoSuchProjectException e = mock(NoSuchProjectException.class);
+    CurrentUser userMock = mock(CurrentUser.class);
+    when(userProviderMock.get()).thenReturn(userMock);
+    when(pcFactoryMock.controlFor((mockEvent.getProjectNameKey()), userMock))
+        .thenReturn(pc);
+    when(pcFactoryMock.controlFor((mockEvent2.getProjectNameKey()), userMock))
+        .thenReturn(pc);
+    when(pc.isVisible()).thenReturn(true);
+    doThrow(e).when(pcFactoryMock).controlFor((mockEvent3.getProjectNameKey()),
+        userMock);
 
     eventsDb = new SQLClient(TEST_DRIVER, TEST_URL, TEST_OPTIONS);
     localEventsDb = new SQLClient(TEST_DRIVER, TEST_LOCAL_URL, TEST_OPTIONS);
-    store =
-        new SQLStore(pcFactoryMock, userProviderMock, cfgMock, eventsDb,
-            localEventsDb, poolMock);
+    store = new SQLStore(pcFactoryMock, userProviderMock, cfgMock, eventsDb,
+        localEventsDb, poolMock);
 
     localEventsDb.createDBIfNotCreated();
     localEventsDb.storeEvent(mockEvent);
@@ -328,61 +299,48 @@
     String json = gson.toJson(mockEvent);
     String json2 = gson.toJson(mockEvent2);
     assertThat(events).containsExactly(json, json2);
-    easyMock.verifyAll();
     tearDown();
   }
 
   @Test
   public void offlineUponStart() throws Exception {
-    setUpClientMock(true);
-    eventsDb.createDBIfNotCreated();
-    expectLastCall().andThrow(new SQLException(new ConnectException())).once();
-    eventsDb.queryOne();
-    expectLastCall().andThrow(new SQLException());
-    easyMock.replayAll();
-    store =
-        new SQLStore(pcFactoryMock, userProviderMock, cfgMock, eventsDb,
-            localEventsDb, poolMock);
+    setUpClientMock();
+    doThrow(new SQLException(new ConnectException())).when(eventsDb)
+        .createDBIfNotCreated();
+    doThrow(new SQLException()).when(eventsDb).queryOne();
+    store = new SQLStore(pcFactoryMock, userProviderMock, cfgMock, eventsDb,
+        localEventsDb, poolMock);
     store.start();
-    easyMock.verifyAll();
+    verify(localEventsDb).createDBIfNotCreated();
   }
 
   @Test
   public void storeLocalOffline() throws Exception {
     MockEvent mockEvent = new MockEvent();
-    setUpClientMock(true);
-    eventsDb.createDBIfNotCreated();
-    expectLastCall().andThrow(new SQLException(new ConnectException())).once();
-    localEventsDb.storeEvent(mockEvent);
-    expectLastCall().once();
-    eventsDb.queryOne();
-    expectLastCall().andThrow(new SQLException());
-    easyMock.replayAll();
-    store =
-        new SQLStore(pcFactoryMock, userProviderMock, cfgMock, eventsDb,
-            localEventsDb, poolMock);
+    setUpClientMock();
+    doThrow(new SQLException(new ConnectException())).when(eventsDb)
+        .createDBIfNotCreated();
+    doThrow(new SQLException()).when(eventsDb).queryOne();
+    store = new SQLStore(pcFactoryMock, userProviderMock, cfgMock, eventsDb,
+        localEventsDb, poolMock);
     store.start();
-
     store.storeEvent(mockEvent);
-    easyMock.verifyAll();
+    verify(localEventsDb).storeEvent(mockEvent);
   }
 
   @Test
   public void storeLocalOfflineAfterNoRetry() throws Exception {
     MockEvent mockEvent = new MockEvent();
-    setUpClientMock(false);
-    expect(cfgMock.getMaxTries()).andReturn(0).once();
-    eventsDb.storeEvent(mockEvent);
-    expectLastCall().andThrow(new SQLException(new ConnectException())).once();
-    expect(localEventsDb.getAll()).andStubReturn(results);
-    easyMock.replayAll();
-    store =
-        new SQLStore(pcFactoryMock, userProviderMock, cfgMock, eventsDb,
-            localEventsDb, poolMock);
+    setUpClientMock();
+    when(cfgMock.getMaxTries()).thenReturn(0);
+    doThrow(new SQLException(new ConnectException())).when(eventsDb)
+        .createDBIfNotCreated();
+    doThrow(new SQLException()).when(eventsDb).queryOne();
+    store = new SQLStore(pcFactoryMock, userProviderMock, cfgMock, eventsDb,
+        localEventsDb, poolMock);
     store.start();
-
     store.storeEvent(mockEvent);
-    easyMock.verifyAll();
+    verify(localEventsDb).storeEvent(mockEvent);
   }
 
   /**
@@ -394,17 +352,16 @@
   @Test
   public void testConnectionTask() throws Exception {
     eventsDb = new SQLClient(TEST_DRIVER, TEST_URL, TEST_OPTIONS);
-    localEventsDb = easyMock.createMock(SQLClient.class);
-    expect(localEventsDb.dbExists()).andReturn(true).once();
-    expect(localEventsDb.getAll()).andReturn(new ArrayList<SQLEntry>());
-    easyMock.replayAll();
-    store =
-        new SQLStore(pcFactoryMock, userProviderMock, cfgMock, eventsDb,
-            localEventsDb, poolMock);
-    eventsDb.createDBIfNotCreated();
+    localEventsDb = mock(SQLClient.class);
+    when(localEventsDb.dbExists()).thenReturn(true);
+    when(localEventsDb.getAll())
+        .thenReturn(ImmutableList.of(mock(SQLEntry.class)));
+    store = new SQLStore(pcFactoryMock, userProviderMock, cfgMock, eventsDb,
+        localEventsDb, poolMock);
+    store.start();
     poolMock.scheduleWithFixedDelay(store.new CheckConnectionTask(), 0, 0,
         TimeUnit.MILLISECONDS);
-    easyMock.verifyAll();
+    verify(localEventsDb, times(2)).removeOldEvents(0);
   }
 
   @Test
@@ -419,34 +376,25 @@
 
   private void checkConnectionAndRestore(boolean copy) throws Exception {
     MockEvent mockEvent = new MockEvent();
-    eventsDb = easyMock.createNiceMock(SQLClient.class);
+    eventsDb = mock(SQLClient.class);
     localEventsDb = new SQLClient(TEST_DRIVER, TEST_LOCAL_URL, TEST_OPTIONS);
     localEventsDb.createDBIfNotCreated();
     localEventsDb.storeEvent(mockEvent);
-    eventsDb.createDBIfNotCreated();
-    expectLastCall().andThrow(new SQLException(new ConnectException())).once();
-    eventsDb.queryOne();
-    expectLastCall().once();
-    eventsDb.storeEvent(EasyMock.anyString(),
-        EasyMock.anyObject(Timestamp.class), EasyMock.anyString());
-    expectLastCall().once();
+    doThrow(new SQLException(new ConnectException())).doNothing().when(eventsDb)
+        .createDBIfNotCreated();
 
     if (copy) {
-      testCopyLocal();
+      when(cfgMock.getCopyLocal()).thenReturn(true);
     }
-    easyMock.replayAll();
 
-    store =
-        new SQLStore(pcFactoryMock, userProviderMock, cfgMock, eventsDb,
-            localEventsDb, poolMock);
+    store = new SQLStore(pcFactoryMock, userProviderMock, cfgMock, eventsDb,
+        localEventsDb, poolMock);
     store.start();
+    verify(eventsDb).queryOne();
+    verify(eventsDb).storeEvent(any(String.class), any(Timestamp.class),
+        any(String.class));
     List<SQLEntry> entries = localEventsDb.getAll();
     assertThat(entries).isEmpty();
-    easyMock.verifyAll();
-  }
-
-  private void testCopyLocal() {
-    expect(cfgMock.getCopyLocal()).andReturn(true).once();
   }
 
   public class MockEvent extends ProjectEvent {
@@ -468,8 +416,8 @@
   }
 
   class PoolMock extends ScheduledThreadPoolExecutor {
-    PoolMock(int corePoolSize) {
-      super(corePoolSize);
+    PoolMock() {
+      super(1);
     }
 
     @Override