How to use DefaultBody class of com.github.kittinunf.fuel.core.requests package

Best Fuel code snippet using com.github.kittinunf.fuel.core.requests.DefaultBody

Deserializable.kt

Source:Deserializable.kt

1package com.github.kittinunf.fuel.core2import com.github.kittinunf.fuel.Fuel3import com.github.kittinunf.fuel.core.deserializers.EmptyDeserializer4import com.github.kittinunf.fuel.core.requests.CancellableRequest5import com.github.kittinunf.fuel.core.requests.DefaultBody6import com.github.kittinunf.fuel.core.requests.RequestTaskCallbacks7import com.github.kittinunf.fuel.core.requests.suspendable8import com.github.kittinunf.fuel.core.requests.toTask9import com.github.kittinunf.result.Result10import com.github.kittinunf.result.getOrElse11import com.github.kittinunf.result.map12import com.github.kittinunf.result.mapError13import java.io.InputStream14import java.io.Reader15import kotlin.jvm.Throws16/**17 * Generic interface for [Response] deserialization.18 *19 * @note you are responsible of using the [Response] [Body] [InputStream] and closing it when you're done. Failing to do20 *   so can result in hanging connections if used in conjunction with [com.github.kittinunf.fuel.toolbox.HttpClient].21 *22 * @see ResponseDeserializable23 */24interface Deserializable<out T : Any> {25    /**26     * Deserialize [response] into [T]27     *28     * @param response [Response] the incoming response29     * @return [T] the instance of [T]30     */31    fun deserialize(response: Response): T32}33interface ResponseDeserializable<out T : Any> : Deserializable<T> {34    override fun deserialize(response: Response): T {35        response.body.toStream().use { stream ->36            return deserialize(stream)37                ?: deserialize(stream.reader())38                ?: reserialize(response, stream).let {39                    deserialize(response.data)40                        ?: deserialize(String(response.data))41                        ?: throw FuelError.wrap(IllegalStateException(42                            "One of deserialize(ByteArray) or deserialize(InputStream) or deserialize(Reader) or " +43                                "deserialize(String) must be implemented"44                        ))45                }46        }47    }48    private fun reserialize(response: Response, stream: InputStream): Response {49        val length = response.body.length50        response.body = DefaultBody.from({ stream }, length?.let { l -> { l } })51        return response52    }53    /**54     * Deserialize into [T] from an [InputStream]55     *56     * @param inputStream [InputStream] source bytes57     * @return [T] deserialized instance of [T] or null when not applied58     */59    fun deserialize(inputStream: InputStream): T? = null60    /**61     * Deserialize into [T] from a [Reader]62     *63     * @param reader [Reader] source bytes64     * @return [T] deserialized instance of [T] or null when not applied...

FuelExtensionsTest.kt

Source:FuelExtensionsTest.kt

...9import com.github.kittinunf.fuel.core.Method10import com.github.kittinunf.fuel.core.Response11import com.github.kittinunf.fuel.core.ResponseResultOf12import com.github.kittinunf.fuel.core.extensions.authentication13import com.github.kittinunf.fuel.core.requests.DefaultBody14import com.github.kittinunf.fuel.core.requests.DefaultRequest15import com.github.kittinunf.result.Result16import org.hamcrest.CoreMatchers.equalTo17import org.hamcrest.MatcherAssert.assertThat18import org.junit.jupiter.api.Test19import org.junit.jupiter.api.assertThrows20import org.mockito.Mockito.`when`21import org.mockito.kotlin.any22import org.mockito.kotlin.mock23import java.io.ByteArrayInputStream24import java.net.URL25import kotlin.test.assertEquals26import kotlin.test.assertTrue27class FuelExtensionsTest {28    private val basicRetryResponse = createRetryResponse("0")29    @Test30    fun `token adds Token Authorization header to request`() {31        val request = DefaultRequest(Method.GET, URL("https://example.com/authentication"))32            .authentication().token("token")33        assertThat(request[Headers.AUTHORIZATION].lastOrNull(), equalTo("Token token"))34    }35    @Test36    fun `responseStringWithRetries returns final response when succeeding within retry count`() {37        val client = mock<Client>()38        `when`(client.executeRequest(any()))39            .thenReturn(basicRetryResponse)40            .thenReturn(41                Response(42                    statusCode = 200,43                    url = URL("https://example.com"),44                    body = DefaultBody.from({ ByteArrayInputStream("final".toByteArray()) }, null)45                )46            )47        FuelManager.instance.client = client48        val (_, response, result) = Fuel.get("https://example.com")49            .responseStringWithRetries(1, 1L)50        assertEquals(200, response.statusCode)51        assertEquals("final", result.get())52    }53    @Test54    fun `responseStringWithRetries returns the last response when a non-throttle response is not received within retry count`() {55        val client = mock<Client>()56        `when`(client.executeRequest(any()))57            .thenReturn(basicRetryResponse)58            .thenReturn(basicRetryResponse)59            .thenReturn(basicRetryResponse) // One more than retry count60            .thenReturn(Response(statusCode = 200, url = URL("https://example.com")))61        FuelManager.instance.client = client62        val (_, response, result) = Fuel.get("https://example.com")63            .responseStringWithRetries(2, 1L) // Would have to be 3 to succeed64        assertEquals(429, response.statusCode) // Status code of last response65        assertTrue(result is Result.Failure)66    }67    @Test68    fun `responseStringWithRetries throws when an invalid Retry-After header is received`() {69        val client = mock<Client>()70        `when`(client.executeRequest(any())).thenReturn(createRetryResponse("INVALID VALUE"))71        FuelManager.instance.client = client72        assertThrows<NumberFormatException> {73            Fuel.get("https://example.com").responseStringWithRetries(1, 1L) // Would have to be 2 to succeed74        }75    }76    @Test77    fun `responseStringWithRetries throws when no Retry-After header is received in HTTP 429 response`() {78        val client = mock<Client>()79        `when`(client.executeRequest(any())).thenReturn(createRetryResponse("", Headers())) // No Retry-After header80        FuelManager.instance.client = client81        assertThrows<IllegalStateException> {82            Fuel.get("https://example.com").responseStringWithRetries(1)83        }84    }85    @Test86    fun `responseStringWithRetries returns non-throttled error by default`() {87        val client = mock<Client>()88        `when`(client.executeRequest(any())).thenReturn(89            Response(90                statusCode = 400,91                url = URL("https://example.com"),92                body = DefaultBody.from({ ByteArrayInputStream("unhandled error".toByteArray()) }, null)93            )94        )95        FuelManager.instance.client = client96        val (_, response, _) = Fuel.get("https://example.com").responseStringWithRetries(1)97        assertEquals(400, response.statusCode)98        assertEquals("unhandled error", response.body().asString("text/html"))99    }100    @Test101    fun `responseStringWithRetries returns fallback error handler's response when faced with a non-throttled error response`() {102        val client = mock<Client>()103        `when`(client.executeRequest(any())).thenReturn(104            Response(105                statusCode = 400,106                url = URL("https://example.com"),107                body = DefaultBody.from({ ByteArrayInputStream("unhandled error".toByteArray()) }, null)108            )109        )110        FuelManager.instance.client = client111        val (_, response, _) = Fuel.get("https://example.com").responseStringWithRetries(1) { r, _ ->112            ResponseResultOf(113                r.first,114                Response(115                    statusCode = 400,116                    url = URL("https://example.com"),117                    body = DefaultBody.from({ ByteArrayInputStream("handled error".toByteArray()) }, null)118                ),119                r.third120            )121        }122        assertEquals(400, response.statusCode)123        assertEquals("handled error", response.body().asString("text/html"))124    }125    private fun createRetryResponse(126        retryAfter: String,127        headers: Headers = Headers.from(Headers.RETRY_AFTER to listOf(retryAfter))128    ) = Response(129        statusCode = 429,130        responseMessage = "RETRY",131        url = URL("https://example.com"),...

DefaultBody.kt

Source:DefaultBody.kt

...9import java.io.InputStream10import java.io.OutputStream11import java.net.URLConnection12import java.nio.charset.Charset13data class DefaultBody(14    internal var openStream: BodySource = EMPTY_STREAM,15    private var calculateLength: BodyLength? = null,16    val charset: Charset = Charsets.UTF_817) : Body {18    /**19     * Represents this body as a string20     * @param contentType [String] the type of the content in the body, or null if a guess is necessary21     * @return [String] the body as a string or a string that represents the body such as (empty) or (consumed)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 = {112            throw FuelError.wrap(IllegalStateException(113                "The input has already been written to an output stream and can not be consumed again."114            ))115        }116        fun from(openStream: BodySource, calculateLength: BodyLength?, charset: Charset = Charsets.UTF_8): DefaultBody {117            return DefaultBody(118                openStream = openStream,119                calculateLength = calculateLength,120                charset = charset121            )122        }123    }124}...

BodyTest.kt

Source:BodyTest.kt

1package com.github.kittinunf.fuel.core2import com.github.kittinunf.fuel.core.requests.DefaultBody3import com.github.kittinunf.fuel.core.requests.DefaultRequest4import org.hamcrest.CoreMatchers.containsString5import org.hamcrest.CoreMatchers.equalTo6import org.hamcrest.MatcherAssert.assertThat7import org.junit.Assert.assertArrayEquals8import org.junit.Test9import java.io.ByteArrayInputStream10import java.io.ByteArrayOutputStream11import java.io.File12import java.net.URL13class BodyTest {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    }42    @Test43    fun bodyFromByteArray() {44        val value = ByteArray(32).apply {45            for (i in 0..(this.size - 1)) {46                this[i] = ('A'..'z').random().toByte()47            }48        }49        DefaultRequest(Method.POST, URL("https://test.fuel.com/"))50            .body(value)51            .apply {52                val output = ByteArrayOutputStream(value.size)53                assertThat(body.length?.toInt(), equalTo(value.size))54                assertArrayEquals(value, body.toByteArray())55                body.writeTo(output)56                assertArrayEquals(value, output.toByteArray())57            }58    }59    @Test60    fun bodyFromFile() {61        val value = "String Body ${Math.random()}"62        val file = File.createTempFile("BodyTest", ".txt")63        file.writeText(value)64        DefaultRequest(Method.POST, URL("https://test.fuel.com/"))65            .body(file)66            .apply {67                val output = ByteArrayOutputStream(value.length)68                assertThat(body.length?.toInt(), equalTo(value.length))69                assertThat(body.toByteArray(), equalTo(value.toByteArray()))70                body.writeTo(output)71                assertThat(output.toString(), equalTo(value))72            }73    }74    @Test75    fun bodyFromStream() {76        val value = "String Body ${Math.random()}"77        val stream = ByteArrayInputStream(value.toByteArray())78        DefaultRequest(Method.POST, URL("https://test.fuel.com/"))79            .body(stream)80            .apply {81                val output = ByteArrayOutputStream(value.length)82                assertThat(body.toByteArray(), equalTo(value.toByteArray()))83                body.writeTo(output)84                assertThat(output.toString(), equalTo(value))85            }86    }87    @Test(expected = FuelError::class)88    fun bodyFromCallbackCanOnlyBeReadOnce() {89        val body = DefaultBody.from({ ByteArrayInputStream("body".toByteArray()) }, { 4 })90        body.writeTo(ByteArrayOutputStream())91        body.writeTo(ByteArrayOutputStream())92    }93    @Test94    fun bodyToByteArrayLoadsItIntoMemory() {95        val value = "String Body ${Math.random()}"96        val body = DefaultBody.from({ ByteArrayInputStream(value.toByteArray()) }, { value.length.toLong() })97        body.toByteArray()98        val output = ByteArrayOutputStream(value.length)99        body.writeTo(output)100        assertThat(output.toString(), equalTo(value))101    }102    @Test103    fun requestWithBodyIsPrintableAfterConsumption() {104        val value = { ByteArrayInputStream("String Body ${Math.random()}".toByteArray()) }105        DefaultRequest(Method.POST, URL("https://test.fuel.com/"))106            .body(value)107            .apply {108                val output = ByteArrayOutputStream()109                body.writeTo(output)110                assertThat(this.toString(), containsString("(consumed)"))...

MockHttpClient.kt

Source:MockHttpClient.kt

1package com.rpmtw.rpmtw_api_client.mock2import com.github.kittinunf.fuel.core.*3import com.github.kittinunf.fuel.core.requests.DefaultBody4import com.github.kittinunf.fuel.toolbox.HttpClient5import com.google.gson.Gson6import com.google.gson.JsonElement7import java.io.ByteArrayInputStream8class MockHttpClient {9    companion object {10        fun mockRequest(response: MockHttpResponse, gson: Gson = Gson()) {11            val httpClient = object : Client {12                @Suppress("LiftReturnOrAssignment")13                override fun executeRequest(request: Request): Response {14                    val body: Body15                    val data: Any? = response.data16                    if (data != null) {17                        if (data is JsonElement) {18                            body = DefaultBody({ ByteArrayInputStream(gson.toJson(data).toByteArray()) })19                        } else {20                            body = DefaultBody({21                                ByteArrayInputStream(22                                    "{\"data\":${gson.toJson(response.data)}}".toByteArray()23                                )24                            })25                        }26                    } else {27                        body = DefaultBody()28                    }29                    FuelManager.instance.client =30                        HttpClient(hook = FuelManager.instance.hook, proxy = FuelManager.instance.proxy)31                    return Response(32                        body = body,33                        statusCode = response.statusCode,34                        responseMessage = response.responseMessage,35                        url = request.url36                    )37                }38            }39            FuelManager.instance.client = httpClient40        }41    }...

CustomClientTest.kt

Source:CustomClientTest.kt

1package com.github.kittinunf.fuel2import com.github.kittinunf.fuel.core.Client3import com.github.kittinunf.fuel.core.requests.DefaultBody4import com.github.kittinunf.fuel.core.FuelManager5import com.github.kittinunf.fuel.core.Method6import com.github.kittinunf.fuel.core.Request7import com.github.kittinunf.fuel.core.Response8import org.hamcrest.CoreMatchers.containsString9import org.hamcrest.CoreMatchers.notNullValue10import org.junit.Assert.assertThat11import org.junit.Test12import java.io.File13import java.nio.charset.Charset14class CustomClientTest {15    private val manager: FuelManager by lazy {16        val dir = System.getProperty("user.dir")17        val currentDir = File(dir, "src/test/assets")18        val mockJson = File(currentDir, "mock.json")19        FuelManager().apply {20            client = object : Client {21                override fun executeRequest(request: Request): Response = Response(22                    url = request.url,23                    body = DefaultBody.from({ mockJson.inputStream() }, null),24                    statusCode = 20025                )26            }27        }28    }29    @Test30    fun httpRequestWithMockedResponse() {31        val (request, response, data) = manager.request(Method.GET, "http://foo.bar").response()32        assertThat(request, notNullValue())33        assertThat(response, notNullValue())34        assertThat(data.get(), notNullValue())35        assertThat(data.get().toString(Charset.defaultCharset()), containsString("key"))36        assertThat(data.get().toString(Charset.defaultCharset()), containsString("value"))37    }...

FuelMockServer.kt

Source:FuelMockServer.kt

1package flank.scripts2import com.github.kittinunf.fuel.core.Client3import com.github.kittinunf.fuel.core.Request4import com.github.kittinunf.fuel.core.Response5import com.github.kittinunf.fuel.core.requests.DefaultBody6import flank.scripts.data.zenhub.ZENHUB_BASE_URL7import flank.scripts.ops.firebase.testContent8class FuelMockServer : Client {9    override fun executeRequest(request: Request): Response {10        val url = request.url.toString()11        return when {12            url.startsWith("https://api.github.com/repos/flank/flank/", ignoreCase = true) -> handleGithubMockRequest(url, request)13            url.startsWith(ZENHUB_BASE_URL) -> handleZenhubMockRequest(url, request)14            url == "http://test.account.service" -> request.buildResponse(testContent, 200)15            else -> Response(request.url)16        }17    }18}19fun Request.buildResponse(body: String, statusCode: Int) =20    Response(21        url, statusCode = statusCode, responseMessage = body,22        body = DefaultBody(23            { body.byteInputStream() },24            { body.length.toLong() }25        )26    )...

IssuesDeserializerTest.kt

Source:IssuesDeserializerTest.kt

1package com.plastickarma.githubapikt.parse2import com.github.kittinunf.fuel.core.Response3import com.github.kittinunf.fuel.core.requests.DefaultBody4import org.assertj.core.api.Assertions.assertThat5import org.junit.jupiter.api.Test6import java.net.URL7class IssuesDeserializerTest {8    @Test9    fun `deserialize returns a list of issues from json`() {10        val response = Response(11            url = URL("https://api.github.com"),12            body = DefaultBody(13                openStream = { IssuesDeserializerTest::class.java.getResourceAsStream("/issues.json") })14        )15        val issues = IssuesDeserializer().deserialize(response)16        assertThat(issues).isNotEmpty17    }18}...

DefaultBody

Using AI Code Generation

1val (data, error) = result2data?.let {3println(data.asString("application/json"))4}5}6val (data, error) = result7data?.let {8println(data.asString("application/json"))9}10}11val (data, error) = result12data?.let {13println(data.asString("application/json"))14}15}16val (data, error) = result17data?.let {18println(data.asString("application/json"))19}20}21val (data, error) = result22data?.let {23println(data.asString("application/json"))24}25}26val (data, error) = result27data?.let {28println(data.asString("application/json"))29}30}31val (data, error) = result32data?.let {33println(data.as

DefaultBody

Using AI Code Generation

1val (data, error) = result2}3val (data, error) = result4}5val (data, error) = result6}7val (data, error) = result8}9val (data, error) = result10}11val (data, error) = result12}13val (data, error) = result14}15val (data, error) = result16}

DefaultBody

Using AI Code Generation

1    val (data, error) = result2    println(data)3}4    val (data, error) = result5    println(data)6}7    val (data, error) = result8    println(data)9}10    val (data, error) = result11    println(data)12}13    val (data, error) = result14    println(data)15}16    val (data, error) = result17    println(data)18}19    val (data, error) = result20    println(data)21}22    val (data, error) = result23    println(data)24}

DefaultBody

Using AI Code Generation

1import com.github.kittinunf.fuel.core.requests.DefaultBody2class MyCustomBody : DefaultBody {3    override fun writeTo(outputStream: OutputStream) {4    }5}6.body(MyCustomBody())7.responseString { request, response, result ->8    println(request)9    println(response)10    println(result)11}12.body { request, url ->13    MyCustomBody()14}15.responseString { request, response, result ->16    println(request)17    println(response)18    println(result)19}20.queryParams(mapOf("foo" to "bar", "hello" to "world"))21.responseString { request, response, result ->22    println(request)23    println(response)24    println(result)25}26.queryParams(listOf("foo" to "bar", "hello" to "world"))27.responseString { request, response, result ->28    println(request)29    println(response)30    println(result)31}32.queryParams("foo" to "bar", "hello" to "world")33.responseString { request, response, result ->34    println(request)35    println(response)36    println(result)37}38.queryParams(mapOf("foo" to "bar", "hello" to "world"))39.responseString { request, response, result ->40    println(request)41    println(response)42    println(result)43}44.queryParams(mapOf("foo" to "bar", "hello" to "world"))45.responseString { request, response, result ->46    println(request)47    println(response)48    println(result)49}50.queryParams(listOf("foo" to "bar", "hello" to "world"))51.responseString { request, response, result ->52    println(request)53    println(response)54    println(result)55}56.queryParams("foo" to "bar", "hello" to "world")57.responseString { request, response, result ->58    println(request)59    println(response)

DefaultBody

Using AI Code Generation

1fun defaultBodyExample() {2.method(PUT)3.body(DefaultBody("Hello, World!"))4.responseString()5println(request)6println(response)7println(result)8}9fun byteArrayBodyExample() {10.method(PUT)11.body(ByteArrayBody("Hello, World!".toByteArray()))12.responseString()13println(request)14println(response)15println(result)16}17fun inputStreamBodyExample() {18.method(PUT)19.body(InputStreamBody("Hello, World!".byteInputStream()))20.responseString()21println(request)22println(response)23println(result)24}25fun fileBodyExample() {26.method(PUT)27.body(FileBody(File("test.txt")))28.responseString()29println(request)30println(response)31println(result)32}33fun byteBufferBodyExample() {34.method(PUT)35.body(ByteBufferBody(ByteBuffer.wrap("Hello, World!".toByteArray())))36.responseString()37println(request)38println(response)39println(result)40}41fun readableByteChannelBodyExample() {42.method(PUT)43.body(ReadableByteChannelBody(Channels.newChannel("Hello, World!".byteInputStream())))44.responseString()45println(request)46println(response)47println(result)48}49fun multipartBodyExample() {50.method(PUT)51.body(MultipartBody(52listOf(53FileDataPart(File("test.txt"), "test.txt"),

DefaultBody

Using AI Code Generation

1     .body(DefaultBody("Hello World!"))2     .response()3     println(request)4     println(response)5     println(result)6     }7     }8Success(data: [B@1d99d3b8)9{10  "args": {}, 11  "files": {}, 12  "form": {}, 13  "headers": {14  },

DefaultBody

Using AI Code Generation

1val data = result.get()2val body = data.body()3println(body)4val data = result.get()5val body = data.body()6println(body)7val data = result.get()8val body = data.body()9println(body)10val data = result.get()11val body = data.body()12println(body)13val data = result.get()14val body = data.body()15println(body)

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.