io.ktor.server.testing / TestApplicationResponse

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

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	`val pipeline: ApplicationSendPipeline` Pipeline for sending content

Functions

awaitWebSocket	`fun awaitWebSocket(durationMillis: Long): Unit` Wait for websocket session completion `fun awaitWebSocket(duration: Duration): Unit`
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

awaitWebSocket	`fun TestApplicationResponse.awaitWebSocket( duration: Duration ): Unit` Wait for websocket session completion
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	`fun TestApplicationResponse.contentType(): ContentType` Return parsed content type from the test response
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
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
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: 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`