package link.roadio.riff.player.library

import org.junit.Assert.assertEquals
import org.junit.Assert.assertTrue
import org.junit.Test
import java.util.concurrent.Executor

class LatestSnapshotLoaderTest {
    private class ManualExecutor : Executor {
        private val tasks = ArrayDeque<Runnable>()

        override fun execute(command: Runnable) {
            tasks.add(command)
        }

        fun drain() {
            while (tasks.isNotEmpty()) tasks.removeFirst().run()
        }
    }

    @Test fun staleCompletionsAreRejectedAndPendingRequestsCoalesce() {
        val worker = ManualExecutor()
        val receiver = ManualExecutor()
        var current = 1
        val loaded = mutableListOf<Int>()
        val received = mutableListOf<Int>()
        val loader =
            LatestSnapshotLoader(worker, receiver, { key: Int ->
                loaded.add(key)
                key
            }, { it == current }) { _, result ->
                received.add(result.getOrThrow())
            }
        loader.request(1)
        assertTrue(loaded.isEmpty())
        worker.drain()
        current = 3
        loader.request(2)
        loader.request(3)
        receiver.drain()
        assertTrue(received.isEmpty())
        worker.drain()
        receiver.drain()
        assertEquals(listOf(1, 3), loaded)
        assertEquals(listOf(3), received)
    }

    @Test fun failureDoesNotLoseAnInvalidationDuringLoad() {
        val worker = ManualExecutor()
        val receiver = ManualExecutor()
        val outcomes = mutableListOf<Boolean>()
        var attempt = 0
        lateinit var loader: LatestSnapshotLoader<Int, Int>
        loader =
            LatestSnapshotLoader(worker, receiver, {
                if (++attempt == 1) {
                    loader.request(it)
                    error("Optional artifact unavailable")
                }
                it
            }, { true }) { _, result -> outcomes.add(result.isSuccess) }
        loader.request(1)
        worker.drain()
        receiver.drain()
        assertEquals(listOf(false, true), outcomes)
    }
}