Unlock 30% off on Manual Testing Annual Plans this Holiday Season.

Copied to Clipboard!

How to use isConsumed method of com.github.kittinunf.fuel.core.Body class

Best Fuel code snippet using com.github.kittinunf.fuel.core.Body.isConsumed

UploadBody.kt

Source:UploadBody.kt

...31    /**32     * Returns if the body is consumed.33     * @return [Boolean] if true, `writeTo`, `toStream` and `toByteArray` may throw34     */35    override fun isConsumed() = !inputAvailable36    /**37     * Returns the body emptiness.38     * @return [Boolean] if true, this body is empty39     */40    override fun isEmpty() = false41    /**42     * Returns the body as an [InputStream].43     *44     * @note callers are responsible for closing the returned stream.45     * @note implementations may choose to make the [Body] `isConsumed` and can not be written or read from again.46     *47     * @return the body as input stream48     */49    override fun toStream(): InputStream {50        throw UnsupportedOperationException(51            "Conversion `toStream` is not supported on UploadBody, because the source is not a single single stream." +52                    "Use `toByteArray` to write the contents to memory or `writeTo` to write the contents to a stream."53        )54    }55    /**56     * Returns the body as a [ByteArray].57     *58     * @note Because the body needs to be read into memory anyway, implementations may choose to make the [Body]59     *  readable once more after calling this method, with the original [InputStream] being closed (and release its60     *  resources). This also means that if an implementation choose to keep it around, `isConsumed` returns false.61     *62     * @return the entire body63     */64    override fun toByteArray(): ByteArray {65        return ByteArrayOutputStream(length?.toInt() ?: 32)66            .use { stream ->67                writeTo(stream)68                stream.toByteArray()69            }70            .also { result ->71                // The entire body is now in memory, and can act as a regular body72                request.body(DefaultBody.from(73                        { ByteArrayInputStream(result) },74                        { result.size.toLong() }75                ))76            }77    }78    /**79     * Writes the body to the [OutputStream].80     *81     * @note callers are responses for closing the [OutputStream].82     * @note implementations may choose to make the [Body] `isConsumed` and can not be written or read from again.83     * @note implementations are recommended to buffer the output stream if they can't ensure bulk writing.84     *85     * @param outputStream [OutputStream] the stream to write to86     * @return [Long] the number of bytes written87     */88    override fun writeTo(outputStream: OutputStream): Long {89        if (!inputAvailable) {90            throw FuelError.wrap(IllegalStateException(91                    "The inputs have already been written to an output stream and can not be consumed again."92            ))93        }94        inputAvailable = false95        val lazyDataparts = request.dataParts96        return outputStream.buffered().let { stream ->...

LoggerAspect.kt

Source:LoggerAspect.kt

...74        if (!(answer.request.method in setOf(75                Method.POST,76                Method.PUT,77                Method.PATCH78            ) && answer.request.body.isConsumed())79        ) {80            reporter("$> ${answer.request.cUrlString()}")81        } else {82            reporter("*** Cannot report curl ***")83        }84    },85    ReportPart.HEADERS_OUT to { answer, reporter ->86        reporter(87            "Header sent: ${88                answer.request.headers.map { (key, value) ->89                    "\t$key:\t${value.joinToString("\n\t\t")}"90                }.joinToString("\n", "\n")91            }"92        )93    },94    ReportPart.COOKIES_OUT to { answer, reporter ->95        reporter("Cookies sent: ${answer.request["Set-Cookies"].joinToString("\n\t", "\n\t")}")96    },97    ReportPart.BODY_OUT to { answer, reporter ->98        if (answer.request.method in setOf(99                Method.POST,100                Method.PUT,101                Method.PATCH102            ) && !answer.request.body.isConsumed()103        ) {104            reporter(105                if (answer.request.body.isConsumed()) {106                    "Length of the sent Body: ${answer.request.body.length}"107                } else {108                    "Body sent:\n${109                        if (answer.request.header(Headers.CONTENT_TYPE).any { it.contains("json") }) {110                            jackson.writerWithDefaultPrettyPrinter().writeValueAsString(answer.body?.invoke())111                        } else {112                            answer.request.body.asString(null)113                        }114                    }"115                }116            )117        } else {118            reporter("*** Cannot report body sent ***")119        }...

DefaultBody.kt

Source:DefaultBody.kt

...22     */23    override fun asString(contentType: String?): String {24        return when {25            isEmpty() -> "(empty)"26            isConsumed() -> "(consumed)"27            else -> representationOfBytes(contentType ?: URLConnection.guessContentTypeFromStream(openStream()))28        }29    }30    /**31     * Returns the body as a [ByteArray].32     *33     * @note Because the body needs to be read into memory anyway, implementations may choose to make the [Body]34     *  readable once more after calling this method, with the original [InputStream] being closed (and release its35     *  resources). This also means that if an implementation choose to keep it around, `isConsumed` returns false.36     *37     * @return the entire body38     */39    override fun toByteArray(): ByteArray {40        if (isEmpty()) {41            return ByteArray(0)42        }43        return ByteArrayOutputStream(length?.toInt() ?: 32)44            .use { stream ->45                writeTo(stream)46                stream.toByteArray()47            }48            .also { result ->49                openStream = { ByteArrayInputStream(result) }50                calculateLength = { result.size.toLong() }51            }52    }53    /**54     * Returns the body as an [InputStream].55     *56     * @note callers are responsible for closing the returned stream.57     * @note implementations may choose to make the [Body] `isConsumed` and can not be written or read from again.58     *59     * @return the body as input stream60     */61    override fun toStream(): InputStream = openStream().buffered().apply {62        // The caller is now responsible for this stream. This make sure that you can't call this twice without handling63        // it. The caller must still call `.close()` on the returned value when done.64        openStream = CONSUMED_STREAM65    }66    /**67     * Writes the body to the [OutputStream].68     *69     * @note callers are responses for closing the [OutputStream].70     * @note implementations may choose to make the [Body] `isConsumed` and can not be written or read from again.71     * @note implementations are recommended to buffer the output stream if they can't ensure bulk writing.72     *73     * @param outputStream [OutputStream] the stream to write to74     * @return [Long] the number of bytes written75     */76    override fun writeTo(outputStream: OutputStream): Long {77        val inputStream = openStream()78        // `copyTo` writes efficiently using a buffer. Reading ensured to be buffered by calling `.buffered`79        return inputStream.buffered()80            .use { it.copyTo(outputStream) }81            .also {82                // The outputStream could be buffered, but we are done reading, so it's time to flush what's left83                outputStream.flush()84                // This prevents implementations from consuming the input stream twice85                openStream = CONSUMED_STREAM86            }87    }88    /**89     * Returns the body emptiness.90     * @return [Boolean] if true, this body is empty91     */92    override fun isEmpty() = openStream === EMPTY_STREAM || (length == 0L)93    /**94     * Returns if the body is consumed.95     * @return [Boolean] if true, `writeTo`, `toStream` and `toByteArray` may throw96     */97    override fun isConsumed() = openStream === CONSUMED_STREAM98    /**99     * Returns the length of the body in bytes100     * @return [Long?] the length in bytes, null if it is unknown101     */102    override val length: Long? by lazy {103        calculateLength?.invoke()?.let {104            if (it == -1L) { null } else { it }105        }106    }107    companion object {108        private val EMPTY_STREAM = {109            ByteArrayInputStream(ByteArray(0))110        }111        private val CONSUMED_STREAM = {...

BodyTest.kt

Source:BodyTest.kt

...14    @Test15    fun bodyIsEmptyByDefault() {16        val body = DefaultBody()17        assertThat(body.isEmpty(), equalTo(true))18        assertThat(body.isConsumed(), equalTo(false))19        val request = DefaultRequest(Method.POST, URL("https://test.fuel.com/"))20        assertThat(request.toString(), containsString("(empty)"))21    }22    @Test23    fun bodyIsConsumedAfterWriting() {24        val body = DefaultBody.from({ ByteArrayInputStream("body".toByteArray()) }, { 4 })25        assertThat(body.isConsumed(), equalTo(false))26        body.writeTo(ByteArrayOutputStream())27        assertThat(body.isConsumed(), equalTo(true))28    }29    @Test30    fun bodyFromString() {31        val value = "String Body ${Math.random()}"32        DefaultRequest(Method.POST, URL("https://test.fuel.com/"))33            .body(value)34            .apply {35                val output = ByteArrayOutputStream(value.length)36                assertThat(body.length?.toInt(), equalTo(value.length))37                assertThat(body.toByteArray(), equalTo(value.toByteArray()))38                body.writeTo(output)39                assertThat(output.toString(), equalTo(value))40            }41    }...

RepeatableBody.kt

Source:RepeatableBody.kt

...15    /**16     * Writes the body to the [OutputStream].17     *18     * @note callers are responses for closing the [OutputStream].19     * @note implementations may choose to make the [Body] `isConsumed` and can not be written or read from again.20     * @note implementations are recommended to buffer the output stream if they can't ensure bulk writing.21     *22     * @param outputStream [OutputStream] the stream to write to23     * @return [Long] the number of bytes written24     */25    override fun writeTo(outputStream: OutputStream): Long {26        val repeatableBodyStream = ByteArrayInputStream(toByteArray())27        return body.writeTo(outputStream)28                .also { length -> body = DefaultBody.from({ repeatableBodyStream }, { length }) }29    }30    /**31     * Returns the body as a [ByteArray].32     *33     * @note Because the body needs to be read into memory anyway, implementations may choose to make the [Body]34     *  readable once more after calling this method, with the original [InputStream] being closed (and release its35     *  resources). This also means that if an implementation choose to keep it around, `isConsumed` returns false.36     *37     * @return the entire body38     */39    override fun toByteArray() = body.toByteArray()40    /**41     * Returns the body as an [InputStream].42     *43     * @note callers are responsible for closing the returned stream.44     * @note implementations may choose to make the [Body] `isConsumed` and can not be written or read from again.45     *46     * @return the body as input stream47     */48    override fun toStream() = body.toStream()49    /**50     * Returns the body emptiness.51     * @return [Boolean] if true, this body is empty52     */53    override fun isEmpty() = body.isEmpty()54    /**55     * Returns if the body is consumed.56     * @return [Boolean] if true, `writeTo`, `toStream` and `toByteArray` may throw57     */58    override fun isConsumed() = body.isConsumed()59    /**60     * Represents this body as a string61     * @param contentType [String] the type of the content in the body, or null if a guess is necessary62     * @return [String] the body as a string or a string that represents the body such as (empty) or (consumed)63     */64    override fun asString(contentType: String?) = body.asString(contentType)65    /**66     * Returns the length of the body in bytes67     * @return [Long?] the length in bytes, null if it is unknown68     */69    override val length = body.length70    /**71     * Makes the body repeatable by e.g. loading its contents into memory72     * @return [RepeatableBody] the body to be repeated...

Body.kt

Source:Body.kt

...9     * Returns the body as a [ByteArray].10     *11     * @note Because the body needs to be read into memory anyway, implementations may choose to make the [Body]12     *  readable once more after calling this method, with the original [InputStream] being closed (and release its13     *  resources). This also means that if an implementation choose to keep it around, `isConsumed` returns false.14     *15     * @return the entire body16     */17    fun toByteArray(): ByteArray18    /**19     * Returns the body as an [InputStream].20     *21     * @note callers are responsible for closing the returned stream.22     * @note implementations may choose to make the [Body] `isConsumed` and can not be written or read from again.23     *24     * @return the body as input stream25     */26    fun toStream(): InputStream27    /**28     * Writes the body to the [OutputStream].29     *30     * @note callers are responses for closing the [OutputStream].31     * @note implementations may choose to make the [Body] `isConsumed` and can not be written or read from again.32     * @note implementations are recommended to buffer the output stream if they can't ensure bulk writing.33     *34     * @param outputStream [OutputStream] the stream to write to35     * @return [Long] the number of bytes written36     */37    fun writeTo(outputStream: OutputStream): Long38    /**39     * Returns the body emptiness.40     * @return [Boolean] if true, this body is empty41     */42    fun isEmpty(): Boolean43    /**44     * Returns if the body is consumed.45     * @return [Boolean] if true, `writeTo`, `toStream` and `toByteArray` may throw46     */47    fun isConsumed(): Boolean48    /**49     * Returns the length of the body in bytes50     * @return [Long?] the length in bytes, null if it is unknown51     */52    val length: Long?53    /**54     * Makes the body repeatable by e.g. loading its contents into memory55     * @return [RepeatableBody] the body to be repeated56     */57    fun asRepeatable(): RepeatableBody = RepeatableBody(this)58    /**59     * Represents this body as a string60     * @param contentType [String] the type of the content in the body, or null if a guess is necessary61     * @return [String] the body as a string or a string that represents the body such as (empty) or (consumed)...

RedirectionInterceptor.kt

Source:RedirectionInterceptor.kt

...41                }42                .requestProgress(request.executionOptions.requestProgress)43                .responseProgress(request.executionOptions.responseProgress)44                .let {45                    if (newMethod === request.method && !request.body.isEmpty() && !request.body.isConsumed())46                        it.body(request.body)47                    else48                        it49                }50            // Redirect51            next(request, newRequest.response().second)52        }53    }...

RepeatableBodyTest.kt

Source:RepeatableBodyTest.kt

...10class RepeatableBodyTest {11    @Test12    fun repeatableBodyIsNeverConsumed() {13        val body = DefaultBody.from({ ByteArrayInputStream("body".toByteArray()) }, { 4 }).asRepeatable()14        assertThat(body.isConsumed(), equalTo(false))15        body.writeTo(ByteArrayOutputStream())16        assertThat(body.isConsumed(), equalTo(false))17    }18    @Test19    fun byteArrayBodyIsRepeatable() {20        val value = ByteArray(32).apply {21            for (i in 0..(this.size - 1)) {22                this[i] = ('A'..'z').random().toByte()23            }24        }25        DefaultRequest(Method.POST, URL("https://test.fuel.com/"))26            .body(value)27            .apply {28                val output = ByteArrayOutputStream(value.size)29                assertThat(body.length?.toInt(), equalTo(value.size))30                assertThat(body.toByteArray(), equalTo(value))31                body.writeTo(output)32                assertThat(output.toString(), equalTo(String(value)))33                assertThat(body.isConsumed(), equalTo(false))34            }35    }36    @Test37    fun stringBodyIsRepeatable() {38        val value = "body"39        DefaultRequest(Method.POST, URL("https://test.fuel.com/"))40            .body(value)41            .apply {42                val output = ByteArrayOutputStream(value.length)43                assertThat(body.length?.toInt(), equalTo(value.length))44                assertThat(body.toByteArray(), equalTo(value.toByteArray()))45                body.writeTo(output)46                assertThat(output.toString(), equalTo(value))47                assertThat(body.isConsumed(), equalTo(false))48            }49    }50    @Test51    fun requestWithRepeatableBodyIsPrintableAfterConsumption() {52        val value = "String Body ${Math.random()}"53        DefaultRequest(Method.POST, URL("https://test.fuel.com/"))54            .body(value)55            .apply {56                val output = ByteArrayOutputStream()57                body.writeTo(output)58                assertThat(this.toString(), CoreMatchers.containsString(value))59            }60    }61}...

isConsumed

Using AI Code Generation

1@JvmOverloads fun Response . body ( offset : Long = 0 ) : Body = Body ( this , offset )2@JvmOverloads fun Response . body ( offset : Long = 0 ) : Body = Body ( this , offset )3@JvmOverloads fun Response . body ( offset : Long = 0 ) : Body = Body ( this , offset )4@JvmOverloads fun Response . body ( offset : Long = 0 ) : Body = Body ( this , offset )5@JvmOverloads fun Response . body ( offset : Long = 0 ) : Body = Body ( this , offset )6@JvmOverloads fun Response . body ( offset : Long = 0 ) : Body = Body ( this , offset )7@JvmOverloads fun Response . body ( offset : Long = 0 ) : Body = Body ( this , offset )8@JvmOverloads fun Response . body ( offset : Long = 0 ) : Body = Body ( this , offset )9@JvmOverloads fun Response . body ( offset : Long = 0 ) : Body = Body ( this , offset )10@JvmOverloads fun Response . body ( offset : Long = 0 ) : Body = Body ( this , offset )11@JvmOverloads fun Response . body ( offset : Long = 0 ) : Body = Body ( this , offset )

isConsumed

Using AI Code Generation

1val body = Body(ByteArray(0))2if (!body.isConsumed) {3}4val response = Response(ByteArray(0))5if (!response.isConsumed) {6}7if (!request.isConsumed) {8}9val headers = Headers()10if (!headers.isConsumed) {11}12val parameters = Parameters()13if (!parameters.isConsumed) {14}15val progress = Progress()16if (!progress.isConsumed) {17}18val requestProgress = RequestProgress()19if (!requestProgress.isConsumed) {20}21val responseProgress = ResponseProgress()22if (!responseProgress.isConsumed) {23}

Automation Testing Tutorials

Learn to execute automation testing from scratch with LambdaTest Learning Hub. Right from setting up the prerequisites to run your first automation test, to following best practices and diving deeper into advanced test scenarios. LambdaTest Learning Hubs compile a list of step-by-step guides to help you be proficient with different test automation frameworks i.e. Selenium, Cypress, TestNG etc.