Java Mockito单元测试：在类的所有方法调用上，返回；“真的”；

我在kotlin

SmsHandler

中有一个类，它的方法

determineFiltersPass

调用另一个类的方法，

SmsSendingFilters

：

class SmsHandler(val filterPredicates: SmsSendingFilters) {
    fun determineFiltersPass(sms: SmsDto): Boolean = with(sms.filters) {
        var pass = true
        for (filter in FiltersDto::class.memberProperties)
            pass = when (FilterType.valueOf(filter.name.toUpperCase())) {
                UNIQUE -> if (filter.get(sms.filters) != null) {
                    val unique = filter.get(sms.filters) as Boolean
                    pass && if (unique) filterPredicates.isUnique().test(sms) else true
                } else pass && true
                RECENT -> if (filter.get(sms.filters) != null) {
                    pass && filterPredicates.shouldSendByTimePeriodFromLastMessage().test(sms)
                } else pass && true
                else -> pass && true
            }
        pass
    }
}


class SmsSendingFilters {

    fun isUnique(): Predicate<SmsDto> = Predicate {
        with(it) {
        repo.findAllByMessageIdAndMobileNumAndAppIdAndParamMap(messageId!!, mobileNum!!, appId!!, paramMap!!.toString()).isEmpty()
        }
    }

    fun shouldSendByTimePeriodFromLastMessage(): Predicate<SmsDto> = Predicate {
        val calendar = Calendar.getInstance()
        calendar.time = Date()
        with(it.filters.recent ?: "" to "") {
            val size = this.second.toInt()
            when (IntervalType.valueOf(this.first.toUpperCase())) {
                SECOND -> calendar.add(Calendar.SECOND, -1 * size)
                MINUTE -> calendar.add(Calendar.MINUTE, -1 * size)
                HOUR -> calendar.add(Calendar.HOUR, -1 * size)
                MONTH -> calendar.add(Calendar.MONTH, -1 * size)
                YEAR -> calendar.add(Calendar.YEAR, -1 * size)
                else -> Unit
            }
            with(it) {
                repo.findAllByMessageIdAndMobileNumAndAppId(messageId!!, mobileNum!!, appId!!)
                    .none { it.dateSent?.toInstant()?.isAfter(calendar.toInstant()) ?: true }
            }
        }
    }
}

但是，符合这一逻辑的东西：

when(filterPredicates.<anyMethodInvoked>().test(any())).thenReturn(true)

when（filterPredicates.（）.test（any（））。然后返回（true）

例如（使用优秀的包装器）：

interface Thingy{
fun foo（）：布尔值
趣味条（）：布尔值
}
类内容测试{
@试验
趣味测试（）{
val t1=mock（defaultAnswer=Answer{false}）
println（t1.foo（））/“false”
println（t1.bar（））/“false”
val t2=mock（defaultAnswer=Answer{true}）
println（t2.foo（））/“true”
println（t2.bar（））/“true”
}
}

当然，在更复杂的情况下，您可能有返回不同类型的方法，在这种情况下，您需要在

答案
实现中做一些更聪明的事情
 

例如（使用优秀的包装器）：

interface Thingy{
fun foo（）：布尔值
趣味条（）：布尔值
}
类内容测试{
@试验
趣味测试（）{
val t1=mock（defaultAnswer=Answer{false}）
println（t1.foo（））/“false”
println（t1.bar（））/“false”
val t2=mock（defaultAnswer=Answer{true}）
println（t2.foo（））/“true”
println（t2.bar（））/“true”
}
}

当然，在更复杂的情况下，您可能有返回不同类型的方法，在这种情况下，您需要在
答案
实现中做一些更聪明的事情
 谢谢你的快速回复。明天我会在工作中试试：谢谢你的快速反应。明天上班时我会试试的
when(filterPredicates.<anyMethodInvoked>().test(any())).thenReturn(true)

interface Thingy {
    fun foo() : Boolean
    fun bar() : Boolean
}

class ThingyTest {
    @Test
    fun test() {
        val t1 = mock<Thingy>(defaultAnswer = Answer { false })
        println(t1.foo())   // "false"
        println(t1.bar())   // "false"

        val t2 = mock<Thingy>(defaultAnswer = Answer { true })
        println(t2.foo())   // "true"
        println(t2.bar())   // "true"
    }
}