mangadex_at_home/src/test/kotlin/mdnet/metrics/GeoIpMetricsFilterTest.kt

package mdnet.metrics

import com.maxmind.geoip2.DatabaseReader
import com.maxmind.geoip2.model.CountryResponse
import com.maxmind.geoip2.record.Country
import io.kotest.core.spec.IsolationMode
import io.kotest.core.spec.style.FreeSpec
import io.micrometer.core.instrument.Counter
import io.micrometer.prometheus.PrometheusMeterRegistry
import io.mockk.confirmVerified
import io.mockk.every
import io.mockk.mockk
import io.mockk.verify
import org.http4k.core.Method
import org.http4k.core.Request
import org.http4k.core.RequestSource
import org.http4k.core.Response
import org.http4k.core.Status
import org.http4k.kotest.shouldHaveStatus
import java.net.InetAddress

class GeoIpMetricsFilterTest : FreeSpec() {
    override fun isolationMode() = IsolationMode.InstancePerTest

    init {
        val registry = mockk<PrometheusMeterRegistry>()
        val databaseReader = mockk<DatabaseReader>()

        val geoIpMetricsFilter = GeoIpMetricsFilter(databaseReader, registry)
        val filterRequest = geoIpMetricsFilter { Response(Status.OK) }

        "invalid source doesn't fail the image serving" {
            val address = "not a resolvable inetaddress"

            val request: Request = Request(Method.GET, "whatever")
                .source(RequestSource(address = address))

            val response = filterRequest(request)

            response.shouldHaveStatus(Status.OK)
        }

        "invalid header doesn't fail the image serving" {
            val address = "not a resolvable inetaddress"

            val request: Request = Request(Method.GET, "whatever")
                .header("X-Forwarded-For", address)

            val response = filterRequest(request)

            response.shouldHaveStatus(Status.OK)
        }

        "valid header and country resolved" {
            val address = "195.154.69.12"
            val countryCode = "COUNTRY_CODE"

            val countryResponse = mockk<CountryResponse>()
            val country = mockk<Country>()
            val counter = mockk<Counter>(relaxUnitFun = true)

            every { country.isoCode } returns countryCode
            every { countryResponse.country } returns country
            every { databaseReader.country(InetAddress.getByName(address)) } returns countryResponse
            every {
                registry.counter(
                    "requests_country_counts",
                    "country", countryCode
                )
            } returns counter

            val request: Request = Request(Method.GET, "whatever")
                .header("X-Forwarded-For", address)

            val response = filterRequest(request)

            response shouldHaveStatus Status.OK

            verify {
                registry.counter(
                    "requests_country_counts",
                    "country", countryCode
                )
            }
            confirmVerified(registry)

            verify {
                counter.increment()
            }
            confirmVerified(counter)
        }
    }
}