diff --git a/spring-data-cassandra/pom.xml b/spring-data-cassandra/pom.xml index 3bb7ff5f2..30de82f8f 100644 --- a/spring-data-cassandra/pom.xml +++ b/spring-data-cassandra/pom.xml @@ -196,24 +196,10 @@ test - com.nhaarman - mockito-kotlin - 1.5.0 + io.mockk + mockk + ${mockk} test - - - org.jetbrains.kotlin - kotlin-stdlib - - - org.jetbrains.kotlin - kotlin-reflect - - - org.mockito - mockito-core - - diff --git a/spring-data-cassandra/src/test/kotlin/org/springframework/data/cassandra/core/AsyncCassandraOperationsExtensionsUnitTests.kt b/spring-data-cassandra/src/test/kotlin/org/springframework/data/cassandra/core/AsyncCassandraOperationsExtensionsUnitTests.kt index d507d500e..6590ff281 100644 --- a/spring-data-cassandra/src/test/kotlin/org/springframework/data/cassandra/core/AsyncCassandraOperationsExtensionsUnitTests.kt +++ b/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(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("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>(), eq(Person::class.java)) + verify { operations.select(eq("SELECT * FROM person"), any>(), eq(Person::class.java)) } } @Test // DATACASS-484 fun `select(String, Consumer) with reified type parameter extension should call its Java counterpart`() { operations.select("SELECT * FROM person") { p -> p.toString() } - verify(operations).select(eq("SELECT * FROM person"), any>(), eq(Person::class.java)) + verify { operations.select(eq("SELECT * FROM person"), any>(), 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("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(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>(), eq(Person::class.java)) + verify { operations.select(eq(statement), any>(), eq(Person::class.java)) } } @Test // DATACASS-484 @@ -122,7 +115,7 @@ class AsyncCassandraOperationsExtensionsUnitTests { val statement = SimpleStatement("SELECT * FROM person") operations.select(statement) { p -> p.toString() } - verify(operations).select(eq(statement), any>(), eq(Person::class.java)) + verify { operations.select(eq(statement), any>(), 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(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(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(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>(), eq(Person::class.java)) + verify { operations.select(eq(Query.empty()), any>(), eq(Person::class.java)) } } @Test // DATACASS-484 fun `select(Query, Consumer) with reified type parameter extension should call its Java counterpart`() { operations.select(Query.empty()) { p -> p.toString() } - verify(operations).select(eq(Query.empty()), any>(), eq(Person::class.java)) + verify { operations.select(eq(Query.empty()), any>(), 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(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(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(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(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() - 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(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("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(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("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("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() - verify(operations).truncate(Person::class.java) + verify { operations.truncate(Person::class.java) } } } + diff --git a/spring-data-cassandra/src/test/kotlin/org/springframework/data/cassandra/core/CassandraOperationsExtensionsUnitTests.kt b/spring-data-cassandra/src/test/kotlin/org/springframework/data/cassandra/core/CassandraOperationsExtensionsUnitTests.kt index 224fe295b..18aaa1ee8 100644 --- a/spring-data-cassandra/src/test/kotlin/org/springframework/data/cassandra/core/CassandraOperationsExtensionsUnitTests.kt +++ b/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(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() - 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("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("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("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(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(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(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(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(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(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(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(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(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(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() - 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(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("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(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("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("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() - verify(operations).truncate(Person::class.java) + verify { operations.truncate(Person::class.java) } } } diff --git a/spring-data-cassandra/src/test/kotlin/org/springframework/data/cassandra/core/ExecutableDeleteOperationExtensionsUnitTests.kt b/spring-data-cassandra/src/test/kotlin/org/springframework/data/cassandra/core/ExecutableDeleteOperationExtensionsUnitTests.kt index 70e2a4488..a13225aa7 100644 --- a/spring-data-cassandra/src/test/kotlin/org/springframework/data/cassandra/core/ExecutableDeleteOperationExtensionsUnitTests.kt +++ b/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(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() - verify(operations).delete(Person::class.java) + verify { operations.delete(Person::class.java) } } } diff --git a/spring-data-cassandra/src/test/kotlin/org/springframework/data/cassandra/core/ExecutableInsertOperationExtensionsUnitTests.kt b/spring-data-cassandra/src/test/kotlin/org/springframework/data/cassandra/core/ExecutableInsertOperationExtensionsUnitTests.kt index d05bd7fd6..2f8c0214b 100644 --- a/spring-data-cassandra/src/test/kotlin/org/springframework/data/cassandra/core/ExecutableInsertOperationExtensionsUnitTests.kt +++ b/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(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() - verify(operations).insert(Person::class.java) + verify { operations.insert(Person::class.java) } } } diff --git a/spring-data-cassandra/src/test/kotlin/org/springframework/data/cassandra/core/ExecutableSelectOperationExtensionsUnitTests.kt b/spring-data-cassandra/src/test/kotlin/org/springframework/data/cassandra/core/ExecutableSelectOperationExtensionsUnitTests.kt index 3467b00f1..de18c68f5 100644 --- a/spring-data-cassandra/src/test/kotlin/org/springframework/data/cassandra/core/ExecutableSelectOperationExtensionsUnitTests.kt +++ b/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(relaxed = true) + + val operationWithProjection = mockk>(relaxed = true) - @Mock(answer = Answers.RETURNS_MOCKS) - lateinit var operationWithProjection: ExecutableSelectOperation.SelectWithProjection @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() - 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(); - verify(operationWithProjection).`as`(User::class.java) + verify { operationWithProjection.`as`(User::class.java) } } } diff --git a/spring-data-cassandra/src/test/kotlin/org/springframework/data/cassandra/core/ExecutableUpdateOperationExtensionsUnitTests.kt b/spring-data-cassandra/src/test/kotlin/org/springframework/data/cassandra/core/ExecutableUpdateOperationExtensionsUnitTests.kt index d930cf1cd..717bdfcbd 100644 --- a/spring-data-cassandra/src/test/kotlin/org/springframework/data/cassandra/core/ExecutableUpdateOperationExtensionsUnitTests.kt +++ b/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(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() - verify(operations).update(Person::class.java) + verify { operations.update(Person::class.java) } } } diff --git a/spring-data-cassandra/src/test/kotlin/org/springframework/data/cassandra/core/ReactiveCassandraOperationsExtensionsUnitTests.kt b/spring-data-cassandra/src/test/kotlin/org/springframework/data/cassandra/core/ReactiveCassandraOperationsExtensionsUnitTests.kt index faf7de578..3238312b8 100644 --- a/spring-data-cassandra/src/test/kotlin/org/springframework/data/cassandra/core/ReactiveCassandraOperationsExtensionsUnitTests.kt +++ b/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(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("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("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(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(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(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(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(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(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() - 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(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("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(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("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("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() - verify(operations).truncate(Person::class.java) + verify { operations.truncate(Person::class.java) } } } diff --git a/spring-data-cassandra/src/test/kotlin/org/springframework/data/cassandra/core/ReactiveDeleteOperationExtensionsUnitTests.kt b/spring-data-cassandra/src/test/kotlin/org/springframework/data/cassandra/core/ReactiveDeleteOperationExtensionsUnitTests.kt index 29e79ef2b..b4c710cb7 100644 --- a/spring-data-cassandra/src/test/kotlin/org/springframework/data/cassandra/core/ReactiveDeleteOperationExtensionsUnitTests.kt +++ b/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(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() - verify(operations).delete(Person::class.java) + verify { operations.delete(Person::class.java) } } } diff --git a/spring-data-cassandra/src/test/kotlin/org/springframework/data/cassandra/core/ReactiveInsertOperationExtensionsUnitTests.kt b/spring-data-cassandra/src/test/kotlin/org/springframework/data/cassandra/core/ReactiveInsertOperationExtensionsUnitTests.kt index 81e082624..62a700c8c 100644 --- a/spring-data-cassandra/src/test/kotlin/org/springframework/data/cassandra/core/ReactiveInsertOperationExtensionsUnitTests.kt +++ b/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(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() - verify(operations).insert(Person::class.java) + verify { operations.insert(Person::class.java) } } } diff --git a/spring-data-cassandra/src/test/kotlin/org/springframework/data/cassandra/core/ReactiveSelectOperationExtensionsUnitTests.kt b/spring-data-cassandra/src/test/kotlin/org/springframework/data/cassandra/core/ReactiveSelectOperationExtensionsUnitTests.kt index 1d9e141d5..d38a2fc2e 100644 --- a/spring-data-cassandra/src/test/kotlin/org/springframework/data/cassandra/core/ReactiveSelectOperationExtensionsUnitTests.kt +++ b/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(relaxed = true) - @Mock(answer = Answers.RETURNS_MOCKS) - lateinit var operationWithProjection: ReactiveSelectOperation.SelectWithProjection + val operationWithProjection = mockk>(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() - 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(); - verify(operationWithProjection).`as`(User::class.java) + verify { operationWithProjection.`as`(User::class.java) } } } diff --git a/spring-data-cassandra/src/test/kotlin/org/springframework/data/cassandra/core/ReactiveUpdateOperationExtensionsUnitTests.kt b/spring-data-cassandra/src/test/kotlin/org/springframework/data/cassandra/core/ReactiveUpdateOperationExtensionsUnitTests.kt index e08bae003..81c881e75 100644 --- a/spring-data-cassandra/src/test/kotlin/org/springframework/data/cassandra/core/ReactiveUpdateOperationExtensionsUnitTests.kt +++ b/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(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() - verify(operations).update(Person::class.java) + verify { operations.update(Person::class.java) } } } diff --git a/spring-data-cassandra/src/test/kotlin/org/springframework/data/cassandra/core/cql/AsyncCqlOperationsExtensionsUnitTests.kt b/spring-data-cassandra/src/test/kotlin/org/springframework/data/cassandra/core/cql/AsyncCqlOperationsExtensionsUnitTests.kt index abb031ca0..dec297317 100644 --- a/spring-data-cassandra/src/test/kotlin/org/springframework/data/cassandra/core/cql/AsyncCqlOperationsExtensionsUnitTests.kt +++ b/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(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("") - 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("", "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>(), eq(3)) + verify { operations.queryForObject(eq(""), any>(), 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(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("") - 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("", "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>(), eq(3)) + verify { operations.queryForList(eq(""), any>(), 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(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>(), 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>(), eq(3)) + verify { operations.query(eq(""), any>(), eq(3)) } } } diff --git a/spring-data-cassandra/src/test/kotlin/org/springframework/data/cassandra/core/cql/CqlOperationsExtensionsUnitTests.kt b/spring-data-cassandra/src/test/kotlin/org/springframework/data/cassandra/core/cql/CqlOperationsExtensionsUnitTests.kt index 6753d2b47..c880a1140 100644 --- a/spring-data-cassandra/src/test/kotlin/org/springframework/data/cassandra/core/cql/CqlOperationsExtensionsUnitTests.kt +++ b/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(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("") - 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("", "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>(), eq(3)) + verify { operations.queryForObject(eq(""), any>(), 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(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("") - 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("", "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>(), eq(3)) + verify { operations.queryForList(eq(""), any>(), 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(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>(), eq(3)) + verify { operations.query(eq(""), any>(), 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>(), eq(3)) + verify { operations.query(eq(""), any>(), eq(3)) } } } diff --git a/spring-data-cassandra/src/test/kotlin/org/springframework/data/cassandra/core/cql/ReactiveCqlOperationsExtensionsUnitTests.kt b/spring-data-cassandra/src/test/kotlin/org/springframework/data/cassandra/core/cql/ReactiveCqlOperationsExtensionsUnitTests.kt index 3331e880c..2f97d897d 100644 --- a/spring-data-cassandra/src/test/kotlin/org/springframework/data/cassandra/core/cql/ReactiveCqlOperationsExtensionsUnitTests.kt +++ b/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(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("") - 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("", "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>(), eq(3)) + verify { operations.queryForObject(eq(""), any>(), 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(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("") - 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("", "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>(), eq(3)) + verify { operations.queryForFlux(eq(""), any>(), 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(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>(), 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>(), eq(3)) + verify { operations.query(eq(""), any>(), eq(3)) } } } diff --git a/spring-data-cassandra/src/test/kotlin/org/springframework/data/cassandra/core/query/CriteriaExtensionsUnitTests.kt b/spring-data-cassandra/src/test/kotlin/org/springframework/data/cassandra/core/query/CriteriaExtensionsUnitTests.kt index bc26c5973..30f4b3555 100644 --- a/spring-data-cassandra/src/test/kotlin/org/springframework/data/cassandra/core/query/CriteriaExtensionsUnitTests.kt +++ b/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(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