BaseMockWebServerTest.kt

import android.util.Log
import androidx.test.espresso.IdlingRegistry
import com.jakewharton.espresso.OkHttp3IdlingResource
import okhttp3.Interceptor
import okhttp3.OkHttpClient
import okhttp3.Response
import okhttp3.mockwebserver.MockResponse
import okhttp3.mockwebserver.MockWebServer
import okhttp3.mockwebserver.QueueDispatcher
import org.junit.After
import org.junit.Before
import org.koin.core.context.loadKoinModules
import org.koin.core.qualifier.named
import org.koin.dsl.module

abstract class BaseMockWebServerTest {

    private val mockWebServer = MockWebServer()

    private val okHttp =
        OkHttpClient
            .Builder()
            .addInterceptor(UrlInterceptor)
            .build()

    private val okHttpIdlingResource =
        OkHttp3IdlingResource.create("MockServer", okHttp)

    @Before
    fun startMockServer() {
        mockWebServer.start()

        val dispatcher = QueueDispatcher()
        dispatcher.setFailFast(MockResponse().setResponseCode(404))
        mockWebServer.dispatcher = dispatcher

        UrlInterceptor.port = mockWebServer.port
        IdlingRegistry.getInstance().register(okHttpIdlingResource)
    }

    @After
    fun shutdownMockServer() {
        IdlingRegistry.getInstance().unregister(okHttpIdlingResource)
        mockWebServer.shutdown()
    }

    fun <ROBOT : TestingRobot<*, *, *>> ROBOT.injectMockApi(
        mockResponseSequence: List<MockResponse> = emptyList()
    ): ROBOT {
        loadKoinModules(module(override = true) {
            single { okHttp }
        })

        mockResponseSequence.forEach { mockWebServer.enqueue(it) }
        return this
    }

    fun <ROBOT : TestingRobot<*, *, *>> ROBOT.launchWithMockApi(
        mockResponseSequence: List<MockResponse> = emptyList()
    ): ROBOT = apply {
        injectMockApi(mockResponseSequence)
        launch()
    }

    object UrlInterceptor : Interceptor {
        var port: Int = 8080

        private val url
            get() = "http://localhost:$port"

        override fun intercept(chain: Interceptor.Chain): Response {
            Log.w(
                "UrlInterceptor",
                "Request ${chain.request().method}: ${chain.request().url} --> $url"
            )

            return with(chain) {
                proceed(
                    request()
                        .newBuilder()
                        .url(url)
                        .build()
                )
            }
        }
    }
}