implement support for relaxed mock on suspending function [closes #640]

mockk/jvm/src/main/kotlin/io/mockk/impl/instantiation/JvmMockFactoryHelper.kt

@@ -4,9 +4,12 @@ import io.mockk.*
 import io.mockk.impl.InternalPlatform
 import io.mockk.impl.stub.Stub
 import io.mockk.proxy.MockKInvocationHandler
+import java.lang.Class
 import java.lang.reflect.InvocationTargetException
 import java.lang.reflect.Method
 import java.lang.reflect.Modifier
+import java.lang.reflect.ParameterizedType
+import java.lang.reflect.WildcardType
 import java.util.concurrent.Callable
 import kotlin.coroutines.Continuation
 import kotlin.reflect.KClass
@@ -133,7 +136,15 @@ object JvmMockFactoryHelper {
 
         val isFnCall = Function::class.java.isAssignableFrom(declaringClass)
 
-        val returnType = kotlinFunc?.returnType as? KClass<*> ?: returnType.kotlin
+        val lastParam = getGenericParameterTypes().lastOrNull() as? ParameterizedType
+        val returnType: KClass<*> = when (isSuspend && lastParam != null) {
+            true -> {
+                val typeArg = lastParam.getActualTypeArguments().first() as WildcardType
+                val bound = typeArg.lowerBounds.first() as Class<*>
+                bound.kotlin
+            }
+            false -> kotlinFunc?.returnType as? KClass<*> ?: returnType.kotlin
+        }
 
         val result = MethodDescription(
             name,
@@ -160,4 +171,4 @@ object JvmMockFactoryHelper {
     val cache = InternalPlatform.weakMap<Method, MethodDescription>()
 
 
-}
+}

mockk/jvm/src/test/kotlin/io/mockk/it/RelaxedSuspendingMockingTest.kt

@@ -0,0 +1,41 @@
+package io.mockk.it
+
+import io.mockk.coEvery
+import io.mockk.mockk
+import kotlinx.coroutines.runBlocking
+import kotlin.test.Test
+import kotlin.test.assertEquals
+
+@Suppress("UNUSED_PARAMETER")
+class RelaxedSuspendingMockingTest {
+    class MockCls {
+        suspend fun op(a: Int, b: Int) = a + b
+        suspend fun opUnit(a: Int, b: Int) {}
+    }
+
+    @Test
+    fun rurfRegularOperationOk() {
+        val mock = mockk<MockCls>(relaxUnitFun = true) {
+            coEvery { op(1, 2) } returns 4
+            coEvery { opUnit(1, 2) } returns Unit
+        }
+
+        assertEquals(4, runBlocking { mock.op(1, 2) })
+        assertEquals(Unit, runBlocking { mock.opUnit(1, 2) })
+    }
+
+    @Test
+    fun rurfFullyRelaxedRegularOperationOk() {
+        val mock = mockk<MockCls>(relaxed = true)
+
+        assertEquals(0, runBlocking { mock.op(1, 2) })
+    }
+
+
+    @Test
+    fun rurfFullyRelaxedRegularUnitOperationOk() {
+        val mock = mockk<MockCls>(relaxed = true)
+
+        assertEquals(Unit, runBlocking { mock.opUnit(1, 2) })
+    }
+}