Add stubbing tests for sync and suspend functions returning value classes

Author: m-koops

tests/src/test/kotlin/test/Classes.kt

@@ -98,6 +98,9 @@ interface SynchronousFunctions {
     fun valueClass(v: ValueClass)
     fun nullableValueClass(v: ValueClass?)
     fun nestedValueClass(v: NestedValueClass)
+    fun valueClassResult(): ValueClass
+    fun nullableValueClassResult(): ValueClass?
+    fun nestedValueClassResult(): NestedValueClass
 }
 
 interface SuspendFunctions {
@@ -110,6 +113,9 @@ interface SuspendFunctions {
     suspend fun stringResult(s: String): String
     suspend fun stringResult(s1: String, s2: String): String
     suspend fun nullableStringResult(): String?
+    suspend fun valueClassResult(): ValueClass
+    suspend fun nullableValueClassResult(): ValueClass?
+    suspend fun nestedValueClassResult(): NestedValueClass
     suspend fun builderMethod(): SuspendFunctions
 }
 

tests/src/test/kotlin/test/CoroutinesOngoingStubbingTest.kt

@@ -1,6 +1,7 @@
 package test
 
 import com.nhaarman.expect.expect
+import kotlinx.coroutines.delay
 import kotlinx.coroutines.runBlocking
 import kotlinx.coroutines.test.runTest
 import org.junit.Ignore
@@ -10,6 +11,7 @@ import org.mockito.kotlin.any
 import org.mockito.kotlin.doAnswer
 import org.mockito.kotlin.doReturn
 import org.mockito.kotlin.doReturnConsecutively
+import org.mockito.kotlin.doSuspendableAnswer
 import org.mockito.kotlin.doThrow
 import org.mockito.kotlin.mock
 import org.mockito.stubbing.Answer
@@ -280,4 +282,59 @@ class CoroutinesOngoingStubbingTest {
         /* Then */
         expect(result).toBe("apple + banana")
     }
+
+    @Test
+    fun `should stub suspendable function call with value class result`() = runTest {
+        /* Given */
+        val valueClass = ValueClass("A")
+        val mock = mock<SuspendFunctions> {
+            on(mock.valueClassResult()) doSuspendableAnswer {
+                delay(1)
+                valueClass
+            }
+        }
+
+        /* When */
+        val result: ValueClass = mock.valueClassResult()
+
+        /* Then */
+        expect(result).toBe(valueClass)
+    }
+
+    @Test
+    fun `should stub suspendable function call with nullable value class result`() = runTest {
+        /* Given */
+        val valueClass = ValueClass("A")
+        val mock = mock<SuspendFunctions> {
+            on (mock.nullableValueClassResult()) doSuspendableAnswer {
+                delay(1)
+                valueClass
+            }
+        }
+
+        /* When */
+        val result: ValueClass? = mock.nullableValueClassResult()
+
+        /* Then */
+        expect(result).toBe(valueClass)
+    }
+
+    @Test
+    fun `should stub suspendable function call with nested value class result`() = runTest {
+        /* Given */
+        val nestedValueClass = NestedValueClass(ValueClass("A"))
+        val mock = mock<SuspendFunctions> {
+            on (mock.nestedValueClassResult()) doSuspendableAnswer {
+                delay(1)
+                nestedValueClass
+            }
+        }
+
+        /* When */
+        val result: NestedValueClass = mock.nestedValueClassResult()
+
+        /* Then */
+        expect(result).toBe(nestedValueClass)
+        expect(result.value).toBe(nestedValueClass.value)
+    }
 }

tests/src/test/kotlin/test/OngoingStubbingTest.kt

@@ -271,6 +271,70 @@ class OngoingStubbingTest : TestBase() {
         expect(m.nullableReturnType()).toBe("Test")
     }
 
+    @Test
+    fun `should stub function call with value class result`() {
+        /* Given */
+        val valueClass = ValueClass("A")
+        val mock = mock<SynchronousFunctions> {
+            on { valueClassResult() } doReturn valueClass
+        }
+
+        /* When */
+        val result: ValueClass = mock.valueClassResult()
+
+        /* Then */
+        expect(result).toBe(valueClass)
+    }
+
+    @Test
+    fun `should stub function call with nullable value class result`() {
+        /* Given */
+        val valueClass = ValueClass("A")
+        val mock = mock<SynchronousFunctions> {
+            on { nullableValueClassResult() } doReturn valueClass
+        }
+
+        /* When */
+        val result: ValueClass? = mock.nullableValueClassResult()
+
+        /* Then */
+        expect(result).toBe(valueClass)
+    }
+
+    @Test
+    fun `should stub function call with nested value class result`() {
+        /* Given */
+        val nestedValueClass = NestedValueClass(ValueClass("A"))
+        val mock = mock<SynchronousFunctions> {
+            on { nestedValueClassResult() } doReturn nestedValueClass
+        }
+
+        /* When */
+        val result: NestedValueClass = mock.nestedValueClassResult()
+
+        /* Then */
+        expect(result).toBe(nestedValueClass)
+        expect(result.value).toBe(nestedValueClass.value)
+    }
+
+    @Test
+    fun `should stub consecutive function calls with value class results`() {
+        /* Given */
+        val valueClassA = ValueClass("A")
+        val valueClassB = ValueClass("B")
+        val mock = mock<SynchronousFunctions> {
+            on { valueClassResult() }.doReturnConsecutively(listOf(valueClassA, valueClassB))
+        }
+
+        /* When */
+        val result1 = mock.valueClassResult()
+        val result2 = mock.valueClassResult()
+
+        /* Then */
+        expect(result1).toBe(valueClassA)
+        expect(result2).toBe(valueClassB)
+    }
+
     @Test
     fun doReturn_throwsNPE() {
         assumeFalse(mockMakerInlineEnabled())