ответ будет отрицательным, если вы не хотите и не можете изменить код. Самый простой способ (и способ, которым я бы порекомендовал) издеватьсяcallerFunпризыв кSomeObject.someFun() это предоставить какой-то способ подсунуть ему фиктивный объект.

например

object SomeObject {
    fun someFun() {}
}

fun callerFun() {
    _callerFun { SomeObject.someFun() }
}

internal inline fun _callerFun(caller: () -> Unit) {
    caller()
}

Идея в том, чтобы изменить то, что вы готовы изменить. Если вы уверены, что вам нужна функция singleton и функция верхнего уровня, которая действует на этот singleton, то, как показано выше, один из способов сделать функцию верхнего уровня тестируемой без изменения ее общедоступной сигнатуры - это переместить ее реализацию вinternal функция, которая позволяет поскользнуться.

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>()

Mockk библиотека, что довольно удобно, можно издеваться надobject просто с мокито и отражением. Объект Kotlin - это обычный Java-класс с приватным конструктором иINSTANCE статическое поле, с отражением можно заменить значениеINSTANCE с высмеянным объектом. После теста оригинал должен быть восстановлен, чтобы изменение не повлияло на другие тесты.

Использование Mockito Kotlin (необходимо добавить конфигурацию расширения, как описаноВот издеваться над выпускными классами):

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(""))

и, используя классделегаты.

Вот мое предложение

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 делегат будет обрабатывать все функции.
Больше вы можете найти в официальномдокументация