DATACASS-629 - Migrate Kotlin tests to Mockk.

spring-data-cassandra/pom.xml

@@ -196,24 +196,10 @@
 			<scope>test</scope>
 		</dependency>
 		<dependency>
-			<groupId>com.nhaarman</groupId>
-			<artifactId>mockito-kotlin</artifactId>
-			<version>1.5.0</version>
+			<groupId>io.mockk</groupId>
+			<artifactId>mockk</artifactId>
+			<version>${mockk}</version>
 			<scope>test</scope>
-			<exclusions>
-				<exclusion>
-					<groupId>org.jetbrains.kotlin</groupId>
-					<artifactId>kotlin-stdlib</artifactId>
-				</exclusion>
-				<exclusion>
-					<groupId>org.jetbrains.kotlin</groupId>
-					<artifactId>kotlin-reflect</artifactId>
-				</exclusion>
-				<exclusion>
-					<groupId>org.mockito</groupId>
-					<artifactId>mockito-core</artifactId>
-				</exclusion>
-			</exclusions>
 		</dependency>
 	</dependencies>
 

spring-data-cassandra/src/test/kotlin/org/springframework/data/cassandra/core/AsyncCassandraOperationsExtensionsUnitTests.kt

@@ -16,14 +16,9 @@
 package org.springframework.data.cassandra.core
 
 import com.datastax.driver.core.SimpleStatement
-import com.nhaarman.mockito_kotlin.any
-import com.nhaarman.mockito_kotlin.eq
-import com.nhaarman.mockito_kotlin.verify
+import io.mockk.mockk
+import io.mockk.verify
 import org.junit.Test
-import org.junit.runner.RunWith
-import org.mockito.Answers
-import org.mockito.Mock
-import org.mockito.junit.MockitoJUnitRunner
 import org.springframework.data.cassandra.core.query.Query
 import org.springframework.data.cassandra.core.query.Update
 import org.springframework.data.cassandra.domain.Person
@@ -34,11 +29,9 @@ import java.util.function.Consumer
  *
  * @author Mark Paluch
  */
-@RunWith(MockitoJUnitRunner::class)
 class AsyncCassandraOperationsExtensionsUnitTests {
 
-	@Mock(answer = Answers.RETURNS_MOCKS)
-	lateinit var operations: AsyncCassandraOperations
+	val operations = mockk<AsyncCassandraOperations>(relaxed = true)
 
 	// -------------------------------------------------------------------------
 	// Methods dealing with static CQL
@@ -48,42 +41,42 @@ class AsyncCassandraOperationsExtensionsUnitTests {
 	fun `select(String, KClass) extension should call its Java counterpart`() {
 
 		operations.select("SELECT * FROM person", Person::class)
-		verify(operations).select("SELECT * FROM person", Person::class.java)
+		verify { operations.select("SELECT * FROM person", Person::class.java) }
 	}
 
 	@Test // DATACASS-484
 	fun `select(String) with reified type parameter extension should call its Java counterpart`() {
 
 		operations.select<Person>("SELECT * FROM person")
-		verify(operations).select("SELECT * FROM person", Person::class.java)
+		verify { operations.select("SELECT * FROM person", Person::class.java) }
 	}
 
 	@Test // DATACASS-484
 	fun `select(String, KClass, Consumer) extension should call its Java counterpart`() {
 
 		operations.select("SELECT * FROM person", Person::class) { p -> p.toString() }
-		verify(operations).select(eq("SELECT * FROM person"), any<Consumer<Person>>(), eq(Person::class.java))
+		verify { operations.select(eq("SELECT * FROM person"), any<Consumer<Person>>(), eq(Person::class.java)) }
 	}
 
 	@Test // DATACASS-484
 	fun `select(String, Consumer) with reified type parameter extension should call its Java counterpart`() {
 
 		operations.select<Person>("SELECT * FROM person") { p -> p.toString() }
-		verify(operations).select(eq("SELECT * FROM person"), any<Consumer<Person>>(), eq(Person::class.java))
+		verify { operations.select(eq("SELECT * FROM person"), any<Consumer<Person>>(), eq(Person::class.java)) }
 	}
 
 	@Test // DATACASS-484
 	fun `selectOne(String, KClass) extension should call its Java counterpart`() {
 
 		operations.selectOne("SELECT * FROM person", Person::class)
-		verify(operations).selectOne("SELECT * FROM person", Person::class.java)
+		verify { operations.selectOne("SELECT * FROM person", Person::class.java) }
 	}
 
 	@Test // DATACASS-484
 	fun `selectOne(String) with reified type parameter extension should call its Java counterpart`() {
 
 		operations.selectOne<Person>("SELECT * FROM person")
-		verify(operations).selectOne("SELECT * FROM person", Person::class.java)
+		verify { operations.selectOne("SELECT * FROM person", Person::class.java) }
 	}
 
 	// -------------------------------------------------------------------------
@@ -96,7 +89,7 @@ class AsyncCassandraOperationsExtensionsUnitTests {
 		val statement = SimpleStatement("SELECT * FROM person")
 
 		operations.select(statement, Person::class)
-		verify(operations).select(statement, Person::class.java)
+		verify { operations.select(statement, Person::class.java) }
 	}
 
 	@Test // DATACASS-484
@@ -104,7 +97,7 @@ class AsyncCassandraOperationsExtensionsUnitTests {
 
 		val statement = SimpleStatement("SELECT * FROM person")
 		operations.select<Person>(statement)
-		verify(operations).select(statement, Person::class.java)
+		verify { operations.select(statement, Person::class.java) }
 	}
 
 	@Test // DATACASS-484
@@ -113,7 +106,7 @@ class AsyncCassandraOperationsExtensionsUnitTests {
 		val statement = SimpleStatement("SELECT * FROM person")
 
 		operations.select(statement, Person::class) { p -> p.toString() }
-		verify(operations).select(eq(statement), any<Consumer<Person>>(), eq(Person::class.java))
+		verify { operations.select(eq(statement), any<Consumer<Person>>(), eq(Person::class.java)) }
 	}
 
 	@Test // DATACASS-484
@@ -122,7 +115,7 @@ class AsyncCassandraOperationsExtensionsUnitTests {
 		val statement = SimpleStatement("SELECT * FROM person")
 
 		operations.select<Person>(statement) { p -> p.toString() }
-		verify(operations).select(eq(statement), any<Consumer<Person>>(), eq(Person::class.java))
+		verify { operations.select(eq(statement), any<Consumer<Person>>(), eq(Person::class.java)) }
 	}
 
 	@Test // DATACASS-484
@@ -131,7 +124,7 @@ class AsyncCassandraOperationsExtensionsUnitTests {
 		val statement = SimpleStatement("SELECT * FROM person")
 
 		operations.slice(statement, Person::class)
-		verify(operations).slice(statement, Person::class.java)
+		verify { operations.slice(statement, Person::class.java) }
 	}
 
 	@Test // DATACASS-484
@@ -140,7 +133,7 @@ class AsyncCassandraOperationsExtensionsUnitTests {
 		val statement = SimpleStatement("SELECT * FROM person")
 
 		operations.slice<Person>(statement)
-		verify(operations).slice(statement, Person::class.java)
+		verify { operations.slice(statement, Person::class.java) }
 	}
 
 	@Test // DATACASS-484
@@ -149,7 +142,7 @@ class AsyncCassandraOperationsExtensionsUnitTests {
 		val statement = SimpleStatement("SELECT * FROM person")
 
 		operations.selectOne(statement, Person::class)
-		verify(operations).selectOne(statement, Person::class.java)
+		verify { operations.selectOne(statement, Person::class.java) }
 	}
 
 	@Test // DATACASS-484
@@ -158,7 +151,7 @@ class AsyncCassandraOperationsExtensionsUnitTests {
 		val statement = SimpleStatement("SELECT * FROM person")
 
 		operations.selectOne<Person>(statement)
-		verify(operations).selectOne(statement, Person::class.java)
+		verify { operations.selectOne(statement, Person::class.java) }
 	}
 
 	// -------------------------------------------------------------------------
@@ -169,84 +162,84 @@ class AsyncCassandraOperationsExtensionsUnitTests {
 	fun `select(Query, KClass) extension should call its Java counterpart`() {
 
 		operations.select(Query.empty(), Person::class)
-		verify(operations).select(Query.empty(), Person::class.java)
+		verify { operations.select(Query.empty(), Person::class.java) }
 	}
 
 	@Test // DATACASS-484
 	fun `select(Query) with reified type parameter extension should call its Java counterpart`() {
 
 		operations.select<Person>(Query.empty())
-		verify(operations).select(Query.empty(), Person::class.java)
+		verify { operations.select(Query.empty(), Person::class.java) }
 	}
 
 	@Test // DATACASS-484
 	fun `select(Query, KClass, Consumer) extension should call its Java counterpart`() {
 
 		operations.select(Query.empty(), Person::class) { p -> p.toString() }
-		verify(operations).select(eq(Query.empty()), any<Consumer<Person>>(), eq(Person::class.java))
+		verify { operations.select(eq(Query.empty()), any<Consumer<Person>>(), eq(Person::class.java)) }
 	}
 
 	@Test // DATACASS-484
 	fun `select(Query, Consumer) with reified type parameter extension should call its Java counterpart`() {
 
 		operations.select<Person>(Query.empty()) { p -> p.toString() }
-		verify(operations).select(eq(Query.empty()), any<Consumer<Person>>(), eq(Person::class.java))
+		verify { operations.select(eq(Query.empty()), any<Consumer<Person>>(), eq(Person::class.java)) }
 	}
 
 	@Test // DATACASS-484
 	fun `slice(Query, KClass) extension should call its Java counterpart`() {
 
 		operations.slice(Query.empty(), Person::class)
-		verify(operations).slice(Query.empty(), Person::class.java)
+		verify { operations.slice(Query.empty(), Person::class.java) }
 	}
 
 	@Test // DATACASS-484
 	fun `slice(Query) with reified type parameter extension should call its Java counterpart`() {
 
 		operations.slice<Person>(Query.empty())
-		verify(operations).slice(Query.empty(), Person::class.java)
+		verify { operations.slice(Query.empty(), Person::class.java) }
 	}
 
 	@Test // DATACASS-484
 	fun `selectOne(Query, KClass) extension should call its Java counterpart`() {
 
 		operations.selectOne(Query.empty(), Person::class)
-		verify(operations).selectOne(Query.empty(), Person::class.java)
+		verify { operations.selectOne(Query.empty(), Person::class.java) }
 	}
 
 	@Test // DATACASS-484
 	fun `selectOne(Query) with reified type parameter extension should call its Java counterpart`() {
 
 		operations.selectOne<Person>(Query.empty())
-		verify(operations).selectOne(Query.empty(), Person::class.java)
+		verify { operations.selectOne(Query.empty(), Person::class.java) }
 	}
 
 	@Test // DATACASS-484
 	fun `update(Query, Update, KClass) extension should call its Java counterpart`() {
 
 		operations.update(Query.empty(), Update.empty(), Person::class)
-		verify(operations).update(Query.empty(), Update.empty(), Person::class.java)
+		verify { operations.update(Query.empty(), Update.empty(), Person::class.java) }
 	}
 
 	@Test // DATACASS-484
 	fun `update(Query, Update) with reified type parameter extension should call its Java counterpart`() {
 
 		operations.update<Person>(Query.empty(), Update.empty())
-		verify(operations).update(Query.empty(), Update.empty(), Person::class.java)
+		verify { operations.update(Query.empty(), Update.empty(), Person::class.java) }
 	}
 
 	@Test // DATACASS-484
 	fun `delete(Query, KClass) extension should call its Java counterpart`() {
 
 		operations.delete(Query.empty(), Person::class)
-		verify(operations).delete(Query.empty(), Person::class.java)
+		verify { operations.delete(Query.empty(), Person::class.java) }
 	}
 
 	@Test // DATACASS-484
 	fun `delete(Query,) with reified type parameter extension should call its Java counterpart`() {
 
 		operations.delete<Person>(Query.empty())
-		verify(operations).delete(Query.empty(), Person::class.java)
+		verify { operations.delete(Query.empty(), Person::class.java) }
 	}
 
 	// -------------------------------------------------------------------------
@@ -257,97 +250,98 @@ class AsyncCassandraOperationsExtensionsUnitTests {
 	fun `count(KClass) extension should call its Java counterpart`() {
 
 		operations.count(Person::class)
-		verify(operations).count(Person::class.java)
+		verify { operations.count(Person::class.java) }
 	}
 
 	@Test // DATACASS-484
 	fun `count() with reified type parameter extension should call its Java counterpart`() {
 
 		operations.count<Person>()
-		verify(operations).count(Person::class.java)
+		verify { operations.count(Person::class.java) }
 	}
 
 	@Test // DATACASS-484
 	fun `count(Query, KClass) extension should call its Java counterpart`() {
 
 		operations.count(Query.empty(), Person::class)
-		verify(operations).count(Query.empty(), Person::class.java)
+		verify { operations.count(Query.empty(), Person::class.java) }
 	}
 
 	@Test // DATACASS-484
 	fun `count(Query) with reified type parameter extension should call its Java counterpart`() {
 
 		operations.count<Person>(Query.empty())
-		verify(operations).count(Query.empty(), Person::class.java)
+		verify { operations.count(Query.empty(), Person::class.java) }
 	}
 
 	@Test // DATACASS-484
 	fun `exists(Any, KClass) extension should call its Java counterpart`() {
 
 		operations.exists("id", Person::class)
-		verify(operations).exists("id", Person::class.java)
+		verify { operations.exists("id", Person::class.java) }
 	}
 
 	@Test // DATACASS-484
 	fun `exists(Any) with reified type parameter extension should call its Java counterpart`() {
 
 		operations.exists<Person>("id")
-		verify(operations).exists("id", Person::class.java)
+		verify { operations.exists("id", Person::class.java) }
 	}
 
 	@Test // DATACASS-484
 	fun `exists(Query, KClass) extension should call its Java counterpart`() {
 
 		operations.exists(Query.empty(), Person::class)
-		verify(operations).exists(Query.empty(), Person::class.java)
+		verify { operations.exists(Query.empty(), Person::class.java) }
 	}
 
 	@Test // DATACASS-484
 	fun `exists(Query) with reified type parameter extension should call its Java counterpart`() {
 
 		operations.exists<Person>(Query.empty())
-		verify(operations).exists(Query.empty(), Person::class.java)
+		verify { operations.exists(Query.empty(), Person::class.java) }
 	}
 
 	@Test // DATACASS-484
 	fun `selectOneById(Any, KClass) extension should call its Java counterpart`() {
 
 		operations.selectOneById("id", Person::class)
-		verify(operations).selectOneById("id", Person::class.java)
+		verify { operations.selectOneById("id", Person::class.java) }
 	}
 
 	@Test // DATACASS-484
 	fun `selectOneById(Any) with reified type parameter extension should call its Java counterpart`() {
 
 		operations.selectOneById<Person>("id")
-		verify(operations).selectOneById("id", Person::class.java)
+		verify { operations.selectOneById("id", Person::class.java) }
 	}
 
 	@Test // DATACASS-484
 	fun `deleteById(Any, KClass) extension should call its Java counterpart`() {
 
 		operations.deleteById("id", Person::class)
-		verify(operations).deleteById("id", Person::class.java)
+		verify { operations.deleteById("id", Person::class.java) }
 	}
 
 	@Test // DATACASS-484
 	fun `deleteById(Any) with reified type parameter extension should call its Java counterpart`() {
 
 		operations.deleteById<Person>("id")
-		verify(operations).deleteById("id", Person::class.java)
+		verify { operations.deleteById("id", Person::class.java) }
 	}
 
 	@Test // DATACASS-484
 	fun `truncate(KClass) extension should call its Java counterpart`() {
 
 		operations.truncate(Person::class)
-		verify(operations).truncate(Person::class.java)
+		verify { operations.truncate(Person::class.java) }
 	}
 
 	@Test // DATACASS-484
 	fun `truncate() with reified type parameter extension should call its Java counterpart`() {
 
 		operations.truncate<Person>()
-		verify(operations).truncate(Person::class.java)
+		verify { operations.truncate(Person::class.java) }
 	}
 }
+

spring-data-cassandra/src/test/kotlin/org/springframework/data/cassandra/core/CassandraOperationsExtensionsUnitTests.kt

@@ -16,14 +16,10 @@
 package org.springframework.data.cassandra.core
 
 import com.datastax.driver.core.SimpleStatement
-import com.nhaarman.mockito_kotlin.doReturn
-import com.nhaarman.mockito_kotlin.verify
-import com.nhaarman.mockito_kotlin.whenever
+import io.mockk.every
+import io.mockk.mockk
+import io.mockk.verify
 import org.junit.Test
-import org.junit.runner.RunWith
-import org.mockito.Answers
-import org.mockito.Mock
-import org.mockito.junit.MockitoJUnitRunner
 import org.springframework.data.cassandra.core.cql.CqlIdentifier
 import org.springframework.data.cassandra.core.query.Query
 import org.springframework.data.cassandra.core.query.Update
@@ -35,28 +31,26 @@ import org.springframework.data.domain.SliceImpl
  *
  * @author Mark Paluch
  */
-@RunWith(MockitoJUnitRunner::class)
 class CassandraOperationsExtensionsUnitTests {
 
-	@Mock(answer = Answers.RETURNS_MOCKS)
-	lateinit var operations: CassandraOperations
+	val operations = mockk<CassandraOperations>(relaxed = true)
 
 	@Test // DATACASS-484
 	fun `getTableName(KClass) extension should call its Java counterpart`() {
 
-		doReturn(CqlIdentifier.of("person")).whenever(operations).getTableName(Person::class.java)
+		every { operations.getTableName(Person::class.java) } returns CqlIdentifier.of("person")
 
 		operations.getTableName(Person::class)
-		verify(operations).getTableName(Person::class.java)
+		verify { operations.getTableName(Person::class.java) }
 	}
 
 	@Test // DATACASS-484
 	fun `getTableName() with reified type parameter extension should call its Java counterpart`() {
 
-		doReturn(CqlIdentifier.of("person")).whenever(operations).getTableName(Person::class.java)
+		every { operations.getTableName(Person::class.java) } returns CqlIdentifier.of("person")
 
 		operations.getTableName<Person>()
-		verify(operations).getTableName(Person::class.java)
+		verify { operations.getTableName(Person::class.java) }
 	}
 
 	// -------------------------------------------------------------------------
@@ -67,46 +61,46 @@ class CassandraOperationsExtensionsUnitTests {
 	fun `select(String, KClass) extension should call its Java counterpart`() {
 
 		operations.select("SELECT * FROM person", Person::class)
-		verify(operations).select("SELECT * FROM person", Person::class.java)
+		verify { operations.select("SELECT * FROM person", Person::class.java) }
 	}
 
 	@Test // DATACASS-484
 	fun `select(String) with reified type parameter extension should call its Java counterpart`() {
 
 		operations.select<Person>("SELECT * FROM person")
-		verify(operations).select("SELECT * FROM person", Person::class.java)
+		verify { operations.select("SELECT * FROM person", Person::class.java) }
 	}
 
 	@Test // DATACASS-484
 	fun `stream(String, KClass) extension should call its Java counterpart`() {
 
 		operations.stream("SELECT * FROM person", Person::class)
-		verify(operations).stream("SELECT * FROM person", Person::class.java)
+		verify { operations.stream("SELECT * FROM person", Person::class.java) }
 	}
 
 	@Test // DATACASS-484
 	fun `stream(String) with reified type parameter extension should call its Java counterpart`() {
 
 		operations.stream<Person>("SELECT * FROM person")
-		verify(operations).stream("SELECT * FROM person", Person::class.java)
+		verify { operations.stream("SELECT * FROM person", Person::class.java) }
 	}
 
 	@Test // DATACASS-484
 	fun `selectOne(String, KClass) extension should call its Java counterpart`() {
 
-		doReturn(Person("Walter", "White")).whenever(operations).selectOne("SELECT * FROM person", Person::class.java)
+		every { operations.selectOne("SELECT * FROM person", Person::class.java) } returns Person("Walter", "White")
 
 		operations.selectOne("SELECT * FROM person", Person::class)
-		verify(operations).selectOne("SELECT * FROM person", Person::class.java)
+		verify { operations.selectOne("SELECT * FROM person", Person::class.java) }
 	}
 
 	@Test // DATACASS-484
 	fun `selectOne(String) with reified type parameter extension should call its Java counterpart`() {
 
-		doReturn(Person("Walter", "White")).whenever(operations).selectOne("SELECT * FROM person", Person::class.java)
+		every { operations.selectOne("SELECT * FROM person", Person::class.java) } returns Person("Walter", "White")
 
 		operations.selectOne<Person>("SELECT * FROM person")
-		verify(operations).selectOne("SELECT * FROM person", Person::class.java)
+		verify { operations.selectOne("SELECT * FROM person", Person::class.java) }
 	}
 
 	// -------------------------------------------------------------------------
@@ -119,7 +113,7 @@ class CassandraOperationsExtensionsUnitTests {
 		val statement = SimpleStatement("SELECT * FROM person")
 
 		operations.select(statement, Person::class)
-		verify(operations).select(statement, Person::class.java)
+		verify { operations.select(statement, Person::class.java) }
 	}
 
 	@Test // DATACASS-484
@@ -127,27 +121,27 @@ class CassandraOperationsExtensionsUnitTests {
 
 		val statement = SimpleStatement("SELECT * FROM person")
 		operations.select<Person>(statement)
-		verify(operations).select(statement, Person::class.java)
+		verify { operations.select(statement, Person::class.java) }
 	}
 
 	@Test // DATACASS-484
 	fun `slice(Statement, KClass) extension should call its Java counterpart`() {
 
 		val statement = SimpleStatement("SELECT * FROM person")
-		doReturn(SliceImpl(listOf(Person("Walter", "White")))).whenever(operations).slice(statement, Person::class.java)
+		every { operations.slice(statement, Person::class.java) } returns SliceImpl(listOf(Person("Walter", "White")))
 
 		operations.slice(statement, Person::class)
-		verify(operations).slice(statement, Person::class.java)
+		verify { operations.slice(statement, Person::class.java) }
 	}
 
 	@Test // DATACASS-484
 	fun `slice(Statement) with reified type parameter extension should call its Java counterpart`() {
 
 		val statement = SimpleStatement("SELECT * FROM person")
-		doReturn(SliceImpl(listOf(Person("Walter", "White")))).whenever(operations).slice(statement, Person::class.java)
+		every { operations.slice(statement, Person::class.java) } returns SliceImpl(listOf(Person("Walter", "White")))
 
 		operations.slice<Person>(statement)
-		verify(operations).slice(statement, Person::class.java)
+		verify { operations.slice(statement, Person::class.java) }
 	}
 
 	@Test // DATACASS-484
@@ -156,7 +150,7 @@ class CassandraOperationsExtensionsUnitTests {
 		val statement = SimpleStatement("SELECT * FROM person")
 
 		operations.stream(statement, Person::class)
-		verify(operations).stream(statement, Person::class.java)
+		verify { operations.stream(statement, Person::class.java) }
 	}
 
 	@Test // DATACASS-484
@@ -165,27 +159,27 @@ class CassandraOperationsExtensionsUnitTests {
 		val statement = SimpleStatement("SELECT * FROM person")
 
 		operations.stream<Person>(statement)
-		verify(operations).stream(statement, Person::class.java)
+		verify { operations.stream(statement, Person::class.java) }
 	}
 
 	@Test // DATACASS-484
 	fun `selectOne(Statement, KClass) extension should call its Java counterpart`() {
 
 		val statement = SimpleStatement("SELECT * FROM person")
-		doReturn(Person("Walter", "White")).whenever(operations).selectOne(statement, Person::class.java)
+		every { operations.selectOne("SELECT * FROM person", Person::class.java) } returns Person("Walter", "White")
 
 		operations.selectOne(statement, Person::class)
-		verify(operations).selectOne(statement, Person::class.java)
+		verify { operations.selectOne(statement, Person::class.java) }
 	}
 
 	@Test // DATACASS-484
 	fun `selectOne(Statement) with reified type parameter extension should call its Java counterpart`() {
 
 		val statement = SimpleStatement("SELECT * FROM person")
-		doReturn(Person("Walter", "White")).whenever(operations).selectOne(statement, Person::class.java)
+		every { operations.selectOne("SELECT * FROM person", Person::class.java) } returns Person("Walter", "White")
 
 		operations.selectOne<Person>(statement)
-		verify(operations).selectOne(statement, Person::class.java)
+		verify { operations.selectOne(statement, Person::class.java) }
 	}
 
 	// -------------------------------------------------------------------------
@@ -196,92 +190,92 @@ class CassandraOperationsExtensionsUnitTests {
 	fun `select(Query, KClass) extension should call its Java counterpart`() {
 
 		operations.select(Query.empty(), Person::class)
-		verify(operations).select(Query.empty(), Person::class.java)
+		verify { operations.select(Query.empty(), Person::class.java) }
 	}
 
 	@Test // DATACASS-484
 	fun `select(Query) with reified type parameter extension should call its Java counterpart`() {
 
 		operations.select<Person>(Query.empty())
-		verify(operations).select(Query.empty(), Person::class.java)
+		verify { operations.select(Query.empty(), Person::class.java) }
 	}
 
 	@Test // DATACASS-484
 	fun `slice(Query, KClass) extension should call its Java counterpart`() {
 
-		doReturn(SliceImpl(listOf(Person("Walter", "White")))).whenever(operations).slice(Query.empty(), Person::class.java)
+		every { operations.slice(Query.empty(), Person::class.java) } returns SliceImpl(listOf(Person("Walter", "White")))
 
 		operations.slice(Query.empty(), Person::class)
-		verify(operations).slice(Query.empty(), Person::class.java)
+		verify { operations.slice(Query.empty(), Person::class.java) }
 	}
 
 	@Test // DATACASS-484
 	fun `slice(Query) with reified type parameter extension should call its Java counterpart`() {
 
-		doReturn(SliceImpl(listOf(Person("Walter", "White")))).whenever(operations).slice(Query.empty(), Person::class.java)
+		every { operations.slice(Query.empty(), Person::class.java) } returns SliceImpl(listOf(Person("Walter", "White")))
 
 		operations.slice<Person>(Query.empty())
-		verify(operations).slice(Query.empty(), Person::class.java)
+		verify { operations.slice(Query.empty(), Person::class.java) }
 	}
 
 	@Test // DATACASS-484
 	fun `stream(Query, KClass) extension should call its Java counterpart`() {
 
 		operations.stream(Query.empty(), Person::class)
-		verify(operations).stream(Query.empty(), Person::class.java)
+		verify { operations.stream(Query.empty(), Person::class.java) }
 	}
 
 	@Test // DATACASS-484
 	fun `stream(Query) with reified type parameter extension should call its Java counterpart`() {
 
 		operations.stream<Person>(Query.empty())
-		verify(operations).stream(Query.empty(), Person::class.java)
+		verify { operations.stream(Query.empty(), Person::class.java) }
 	}
 
 	@Test // DATACASS-484
 	fun `selectOne(Query, KClass) extension should call its Java counterpart`() {
 
-		doReturn(Person("Walter", "White")).whenever(operations).selectOne(Query.empty(), Person::class.java)
+		every { operations.selectOne(Query.empty(), Person::class.java) } returns Person("Walter", "White")
 
 		operations.selectOne(Query.empty(), Person::class)
-		verify(operations).selectOne(Query.empty(), Person::class.java)
+		verify { operations.selectOne(Query.empty(), Person::class.java) }
 	}
 
 	@Test // DATACASS-484
 	fun `selectOne(Query) with reified type parameter extension should call its Java counterpart`() {
 
-		doReturn(Person("Walter", "White")).whenever(operations).selectOne(Query.empty(), Person::class.java)
+		every { operations.selectOne(Query.empty(), Person::class.java) } returns Person("Walter", "White")
 
 		operations.selectOne<Person>(Query.empty())
-		verify(operations).selectOne(Query.empty(), Person::class.java)
+		verify { operations.selectOne(Query.empty(), Person::class.java) }
 	}
 
 	@Test // DATACASS-484
 	fun `update(Query, Update, KClass) extension should call its Java counterpart`() {
 
 		operations.update(Query.empty(), Update.empty(), Person::class)
-		verify(operations).update(Query.empty(), Update.empty(), Person::class.java)
+		verify { operations.update(Query.empty(), Update.empty(), Person::class.java) }
 	}
 
 	@Test // DATACASS-484
 	fun `update(Query, Update) with reified type parameter extension should call its Java counterpart`() {
 
 		operations.update<Person>(Query.empty(), Update.empty())
-		verify(operations).update(Query.empty(), Update.empty(), Person::class.java)
+		verify { operations.update(Query.empty(), Update.empty(), Person::class.java) }
 	}
 
 	@Test // DATACASS-484
 	fun `delete(Query, KClass) extension should call its Java counterpart`() {
 
 		operations.delete(Query.empty(), Person::class)
-		verify(operations).delete(Query.empty(), Person::class.java)
+		verify { operations.delete(Query.empty(), Person::class.java) }
 	}
 
 	@Test // DATACASS-484
 	fun `delete(Query,) with reified type parameter extension should call its Java counterpart`() {
 
 		operations.delete<Person>(Query.empty())
-		verify(operations).delete(Query.empty(), Person::class.java)
+		verify { operations.delete(Query.empty(), Person::class.java) }
 	}
 
 	// -------------------------------------------------------------------------
@@ -292,101 +286,101 @@ class CassandraOperationsExtensionsUnitTests {
 	fun `count(KClass) extension should call its Java counterpart`() {
 
 		operations.count(Person::class)
-		verify(operations).count(Person::class.java)
+		verify { operations.count(Person::class.java) }
 	}
 
 	@Test // DATACASS-484
 	fun `count() with reified type parameter extension should call its Java counterpart`() {
 
 		operations.count<Person>()
-		verify(operations).count(Person::class.java)
+		verify { operations.count(Person::class.java) }
 	}
 
 	@Test // DATACASS-484
 	fun `count(Query, KClass) extension should call its Java counterpart`() {
 
 		operations.count(Query.empty(), Person::class)
-		verify(operations).count(Query.empty(), Person::class.java)
+		verify { operations.count(Query.empty(), Person::class.java) }
 	}
 
 	@Test // DATACASS-484
 	fun `count(Query) with reified type parameter extension should call its Java counterpart`() {
 
 		operations.count<Person>(Query.empty())
-		verify(operations).count(Query.empty(), Person::class.java)
+		verify { operations.count(Query.empty(), Person::class.java) }
 	}
 
 	@Test // DATACASS-484
 	fun `exists(Any, KClass) extension should call its Java counterpart`() {
 
 		operations.exists("id", Person::class)
-		verify(operations).exists("id", Person::class.java)
+		verify { operations.exists("id", Person::class.java) }
 	}
 
 	@Test // DATACASS-484
 	fun `exists(Any) with reified type parameter extension should call its Java counterpart`() {
 
 		operations.exists<Person>("id")
-		verify(operations).exists("id", Person::class.java)
+		verify { operations.exists("id", Person::class.java) }
 	}
 
 	@Test // DATACASS-484
 	fun `exists(Query, KClass) extension should call its Java counterpart`() {
 
 		operations.exists(Query.empty(), Person::class)
-		verify(operations).exists(Query.empty(), Person::class.java)
+		verify { operations.exists(Query.empty(), Person::class.java) }
 	}
 
 	@Test // DATACASS-484
 	fun `exists(Query) with reified type parameter extension should call its Java counterpart`() {
 
 		operations.exists<Person>(Query.empty())
-		verify(operations).exists(Query.empty(), Person::class.java)
+		verify { operations.exists(Query.empty(), Person::class.java) }
 	}
 
 	@Test // DATACASS-484
 	fun `selectOneById(Any, KClass) extension should call its Java counterpart`() {
 
-		doReturn(Person("Walter", "White")).whenever(operations).selectOneById("id", Person::class.java)
+		every { operations.selectOneById("id", Person::class.java) } returns Person("Walter", "White")
 
 		operations.selectOneById("id", Person::class)
-		verify(operations).selectOneById("id", Person::class.java)
+		verify { operations.selectOneById("id", Person::class.java) }
 	}
 
 	@Test // DATACASS-484
 	fun `selectOneById(Any) with reified type parameter extension should call its Java counterpart`() {
 
-		doReturn(Person("Walter", "White")).whenever(operations).selectOneById("id", Person::class.java)
+		every { operations.selectOneById("id", Person::class.java) } returns Person("Walter", "White")
 
 		operations.selectOneById<Person>("id")
-		verify(operations).selectOneById("id", Person::class.java)
+		verify { operations.selectOneById("id", Person::class.java) }
 	}
 
 	@Test // DATACASS-484
 	fun `deleteById(Any, KClass) extension should call its Java counterpart`() {
 
 		operations.deleteById("id", Person::class)
-		verify(operations).deleteById("id", Person::class.java)
+		verify { operations.deleteById("id", Person::class.java) }
 	}
 
 	@Test // DATACASS-484
 	fun `deleteById(Any) with reified type parameter extension should call its Java counterpart`() {
 
 		operations.deleteById<Person>("id")
-		verify(operations).deleteById("id", Person::class.java)
+		verify { operations.deleteById("id", Person::class.java) }
 	}
 
 	@Test // DATACASS-484
 	fun `truncate(KClass) extension should call its Java counterpart`() {
 
 		operations.truncate(Person::class)
-		verify(operations).truncate(Person::class.java)
+		verify { operations.truncate(Person::class.java) }
 	}
 
 	@Test // DATACASS-484
 	fun `truncate() with reified type parameter extension should call its Java counterpart`() {
 
 		operations.truncate<Person>()
-		verify(operations).truncate(Person::class.java)
+		verify { operations.truncate(Person::class.java) }
 	}
 }

spring-data-cassandra/src/test/kotlin/org/springframework/data/cassandra/core/ExecutableDeleteOperationExtensionsUnitTests.kt

@@ -15,12 +15,10 @@
  */
 package org.springframework.data.cassandra.core
 
-import com.nhaarman.mockito_kotlin.verify
+import io.mockk.mockk
+import io.mockk.verify
+import org.junit.Ignore
 import org.junit.Test
-import org.junit.runner.RunWith
-import org.mockito.Answers
-import org.mockito.Mock
-import org.mockito.junit.MockitoJUnitRunner
 import org.springframework.data.cassandra.domain.Person
 
 /**
@@ -28,23 +26,21 @@ import org.springframework.data.cassandra.domain.Person
  *
  * @author Mark Paluch
  */
-@RunWith(MockitoJUnitRunner::class)
 class ExecutableDeleteOperationExtensionsUnitTests {
 
-	@Mock(answer = Answers.RETURNS_MOCKS)
-	lateinit var operations: FluentCassandraOperations
+	val operations = mockk<FluentCassandraOperations>(relaxed = true)
 
 	@Test // DATACASS-484
 	fun `delete(KClass) extension should call its Java counterpart`() {
 
 		operations.delete(Person::class);
-		verify(operations).delete(Person::class.java)
+		verify { operations.delete(Person::class.java) }
 	}
 
 	@Test // DATACASS-484
 	fun `delete() with reified type parameter extension should call its Java counterpart`() {
 
 		operations.delete<Person>()
-		verify(operations).delete(Person::class.java)
+		verify { operations.delete(Person::class.java) }
 	}
 }

spring-data-cassandra/src/test/kotlin/org/springframework/data/cassandra/core/ExecutableInsertOperationExtensionsUnitTests.kt

@@ -15,12 +15,9 @@
  */
 package org.springframework.data.cassandra.core
 
-import com.nhaarman.mockito_kotlin.verify
+import io.mockk.mockk
+import io.mockk.verify
 import org.junit.Test
-import org.junit.runner.RunWith
-import org.mockito.Answers
-import org.mockito.Mock
-import org.mockito.junit.MockitoJUnitRunner
 import org.springframework.data.cassandra.domain.Person
 
 /**
@@ -28,23 +25,21 @@ import org.springframework.data.cassandra.domain.Person
  *
  * @author Mark Paluch
  */
-@RunWith(MockitoJUnitRunner::class)
 class ExecutableInsertOperationExtensionsUnitTests {
 
-	@Mock(answer = Answers.RETURNS_MOCKS)
-	lateinit var operations: FluentCassandraOperations
+	val operations = mockk<FluentCassandraOperations>(relaxed = true)
 
 	@Test // DATACASS-484
 	fun `insert(KClass) extension should call its Java counterpart`() {
 
 		operations.insert(Person::class);
-		verify(operations).insert(Person::class.java)
+		verify { operations.insert(Person::class.java) }
 	}
 
 	@Test // DATACASS-484
 	fun `insert() with reified type parameter extension should call its Java counterpart`() {
 
 		operations.insert<Person>()
-		verify(operations).insert(Person::class.java)
+		verify { operations.insert(Person::class.java) }
 	}
 }

spring-data-cassandra/src/test/kotlin/org/springframework/data/cassandra/core/ExecutableSelectOperationExtensionsUnitTests.kt

@@ -15,12 +15,9 @@
  */
 package org.springframework.data.cassandra.core
 
-import com.nhaarman.mockito_kotlin.verify
+import io.mockk.mockk
+import io.mockk.verify
 import org.junit.Test
-import org.junit.runner.RunWith
-import org.mockito.Answers
-import org.mockito.Mock
-import org.mockito.junit.MockitoJUnitRunner
 import org.springframework.data.cassandra.domain.Person
 import org.springframework.data.cassandra.domain.User
 
@@ -29,40 +26,38 @@ import org.springframework.data.cassandra.domain.User
  *
  * @author Mark Paluch
  */
-@RunWith(MockitoJUnitRunner::class)
 class ExecutableSelectOperationExtensionsUnitTests {
 
-	@Mock(answer = Answers.RETURNS_MOCKS)
-	lateinit var operations: FluentCassandraOperations
+	val operations = mockk<FluentCassandraOperations>(relaxed = true)
+
+	val operationWithProjection = mockk<ExecutableSelectOperation.SelectWithProjection<User>>(relaxed = true)
 
-	@Mock(answer = Answers.RETURNS_MOCKS)
-	lateinit var operationWithProjection: ExecutableSelectOperation.SelectWithProjection<User>
 
 	@Test // DATACASS-484
 	fun `query(KClass) extension should call its Java counterpart`() {
 
 		operations.query(Person::class);
-		verify(operations).query(Person::class.java)
+		verify { operations.query(Person::class.java) }
 	}
 
 	@Test // DATACASS-484
 	fun `query() with reified type parameter extension should call its Java counterpart`() {
 
 		operations.query<Person>()
-		verify(operations).query(Person::class.java)
+		verify { operations.query(Person::class.java) }
 	}
 
 	@Test // DATACASS-484
 	fun `asType(KClass) extension should call its Java counterpart`() {
 
 		operationWithProjection.asType(User::class);
-		verify(operationWithProjection).`as`(User::class.java)
+		verify { operationWithProjection.`as`(User::class.java) }
 	}
 
 	@Test // DATACASS-484
 	fun `asType() with reified type parameter extension should call its Java counterpart`() {
 
 		operationWithProjection.asType<User>();
-		verify(operationWithProjection).`as`(User::class.java)
+		verify { operationWithProjection.`as`(User::class.java) }
 	}
 }

spring-data-cassandra/src/test/kotlin/org/springframework/data/cassandra/core/ExecutableUpdateOperationExtensionsUnitTests.kt

@@ -15,12 +15,9 @@
  */
 package org.springframework.data.cassandra.core
 
-import com.nhaarman.mockito_kotlin.verify
+import io.mockk.mockk
+import io.mockk.verify
 import org.junit.Test
-import org.junit.runner.RunWith
-import org.mockito.Answers
-import org.mockito.Mock
-import org.mockito.junit.MockitoJUnitRunner
 import org.springframework.data.cassandra.domain.Person
 
 /**
@@ -28,23 +25,21 @@ import org.springframework.data.cassandra.domain.Person
  *
  * @author Mark Paluch
  */
-@RunWith(MockitoJUnitRunner::class)
 class ExecutableUpdateOperationExtensionsUnitTests {
 
-	@Mock(answer = Answers.RETURNS_MOCKS)
-	lateinit var operations: FluentCassandraOperations
+	val operations = mockk<FluentCassandraOperations>(relaxed = true)
 
 	@Test // DATACASS-484
 	fun `update(KClass) extension should call its Java counterpart`() {
 
 		operations.update(Person::class);
-		verify(operations).update(Person::class.java)
+		verify { operations.update(Person::class.java) }
 	}
 
 	@Test // DATACASS-484
 	fun `update() with reified type parameter extension should call its Java counterpart`() {
 
 		operations.update<Person>()
-		verify(operations).update(Person::class.java)
+		verify { operations.update(Person::class.java) }
 	}
 }

spring-data-cassandra/src/test/kotlin/org/springframework/data/cassandra/core/ReactiveCassandraOperationsExtensionsUnitTests.kt

@@ -16,12 +16,9 @@
 package org.springframework.data.cassandra.core
 
 import com.datastax.driver.core.SimpleStatement
-import com.nhaarman.mockito_kotlin.verify
+import io.mockk.mockk
+import io.mockk.verify
 import org.junit.Test
-import org.junit.runner.RunWith
-import org.mockito.Answers
-import org.mockito.Mock
-import org.mockito.junit.MockitoJUnitRunner
 import org.springframework.data.cassandra.core.query.Query
 import org.springframework.data.cassandra.core.query.Update
 import org.springframework.data.cassandra.domain.Person
@@ -31,11 +28,9 @@ import org.springframework.data.cassandra.domain.Person
  *
  * @author Mark Paluch
  */
-@RunWith(MockitoJUnitRunner::class)
 class ReactiveCassandraOperationsExtensionsUnitTests {
 
-	@Mock(answer = Answers.RETURNS_MOCKS)
-	lateinit var operations: ReactiveCassandraOperations
+	val operations = mockk<ReactiveCassandraOperations>(relaxed = true)
 
 	// -------------------------------------------------------------------------
 	// Methods dealing with static CQL
@@ -45,28 +40,28 @@ class ReactiveCassandraOperationsExtensionsUnitTests {
 	fun `select(String, KClass) extension should call its Java counterpart`() {
 
 		operations.select("SELECT * FROM person", Person::class)
-		verify(operations).select("SELECT * FROM person", Person::class.java)
+		verify { operations.select("SELECT * FROM person", Person::class.java) }
 	}
 
 	@Test // DATACASS-484
 	fun `select(String) with reified type parameter extension should call its Java counterpart`() {
 
 		operations.select<Person>("SELECT * FROM person")
-		verify(operations).select("SELECT * FROM person", Person::class.java)
+		verify { operations.select("SELECT * FROM person", Person::class.java) }
 	}
 
 	@Test // DATACASS-484
 	fun `selectOne(String, KClass) extension should call its Java counterpart`() {
 
 		operations.selectOne("SELECT * FROM person", Person::class)
-		verify(operations).selectOne("SELECT * FROM person", Person::class.java)
+		verify { operations.selectOne("SELECT * FROM person", Person::class.java) }
 	}
 
 	@Test // DATACASS-484
 	fun `selectOne(String) with reified type parameter extension should call its Java counterpart`() {
 
 		operations.selectOne<Person>("SELECT * FROM person")
-		verify(operations).selectOne("SELECT * FROM person", Person::class.java)
+		verify { operations.selectOne("SELECT * FROM person", Person::class.java) }
 	}
 
 	// -------------------------------------------------------------------------
@@ -79,7 +74,7 @@ class ReactiveCassandraOperationsExtensionsUnitTests {
 		val statement = SimpleStatement("SELECT * FROM person")
 
 		operations.select(statement, Person::class)
-		verify(operations).select(statement, Person::class.java)
+		verify { operations.select(statement, Person::class.java) }
 	}
 
 	@Test // DATACASS-484
@@ -87,7 +82,7 @@ class ReactiveCassandraOperationsExtensionsUnitTests {
 
 		val statement = SimpleStatement("SELECT * FROM person")
 		operations.select<Person>(statement)
-		verify(operations).select(statement, Person::class.java)
+		verify { operations.select(statement, Person::class.java) }
 	}
 
 	@Test // DATACASS-484
@@ -96,7 +91,7 @@ class ReactiveCassandraOperationsExtensionsUnitTests {
 		val statement = SimpleStatement("SELECT * FROM person")
 
 		operations.selectOne(statement, Person::class)
-		verify(operations).selectOne(statement, Person::class.java)
+		verify { operations.selectOne(statement, Person::class.java) }
 	}
 
 	@Test // DATACASS-484
@@ -105,7 +100,7 @@ class ReactiveCassandraOperationsExtensionsUnitTests {
 		val statement = SimpleStatement("SELECT * FROM person")
 
 		operations.selectOne<Person>(statement)
-		verify(operations).selectOne(statement, Person::class.java)
+		verify { operations.selectOne(statement, Person::class.java) }
 	}
 
 	// -------------------------------------------------------------------------
@@ -116,56 +111,56 @@ class ReactiveCassandraOperationsExtensionsUnitTests {
 	fun `select(Query, KClass) extension should call its Java counterpart`() {
 
 		operations.select(Query.empty(), Person::class)
-		verify(operations).select(Query.empty(), Person::class.java)
+		verify { operations.select(Query.empty(), Person::class.java) }
 	}
 
 	@Test // DATACASS-484
 	fun `select(Query) with reified type parameter extension should call its Java counterpart`() {
 
 		operations.select<Person>(Query.empty())
-		verify(operations).select(Query.empty(), Person::class.java)
+		verify { operations.select(Query.empty(), Person::class.java) }
 	}
 
 	@Test // DATACASS-484
 	fun `selectOne(Query, KClass) extension should call its Java counterpart`() {
 
 		operations.selectOne(Query.empty(), Person::class)
-		verify(operations).selectOne(Query.empty(), Person::class.java)
+		verify { operations.selectOne(Query.empty(), Person::class.java) }
 	}
 
 	@Test // DATACASS-484
 	fun `selectOne(Query) with reified type parameter extension should call its Java counterpart`() {
 
 		operations.selectOne<Person>(Query.empty())
-		verify(operations).selectOne(Query.empty(), Person::class.java)
+		verify { operations.selectOne(Query.empty(), Person::class.java) }
 	}
 
 	@Test // DATACASS-484
 	fun `update(Query, Update, KClass) extension should call its Java counterpart`() {
 
 		operations.update(Query.empty(), Update.empty(), Person::class)
-		verify(operations).update(Query.empty(), Update.empty(), Person::class.java)
+		verify { operations.update(Query.empty(), Update.empty(), Person::class.java) }
 	}
 
 	@Test // DATACASS-484
 	fun `update(Query, Update) with reified type parameter extension should call its Java counterpart`() {
 
 		operations.update<Person>(Query.empty(), Update.empty())
-		verify(operations).update(Query.empty(), Update.empty(), Person::class.java)
+		verify { operations.update(Query.empty(), Update.empty(), Person::class.java) }
 	}
 
 	@Test // DATACASS-484
 	fun `delete(Query, KClass) extension should call its Java counterpart`() {
 
 		operations.delete(Query.empty(), Person::class)
-		verify(operations).delete(Query.empty(), Person::class.java)
+		verify { operations.delete(Query.empty(), Person::class.java) }
 	}
 
 	@Test // DATACASS-484
 	fun `delete(Query) with reified type parameter extension should call its Java counterpart`() {
 
 		operations.delete<Person>(Query.empty())
-		verify(operations).delete(Query.empty(), Person::class.java)
+		verify { operations.delete(Query.empty(), Person::class.java) }
 	}
 
 	// -------------------------------------------------------------------------
@@ -176,97 +171,97 @@ class ReactiveCassandraOperationsExtensionsUnitTests {
 	fun `count(KClass) extension should call its Java counterpart`() {
 
 		operations.count(Person::class)
-		verify(operations).count(Person::class.java)
+		verify { operations.count(Person::class.java) }
 	}
 
 	@Test // DATACASS-484
 	fun `count() with reified type parameter extension should call its Java counterpart`() {
 
 		operations.count<Person>()
-		verify(operations).count(Person::class.java)
+		verify { operations.count(Person::class.java) }
 	}
 
 	@Test // DATACASS-484
 	fun `count(Query, KClass) extension should call its Java counterpart`() {
 
 		operations.count(Query.empty(), Person::class)
-		verify(operations).count(Query.empty(), Person::class.java)
+		verify { operations.count(Query.empty(), Person::class.java) }
 	}
 
 	@Test // DATACASS-484
 	fun `count(Query) with reified type parameter extension should call its Java counterpart`() {
 
 		operations.count<Person>(Query.empty())
-		verify(operations).count(Query.empty(), Person::class.java)
+		verify { operations.count(Query.empty(), Person::class.java) }
 	}
 
 	@Test // DATACASS-484
 	fun `exists(Any, KClass) extension should call its Java counterpart`() {
 
 		operations.exists("id", Person::class)
-		verify(operations).exists("id", Person::class.java)
+		verify { operations.exists("id", Person::class.java) }
 	}
 
 	@Test // DATACASS-484
 	fun `exists(Any) with reified type parameter extension should call its Java counterpart`() {
 
 		operations.exists<Person>("id")
-		verify(operations).exists("id", Person::class.java)
+		verify { operations.exists("id", Person::class.java) }
 	}
 
 	@Test // DATACASS-484
 	fun `exists(Query, KClass) extension should call its Java counterpart`() {
 
 		operations.exists(Query.empty(), Person::class)
-		verify(operations).exists(Query.empty(), Person::class.java)
+		verify { operations.exists(Query.empty(), Person::class.java) }
 	}
 
 	@Test // DATACASS-484
 	fun `exists(Query) with reified type parameter extension should call its Java counterpart`() {
 
 		operations.exists<Person>(Query.empty())
-		verify(operations).exists(Query.empty(), Person::class.java)
+		verify { operations.exists(Query.empty(), Person::class.java) }
 	}
 
 	@Test // DATACASS-484
 	fun `selectOneById(Any, KClass) extension should call its Java counterpart`() {
 
 		operations.selectOneById("id", Person::class)
-		verify(operations).selectOneById("id", Person::class.java)
+		verify { operations.selectOneById("id", Person::class.java) }
 	}
 
 	@Test // DATACASS-484
 	fun `selectOneById(Any) with reified type parameter extension should call its Java counterpart`() {
 
 		operations.selectOneById<Person>("id")
-		verify(operations).selectOneById("id", Person::class.java)
+		verify { operations.selectOneById("id", Person::class.java) }
 	}
 
 	@Test // DATACASS-484
 	fun `deleteById(Any, KClass) extension should call its Java counterpart`() {
 
 		operations.deleteById("id", Person::class)
-		verify(operations).deleteById("id", Person::class.java)
+		verify { operations.deleteById("id", Person::class.java) }
 	}
 
 	@Test // DATACASS-484
 	fun `deleteById(Any) with reified type parameter extension should call its Java counterpart`() {
 
 		operations.deleteById<Person>("id")
-		verify(operations).deleteById("id", Person::class.java)
+		verify { operations.deleteById("id", Person::class.java) }
 	}
 
 	@Test // DATACASS-484
 	fun `truncate(KClass) extension should call its Java counterpart`() {
 
 		operations.truncate(Person::class)
-		verify(operations).truncate(Person::class.java)
+		verify { operations.truncate(Person::class.java) }
 	}
 
 	@Test // DATACASS-484
 	fun `truncate() with reified type parameter extension should call its Java counterpart`() {
 
 		operations.truncate<Person>()
-		verify(operations).truncate(Person::class.java)
+		verify { operations.truncate(Person::class.java) }
 	}
 }

spring-data-cassandra/src/test/kotlin/org/springframework/data/cassandra/core/ReactiveDeleteOperationExtensionsUnitTests.kt

@@ -15,12 +15,9 @@
  */
 package org.springframework.data.cassandra.core
 
-import com.nhaarman.mockito_kotlin.verify
+import io.mockk.mockk
+import io.mockk.verify
 import org.junit.Test
-import org.junit.runner.RunWith
-import org.mockito.Answers
-import org.mockito.Mock
-import org.mockito.junit.MockitoJUnitRunner
 import org.springframework.data.cassandra.domain.Person
 
 /**
@@ -28,23 +25,21 @@ import org.springframework.data.cassandra.domain.Person
  *
  * @author Mark Paluch
  */
-@RunWith(MockitoJUnitRunner::class)
 class ReactiveDeleteOperationExtensionsUnitTests {
 
-	@Mock(answer = Answers.RETURNS_MOCKS)
-	lateinit var operations: ReactiveFluentCassandraOperations
+	val operations = mockk<ReactiveFluentCassandraOperations>(relaxed = true)
 
 	@Test // DATACASS-484
 	fun `delete(KClass) extension should call its Java counterpart`() {
 
 		operations.delete(Person::class);
-		verify(operations).delete(Person::class.java)
+		verify { operations.delete(Person::class.java) }
 	}
 
 	@Test // DATACASS-484
 	fun `delete() with reified type parameter extension should call its Java counterpart`() {
 
 		operations.delete<Person>()
-		verify(operations).delete(Person::class.java)
+		verify { operations.delete(Person::class.java) }
 	}
 }

spring-data-cassandra/src/test/kotlin/org/springframework/data/cassandra/core/ReactiveInsertOperationExtensionsUnitTests.kt

@@ -15,12 +15,10 @@
  */
 package org.springframework.data.cassandra.core
 
-import com.nhaarman.mockito_kotlin.verify
+import io.mockk.mockk
+import io.mockk.verify
+import org.junit.Ignore
 import org.junit.Test
-import org.junit.runner.RunWith
-import org.mockito.Answers
-import org.mockito.Mock
-import org.mockito.junit.MockitoJUnitRunner
 import org.springframework.data.cassandra.domain.Person
 
 /**
@@ -28,23 +26,21 @@ import org.springframework.data.cassandra.domain.Person
  *
  * @author Mark Paluch
  */
-@RunWith(MockitoJUnitRunner::class)
 class ReactiveInsertOperationExtensionsUnitTests {
 
-	@Mock(answer = Answers.RETURNS_MOCKS)
-	lateinit var operations: ReactiveFluentCassandraOperations
+	val operations = mockk<ReactiveFluentCassandraOperations>(relaxed = true)
 
 	@Test // DATACASS-484
 	fun `insert(KClass) extension should call its Java counterpart`() {
 
 		operations.insert(Person::class);
-		verify(operations).insert(Person::class.java)
+		verify { operations.insert(Person::class.java) }
 	}
 
 	@Test // DATACASS-484
 	fun `insert() with reified type parameter extension should call its Java counterpart`() {
 
 		operations.insert<Person>()
-		verify(operations).insert(Person::class.java)
+		verify { operations.insert(Person::class.java) }
 	}
 }

spring-data-cassandra/src/test/kotlin/org/springframework/data/cassandra/core/ReactiveSelectOperationExtensionsUnitTests.kt

@@ -15,12 +15,9 @@
  */
 package org.springframework.data.cassandra.core
 
-import com.nhaarman.mockito_kotlin.verify
+import io.mockk.mockk
+import io.mockk.verify
 import org.junit.Test
-import org.junit.runner.RunWith
-import org.mockito.Answers
-import org.mockito.Mock
-import org.mockito.junit.MockitoJUnitRunner
 import org.springframework.data.cassandra.domain.Person
 import org.springframework.data.cassandra.domain.User
 
@@ -29,40 +26,37 @@ import org.springframework.data.cassandra.domain.User
  *
  * @author Mark Paluch
  */
-@RunWith(MockitoJUnitRunner::class)
 class ReactiveSelectOperationExtensionsUnitTests {
 
-	@Mock(answer = Answers.RETURNS_MOCKS)
-	lateinit var operations: ReactiveFluentCassandraOperations
+	val operations = mockk<ReactiveCassandraOperations>(relaxed = true)
 
-	@Mock(answer = Answers.RETURNS_MOCKS)
-	lateinit var operationWithProjection: ReactiveSelectOperation.SelectWithProjection<User>
+	val operationWithProjection = mockk<ReactiveSelectOperation.SelectWithProjection<User>>(relaxed = true)
 
 	@Test // DATACASS-484
 	fun `query(KClass) extension should call its Java counterpart`() {
 
 		operations.query(Person::class);
-		verify(operations).query(Person::class.java)
+		verify { operations.query(Person::class.java) }
 	}
 
 	@Test // DATACASS-484
 	fun `query() with reified type parameter extension should call its Java counterpart`() {
 
 		operations.query<Person>()
-		verify(operations).query(Person::class.java)
+		verify { operations.query(Person::class.java) }
 	}
 
 	@Test // DATACASS-484
 	fun `asType(KClass) extension should call its Java counterpart`() {
 
 		operationWithProjection.asType(User::class);
-		verify(operationWithProjection).`as`(User::class.java)
+		verify { operationWithProjection.`as`(User::class.java) }
 	}
 
 	@Test // DATACASS-484
 	fun `asType() with reified type parameter extension should call its Java counterpart`() {
 
 		operationWithProjection.asType<User>();
-		verify(operationWithProjection).`as`(User::class.java)
+		verify { operationWithProjection.`as`(User::class.java) }
 	}
 }

spring-data-cassandra/src/test/kotlin/org/springframework/data/cassandra/core/ReactiveUpdateOperationExtensionsUnitTests.kt

@@ -15,12 +15,9 @@
  */
 package org.springframework.data.cassandra.core
 
-import com.nhaarman.mockito_kotlin.verify
+import io.mockk.mockk
+import io.mockk.verify
 import org.junit.Test
-import org.junit.runner.RunWith
-import org.mockito.Answers
-import org.mockito.Mock
-import org.mockito.junit.MockitoJUnitRunner
 import org.springframework.data.cassandra.domain.Person
 
 /**
@@ -28,23 +25,21 @@ import org.springframework.data.cassandra.domain.Person
  *
  * @author Mark Paluch
  */
-@RunWith(MockitoJUnitRunner::class)
 class ReactiveUpdateOperationExtensionsUnitTests {
 
-	@Mock(answer = Answers.RETURNS_MOCKS)
-	lateinit var operations: ReactiveFluentCassandraOperations
+	val operations = mockk<ReactiveFluentCassandraOperations>(relaxed = true)
 
 	@Test // DATACASS-484
 	fun `update(KClass) extension should call its Java counterpart`() {
 
 		operations.update(Person::class);
-		verify(operations).update(Person::class.java)
+		verify { operations.update(Person::class.java) }
 	}
 
 	@Test // DATACASS-484
 	fun `update() with reified type parameter extension should call its Java counterpart`() {
 
 		operations.update<Person>()
-		verify(operations).update(Person::class.java)
+		verify { operations.update(Person::class.java) }
 	}
 }

spring-data-cassandra/src/test/kotlin/org/springframework/data/cassandra/core/cql/AsyncCqlOperationsExtensionsUnitTests.kt

@@ -17,15 +17,10 @@ package org.springframework.data.cassandra.core.cql
 
 import com.datastax.driver.core.Row
 import com.datastax.driver.core.SimpleStatement
-import com.nhaarman.mockito_kotlin.any
-import com.nhaarman.mockito_kotlin.eq
-import com.nhaarman.mockito_kotlin.verify
+import io.mockk.mockk
+import io.mockk.verify
 import org.junit.Ignore
 import org.junit.Test
-import org.junit.runner.RunWith
-import org.mockito.Answers
-import org.mockito.Mock
-import org.mockito.junit.MockitoJUnitRunner
 import org.springframework.data.cassandra.domain.Person
 
 /**
@@ -33,45 +28,43 @@ import org.springframework.data.cassandra.domain.Person
  *
  * @author Mark Paluch
  */
-@RunWith(MockitoJUnitRunner::class)
 class AsyncCqlOperationsExtensionsUnitTests {
 
-	@Mock(answer = Answers.RETURNS_MOCKS)
-	lateinit var operations: AsyncCqlOperations
+	val operations = mockk<AsyncCqlOperations>(relaxed = true)
 
 	@Test // DATACASS-484
 	fun `queryForObject(String, KClass) extension should call its Java counterpart`() {
 
 		operations.queryForObject("", Person::class)
-		verify(operations).queryForObject("", Person::class.java)
+		verify { operations.queryForObject("", Person::class.java) }
 	}
 
 	@Test // DATACASS-484
 	fun `queryForObject(String) extension should call its Java counterpart`() {
 
 		operations.queryForObject<Person>("")
-		verify(operations).queryForObject("", Person::class.java)
+		verify { operations.queryForObject("", Person::class.java) }
 	}
 
 	@Test // DATACASS-484
 	fun `queryForObject(String, KClass, array) extension should call its Java counterpart`() {
 
 		operations.queryForObject("", Person::class, "foo", "bar")
-		verify(operations).queryForObject("", Person::class.java, arrayOf("foo", "bar"))
+		verify { operations.queryForObject("", Person::class.java, arrayOf("foo", "bar")) }
 	}
 
 	@Test // DATACASS-484
 	fun `queryForObject(String, array) extension should call its Java counterpart`() {
 
 		operations.queryForObject<Person>("", "foo", "bar")
-		verify(operations).queryForObject("", Person::class.java, arrayOf("foo", "bar"))
+		verify { operations.queryForObject("", Person::class.java, arrayOf("foo", "bar")) }
 	}
 
 	@Test // DATACASS-484
 	fun `queryForObject(String, RowMapper, array) extension should call its Java counterpart`() {
 
 		operations.queryForObject("", 3) { rs: Row, _: Int -> rs.getInt(1) }
-		verify(operations).queryForObject(eq(""), any<RowMapper<Int>>(), eq(3))
+		verify { operations.queryForObject(eq(""), any<RowMapper<Int>>(), eq(3)) }
 	}
 
 	@Test // DATACASS-484
@@ -80,7 +73,7 @@ class AsyncCqlOperationsExtensionsUnitTests {
 		val statement = SimpleStatement("SELECT * FROM person")
 
 		operations.queryForObject(statement, Person::class)
-		verify(operations).queryForObject(statement, Person::class.java)
+		verify { operations.queryForObject(statement, Person::class.java) }
 	}
 
 	@Test // DATACASS-484
@@ -89,21 +82,21 @@ class AsyncCqlOperationsExtensionsUnitTests {
 		val statement = SimpleStatement("SELECT * FROM person")
 
 		operations.queryForObject<Person>(statement)
-		verify(operations).queryForObject(statement, Person::class.java)
+		verify { operations.queryForObject(statement, Person::class.java) }
 	}
 
 	@Test // DATACASS-484
 	fun `queryForList(String) extension should call its Java counterpart`() {
 
 		operations.queryForList<Person>("")
-		verify(operations).queryForList("", Person::class.java)
+		verify { operations.queryForList("", Person::class.java) }
 	}
 
 	@Test // DATACASS-484
 	fun `queryForList(String, array) extension should call its Java counterpart`() {
 
 		operations.queryForList<Person>("", "foo", "bar")
-		verify(operations).queryForList("", Person::class.java, arrayOf("foo", "bar"))
+		verify { operations.queryForList("", Person::class.java, arrayOf("foo", "bar")) }
 	}
 
 	@Test // DATACASS-484
@@ -111,7 +104,7 @@ class AsyncCqlOperationsExtensionsUnitTests {
 	fun `queryForList(String, RowMapper, array) extension should call its Java counterpart`() {
 
 		//operations.queryForList("", 3) { rs: Row, _: Int -> rs.getInt(1) }
-		verify(operations).queryForList(eq(""), any<RowMapper<Int>>(), eq(3))
+		verify { operations.queryForList(eq(""), any<RowMapper<Int>>(), eq(3)) }
 	}
 
 	@Test // DATACASS-484
@@ -120,7 +113,7 @@ class AsyncCqlOperationsExtensionsUnitTests {
 		val statement = SimpleStatement("SELECT * FROM person")
 
 		operations.queryForList(statement, Person::class)
-		verify(operations).queryForList(statement, Person::class.java)
+		verify { operations.queryForList(statement, Person::class.java) }
 	}
 
 	@Test // DATACASS-484
@@ -129,20 +122,20 @@ class AsyncCqlOperationsExtensionsUnitTests {
 		val statement = SimpleStatement("SELECT * FROM person")
 
 		operations.queryForList<Person>(statement)
-		verify(operations).queryForList(statement, Person::class.java)
+		verify { operations.queryForList(statement, Person::class.java) }
 	}
 
 	@Test // DATACASS-484
 	fun `query(String, ResultSetExtractor, array) extension should call its Java counterpart`() {
 
 		operations.query("", 3) { rs -> Person("Walter", rs.single().getString(0)) }
-		verify(operations).query(eq(""), any<ResultSetExtractor<Person>>(), eq(3))
+		verify { operations.query(eq(""), any<ResultSetExtractor<Person>>(), eq(3)) }
 	}
 
 	@Test // DATACASS-484
 	fun `query(String, RowMapper, array) extension should call its Java counterpart`() {
 
 		operations.query("", 3) { row, _ -> row.columnDefinitions }
-		verify(operations).query(eq(""), any<RowMapper<Person>>(), eq(3))
+		verify { operations.query(eq(""), any<RowMapper<Person>>(), eq(3)) }
 	}
 }

spring-data-cassandra/src/test/kotlin/org/springframework/data/cassandra/core/cql/CqlOperationsExtensionsUnitTests.kt

@@ -17,15 +17,10 @@ package org.springframework.data.cassandra.core.cql
 
 import com.datastax.driver.core.Row
 import com.datastax.driver.core.SimpleStatement
-import com.nhaarman.mockito_kotlin.any
-import com.nhaarman.mockito_kotlin.eq
-import com.nhaarman.mockito_kotlin.verify
+import io.mockk.mockk
+import io.mockk.verify
 import org.junit.Ignore
 import org.junit.Test
-import org.junit.runner.RunWith
-import org.mockito.Answers
-import org.mockito.Mock
-import org.mockito.junit.MockitoJUnitRunner
 import org.springframework.data.cassandra.domain.Person
 
 /**
@@ -33,45 +28,43 @@ import org.springframework.data.cassandra.domain.Person
  *
  * @author Mark Paluch
  */
-@RunWith(MockitoJUnitRunner::class)
 class CqlOperationsExtensionsUnitTests {
 
-	@Mock(answer = Answers.RETURNS_MOCKS)
-	lateinit var operations: CqlOperations
+	val operations = mockk<CqlOperations>(relaxed = true)
 
 	@Test // DATACASS-484
 	fun `queryForObject(String, KClass) extension should call its Java counterpart`() {
 
 		operations.queryForObject("", Person::class)
-		verify(operations).queryForObject("", Person::class.java)
+		verify { operations.queryForObject("", Person::class.java) }
 	}
 
 	@Test // DATACASS-484
 	fun `queryForObject(String) extension should call its Java counterpart`() {
 
 		operations.queryForObject<Person>("")
-		verify(operations).queryForObject("", Person::class.java)
+		verify { operations.queryForObject("", Person::class.java) }
 	}
 
 	@Test // DATACASS-484
 	fun `queryForObject(String, KClass, array) extension should call its Java counterpart`() {
 
 		operations.queryForObject("", Person::class, "foo", "bar")
-		verify(operations).queryForObject("", Person::class.java, arrayOf("foo", "bar"))
+		verify { operations.queryForObject("", Person::class.java, arrayOf("foo", "bar")) }
 	}
 
 	@Test // DATACASS-484
 	fun `queryForObject(String, array) extension should call its Java counterpart`() {
 
 		operations.queryForObject<Person>("", "foo", "bar")
-		verify(operations).queryForObject("", Person::class.java, arrayOf("foo", "bar"))
+		verify { operations.queryForObject("", Person::class.java, arrayOf("foo", "bar")) }
 	}
 
 	@Test // DATACASS-484
 	fun `queryForObject(String, RowMapper, array) extension should call its Java counterpart`() {
 
 		operations.queryForObject("", 3) { rs: Row, _: Int -> rs.getInt(1) }
-		verify(operations).queryForObject(eq(""), any<RowMapper<Int>>(), eq(3))
+		verify { operations.queryForObject(eq(""), any<RowMapper<Int>>(), eq(3)) }
 	}
 
 	@Test // DATACASS-484
@@ -80,7 +73,7 @@ class CqlOperationsExtensionsUnitTests {
 		val statement = SimpleStatement("SELECT * FROM person")
 
 		operations.queryForObject(statement, Person::class)
-		verify(operations).queryForObject(statement, Person::class.java)
+		verify { operations.queryForObject(statement, Person::class.java) }
 	}
 
 	@Test // DATACASS-484
@@ -89,21 +82,21 @@ class CqlOperationsExtensionsUnitTests {
 		val statement = SimpleStatement("SELECT * FROM person")
 
 		operations.queryForObject<Person>(statement)
-		verify(operations).queryForObject(statement, Person::class.java)
+		verify { operations.queryForObject(statement, Person::class.java) }
 	}
 
 	@Test // DATACASS-484
 	fun `queryForList(String) extension should call its Java counterpart`() {
 
 		operations.queryForList<Person>("")
-		verify(operations).queryForList("", Person::class.java)
+		verify { operations.queryForList("", Person::class.java) }
 	}
 
 	@Test // DATACASS-484
 	fun `queryForList(String, array) extension should call its Java counterpart`() {
 
 		operations.queryForList<Person>("", "foo", "bar")
-		verify(operations).queryForList("", Person::class.java, arrayOf("foo", "bar"))
+		verify { operations.queryForList("", Person::class.java, arrayOf("foo", "bar")) }
 	}
 
 	@Test // DATACASS-484
@@ -111,7 +104,7 @@ class CqlOperationsExtensionsUnitTests {
 	fun `queryForList(String, RowMapper, array) extension should call its Java counterpart`() {
 
 		//operations.queryForList("", 3) { rs: Row, _: Int -> rs.getInt(1) }
-		verify(operations).queryForList(eq(""), any<RowMapper<Int>>(), eq(3))
+		verify { operations.queryForList(eq(""), any<RowMapper<Int>>(), eq(3)) }
 	}
 
 	@Test // DATACASS-484
@@ -120,7 +113,7 @@ class CqlOperationsExtensionsUnitTests {
 		val statement = SimpleStatement("SELECT * FROM person")
 
 		operations.queryForList(statement, Person::class)
-		verify(operations).queryForList(statement, Person::class.java)
+		verify { operations.queryForList(statement, Person::class.java) }
 	}
 
 	@Test // DATACASS-484
@@ -129,27 +122,27 @@ class CqlOperationsExtensionsUnitTests {
 		val statement = SimpleStatement("SELECT * FROM person")
 
 		operations.queryForList<Person>(statement)
-		verify(operations).queryForList(statement, Person::class.java)
+		verify { operations.queryForList(statement, Person::class.java) }
 	}
 
 	@Test // DATACASS-484
 	fun `query(String, ResultSetExtractor, array) extension should call its Java counterpart`() {
 
 		operations.query<Person>("", 3) { rs -> Person("Walter", rs.single().getString(0)) }
-		verify(operations).query(eq(""), any<ResultSetExtractor<Person>>(), eq(3))
+		verify { operations.query(eq(""), any<ResultSetExtractor<Person>>(), eq(3)) }
 	}
 
 	@Test // DATACASS-484
 	fun `query(String, RowCallbackHandler, array) extension should call its Java counterpart`() {
 
 		operations.query("", 3) { row -> row.columnDefinitions }
-		verify(operations).query(eq(""), any(), eq(3))
+		verify { operations.query(eq(""), any(), eq(3)) }
 	}
 
 	@Test // DATACASS-484
 	fun `query(String, RowMapper, array) extension should call its Java counterpart`() {
 
 		operations.query("", 3) { row, _ -> row.columnDefinitions }
-		verify(operations).query(eq(""), any<RowMapper<Person>>(), eq(3))
+		verify { operations.query(eq(""), any<RowMapper<Person>>(), eq(3)) }
 	}
 }

spring-data-cassandra/src/test/kotlin/org/springframework/data/cassandra/core/cql/ReactiveCqlOperationsExtensionsUnitTests.kt

@@ -17,15 +17,10 @@ package org.springframework.data.cassandra.core.cql
 
 import com.datastax.driver.core.Row
 import com.datastax.driver.core.SimpleStatement
-import com.nhaarman.mockito_kotlin.any
-import com.nhaarman.mockito_kotlin.eq
-import com.nhaarman.mockito_kotlin.verify
+import io.mockk.mockk
+import io.mockk.verify
 import org.junit.Ignore
 import org.junit.Test
-import org.junit.runner.RunWith
-import org.mockito.Answers
-import org.mockito.Mock
-import org.mockito.junit.MockitoJUnitRunner
 import org.springframework.data.cassandra.domain.Person
 
 /**
@@ -33,45 +28,43 @@ import org.springframework.data.cassandra.domain.Person
  *
  * @author Mark Paluch
  */
-@RunWith(MockitoJUnitRunner::class)
 class ReactiveCqlOperationsExtensionsUnitTests {
 
-	@Mock(answer = Answers.RETURNS_MOCKS)
-	lateinit var operations: ReactiveCqlOperations
+	val operations = mockk<ReactiveCqlOperations>(relaxed = true)
 
 	@Test // DATACASS-484
 	fun `queryForObject(String, KClass) extension should call its Java counterpart`() {
 
 		operations.queryForObject("", Person::class)
-		verify(operations).queryForObject("", Person::class.java)
+		verify { operations.queryForObject("", Person::class.java) }
 	}
 
 	@Test // DATACASS-484
 	fun `queryForObject(String) extension should call its Java counterpart`() {
 
 		operations.queryForObject<Person>("")
-		verify(operations).queryForObject("", Person::class.java)
+		verify { operations.queryForObject("", Person::class.java) }
 	}
 
 	@Test // DATACASS-484
 	fun `queryForObject(String, KClass, array) extension should call its Java counterpart`() {
 
 		operations.queryForObject("", Person::class, "foo", "bar")
-		verify(operations).queryForObject("", Person::class.java, arrayOf("foo", "bar"))
+		verify { operations.queryForObject("", Person::class.java, arrayOf("foo", "bar")) }
 	}
 
 	@Test // DATACASS-484
 	fun `queryForObject(String, array) extension should call its Java counterpart`() {
 
 		operations.queryForObject<Person>("", "foo", "bar")
-		verify(operations).queryForObject("", Person::class.java, arrayOf("foo", "bar"))
+		verify { operations.queryForObject("", Person::class.java, arrayOf("foo", "bar")) }
 	}
 
 	@Test // DATACASS-484
 	fun `queryForObject(String, RowMapper, array) extension should call its Java counterpart`() {
 
 		operations.queryForObject("", 3) { rs: Row, _: Int -> rs.getInt(1) }
-		verify(operations).queryForObject(eq(""), any<RowMapper<Int>>(), eq(3))
+		verify { operations.queryForObject(eq(""), any<RowMapper<Int>>(), eq(3)) }
 	}
 
 	@Test // DATACASS-484
@@ -80,7 +73,7 @@ class ReactiveCqlOperationsExtensionsUnitTests {
 		val statement = SimpleStatement("SELECT * FROM person")
 
 		operations.queryForObject(statement, Person::class)
-		verify(operations).queryForObject(statement, Person::class.java)
+		verify { operations.queryForObject(statement, Person::class.java) }
 	}
 
 	@Test // DATACASS-484
@@ -89,21 +82,21 @@ class ReactiveCqlOperationsExtensionsUnitTests {
 		val statement = SimpleStatement("SELECT * FROM person")
 
 		operations.queryForObject<Person>(statement)
-		verify(operations).queryForObject(statement, Person::class.java)
+		verify { operations.queryForObject(statement, Person::class.java) }
 	}
 
 	@Test // DATACASS-484
 	fun `queryForFlux(String) extension should call its Java counterpart`() {
 
 		operations.queryForFlux<Person>("")
-		verify(operations).queryForFlux("", Person::class.java)
+		verify { operations.queryForFlux("", Person::class.java) }
 	}
 
 	@Test // DATACASS-484
 	fun `queryForFlux(String, array) extension should call its Java counterpart`() {
 
 		operations.queryForFlux<Person>("", "foo", "bar")
-		verify(operations).queryForFlux("", Person::class.java, arrayOf("foo", "bar"))
+		verify { operations.queryForFlux("", Person::class.java, arrayOf("foo", "bar")) }
 	}
 
 	@Test // DATACASS-484
@@ -111,7 +104,7 @@ class ReactiveCqlOperationsExtensionsUnitTests {
 	fun `queryForFlux(String, RowMapper, array) extension should call its Java counterpart`() {
 
 		//operations.queryForFlux("", 3) { rs: Row, _: Int -> rs.getInt(1) }
-		verify(operations).queryForFlux(eq(""), any<RowMapper<Int>>(), eq(3))
+		verify { operations.queryForFlux(eq(""), any<RowMapper<Int>>(), eq(3)) }
 	}
 
 	@Test // DATACASS-484
@@ -120,7 +113,7 @@ class ReactiveCqlOperationsExtensionsUnitTests {
 		val statement = SimpleStatement("SELECT * FROM person")
 
 		operations.queryForFlux(statement, Person::class)
-		verify(operations).queryForFlux(statement, Person::class.java)
+		verify { operations.queryForFlux(statement, Person::class.java) }
 	}
 
 	@Test // DATACASS-484
@@ -129,20 +122,20 @@ class ReactiveCqlOperationsExtensionsUnitTests {
 		val statement = SimpleStatement("SELECT * FROM person")
 
 		operations.queryForFlux<Person>(statement)
-		verify(operations).queryForFlux(statement, Person::class.java)
+		verify { operations.queryForFlux(statement, Person::class.java) }
 	}
 
 	@Test // DATACASS-484
 	fun `query(String, ResultSetExtractor, array) extension should call its Java counterpart`() {
 
 		operations.query("", 3) { rs -> rs.rows().next().cast(Person::class.java) }
-		verify(operations).query(eq(""), any<ReactiveResultSetExtractor<Person>>(), eq(3))
+		verify { operations.query(eq(""), any<ReactiveResultSetExtractor<Person>>(), eq(3)) }
 	}
 
 	@Test // DATACASS-484
 	fun `query(String, RowMapper, array) extension should call its Java counterpart`() {
 
 		operations.query("", 3) { row, _ -> row.columnDefinitions }
-		verify(operations).query(eq(""), any<RowMapper<Person>>(), eq(3))
+		verify { operations.query(eq(""), any<RowMapper<Person>>(), eq(3)) }
 	}
 }

spring-data-cassandra/src/test/kotlin/org/springframework/data/cassandra/core/query/CriteriaExtensionsUnitTests.kt

@@ -15,25 +15,20 @@
  */
 package org.springframework.data.cassandra.core.query
 
-import com.nhaarman.mockito_kotlin.verify
+import io.mockk.mockk
+import io.mockk.verify
 import org.assertj.core.api.Assertions.assertThat
+import org.junit.Ignore
 import org.junit.Test
-import org.junit.runner.RunWith
-import org.mockito.Answers
-import org.mockito.Mock
-import org.mockito.Mockito
-import org.mockito.junit.MockitoJUnitRunner
 
 /**
  * Unit tests for [CriteriaExtensions].
  *
  * @author Mark Paluch
  */
-@RunWith(MockitoJUnitRunner::class)
 class CriteriaExtensionsUnitTests {
 
-	@Mock(answer = Answers.RETURNS_MOCKS)
-	lateinit var criteria: Criteria
+	val criteria = mockk<Criteria>(relaxed = true)
 
 	@Test // DATACASS-484
 	fun `isEqualTo() extension should call its Java counterpart`() {
@@ -41,7 +36,7 @@ class CriteriaExtensionsUnitTests {
 		val foo = "foo"
 		criteria.isEqualTo(foo)
 
-		verify(criteria).`is`(foo)
+		verify { criteria.`is`(foo) }
 	}
 
 	@Test // DATACASS-484
@@ -49,7 +44,7 @@ class CriteriaExtensionsUnitTests {
 
 		criteria.isEqualTo(null)
 
-		verify(criteria).`is`(null)
+		verify { criteria.`is`(null) }
 	}
 
 	@Test // DATACASS-484
@@ -60,7 +55,7 @@ class CriteriaExtensionsUnitTests {
 
 		criteria.inValues(foo, bar)
 
-		Mockito.verify(criteria).`in`(foo, bar)
+		verify { criteria.`in`(foo, bar) }
 	}
 
 	@Test // DATACASS-484
@@ -68,7 +63,7 @@ class CriteriaExtensionsUnitTests {
 
 		criteria.inValues(null, null)
 
-		Mockito.verify(criteria).`in`(null, null)
+		verify { criteria.`in`(null, null) }
 	}
 
 	@Test // DATACASS-484
@@ -78,7 +73,7 @@ class CriteriaExtensionsUnitTests {
 
 		criteria.inValues(c)
 
-		verify(criteria).`in`(c)
+		verify { criteria.`in`(c) }
 	}
 
 	@Test // DATACASS-484
@@ -88,7 +83,7 @@ class CriteriaExtensionsUnitTests {
 
 		criteria.inValues(c)
 
-		verify(criteria).`in`(c)
+		verify { criteria.`in`(c) }
 	}
 
 	@Test // DATACASS-484