EngineTestBase

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

Types

PublishedTimeout

class PublishedTimeout : Timeout

Annotations

Http2Only

annotation class Http2Only

NoHttp2

annotation class NoHttp2

Constructors

<init>

EngineTestBase(
    applicationEngineFactory: ApplicationEngineFactory<TEngine, TConfiguration>)

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: ArrayList<Throwable>

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: ExecutorCoroutineDispatcher

testLog

val testLog: Logger

timeout

open val timeout: PublishedTimeout

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

Companion Object Properties

keyStore

lateinit var keyStore: KeyStore

keyStoreFile

val keyStoreFile: File

sslContext

lateinit var sslContext: SSLContext

trustManager

lateinit var trustManager: X509TrustManager

Companion Object Functions

setupAll

fun setupAll(): Unit

Extension Functions

decodeChunked

fun CoroutineScope.decodeChunked(
    input: ByteReadChannel
): 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

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

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

startConnectionPipeline

fun CoroutineScope.startConnectionPipeline(
    input: ByteReadChannel,
    output: ByteWriteChannel,
    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

Inheritors

EngineStressSuite

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

EngineTestSuite

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