Migrate mockito to latest 2.10.0

Upgrade from mockito to latest version that among other nice features has
support of Java 9, report for unnecessary mocking, possibility to mock
final classes.
Full release notes can be found at: https://github.com/mockito/mockito/blob/release/2.x/doc/release-notes/official.md#2100-2017-09-08-published-to-jcentermaven-central

community/bolt/src/test/java/org/neo4j/bolt/BoltChannelTest.java

@@ -26,7 +26,7 @@
 import org.junit.runner.RunWith;
 import org.mockito.InOrder;
 import org.mockito.Mock;
-import org.mockito.runners.MockitoJUnitRunner;
+import org.mockito.junit.MockitoJUnitRunner;
 
 import org.neo4j.bolt.logging.BoltMessageLogger;
 

community/bolt/src/test/java/org/neo4j/bolt/logging/BoltMessageLoggerImplTest.java

@@ -19,16 +19,16 @@
  */
 package org.neo4j.bolt.logging;
 
-import java.net.InetSocketAddress;
-
 import io.netty.channel.Channel;
 import io.netty.channel.unix.DomainSocketAddress;
 import io.netty.util.Attribute;
 import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.mockito.Mock;
-import org.mockito.runners.MockitoJUnitRunner;
+import org.mockito.junit.MockitoJUnitRunner;
+
+import java.net.InetSocketAddress;
 
 import org.neo4j.bolt.v1.runtime.Neo4jError;
 import org.neo4j.kernel.DeadlockDetectedException;
@@ -37,7 +37,6 @@
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
-
 import static org.neo4j.bolt.logging.BoltMessageLoggerImpl.CORRELATION_ATTRIBUTE_KEY;
 import static org.neo4j.helpers.ValueUtils.asMapValue;
 import static org.neo4j.helpers.collection.MapUtil.map;

community/bolt/src/test/java/org/neo4j/bolt/logging/BoltMessageLoggingTest.java

@@ -19,15 +19,15 @@
  */
 package org.neo4j.bolt.logging;
 
-import java.io.IOException;
-import java.net.InetSocketAddress;
-
 import io.netty.channel.Channel;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.mockito.Answers;
 import org.mockito.Mock;
-import org.mockito.runners.MockitoJUnitRunner;
+import org.mockito.junit.MockitoJUnitRunner;
+
+import java.io.IOException;
+import java.net.InetSocketAddress;
 
 import org.neo4j.io.fs.FileSystemAbstraction;
 import org.neo4j.kernel.configuration.Config;
@@ -42,7 +42,6 @@
 import static org.mockito.Matchers.startsWith;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
-
 import static org.neo4j.graphdb.factory.GraphDatabaseSettings.bolt_logging_enabled;
 import static org.neo4j.helpers.collection.MapUtil.stringMap;
 
@@ -64,7 +63,6 @@ public void shouldCreateNullLoggerWhenDisabled()
     {
         Config config = newConfig( false );
 
-        when( channel.remoteAddress() ).thenReturn( inetSocketAddress );
         BoltMessageLogging logging = BoltMessageLogging.create( fs, jobScheduler, config, log );
         BoltMessageLogger logger = logging.newLogger( channel );
 

community/bolt/src/test/java/org/neo4j/bolt/v1/transport/socket/ChunkedOutputTest.java

@@ -22,7 +22,6 @@
 import io.netty.buffer.ByteBuf;
 import io.netty.buffer.UnpooledByteBufAllocator;
 import io.netty.channel.Channel;
-import io.netty.channel.ChannelPromise;
 import org.junit.After;
 import org.junit.Before;
 import org.junit.Test;
@@ -43,6 +42,7 @@
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.fail;
+import static org.mockito.ArgumentMatchers.isNull;
 import static org.mockito.Matchers.any;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.when;
@@ -193,10 +193,10 @@ public void shouldQueueWritesMadeWhileFlushing() throws Throwable
         final CountDownLatch finishLatch = new CountDownLatch( 1 );
         final AtomicBoolean parallelException = new AtomicBoolean( false );
 
-        when( ch.writeAndFlush( any(), any( ChannelPromise.class ) ) ).thenAnswer( invocation ->
+        when( ch.writeAndFlush( any(), isNull() ) ).thenAnswer( invocation ->
         {
             startLatch.countDown();
-            ByteBuf byteBuf = (ByteBuf) invocation.getArguments()[0];
+            ByteBuf byteBuf = invocation.getArgument( 0 );
             writtenData.limit( writtenData.position() + byteBuf.readableBytes() );
             byteBuf.readBytes( writtenData );
             return null;
@@ -275,9 +275,9 @@ public void shouldFlushOnClose() throws Throwable
 
     private void setupWriteAndFlush()
     {
-        when( ch.writeAndFlush( any(), any( ChannelPromise.class ) ) ).thenAnswer( invocation ->
+        when( ch.writeAndFlush( any(), isNull() ) ).thenAnswer( invocation ->
         {
-            ByteBuf byteBuf = (ByteBuf) invocation.getArguments()[0];
+            ByteBuf byteBuf = invocation.getArgument( 0 );
             writtenData.limit( writtenData.position() + byteBuf.readableBytes() );
             byteBuf.readBytes( writtenData );
             return null;

community/bolt/src/test/java/org/neo4j/bolt/v1/transport/socket/Chunker.java

@@ -22,15 +22,13 @@
 import io.netty.buffer.ByteBuf;
 import io.netty.buffer.UnpooledByteBufAllocator;
 import io.netty.channel.Channel;
-import io.netty.channel.ChannelPromise;
-import org.mockito.invocation.InvocationOnMock;
-import org.mockito.stubbing.Answer;
 
 import java.io.IOException;
 import java.nio.ByteBuffer;
 
 import org.neo4j.bolt.v1.transport.ChunkedOutput;
 
+import static org.mockito.ArgumentMatchers.isNull;
 import static org.mockito.Matchers.any;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.when;
@@ -48,9 +46,9 @@ public static byte[] chunk( int maxChunkSize, byte[][] messages ) throws IOExcep
 
         Channel ch = mock( Channel.class );
         when( ch.alloc() ).thenReturn( UnpooledByteBufAllocator.DEFAULT );
-        when( ch.writeAndFlush( any(), any( ChannelPromise.class ) ) ).then( inv ->
+        when( ch.writeAndFlush( any(), isNull() ) ).then( inv ->
         {
-            ByteBuf buf = (ByteBuf) inv.getArguments()[0];
+            ByteBuf buf = inv.getArgument( 0 );
             outputBuffer.limit( outputBuffer.position() + buf.readableBytes() );
             buf.readBytes( outputBuffer );
             buf.release();

community/bolt/src/test/java/org/neo4j/bolt/v1/transport/socket/FragmentedMessageDeliveryTest.java

@@ -113,10 +113,10 @@ private void testPermutation( byte[] unfragmented, ByteBuf[] fragments ) throws
         BoltStateMachine machine = mock( BoltStateMachine.class );
 
         Channel ch = mock( Channel.class );
-        when(ch.alloc()).thenReturn( UnpooledByteBufAllocator.DEFAULT );
+        when( ch.alloc() ).thenReturn( UnpooledByteBufAllocator.DEFAULT );
 
         ChannelHandlerContext ctx = mock( ChannelHandlerContext.class );
-        when(ctx.channel()).thenReturn( ch );
+        when( ctx.channel() ).thenReturn( ch );
 
         BoltChannel boltChannel = mock( BoltChannel.class );
         when( boltChannel.channelHandlerContext() ).thenReturn( ctx );

community/consistency-check/src/test/java/org/neo4j/consistency/CheckConsistencyCommandTest.java

@@ -51,7 +51,6 @@
 import static org.mockito.Matchers.anyObject;
 import static org.mockito.Matchers.eq;
 import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.stub;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
 
@@ -158,9 +157,9 @@ public void shouldWriteReportFileToCurrentDirectoryByDefault()
                 new CheckConsistencyCommand( homeDir, testDir.directory( "conf" ).toPath(), outsideWorld,
                         consistencyCheckService );
 
-        stub( consistencyCheckService.runFullConsistencyCheck( anyObject(), anyObject(), anyObject(), anyObject(),
+        when( consistencyCheckService.runFullConsistencyCheck( anyObject(), anyObject(), anyObject(), anyObject(),
                 anyObject(), anyBoolean(), anyObject(), any( CheckConsistencyConfig.class ) ) )
-                .toReturn( ConsistencyCheckService.Result.success( null ) );
+                .thenReturn( ConsistencyCheckService.Result.success( null ) );
 
         checkConsistencyCommand.execute( new String[]{"--database=mydb"} );
 
@@ -182,9 +181,9 @@ public void shouldWriteReportFileToSpecifiedDirectory()
                 new CheckConsistencyCommand( homeDir, testDir.directory( "conf" ).toPath(), outsideWorld,
                         consistencyCheckService );
 
-        stub( consistencyCheckService.runFullConsistencyCheck( anyObject(), anyObject(), anyObject(), anyObject(),
+        when( consistencyCheckService.runFullConsistencyCheck( anyObject(), anyObject(), anyObject(), anyObject(),
                 anyObject(), anyBoolean(), anyObject(), any( CheckConsistencyConfig.class ) ) )
-                .toReturn( ConsistencyCheckService.Result.success( null ) );
+                .thenReturn( ConsistencyCheckService.Result.success( null ) );
 
         checkConsistencyCommand.execute( new String[]{"--database=mydb", "--report-dir=some-dir-or-other"} );
 
@@ -207,9 +206,9 @@ public void shouldCanonicalizeReportDirectory()
                 new CheckConsistencyCommand( homeDir, testDir.directory( "conf" ).toPath(), outsideWorld,
                         consistencyCheckService );
 
-        stub( consistencyCheckService.runFullConsistencyCheck( anyObject(), anyObject(), anyObject(), anyObject(),
+        when( consistencyCheckService.runFullConsistencyCheck( anyObject(), anyObject(), anyObject(), anyObject(),
                 anyObject(), anyBoolean(), anyObject(), any( CheckConsistencyConfig.class ) ) )
-                .toReturn( ConsistencyCheckService.Result.success( null ) );
+                .thenReturn( ConsistencyCheckService.Result.success( null ) );
 
         checkConsistencyCommand.execute( new String[]{"--database=mydb", "--report-dir=" + Paths.get( "..", "bar" )} );
 
@@ -231,9 +230,9 @@ public void passesOnCheckParameters() throws Exception
                 new CheckConsistencyCommand( homeDir, testDir.directory( "conf" ).toPath(), outsideWorld,
                         consistencyCheckService );
 
-        stub( consistencyCheckService.runFullConsistencyCheck( anyObject(), anyObject(), anyObject(), anyObject(),
+        when( consistencyCheckService.runFullConsistencyCheck( anyObject(), anyObject(), anyObject(), anyObject(),
                 anyObject(), anyBoolean(), anyObject(), any( CheckConsistencyConfig.class ) ) )
-                .toReturn( ConsistencyCheckService.Result.success( null ) );
+                .thenReturn( ConsistencyCheckService.Result.success( null ) );
 
         checkConsistencyCommand.execute( new String[]{"--database=mydb", "--check-graph=false",
                 "--check-indexes=false", "--check-label-scan-store=false", "--check-property-owners=true"} );
@@ -254,9 +253,9 @@ public void databaseAndBackupAreMutuallyExclusive() throws Exception
                 new CheckConsistencyCommand( homeDir, testDir.directory( "conf" ).toPath(), outsideWorld,
                         consistencyCheckService );
 
-        stub( consistencyCheckService.runFullConsistencyCheck( anyObject(), anyObject(), anyObject(), anyObject(),
+        when( consistencyCheckService.runFullConsistencyCheck( anyObject(), anyObject(), anyObject(), anyObject(),
                 anyObject(), anyBoolean(), any( CheckConsistencyConfig.class ) ) )
-                .toReturn( ConsistencyCheckService.Result.success( null ) );
+                .thenReturn( ConsistencyCheckService.Result.success( null ) );
 
         expect.expect( IncorrectUsage.class );
         expect.expectMessage( "Only one of '--database' and '--backup' can be specified." );

community/consistency-check/src/test/java/org/neo4j/consistency/report/ConsistencyReporterTest.java

@@ -31,6 +31,7 @@
 import org.junit.runners.Suite;
 import org.junit.runners.model.Statement;
 import org.mockito.ArgumentCaptor;
+import org.mockito.ArgumentMatchers;
 import org.mockito.invocation.InvocationOnMock;
 import org.mockito.stubbing.Answer;
 
@@ -52,8 +53,8 @@
 import org.neo4j.consistency.store.synthetic.IndexEntry;
 import org.neo4j.consistency.store.synthetic.LabelScanDocument;
 import org.neo4j.kernel.api.index.SchemaIndexProvider;
-import org.neo4j.kernel.api.schema.SchemaDescriptor;
 import org.neo4j.kernel.api.labelscan.NodeLabelRange;
+import org.neo4j.kernel.api.schema.SchemaDescriptor;
 import org.neo4j.kernel.api.schema.index.IndexDescriptorFactory;
 import org.neo4j.kernel.impl.store.record.AbstractBaseRecord;
 import org.neo4j.kernel.impl.store.record.DynamicRecord;
@@ -75,13 +76,13 @@
 import static org.junit.Assert.assertThat;
 import static org.junit.Assert.assertTrue;
 import static org.mockito.Matchers.any;
-import static org.mockito.Matchers.argThat;
 import static org.mockito.Mockito.doAnswer;
 import static org.mockito.Mockito.doThrow;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.verifyNoMoreInteractions;
 import static org.mockito.Mockito.verifyZeroInteractions;
+import static org.mockito.hamcrest.MockitoHamcrest.argThat;
 import static org.neo4j.consistency.report.ConsistencyReporter.NO_MONITOR;
 import static org.neo4j.kernel.impl.store.counts.keys.CountsKeyFactory.nodeKey;
 
@@ -230,8 +231,7 @@ public void shouldLogInconsistency() throws Exception
                 else
                 {
                     verify( report ).error( any( RecordType.class ),
-                                            any( AbstractBaseRecord.class ),
-                                            argThat( hasExpectedFormat() ), any( Object[].class ) );
+                                            any( AbstractBaseRecord.class ), argThat( hasExpectedFormat() ), nullSafeAny() );
                 }
             }
             else
@@ -246,7 +246,7 @@ public void shouldLogInconsistency() throws Exception
                 {
                     verify( report ).warning( any( RecordType.class ),
                                               any( AbstractBaseRecord.class ),
-                                              argThat( hasExpectedFormat() ), any( Object[].class ) );
+                                              argThat( hasExpectedFormat() ), nullSafeAny() );
                 }
             }
         }
@@ -457,6 +457,11 @@ public Object answer( InvocationOnMock invocation ) throws Throwable
         }
     }
 
+    private static <T> T[] nullSafeAny()
+    {
+        return ArgumentMatchers.argThat( argument -> true );
+    }
+
     private static Matcher<String> hasExpectedFormat()
     {
         return new TypeSafeMatcher<String>()

community/consistency-check/src/test/java/org/neo4j/consistency/store/RecordAccessStub.java

@@ -56,6 +56,7 @@
 import org.neo4j.kernel.impl.store.record.RelationshipTypeTokenRecord;
 
 import static java.util.Collections.singletonMap;
+import static org.mockito.ArgumentMatchers.isNull;
 import static org.mockito.Matchers.any;
 import static org.mockito.Mockito.doAnswer;
 import static org.mockito.Mockito.mock;
@@ -114,6 +115,7 @@ public <REFERRED extends AbstractBaseRecord> void comparativeCheck(
             {
                 PendingReferenceCheck mock = mock( PendingReferenceCheck.class );
                 DeferredReferenceCheck check = new DeferredReferenceCheck( Engine.this, checker );
+                doAnswer( check ).when( mock ).checkReference( isNull(), isNull() );
                 doAnswer( check ).when( mock ).checkReference( any( AbstractBaseRecord.class ),
                                                                any( RecordAccess.class ) );
                 doAnswer( check ).when( mock ).checkDiffReference( any( AbstractBaseRecord.class ),

community/cypher/cypher-compiler-3.4/src/test/scala/org/neo4j/cypher/internal/compiler/v3_4/ast/rewriters/CNFNormalizerTest.scala

@@ -19,13 +19,13 @@
  */
 package org.neo4j.cypher.internal.compiler.v3_4.ast.rewriters
 
-import org.mockito.Matchers._
+import org.mockito.ArgumentMatchers._
 import org.mockito.Mockito._
 import org.neo4j.cypher.internal.compiler.v3_4.test_helpers.ContextHelper
-import org.neo4j.cypher.internal.frontend.v3_4.{AstRewritingMonitor, Rewriter}
 import org.neo4j.cypher.internal.frontend.v3_4.ast.rewriters.CNFNormalizer
 import org.neo4j.cypher.internal.frontend.v3_4.phases.Monitors
 import org.neo4j.cypher.internal.frontend.v3_4.test_helpers.CypherFunSuite
+import org.neo4j.cypher.internal.frontend.v3_4.{AstRewritingMonitor, Rewriter}
 
 class CNFNormalizerTest extends CypherFunSuite with PredicateTestSupport {
 

community/cypher/cypher-compiler-3.4/src/test/scala/org/neo4j/cypher/internal/compiler/v3_4/helpers/CachedFunctionTest.scala

@@ -19,7 +19,7 @@
  */
 package org.neo4j.cypher.internal.compiler.v3_4.helpers
 
-import org.mockito.Matchers._
+import org.mockito.ArgumentMatchers._
 import org.mockito.Mockito._
 import org.neo4j.cypher.internal.frontend.v3_4.test_helpers.CypherFunSuite
 import org.neo4j.cypher.internal.ir.v3_4.{IdName, QueryGraph}

community/cypher/cypher-compiler-3.4/src/test/scala/org/neo4j/cypher/internal/compiler/v3_4/planner/LogicalPlanningTestSupport.scala

@@ -19,7 +19,7 @@
  */
 package org.neo4j.cypher.internal.compiler.v3_4.planner
 
-import org.mockito.Matchers._
+import org.mockito.ArgumentMatchers._
 import org.mockito.Mockito._
 import org.neo4j.cypher.internal.compiler.v3_4._
 import org.neo4j.cypher.internal.compiler.v3_4.ast.rewriters.namePatternPredicatePatternElements
@@ -94,7 +94,7 @@ trait LogicalPlanningTestSupport extends CypherTestSupport with AstConstructionT
 
   def newMockedStrategy(plan: LogicalPlan) = {
     val strategy = mock[QueryGraphSolver]
-    doReturn(plan).when(strategy).plan(any())(any())
+    doReturn(plan, Nil: _*).when(strategy).plan(any())(any())
     strategy
   }
 
@@ -120,7 +120,7 @@ trait LogicalPlanningTestSupport extends CypherTestSupport with AstConstructionT
 
   def newMockedPlanContext(implicit statistics: GraphStatistics = newMockedStatistics) = {
     val context = mock[PlanContext]
-    doReturn(statistics).when(context).statistics
+    doReturn(statistics, Nil: _*).when(context).statistics
     context
   }
 

community/cypher/cypher-compiler-3.4/src/test/scala/org/neo4j/cypher/internal/compiler/v3_4/planner/logical/DefaultQueryPlannerTest.scala

@@ -19,7 +19,7 @@
  */
 package org.neo4j.cypher.internal.compiler.v3_4.planner.logical
 
-import org.mockito.Matchers.any
+import org.mockito.ArgumentMatchers.any
 import org.mockito.Mockito.{times, verify, when}
 import org.neo4j.cypher.internal.compiler.v3_4.planner._
 import org.neo4j.cypher.internal.compiler.v3_4.planner.logical.Metrics.QueryGraphSolverInput

community/cypher/cypher-compiler-3.4/src/test/scala/org/neo4j/cypher/internal/compiler/v3_4/planner/logical/PriorityLeafPlannerListTest.scala

@@ -19,7 +19,7 @@
  */
 package org.neo4j.cypher.internal.compiler.v3_4.planner.logical
 
-import org.mockito.Matchers.any
+import org.mockito.ArgumentMatchers.any
 import org.mockito.Mockito.{verify, verifyZeroInteractions, when}
 import org.neo4j.cypher.internal.compiler.v3_4.planner.LogicalPlanningTestSupport2
 import org.neo4j.cypher.internal.frontend.v3_4.test_helpers.CypherFunSuite

community/cypher/cypher-compiler-3.4/src/test/scala/org/neo4j/cypher/internal/compiler/v3_4/planner/logical/cardinality/assumeIndependence/PatternSelectivityCalculatorTest.scala

@@ -19,7 +19,7 @@
  */
 package org.neo4j.cypher.internal.compiler.v3_4.planner.logical.cardinality.assumeIndependence
 
-import org.mockito.Matchers.any
+import org.mockito.ArgumentMatchers.any
 import org.mockito.Mockito._
 import org.mockito.invocation.InvocationOnMock
 import org.mockito.stubbing.Answer
@@ -90,7 +90,7 @@ class PatternSelectivityCalculatorTest extends CypherFunSuite with LogicalPlanCo
     val stats: GraphStatistics = mock[GraphStatistics]
     when(stats.nodesWithLabelCardinality(any())).thenAnswer(new Answer[Cardinality] {
       override def answer(invocationOnMock: InvocationOnMock): Cardinality = {
-        val arg = invocationOnMock.getArguments()(0).asInstanceOf[Option[LabelId]]
+        val arg:Option[LabelId] = invocationOnMock.getArgument(0)
         arg match {
           case None => Cardinality(10)
           case Some(_) => Cardinality(1)