SustainabilityTestSuite

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

Constructors

<init>

SustainabilityTestSuite(
    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

testApplicationScopeCancellation

fun testApplicationScopeCancellation(): Unit

testBigFile

fun testBigFile(): Unit

testBigFileHttpUrlConnection

fun testBigFileHttpUrlConnection(): Unit

testBlockingConcurrency

fun testBlockingConcurrency(): Unit

testBlockingDeadlock

open fun testBlockingDeadlock(): Unit

testChunkedWrongLength

open fun testChunkedWrongLength(): Unit

testEmbeddedServerCancellation

fun testEmbeddedServerCancellation(): Unit

testGetWithBody

fun testGetWithBody(): Unit

testIgnorePostContent

fun testIgnorePostContent(): Unit

testLoggerOnError

fun testLoggerOnError(): Unit

testRepeatRequest

fun testRepeatRequest(): 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