Testing Kotlin Lambda Invocations without Mocking

class DataLoader {
    ....

    fun load(query: String, fetcher: (String) -> Data): Data {
        return findCachedData(query) ?: fetcher(query).also { fetchedData ->
            cacheData(query, fetchedData)
        }
    }
}


data class Data(val result: String)

fun findCachedData(query: String): Data? {....}
fun cacheData(query: String, data: Data) {....}

val data1 = dataLoader.load("a") { query ->
    // this should be invoked the first time
    api.fetchDataByQuery(query)
}

val data2 = dataLoader.load("a") { query ->
    // this should NOT be invoked the second time as cached Data is available
    api.fetchDataByQuery(query)
}

private val dataLoader = DataLoader(...)

private val testData = Data("result")

@Test
fun `fetcher is not executed when data associated with the query exists in cache`() {
    val mockFetcher = mock<(String) -> Data> {
        on { invoke(any()) }.doReturn(testData)
    }

    dataLoader.load("query", mockFetcher)

    // fetcher should be invoked the first time
    verify(mockFetcher, times(1)).invoke(any())

    clearInvocations(mockFetcher)

    dataLoader.load("query", mockFetcher)

    // fetcher should NOT be invoked for the same query the second time
    verify(mockFetcher, times(0)).invoke(any())
}

private val dataLoader = DataLoader(...)

private val testData = Data("result")

@Test
fun `fetcher is not executed when data associated with the query exists in cache`() {
    val mockFetcher = mockk<(String) -> Data>()
    every { mockFetcher.invoke(any()) } returns testData

    dataLoader.load("query", mockFetcher)

    // fetcher should be invoked the first time
    verify(exactly = 1) { mockFetcher(any()) }

    clearMocks(mockFetcher)

    dataLoader.load("query", mockFetcher)

    // fetcher should NOT be invoked for the same query the second time
    verify(exactly = 1) { mockFetcher(any()) }
}

dataLoader.load("a") {
    // perform any side-effects...
    ....
    // return data
    Data("result")
}

private val dataLoader = DataLoader(...)

private val testData = Data("result")

@Test
fun `fetcher is not executed when data associated with the query exists in cache`() {
    var invokeCount = 0
    val testFetcher = { _: String ->
        invokeCount++
        testData
    }

    dataLoader.load("query", testFetcher)

    assertThat(invokeCount).isEqualTo(1)

    dataLoader.load("query", testFetcher)

    // invokeCount should NOT increment
    assertThat(invokeCount).isEqualTo(1)
}

class TestFetcher(val expectedData: Data) : (String) -> Data {
    var invokeCount = 0

    override fun invoke(query: String): Data {
        invokeCount++
        return expectedData
    }
}

private val dataLoader = DataLoader(...)

private val testData = Data("result")

@Test
fun `fetcher is not executed when data associated with the query exists in cache`() {
    val testFetcher = TestFetcher(expectedData = testData)

    dataLoader.load("query", testFetcher)

    assertThat(testFetcher.invokeCount).isEqualTo(1)

    dataLoader.load("query", testFetcher)

    // invokeCount should NOT increment
    assertThat(testFetcher.invokeCount).isEqualTo(1)
}

class FailedTestFetcher(val expectedException: Exception) : (String) -> Data {
    var invokeCount = 0

    override fun invoke(query: String): Data {
        invokeCount++
        throw expectedException
    }
}

private val dataLoader = DataLoader(...)

@Test
fun `fetcher exception is propagated`() {
    val testFetcher = FailedTestFetcher(expectedException = IOException())

    assertThrows(IOException::class.java) {
        dataLoader.load("query", testFetcher)
    }

    assertThat(testFetcher.invokeCount).isEqualTo(1)
}

// doesn't compile
class Fetcher : suspend (String) -> Data { 
    override suspend fun invoke(query: String): Data = ....
}

interface Cache<in Key : Any, Value : Any> {
....
    /**
     * Returns the value associated with [key] in this cache if exists,
     * otherwise gets the value by invoking [loader], associates the value with [key] in the cache,
     * and returns the cached value.
     *
     * Note that [loader] is executed on the caller's thread. When called from multiple threads
     * concurrently, if an unexpired value for the [key] is present by the time the [loader] returns
     * the new value, the existing value won't be replaced by the new value.
     * Instead the existing value will be returned.
     *
     * Any exceptions thrown by the [loader] will be propagated to the caller of this function.
     */
    fun get(key: Key, loader: () -> Value): Value
....
}

@Test
fun `get(key, loader) returns existing value when an unexpired entry with the associated key exists before executing the loader`() {
    val cache = Cache.Builder.newBuilder()
        .expireAfterAccess(expiryDuration, TimeUnit.NANOSECONDS)
        .build<Long, String>()

    cache.put(1, "dog")

    // create a new `() -> Value` lambda
    val loader = createLoader("cat")

    val value = cache.get(1, loader)

    // loader should not have been invoked as "dog" is already in the cache.
    assertThat(loader.invokeCount)
        .isEqualTo(0)

    assertThat(value)
        .isEqualTo("dog")
}

private class TestLoader<Value>(private val block: () -> Value) : () -> Value {
    var invokeCount = 0
    override operator fun invoke(): Value {
        invokeCount++
        return block()
    }
}

// a regular loader that returns computed value immediately
private fun <Value> createLoader(computedValue: Value) =
    TestLoader { computedValue }

// a loader that throws an exception immediately
private fun createFailingLoader(exception: Exception) =
    TestLoader { throw exception }

// a loader that takes certain duration (virtual) to execute and return the computed value
private fun <Value> createSlowLoader(
    computedValue: Value,
    executionTime: Long
) = TestLoader {
    runBlocking { delay(executionTime) }
    computedValue
}