给出一个Kotlin单例对象和一个称之为方法的乐趣
object SomeObject {
fun someFun() {}
}
fun callerFun() {
SomeObject.someFun()
}
有没有办法模拟对SomeObject.someFun()的调用？
只需让对象实现一个接口，就可以使用任何模拟库来模拟对象。这里是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)
}
}
Kotlin有一个非常好的模拟库 - Mockk，它允许你模拟物体，就像你想要的那样。
截至其文档：
对象可以按照以下方式转换为模拟：
object MockObj {
fun add(a: Int, b: Int) = a + b
}
mockkObject(MockObj) // aplies mocking to an Object
assertEquals(3, MockObj.add(1, 2))
every { MockObj.add(1, 2) } returns 55
assertEquals(55, MockObj.add(1, 2))
要还原，请使用unmockkAll或unmockkObject：
@Before
fun beforeTests() {
mockkObject(MockObj)
every { MockObj.add(1,2) } returns 55
}
@Test
fun willUseMockBehaviour() {
assertEquals(55, MockObj.add(1,2))
}
@After
fun afterTests() {
unmockkAll()
// or unmockkObject(MockObj)
}
尽管Kotlin语言有限制，但如果测试逻辑需要以下内容，则可以创建对象的新实例：
val newObjectMock = mockk<MockObj>()
通过使用类委托，您可以在没有任何额外库的情况下模拟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找到
除了使用非常方便的Mockk库，人们可以简单地用Mockito和反射模拟一个object。 Kotlin对象只是一个带有私有构造函数和INSTANCE静态字段的常规Java类，反射可以用模拟对象替换INSTANCE的值。测试后应恢复原件，以便更改不会影响其他测试
使用Mockito Kotlin（需要添加一个扩展配置，如here描述的模拟最终类）：
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(""))
除非您愿意并且能够更改代码，否则操作字节代码的答案是否定的。模拟callerFun对SomeObject.someFun()的调用最直接的方式（以及我推荐的方式）是提供一些方法来将它作为模拟对象。
EG
object SomeObject {
fun someFun() {}
}
fun callerFun() {
_callerFun { SomeObject.someFun() }
}
internal inline fun _callerFun(caller: () -> Unit) {
caller()
}
这里的想法是改变你愿意改变的东西。如果你确定你想要一个单例和一个顶级函数作用于那个单例，那么一种方法，如上所示，使顶级函数可测试而不改变其公共签名是将其实现移动到internal函数允许滑倒模拟。