Mockoon to MockServer mapping (it is a simple test)

MockoonMapper.kt

package br.com.everton.mockserver.mockoon

import org.mockserver.model.Header

class Mockoon(val data:List<MockoonData>)
class MockoonData(val item:MockoonItem)
class MockoonItem(val port:Int, val latency: Int, val endpointPrefix: String, val routes: List<MockoonRoute>)
class MockoonRoute(val method:String, val endpoint: String, val responses: List<MockoonResponse>, val enabled:Boolean)
class MockoonResponse(val body:String, val statusCode: Int, val latency:Long, val headers: List<MockoonHeader>, val rules: List<MockoonRule>)
class MockoonRule(val target:RuleType, val modifier:String, val value:String, val isRegex:Boolean) {
    fun asHeader():Header = Header(modifier, listOf(value))
}

enum class RuleType { header }

class MockoonHeader(val key:String, val value:String) {
    fun asHeader():Header = Header(key, listOf(value))
}

StartMockServer.kt

package br.com.everton.mockserver.mockoon

import br.com.eive.integration.test.TestFiles
import org.junit.Test
import org.mockserver.integration.ClientAndServer
import org.mockserver.matchers.Times
import org.mockserver.model.Delay
import org.mockserver.model.HttpRequest
import org.mockserver.model.HttpResponse
import org.mockserver.model.NottableString

class StartMockServer {

     fun start():Unit {
        val mockoon = TestFiles.read("/mockoon.json", Mockoon::class) // Read and deserialize mockoon.json


        mockoon.data.forEach {data ->
            val item = data.item
            val server = ClientAndServer.startClientAndServer(data.item.port)
            item.routes.filter { it.enabled }.forEach { route ->
                val path = "/"+listOf(item.endpointPrefix, route.endpoint).filter { !it.isEmpty() }.joinToString("/")
                val request = HttpRequest.request()
                        .withPath(path)
                        .withMethod(route.method.toUpperCase())

                route.responses.forEachIndexed { i, response ->
                    val times = if (i == route.responses.size - 1) Times.unlimited() else Times.once()

                    response.rules.filter { it.target == RuleType.header }.map { it.asHeader() }

                    server.`when`(request, times).respond(HttpResponse.response()
                            .withBody(response.body)
                            .withDelay(Delay.milliseconds(response.latency))
                            .withHeaders(response.headers.filter { it.key.isNotEmpty() }.map { it.asHeader() })
                            .withStatusCode(response.statusCode))
                }
            }
        }

        Thread.sleep(60000)

    }


}