Is there a simple way to create an HttpClient using TestApplicationEngine without the withTestApplication around each test? I just want to create the client once on test initialization and use it without withTestApplication and handleRequest...

The

TestApplicationEngine

doesn't use

HttpClient

instance as well as a client's Mock engine doesn't use Ktor server.

This is in the TestApplicationEngine source code:

}

    /**
     * An instance of client engine user to be used in [client].
     */
    val engine: HttpClientEngine = TestHttpClientEngine.create { app = this@TestApplicationEngine }

    /**
     * A client instance connected to this test server instance. Only works until engine stop invocation.
     */
    val client: HttpClient = HttpClient(engine)

Indeed. Could you please describe your problem in more detail?

this worked for me:

val server = TestApplicationEngine(environment = createTestEnvironment {
            module {
...
            }
        }) {}.apply { start() }

And how do you get the client @christophsturm?

i don’t create a client, i just call handleRequest on the server.

@dave08 in other words you want to set the server part up once and make requests in each test, correct?

in other words you want to set the server part up once and make requests in each test, correct?

yes. What you called Arrange, isn't arrange for me, it's the SUT (subject under test), that doesn't change in the arrange step --- arrange has more to do with db setup and request inputs that get sent to the SUT or are the state the SUT is in... @Aleksei Tirman [JB]

There is a design ticket for new testing API that we want to implement in 2.0.0 https://youtrack.jetbrains.com/issue/KTOR-971 Please take a look and comment if this will cover your needs

You can create an instance of

TestApplicationEngine

manually, assign the client to a test class property, and make requests in each test to the same server instance. Here is an example:

import io.ktor.application.*
import io.ktor.client.*
import io.ktor.client.request.*
import io.ktor.response.*
import io.ktor.routing.*
import io.ktor.server.testing.*
import kotlinx.coroutines.*
import kotlin.test.AfterTest
import kotlin.test.BeforeTest
import kotlin.test.Test
import kotlin.test.assertEquals

fun Application.module() {
    routing {
        get("/1") {
            call.respondText { "hello" }
        }

        get("/2") {
            call.respondText { "world" }
        }
    }
}

class SimpleTest {
    private lateinit var engine: TestApplicationEngine
    private lateinit var client: HttpClient

    @BeforeTest
    fun arrange() {
        engine = TestApplicationEngine(createTestEnvironment())
        engine.application.module()
        client = engine.client
        engine.start()
    }

    @AfterTest
    fun stopServer() {
        engine.stop(0L, 0L)
    }

    @Test
    fun test1() = runBlocking {
        val response = client.get<String>("/1")
        assertEquals("hello", response)
    }

    @Test
    fun test2() = runBlocking {
        val response = client.get<String>("/2")
        assertEquals("world", response)
    }
}

I would have preferred the opposite... instead of having

client = engine.client

where the client is being created by by the TestEngine, to use the TestEngine as the client's Engine (like instead of CIO, or OkHttp...), even in that ticket it seems like the proposition is going in the same direction in that sense... that way you stick to SRP (and dependency injection is easier... the same tests could be used with a real server running on a port, or the fake server...)

I understand but it's not possible right now that's why I can only suggest the solution above.

Ok, I guess that's better than nothing... but what about adding plugins to the client? Is that currently possible?

Actually, you can create an instance of

HttpClient

with a test server engine. In that case you can install any plugins for the client.

import io.ktor.application.*
import io.ktor.client.*
import io.ktor.client.features.*
import io.ktor.client.request.*
import io.ktor.response.*
import io.ktor.routing.*
import io.ktor.server.testing.*
import io.ktor.server.testing.client.*
import kotlinx.coroutines.*
import kotlin.test.AfterTest
import kotlin.test.BeforeTest
import kotlin.test.Test
import kotlin.test.assertEquals

fun Application.module() {
    routing {
        get("/1") {
            call.respondText { "hello" }
        }

        get("/2") {
            call.respondText { "world" }
        }

        get("/3") {
            call.respondText { call.request.headers["custom"]!! }
        }
    }
}

class SimpleTest {
    private lateinit var engine: TestApplicationEngine
    private lateinit var client: HttpClient

    @BeforeTest
    fun arrange() {
        engine = TestApplicationEngine(createTestEnvironment())
        engine.application.module()
        val clientEngine = TestHttpClientEngine.create { app = engine }
        client = HttpClient(clientEngine) {
            install(DefaultRequest) {
                header("custom", "value")
            }
        }
        engine.start()
    }

    @AfterTest
    fun stopServer() {
        engine.stop(0L, 0L)
    }

    @Test
    fun test1() = runBlocking {
        val response = client.get<String>("/1")
        assertEquals("hello", response)
    }

    @Test
    fun test2() = runBlocking {
        val response = client.get<String>("/2")
        assertEquals("world", response)
    }

    @Test
    fun testPlugin() = runBlocking {
        val response = client.get<String>("/3")
        assertEquals("value", response)
    }
}

That's great 👍🏼! Just what I wanted! Just wondering... would it be compatible with ktor client 2.0? I'm not quite ready to use it on the server side, but to get used to the new api in unit tests might be a good way to get started with it...

@dave08

Does the engine have to be started after it's passed to the client

No, you can start an engine before an assignment

Just wondering... would it be compatible with ktor client 2.0?

Yes, it's compatible with Ktor 2.0.0. You just need to adjust imports of packages and API for getting the body of a response.