给出一个Kotlin单例对象和一个称之为“方法”的乐趣
object SomeObject {
fun someFun() {}
}
fun callerFun() {
SomeObject.someFun()
}
有没有办法模拟对SomeObject.someFun()
的调用?
答案 0 :(得分:9)
对于Kotlin来说,这是一个非常好的模拟库 - Mockk,它允许你模拟对象,就像你想要的那样。
截至其文档:
可以按照以下方式将对象转换为模拟:
object MockObj {
fun add(a: Int, b: Int) = a + b
}
mockkObject(MockObj) {
assertEquals(3, MockObj.add(1, 2))
every { MockObj.add(1, 2) } returns 55
assertEquals(55, MockObj.add(1, 2))
}
尽管有Kotlin语言限制,但如果测试逻辑需要,则可以创建新的对象实例:
val newObjectMock = mockk<MockObj>()
答案 1 :(得分:8)
让你的对象实现一个接口,而不是用任何模拟库来模拟你的对象。这里是Junit + Mockito + Mockito-Kotlin的例子:
import com.nhaarman.mockito_kotlin.mock
import com.nhaarman.mockito_kotlin.whenever
import org.junit.Assert.assertEquals
import org.junit.Test
object SomeObject : SomeInterface {
override fun someFun():String {
return ""
}
}
interface SomeInterface {
fun someFun():String
}
class SampleTest {
@Test
fun test_with_mock() {
val mock = mock<SomeInterface>()
whenever(mock.someFun()).thenReturn("42")
val answer = mock.someFun()
assertEquals("42", answer)
}
}
如果您想要SomeObject
内的模拟callerFun
:
import com.nhaarman.mockito_kotlin.mock
import com.nhaarman.mockito_kotlin.whenever
import org.junit.Assert.assertEquals
import org.junit.Test
object SomeObject : SomeInterface {
override fun someFun():String {
return ""
}
}
class Caller(val someInterface: SomeInterface) {
fun callerFun():String {
return "Test ${someInterface.someFun()}"
}
}
// Example of use
val test = Caller(SomeObject).callerFun()
interface SomeInterface {
fun someFun():String
}
class SampleTest {
@Test
fun test_with_mock() {
val mock = mock<SomeInterface>()
val caller = Caller(mock)
whenever(mock.someFun()).thenReturn("42")
val answer = caller.callerFun()
assertEquals("Test 42", answer)
}
}
答案 2 :(得分:4)
您可以使用类委托来模拟没有任何额外库的Object。
这是我的建议
val someObjectDelegate : SomeInterface? = null
object SomeObject: by someObjectDelegate ?: SomeObjectImpl
object SomeObjectImpl : SomeInterface {
fun someFun() {
println("SomeObjectImpl someFun called")
}
}
interface SomeInterface {
fun someFun()
}
在测试中,您可以设置将改变行为的委托对象,否则它将使用它的真实实现。
@Beofre
fun setUp() {
someObjectDelegate = object : SomeInterface {
fun someFun() {
println("Mocked function")
}
}
// Will call method from your delegate
SomeObject.someFun()
}
当然上面的名字很糟糕,但为了举例,它显示了目的。
初始化SomeObject后,委托将处理所有功能 您可以在官方documentation
找到更多内容答案 3 :(得分:3)
除了使用非常方便的here库之外,还可以使用Mockito和反射模拟object
。 Kotlin对象只是一个带有私有构造函数和INSTANCE
静态字段的常规Java类,反射可以用模拟对象替换INSTANCE
的值。测试后应恢复原件,以便更改不会影响其他测试
使用Mockito Kotlin(需要将https://stackoverflow.com/a/39368284/3701429所述的扩展配置添加到模拟最终类中):
testCompile "com.nhaarman:mockito-kotlin:1.5.0"
第一个乐趣可以替换INSTANCE
类中静态object
字段的值并返回先前的值
fun <T> replaceObjectInstance(clazz: Class<T>, newInstance: T): T {
if (!clazz.declaredFields.any {
it.name == "INSTANCE" && it.type == clazz && Modifier.isStatic(it.modifiers)
}) {
throw InstantiationException("clazz ${clazz.canonicalName} does not have a static " +
"INSTANCE field, is it really a Kotlin \"object\"?")
}
val instanceField = clazz.getDeclaredField("INSTANCE")
val modifiersField = Field::class.java.getDeclaredField("modifiers")
modifiersField.isAccessible = true
modifiersField.setInt(instanceField, instanceField.modifiers and Modifier.FINAL.inv())
instanceField.isAccessible = true
val originalInstance = instanceField.get(null) as T
instanceField.set(null, newInstance)
return originalInstance
}
然后你可以有一个乐趣,它将创建object
的模拟实例,并用模拟的原始值替换原始值,返回原始值以便以后重置
fun <T> mockObject(clazz: Class<T>): T {
val constructor = clazz.declaredConstructors.find { it.parameterCount == 0 }
?: throw InstantiationException("class ${clazz.canonicalName} has no empty constructor, " +
"is it really a Kotlin \"object\"?")
constructor.isAccessible = true
val mockedInstance = spy(constructor.newInstance() as T)
return replaceObjectInstance(clazz, mockedInstance)
}
加入一些Kotlin糖
class MockedScope<T : Any>(private val clazz: Class<T>) {
fun test(block: () -> Unit) {
val originalInstance = mockObject(clazz)
block.invoke()
replaceObjectInstance(clazz, originalInstance)
}
}
fun <T : Any> withMockObject(clazz: Class<T>) = MockedScope(clazz)
最后,给出object
object Foo {
fun bar(arg: String) = 0
}
你可以这样测试
withMockObject(Foo.javaClass).test {
doAnswer { 1 }.whenever(Foo).bar(any())
Assert.assertEquals(1, Foo.bar(""))
}
Assert.assertEquals(0, Foo.bar(""))
答案 4 :(得分:1)
除非您愿意并且能够更改代码,否则操作字节代码的答案是否定的。模拟callerFun
调用SomeObject.someFun()
的最直接的方式(以及我推荐的方式)是提供一些方法来将它作为模拟对象。
e.g。
object SomeObject {
fun someFun() {}
}
fun callerFun() {
_callerFun { SomeObject.someFun() }
}
internal inline fun _callerFun(caller: () -> Unit) {
caller()
}
这里的想法是改变你愿意改变的东西。如果你确定你想要一个单例和一个顶级函数作用于那个单例,那么一种方法,如上所示,使顶层函数可测试而不改变它的公共签名是将它的实现移动到{{ 1}}允许滑动模拟的函数。