Kotlin Mockito仿制药

Question

假设我的课是：

open class TestThis{
    @Autowired
    private var myService : MyService? = null

    fun doMyFunction(){
        val result = myService.doSomething("hello world", Function { entry ->
                        var retVal : Boolean = false
                        //some processing
                        retVal
                    })
    }
}

@Service
open class MyService{
    fun doSomething(str1 : String, java.util.Function<MyCrap, Boolean>) : List<String>{
        //do something here
    }
}


@RunWith(MockitoJUnitRunner::class)
class TestThisTest{
    @Mock
    var myService : MyService? = null

    @InjectMocks
    var test : TestThis? = null

    @Before
    fun before(){
        val list : List<String> = //init list

        //this line causes compilation error due to generics. error 1
        Mockito.`when`(myService.doSomething(Mockito.anyString(), Mockito.any(Function::class.java))).thenReturn(list)

        //this line also causes compilation error due to generics. error 2
        Mockito.`when`(myService.doSomething(Mockito.anyString(), Mockito.any(Function<MyCrap, Boolean>::class.java))).thenReturn(list)
    }
}

错误1：

类型推理失败。预期类型不匹配。

错误2：

只允许在类字面的左侧

的左侧

，因此如何模拟myService＃dosomething？

Answer 1

让匹配者与Kotlin合作可能是一个问题。

• 如果您在Kotlin中编写的方法不使用无效参数，则我们无法使用mockito.yany（）与它匹配。这是因为它返回null，并且无法分配给不可删除的参数。
• 在Kotlin类中，默认情况下是最终成员，我们需要打开它们，因为禁止模拟方法通用
• 类模拟rive错误，例如您所描述的只允许在类文字

所有这些问题都可以通过简单Mockitoutils类解决：

    object MockitoUtils {

        inline fun <reified T> anyObject(): T {
            return Mockito.any(T::class.java) ?: createInstance()
        }

        inline fun <reified T : Any> createInstance(): T {
            return when (T::class) {
                Boolean::class -> false as T
                Byte::class -> 0.toByte() as T
                Char::class -> 0.toChar() as T
                Short::class -> 0.toShort() as T
                Int::class -> 0 as T
                Long::class -> 0L as T
                Float::class -> 0f as T
                Double::class -> 0.0 as T
                else -> createInstance(T::class)
            }
        }

        fun <T : Any> createInstance(kClass: KClass<T>): T {
            return castNull()
        }

        @Suppress("UNCHECKED_CAST")
        private fun <T> castNull(): T = null as T
    }

使用示例：

Mockito.`when`(myService!!.doSomething(Mockito.anyString(), MockitoUtils.anyObject())).thenReturn(list)

模拟服务：

open class MyService {

    open fun doSomething(str1 : String, func : java.util.function.Function<MyCrap, Boolean>) : List<String>{
        return emptyList()
    }

}

测试服务：

open class TestThis{
    private var myService : MyService? = null

    fun doMyFunction() : List<String>? {
        val result = myService?.doSomething("hello world", java.util.function.Function { entry ->
            var retVal : Boolean = false
            //some processing
            retVal
        } )
        return result;
    }
}

import org.junit.Assert
import org.junit.Before
import org.junit.Test
import org.junit.runner.RunWith
import org.mockito.InjectMocks
import org.mockito.Mock
import org.mockito.Mockito
import org.mockito.junit.MockitoJUnitRunner
import kotlin.reflect.KClass

@RunWith(MockitoJUnitRunner::class)
class TestThisTest{
    @Mock
    var myService : MyService? = null

    @InjectMocks
    var test : TestThis? = null

    @Before
    fun before(){
        val list : ArrayList<String> = arrayListOf()
        list.add("123")

        val thenReturn = Mockito.`when`(myService!!.doSomething(Mockito.anyString(), MockitoUtils.anyObject())).thenReturn(list)

    }

    @Test
    fun test() {
        val list = test!!.doMyFunction()
        Assert.assertTrue(list!!.contains("123"))
    }

    object MockitoUtils {

        inline fun <reified T> anyObject(): T {
            return Mockito.any(T::class.java) ?: createInstance()
        }

        inline fun <reified T : Any> createInstance(): T {
            return when (T::class) {
                Boolean::class -> false as T
                Byte::class -> 0.toByte() as T
                Char::class -> 0.toChar() as T
                Short::class -> 0.toShort() as T
                Int::class -> 0 as T
                Long::class -> 0L as T
                Float::class -> 0f as T
                Double::class -> 0.0 as T
                else -> createInstance(T::class)
            }
        }

        fun <T : Any> createInstance(kClass: KClass<T>): T {
            return castNull()
        }

        @Suppress("UNCHECKED_CAST")
        private fun <T> castNull(): T = null as T
    }
}

替代解决方案：

另一个可能的解决方案是使用库 oighito-kotlin 。

maven> maven ：

<dependency>
    <groupId>org.mockito.kotlin</groupId>
    <artifactId>mockito-kotlin</artifactId>
    <version>4.0.0</version>
    <scope>test</scope>
</dependency>

Answer 2

当您尝试在此服务中测试某些内容时，您不应嘲笑“测试”。如果您嘲笑它，那么没有任何“内部”。这只是一个模拟。
尝试实现它，然后注入MyService的模拟。

您正在写测试的地方似乎也很奇怪。为什么在测试级测试中的MyService进行单位测试。您应该为MyService创建自己的单位测试。