TestApplicationResponse

class TestApplicationResponse : 
    BaseApplicationResponse,
    CoroutineScope

Represents test call response received from server

Constructors

<init>

TestApplicationResponse(
    call: TestApplicationCall,
    readResponse: Boolean = false)

Represents test call response received from server

Properties

byteContent

var byteContent: ByteArray?

Response body byte content. Could be blocking. Remains null until response appears.

content

val content: String?

Response body text content. Could be blocking. Remains null until response appears.

headers

val headers: ResponseHeaders

Headers for this response

readResponse

val readResponse: Boolean

if response channel need to be consumed into byteContent

Inherited Properties

bufferPool

open val bufferPool: ObjectPool<ByteBuffer>

ByteBuffer pool

call

open val call: ApplicationCall

ApplicationCall instance this ApplicationResponse is attached to

cookies

open val cookies: ResponseCookies

Cookies for this response

pipeline

Pipeline for sending content

Functions

awaitWebSocket

fun awaitWebSocket(duration: Duration): Unit

Wait for websocket session completion

contentChannel

fun contentChannel(): ByteReadChannel?

Response body content channel

flush

suspend fun flush(): Unit

Await for response job completion

respondOutgoingContent

suspend fun respondOutgoingContent(
    content: OutgoingContent
): Unit

Process response outgoing content

respondUpgrade

suspend fun respondUpgrade(upgrade: ProtocolUpgrade): Unit

Process upgrade response

responseChannel

suspend fun responseChannel(): ByteWriteChannel

Get response output channel

setStatus

fun setStatus(statusCode: HttpStatusCode): Unit

Set underlying engine’s response status

websocketChannel

fun websocketChannel(): ByteReadChannel?

Websocket session’s channel

Inherited Functions

commitHeaders

fun commitHeaders(content: OutgoingContent): Unit

Commit header values and status and pass them to the underlying engine

push

open fun push(builder: ResponsePushBuilder): Unit

Produces HTTP/2 push from server to client or sets HTTP/1.x hint header or does nothing. Exact behaviour is up to engine implementation.

respondFromBytes

open suspend fun respondFromBytes(bytes: ByteArray): Unit

Respond with bytes content

respondFromChannel

open suspend fun respondFromChannel(
    readChannel: ByteReadChannel
): Unit

Respond from readChannel

respondNoContent

open suspend fun respondNoContent(content: NoContent): Unit

Process response with no content

respondWriteChannelContent

open suspend fun respondWriteChannelContent(
    content: WriteChannelContent
): Unit

Process response content using OutgoingContent.WriteChannelContent.writeTo.

status

open fun status(): HttpStatusCode?

Currently set status code for this response, or null if none was set

open fun status(value: HttpStatusCode): Unit

Set status for this response

Extension Functions

cacheControl

fun ApplicationResponse.cacheControl(
    value: CacheControl
): Unit

Append response Cache-Control HTTP header value

contentRange

fun ApplicationResponse.contentRange(
    range: LongRange?,
    fullLength: Long? = null,
    unit: RangeUnits
): Unit
fun ApplicationResponse.contentRange(
    range: LongRange?,
    fullLength: Long? = null,
    unit: String = RangeUnits.Bytes.unitToken
): Unit

Append response Content-Range header with specified range and fullLength

contentType

Return parsed content type from the test response

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

etag

fun ApplicationResponse.etag(value: String): Unit

Append response E-Tag HTTP header value

expires

fun ApplicationResponse.expires(value: LocalDateTime): Unit

Append response Expires HTTP header value

header

fun ApplicationResponse.header(
    name: String,
    value: String
): Unit

Append HTTP response header with string value

fun ApplicationResponse.header(
    name: String,
    value: Int
): Unit

Append HTTP response header with integer numeric value

fun ApplicationResponse.header(
    name: String,
    value: Long
): Unit

Append HTTP response header with long integer numeric value

fun ApplicationResponse.header(
    name: String,
    date: Temporal
): Unit

Append HTTP response header with temporal date (date, time and so on)

httpServer

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

Start an http server with settings invoking handler for every request

lastModified

fun ApplicationResponse.lastModified(
    dateTime: ZonedDateTime
): Unit

Append response Last-Modified HTTP header value from dateTime

link

fun ApplicationResponse.link(header: LinkHeader): Unit

Append Link header to HTTP response

fun ApplicationResponse.link(
    uri: String,
    vararg rel: String
): Unit

Append Link header to HTTP response with specified uri and rel

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