Release 0.6.0

mockito-kotlin/build.gradle

@@ -20,7 +20,7 @@ repositories {
 dependencies {
   compile "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
   compile "org.jetbrains.kotlin:kotlin-reflect:$kotlin_version"
-  compile "org.mockito:mockito-core:2.0.52-beta"
+  compile "org.mockito:mockito-core:2.0.99-beta"
 
   /* Tests */
   testCompile "junit:junit:4.12"

mockito-kotlin/src/main/kotlin/com/nhaarman/mockito_kotlin/CreateInstance.kt

@@ -177,7 +177,7 @@ private fun <T : Any> KType.createNullableInstance(): T? {
 private fun <T> Class<T>.uncheckedMock(): T {
     val impl = MockSettingsImpl<T>().defaultAnswer(Answers.RETURNS_DEFAULTS) as MockSettingsImpl<T>
     val creationSettings = impl.confirm(this)
-    return MockUtil().createMock(creationSettings).apply {
+    return MockUtil.createMock(creationSettings).apply {
         (this as MockMethodInterceptor.MockAccess).mockitoInterceptor = null
     }
 }

mockito-kotlin/src/main/kotlin/com/nhaarman/mockito_kotlin/Mockito.kt

@@ -31,7 +31,6 @@ import org.mockito.MockingDetails
 import org.mockito.Mockito
 import org.mockito.invocation.InvocationOnMock
 import org.mockito.stubbing.Answer
-import org.mockito.stubbing.DeprecatedOngoingStubbing
 import org.mockito.stubbing.OngoingStubbing
 import org.mockito.stubbing.Stubber
 import org.mockito.verification.VerificationMode
@@ -80,6 +79,18 @@ inline fun <reified T : Any> mock(defaultAnswer: Answer<Any>): T = Mockito.mock(
 inline fun <reified T : Any> mock(s: MockSettings): T = Mockito.mock(T::class.java, s)!!
 inline fun <reified T : Any> mock(s: String): T = Mockito.mock(T::class.java, s)!!
 
+inline fun <reified T : Any> mock(stubbing: KStubbing<T>.() -> Unit): T
+        = Mockito.mock(T::class.java)!!.apply { stubbing(KStubbing(this)) }
+
+class KStubbing<out T>(private val mock: T) {
+    fun <R> on(methodCall: R) = Mockito.`when`(methodCall)
+    fun <R> on(methodCall: T.() -> R) = Mockito.`when`(mock.methodCall())
+}
+
+infix fun <T> OngoingStubbing<T>.doReturn(t: T): OngoingStubbing<T> = thenReturn(t)
+fun <T> OngoingStubbing<T>.doReturn(t: T, vararg ts: T): OngoingStubbing<T> = thenReturn(t, *ts)
+inline infix fun <reified T> OngoingStubbing<T>.doReturn(ts: List<T>): OngoingStubbing<T> = thenReturn(ts[0], *ts.drop(1).toTypedArray())
+
 fun mockingDetails(toInspect: Any): MockingDetails = Mockito.mockingDetails(toInspect)!!
 fun never(): VerificationMode = Mockito.never()!!
 inline fun <reified T : Any> notNull(): T? = Mockito.notNull(T::class.java)
@@ -93,7 +104,6 @@ fun <T> same(value: T): T? = Mockito.same(value)
 inline fun <reified T : Any> spy(): T = Mockito.spy(T::class.java)!!
 fun <T> spy(value: T): T = Mockito.spy(value)!!
 
-fun <T> stub(methodCall: T): DeprecatedOngoingStubbing<T> = Mockito.stub(methodCall)!!
 fun timeout(millis: Long): VerificationWithTimeout = Mockito.timeout(millis)!!
 fun times(numInvocations: Int): VerificationMode = Mockito.times(numInvocations)!!
 fun validateMockitoUsage() = Mockito.validateMockitoUsage()

mockito-kotlin/src/test/kotlin/MockitoTest.kt

@@ -282,4 +282,60 @@ class MockitoTest {
             mock.go()
         }
     }
+
+    @Test
+    fun testMockStubbing_lambda() {
+        /* Given */
+        val mock = mock<Open>() {
+            on { stringResult() } doReturn "A"
+        }
+
+        /* When */
+        val result = mock.stringResult()
+
+        /* Then */
+        expect(result).toBe("A")
+    }
+
+    @Test
+    fun testMockStubbing_normalOverridesLambda() {
+        /* Given */
+        val mock = mock<Open>() {
+            on { stringResult() }.doReturn("A")
+        }
+        whenever(mock.stringResult()).thenReturn("B")
+
+        /* When */
+        val result = mock.stringResult()
+
+        /* Then */
+        expect(result).toBe("B")
+    }
+
+    @Test
+    fun testMockStubbing_methodCall() {
+        /* Given */
+        val mock = mock<Open>()
+        mock<Open> {
+            on(mock.stringResult()).doReturn("A")
+        }
+
+        /* When */
+        val result = mock.stringResult()
+
+        /* Then */
+        expect(result).toBe("A")
+    }
+
+    @Test
+    fun doReturn_withSingleItemList() {
+        /* Given */
+        val mock = mock<Open> {
+            on { stringResult() } doReturn listOf("a", "b")
+        }
+
+        /* Then */
+        expect(mock.stringResult()).toBe("a")
+        expect(mock.stringResult()).toBe("b")
+    }
 }