Question

对于以下Kotlin类：

class ProductLogic(

        private val product: Product?

) {

    fun shouldShow(): Boolean {
        if (product == null) {
            return false
        }
        val version = product.version!!
        if (!Utils.isAtLeastVersionX(version.major, version.minor)) {
            return false
        }
        return true
    }

}

我正在尝试在Kotlin中编写参数化测试：

@RunWith(ParameterizedRobolectricTestRunner::class)
@Config(constants = BuildConfig::class, sdk = [19], packageName = "com.example")
class ProductLogicTest(

        private val product: Product?,
        private val shouldShow: Boolean

) {

    @Before
    fun setUp() {
        // doReturn(VERSION).`when`(product).version // (2) Raises a NotAMockException
    }

    @Test
    fun shouldShow() {
        assertThat(ProductLogic(product).shouldShow(), `is`(shouldShow))
    }

    companion object {
        @JvmStatic
        @Parameters(name = "{index}: {0} => {1}")
        fun data(): Collection<Array<Any?>> {
            val productMock = mock<Product>(Product::class.java)
            doReturn(VERSION).`when`(productMock).version // (1) Is not applied
            return asList(
                       arrayOf(productMock, false),
                       // ...
            )
        }

}

我想参数化Product#version属性的值。当我（1）在data()函数中修改其值时，在运行测试时将不应用该值。当我（2）尝试在@Before中修改其值时，会引发NotAMockException：

org.mockito.exceptions.misusing.NotAMockException: 
Argument passed to when() is not a mock!
Example of correct stubbing:
    doThrow(new RuntimeException()).when(mock).someMethod();

请注意，该示例已简化-实际的ProductLogic类包含更多的参数，可使用参数化测试进行纠正。

Answer 1

机器人和Mockito版本：

testImplementation 'org.robolectric:robolectric:4.1'
testImplementation 'org.mockito:mockito-core:2.23.4'

此外，为了模拟最终课程，我创建了包含内容的文件src/test/resources/mockito-extensions/org.mockito.plugins.MockMaker

mock-maker-inline

要测试的课程：

class ProductLogic(private val product: Product?) {
    fun shouldShow(): Boolean {
        if (product == null) {
            return false
        }
        val version = product.version
        return !isAtLeastVersionX(version.minor, version.major)
    }

    private fun isAtLeastVersionX(minor: Int, major: Int): Boolean {
        val v = 5
        return v in minor..major
    }
}

class Product(val version: Version)

class Version(val minor: Int, val major: Int)

下一个测试代码对我有用，并且测试通过：

import org.hamcrest.CoreMatchers.`is`
import org.junit.Assert.assertThat
import org.junit.Before
import org.junit.Test
import org.junit.runner.RunWith
import org.mockito.Mockito.doReturn
import org.mockito.Mockito.mock
import org.robolectric.ParameterizedRobolectricTestRunner
import org.robolectric.annotation.Config
import java.util.Arrays.asList

@RunWith(ParameterizedRobolectricTestRunner::class)
@Config(sdk = [19], packageName = "com.example")
class ProductLogicTest(private val product: Product,
                       private val shouldShow: Boolean) {

    @Before
    fun setUp() {
        //doReturn(VERSION).`when`(product).version // if uncomment works fine
    }

    @Test
    fun shouldShow() {
        assertThat(ProductLogic(product).shouldShow(), `is`(shouldShow))
    }


    companion object {
        private val VERSION = Version(1, 5)

        @JvmStatic
        @ParameterizedRobolectricTestRunner.Parameters(name = "{index}: {0} => {1}")
        fun data(): Collection<Array<Any?>> {
            val productMock = mock(Product::class.java)
            doReturn(VERSION).`when`(productMock).version // Works fine
            return asList(
                    arrayOf(productMock, false)
            )
        }
    }
}

NotAMockException /如何在Kotlin的参数化测试中对值存根？

1 个答案: