org.mockito.kotlin.OngoingStubbing.kt Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of mockito-kotlin Show documentation
Using Mockito with Kotlin.
The newest version!
/*
 * The MIT License
 *
 * Copyright (c) 2018 Niek Haarman
 * Copyright (c) 2007 Mockito contributors
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */

package org.mockito.kotlin

import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.runBlocking
import org.mockito.Mockito
import org.mockito.kotlin.internal.KAnswer
import org.mockito.kotlin.internal.SuspendableAnswer
import org.mockito.stubbing.Answer
import org.mockito.stubbing.OngoingStubbing
import kotlin.reflect.KClass

/**
 * Enables stubbing methods. Use it when you want the mock to return particular value when particular method is called.
 *
 * Alias for [Mockito.when].
 */
@Suppress("NOTHING_TO_INLINE")
inline fun  whenever(methodCall: T): OngoingStubbing {
    return Mockito.`when`(methodCall)!!
}

/**
 * Enables stubbing suspending methods. Use it when you want the mock to return particular value when particular suspending method is called.
 *
 * Warning: Only one method call can be stubbed in the function.
 * other method calls are ignored!
 */
fun  wheneverBlocking(methodCall: suspend CoroutineScope.() -> T): OngoingStubbing {
    return runBlocking { Mockito.`when`(methodCall()) }
}

/**
 * Sets a return value to be returned when the method is called.
 *
 * Alias for [OngoingStubbing.thenReturn].
 */
infix fun  OngoingStubbing.doReturn(t: T): OngoingStubbing {
    return thenReturn(t)
}

/**
 * Sets consecutive return values to be returned when the method is called.
 *
 * Alias for [OngoingStubbing.thenReturn].
 */
fun  OngoingStubbing.doReturn(t: T, vararg ts: T): OngoingStubbing {
    return thenReturn(t, *ts)
}

/**
 * Sets consecutive return values to be returned when the method is called.
 */
inline infix fun  OngoingStubbing.doReturnConsecutively(ts: List): OngoingStubbing {
    return thenReturn(
          ts[0],
          *ts.drop(1).toTypedArray()
    )
}

/**
 * Sets Throwable objects to be thrown when the method is called.
 *
 * Alias for [OngoingStubbing.thenThrow].
 */
infix fun  OngoingStubbing.doThrow(t: Throwable): OngoingStubbing {
    return thenThrow(t)
}

/**
 * Sets Throwable objects to be thrown when the method is called.
 *
 * Alias for [OngoingStubbing.doThrow].
 */
fun  OngoingStubbing.doThrow(
    t: Throwable,
    vararg ts: Throwable
): OngoingStubbing {
    return thenThrow(t, *ts)
}

/**
 * Sets a Throwable type to be thrown when the method is called.
 */
infix fun  OngoingStubbing.doThrow(t: KClass): OngoingStubbing {
    return thenThrow(t.java)
}

/**
 * Sets Throwable classes to be thrown when the method is called.
 */
fun  OngoingStubbing.doThrow(
    t: KClass,
    vararg ts: KClass
): OngoingStubbing {
    return thenThrow(t.java, *ts.map { it.java }.toTypedArray())
}

/**
 * Sets a generic Answer for the method.
 *
 * Alias for [OngoingStubbing.thenAnswer].
 */
infix fun  OngoingStubbing.doAnswer(answer: Answer<*>): OngoingStubbing {
    return thenAnswer(answer)
}

/**
 * Sets a generic Answer for the method using a lambda.
 */
infix fun  OngoingStubbing.doAnswer(answer: (KInvocationOnMock) -> T?): OngoingStubbing {
    return thenAnswer(KAnswer(answer))
}

infix fun  OngoingStubbing.doSuspendableAnswer(answer: suspend (KInvocationOnMock) -> T?): OngoingStubbing {
    return thenAnswer(SuspendableAnswer(answer))
}