HttpServerTestSuite

abstract class HttpServerTestSuite<TEngine : ApplicationEngine, TConfiguration : Configuration> : 
    EngineTestBase<TEngine, TConfiguration>

Constructors

<init>

HttpServerTestSuite(
    hostFactory: ApplicationEngineFactory<TEngine, TConfiguration>)

Inherited Properties

applicationEngineFactory

val applicationEngineFactory: ApplicationEngineFactory<TEngine, TConfiguration>

callGroupSize

var callGroupSize: Int

coroutineContext

open val coroutineContext: <ERROR CLASS>

enableHttp2

var enableHttp2: Boolean

enableSsl

var enableSsl: Boolean

exceptions

val exceptions: <ERROR CLASS>

isUnderDebugger

val isUnderDebugger: Boolean

port

var port: Int

server

var server: TEngine?

socketReadTimeout

val socketReadTimeout: Int

sslPort

var sslPort: Int

test

val test: TestName

testDispatcher

val testDispatcher: <ERROR CLASS>

testLog

val testLog: Logger

timeout

open val timeout: Long

timeoutRule

val timeoutRule: <ERROR CLASS>

Functions

test404

fun test404(): Unit

testClosedConnection

fun testClosedConnection(): Unit

testConnectionReset

fun testConnectionReset(): Unit

testCookie

fun testCookie(): Unit

testFormUrlEncoded

fun testFormUrlEncoded(): Unit

testHeadRequest

fun testHeadRequest(): Unit

testHeader

fun testHeader(): Unit

testHeadersReturnCorrectly

fun testHeadersReturnCorrectly(): Unit

testPathComponentsDecoding

fun testPathComponentsDecoding(): Unit

testProxyHeaders

fun testProxyHeaders(): Unit

testRedirect

fun testRedirect(): Unit

testRedirectFromInterceptor

fun testRedirectFromInterceptor(): Unit

testRemoteHost

fun testRemoteHost(): Unit

testRequestParameters

fun testRequestParameters(): Unit

testRequestParts

fun testRequestParts(): Unit

testRequestTwiceInOneBufferWithKeepAlive

fun testRequestTwiceInOneBufferWithKeepAlive(): Unit

testRequestTwiceNoKeepAlive

fun testRequestTwiceNoKeepAlive(): Unit

testRequestTwiceWithKeepAlive

fun testRequestTwiceWithKeepAlive(): Unit

testServerPush

fun testServerPush(): Unit

testStatusCodeDirect

fun testStatusCodeDirect(): Unit

testStatusCodeViaResponseObject

fun testStatusCodeViaResponseObject(): Unit

testStatusPages404

fun testStatusPages404(): Unit

testUpgrade

open fun testUpgrade(): Unit

Inherited Functions

configure

open fun configure(configuration: TConfiguration): Unit

createAndStartServer

fun createAndStartServer(
    log: Logger? = null,
    parent: <ERROR CLASS> = EmptyCoroutineContext,
    routingConfigurer: Routing.() -> Unit
): TEngine

createServer

open fun createServer(
    log: Logger?,
    parent: <ERROR CLASS> = EmptyCoroutineContext,
    module: Application.() -> Unit
): TEngine

features

open fun features(
    application: Application,
    routingConfigurer: Routing.() -> Unit
): Unit

findFreePort

fun findFreePort(): Int

setUpBase

fun setUpBase(): Unit

socket

fun socket(block: Socket.() -> Unit): Unit

tearDownBase

fun tearDownBase(): Unit

withUrl

fun withUrl(
    path: String,
    builder: suspend HttpRequestBuilder.() -> Unit = {},
    block: suspend HttpResponse.(Int) -> Unit
): Unit

Extension Functions

decodeChunked

fun CoroutineScope.decodeChunked(
    input: ByteReadChannel
): DecoderJob
fun CoroutineScope.decodeChunked(
    input: ByteReadChannel,
    contentLength: Long
): DecoderJob

Start a chunked stream decoder coroutine

embeddedServer

fun <TEngine : ApplicationEngine, TConfiguration : Configuration> CoroutineScope.embeddedServer(
    factory: ApplicationEngineFactory<TEngine, TConfiguration>,
    port: Int = 80,
    host: String = "0.0.0.0",
    watchPaths: List<String> = emptyList(),
    parentCoroutineContext: <ERROR CLASS> = EmptyCoroutineContext,
    configure: TConfiguration.() -> Unit = {},
    module: Application.() -> Unit
): TEngine

Creates an embedded server with the given factory, listening on host:port

httpServer

fun CoroutineScope.httpServer(
    settings: HttpServerSettings,
    handler: HttpRequestHandler
): HttpServer

Start an http server with settings invoking handler for every request

httpServer

fun CoroutineScope.httpServer(
    settings: HttpServerSettings,
    handler: suspend CoroutineScope.(request: Request, input: ByteReadChannel, output: ByteWriteChannel, upgraded: CompletableDeferred<Boolean>?) -> Unit
): HttpServer

Start an http server with settings invoking handler for every request

mapEngineExceptions

fun CoroutineScope.mapEngineExceptions(
    input: ByteReadChannel,
    request: HttpRequestData
): ByteReadChannel

Returns ByteReadChannel with ByteChannel.close handler that returns SocketTimeoutException instead of SocketTimeoutException.

fun CoroutineScope.mapEngineExceptions(
    output: ByteWriteChannel,
    request: HttpRequestData
): ByteWriteChannel

Returns ByteWriteChannel with ByteChannel.close handler that returns SocketTimeoutException instead of SocketTimeoutException.

parseMultipart

fun CoroutineScope.parseMultipart(
    input: ByteReadChannel,
    headers: HttpHeadersMap
): ReceiveChannel<MultipartEvent>
fun CoroutineScope.parseMultipart(
    input: ByteReadChannel,
    contentType: CharSequence,
    contentLength: Long?
): ReceiveChannel<MultipartEvent>
fun CoroutineScope.parseMultipart(
    boundaryPrefixed: ByteBuffer,
    input: ByteReadChannel,
    totalLength: Long?
): ReceiveChannel<MultipartEvent>

Starts a multipart parser coroutine producing multipart events

pinger

fun CoroutineScope.pinger(
    outgoing: SendChannel<Frame>,
    period: Duration,
    timeout: Duration,
    pool: ObjectPool<ByteBuffer> = KtorDefaultPool
): SendChannel<Pong>

Launch pinger coroutine on CoroutineScope that is sending ping every specified period to outgoing channel, waiting for and verifying client’s pong frames. It is also handling timeout and sending timeout close frame

fun CoroutineScope.pinger(
    outgoing: SendChannel<Frame>,
    periodMillis: Long,
    timeoutMillis: Long,
    pool: ObjectPool<ByteBuffer> = KtorDefaultPool
): SendChannel<Pong>

Launch pinger coroutine on CoroutineScope that is sending ping every specified periodMillis to outgoing channel, waiting for and verifying client’s pong frames. It is also handling timeoutMillis and sending timeout close frame

pinger

fun CoroutineScope.pinger(
    outgoing: SendChannel<Frame>,
    period: <ERROR CLASS>,
    timeout: <ERROR CLASS>,
    pool: ObjectPool<ByteBuffer> = KtorDefaultPool
): SendChannel<Pong>

Launch pinger coroutine on CoroutineScope that is sending ping every specified period to outgoing channel, waiting for and verifying client’s pong frames. It is also handling timeout and sending timeout close frame

ponger

fun CoroutineScope.ponger(
    outgoing: SendChannel<Pong>,
    pool: ObjectPool<ByteBuffer> = KtorDefaultPool
): SendChannel<Ping>

Launch a ponger actor job on the CoroutineScope sending pongs to outgoing channel. It is acting for every client’s ping frame and replying with corresponding pong

reader

fun CoroutineScope.reader(
    coroutineContext: <ERROR CLASS> = EmptyCoroutineContext,
    channel: ByteChannel,
    block: suspend ReaderScope.() -> Unit
): ReaderJob
fun CoroutineScope.reader(
    coroutineContext: <ERROR CLASS> = EmptyCoroutineContext,
    autoFlush: Boolean = false,
    block: suspend ReaderScope.() -> Unit
): ReaderJob

startConnectionPipeline

fun CoroutineScope.startConnectionPipeline(
    input: ByteReadChannel,
    output: ByteWriteChannel,
    timeout: WeakTimeoutQueue,
    handler: suspend CoroutineScope.(request: Request, input: ByteReadChannel, output: ByteWriteChannel, upgraded: CompletableDeferred<Boolean>?) -> Unit
): Job

Start connection HTTP pipeline invoking handler for every request. Note that handler could be invoked multiple times concurrently due to HTTP pipeline nature

startServerConnectionPipeline

fun CoroutineScope.startServerConnectionPipeline(
    connection: ServerIncomingConnection,
    timeout: WeakTimeoutQueue,
    handler: HttpRequestHandler
): Job

Start connection HTTP pipeline invoking handler for every request. Note that handler could be invoked multiple times concurrently due to HTTP pipeline nature

writeMultipleRanges

fun CoroutineScope.writeMultipleRanges(
    channelProducer: (LongRange) -> ByteReadChannel,
    ranges: List<LongRange>,
    fullLength: Long?,
    boundary: String,
    contentType: String
): ByteReadChannel

Start multirange response writer coroutine

writer

fun CoroutineScope.writer(
    coroutineContext: <ERROR CLASS> = EmptyCoroutineContext,
    channel: ByteChannel,
    block: suspend WriterScope.() -> Unit
): WriterJob
fun CoroutineScope.writer(
    coroutineContext: <ERROR CLASS> = EmptyCoroutineContext,
    autoFlush: Boolean = false,
    block: suspend WriterScope.() -> Unit
): WriterJob