Best Fuel code snippet using com.github.kittinunf.fuel.core.requests.private.deserialize
RxFuel.kt
Source:RxFuel.kt
2import com.github.kittinunf.fuel.core.Deserializable3import com.github.kittinunf.fuel.core.FuelError4import com.github.kittinunf.fuel.core.Request5import com.github.kittinunf.fuel.core.Response6import com.github.kittinunf.fuel.core.deserializers.ByteArrayDeserializer7import com.github.kittinunf.fuel.core.deserializers.EmptyDeserializer8import com.github.kittinunf.fuel.core.deserializers.StringDeserializer9import com.github.kittinunf.fuel.core.requests.CancellableRequest10import com.github.kittinunf.fuel.core.response11import com.github.kittinunf.result.Result12import io.reactivex.rxjava3.core.Completable13import io.reactivex.rxjava3.core.Single14import java.nio.charset.Charset15private fun <T : Any> Request.rxResponseSingle(deserializable: Deserializable<T>): Single<T> =16 rx { onSuccess, onFailure ->17 response(deserializable) { _, _, result ->18 result.fold(19 success = { t -> t.also { onSuccess(t) } },20 failure = { e -> onFailure(e) }21 )22 }23 }24private fun <T : Any> Request.rxResponsePair(deserializable: Deserializable<T>): Single<Pair<Response, T>> =25 rx { onSuccess, onFailure ->26 response(deserializable) { _, response, result ->27 result.fold(28 success = { t -> t.also { onSuccess(Pair(response, t)) } },29 failure = { e -> onFailure(e) }30 )31 }32 }33private fun <T : Any> Request.rxResponseTriple(deserializable: Deserializable<T>): Single<Triple<Request, Response, T>> =34 rx { onSuccess, onFailure ->35 response(deserializable) { request, response, result ->36 result.fold(37 success = { t -> t.also { onSuccess(Triple(request, response, t)) } },38 failure = { e -> onFailure(e) }39 )40 }41 }42private fun <T : Any> Request.rxResultSingle(deserializable: Deserializable<T>): Single<Result<T, FuelError>> =43 rx { onSuccess ->44 response(deserializable) { _, _, result ->45 onSuccess(result)46 }47 }48private fun <T : Any> Request.rxResultPair(deserializable: Deserializable<T>): Single<Pair<Response, Result<T, FuelError>>> =49 rx { onSuccess ->50 response(deserializable) { _, response, result ->51 onSuccess(response to result)52 }53 }54private fun <T : Any> Request.rxResultTriple(deserializable: Deserializable<T>): Single<Triple<Request, Response, Result<T, FuelError>>> =55 rx { onSuccess ->56 response(deserializable) { request, response, result ->57 onSuccess(Triple(request, response, result))58 }59 }60/**61 * Returns a reactive stream for a [Single] value response [ByteArray]62 *63 * @see rxBytes64 * @return [Single<ByteArray>]65 */66fun Request.rxResponse() = rxResponseSingle(ByteArrayDeserializer())67/**68 * Returns a reactive stream for a [Single] value response [ByteArray]69 *70 * @see rxBytes71 * @return [Single<Pair<Response, ByteArray>>] the [ByteArray] wrapped into a [Pair] with [Response]72 */73fun Request.rxResponsePair() = rxResponsePair(ByteArrayDeserializer())74/**75 * Returns a reactive stream for a [Single] value response [ByteArray]76 *77 * @see rxBytes78 * @return [Single<Triple<Request, Response, ByteArray>>] the [ByteArray] wrapped into a [Triple] with [Response] and [Request]79 */80fun Request.rxResponseTriple() = rxResponseTriple(ByteArrayDeserializer())81/**82 * Returns a reactive stream for a [Single] value response [String]83 *84 * @see rxString85 *86 * @param charset [Charset] the character set to deserialize with87 * @return [Single<String>]88 */89fun Request.rxResponseString(charset: Charset = Charsets.UTF_8) = rxResponseSingle(StringDeserializer(charset))90/**91 * Returns a reactive stream for a [Single] value response [String]92 *93 * @see rxString94 *95 * @param charset [Charset] the character set to deserialize with96 * @return [Single<Pair<Response, String>>] the [String] wrapped into a [Pair] with [Response]97 */98fun Request.rxResponseStringPair(charset: Charset = Charsets.UTF_8) = rxResponsePair(StringDeserializer(charset))99/**100 * Returns a reactive stream for a [Single] value response [String]101 *102 * @see rxString103 *104 * @param charset [Charset] the character set to deserialize with105 * @return [Single<Triple<Request, Response, String>>] the [String] wrapped into a [Triple] with [Response] and [Request]106 */107fun Request.rxResponseStringTriple(charset: Charset = Charsets.UTF_8) = rxResponseTriple(StringDeserializer(charset))108/**109 * Returns a reactive stream for a [Single] value response object [T]110 *111 * @see rxObject112 *113 * @param deserializable [Deserializable<T>] something that can deserialize the [Response] to a [T]114 * @return [Single<T>]115 */116fun <T : Any> Request.rxResponseObject(deserializable: Deserializable<T>) = rxResponseSingle(deserializable)117/**118 * Returns a reactive stream for a [Single] value response object [T]119 *120 * @see rxObject121 *122 * @param deserializable [Deserializable<T>] something that can deserialize the [Response] to a [T]123 * @return [Single<Pair<Response, T>>] the [T] wrapped into a [Pair] with [Response]124 */125fun <T : Any> Request.rxResponseObjectPair(deserializable: Deserializable<T>) = rxResponsePair(deserializable)126/**127 * Returns a reactive stream for a [Single] value response object [T]128 *129 * @see rxObject130 *131 * @param deserializable [Deserializable<T>] something that can deserialize the [Response] to a [T]132 * @return [Single<Triple<Request, Response, T>>] the [T] wrapped into a [Triple] with [Response] and [Request]133 */134fun <T : Any> Request.rxResponseObjectTriple(deserializable: Deserializable<T>) = rxResponseTriple(deserializable)135/**136 * Returns a reactive stream for a [Single] value result of [ByteArray]137 *138 * @see rxResponse139 * @return [Single<Result<ByteArray, FuelError>>] the [ByteArray] wrapped into a [Result]140 */141fun Request.rxBytes() = rxResultSingle(ByteArrayDeserializer())142/**143 * Returns a reactive stream for a [Single] value result of [ByteArray]144 *145 * @see rxResponse146 * @return [Single<Pair<Response, Result<ByteArray, FuelError>>>] the [ByteArray] wrapped into a [Result] together with a [Pair] with [Response]147 */148fun Request.rxBytesPair() = rxResultPair(ByteArrayDeserializer())149/**150 * Returns a reactive stream for a [Single] value result of [ByteArray]151 *152 * @see rxResponse153 * @return [Single<Triple<Request, Response, Result<ByteArray, FuelError>>>] the [ByteArray] wrapped into a [Result] together with a [Triple] with [Response] and [Request]154 */155fun Request.rxBytesTriple() = rxResultTriple(ByteArrayDeserializer())156/**157 * Returns a reactive stream for a [Single] value result of [ByteArray]158 *159 * @see rxResponseString160 *161 * @param charset [Charset] the character set to deserialize with162 * @return [Single<Result<String, FuelError>>] the [String] wrapped into a [Result]163 */164fun Request.rxString(charset: Charset = Charsets.UTF_8) = rxResultSingle(StringDeserializer(charset))165/**166 * Returns a reactive stream for a [Single] value result of [String]167 *168 * @see rxResponseString169 * @return [Single<Pair<Response, Result<String, FuelError>>>] the [String] wrapped into a [Result] together with a [Pair] with [Response]170 */171fun Request.rxStringPair(charset: Charset = Charsets.UTF_8) = rxResultPair(StringDeserializer(charset))172/**173 * Returns a reactive stream for a [Single] value result of [String]174 *175 * @see rxResponseString176 * @return [Single<Triple<Request, Response, Result<String, FuelError>>>] the [String] wrapped into a [Result] together with a [Triple] with [Response] and [Request]177 */178fun Request.rxStringTriple(charset: Charset = Charsets.UTF_8) = rxResultTriple(StringDeserializer(charset))179/**180 * Returns a reactive stream for a [Single] value result of [T]181 *182 * @see rxResponseObject183 *184 * @param deserializable [Deserializable<T>] something that can deserialize the [Response] to a [T]185 * @return [Single<Result<T, FuelError>>] the [T] wrapped into a [Result]186 */187fun <T : Any> Request.rxObject(deserializable: Deserializable<T>) = rxResultSingle(deserializable)188/**189 * Returns a reactive stream for a [Single] value result of [T]190 *191 * @see rxResponseObject192 * @return [Single<Pair<Response, Result<T, FuelError>>>] the [T] wrapped into a [Result] together with a [Pair] with [Response]193 */194fun <T : Any> Request.rxObjectPair(deserializable: Deserializable<T>) = rxResultPair(deserializable)195/**196 * Returns a reactive stream for a [Single] value result of [T]197 *198 * @see rxResponseObject...
Zendesk.kt
Source:Zendesk.kt
...245 .run()246 .map { it.section }247 class ZendeskResponseDeserializable2<T : ZendeskApiBody>(val responseType: KClass<out T>) :248 ResponseDeserializable<T> {249 override fun deserialize(content: String): T = when (responseType) {250 ZendeskApiBody.EmptyBody::class -> ZendeskApiBody.EmptyBody as T251 else -> gson.fromJson(content, responseType.java)252 }253 }254 private fun <T : ZendeskApiBody> ZendeskRequest<T>.run(requestConfigBlock: Request.() -> Unit = {}) =255 get(url)256 .apply(requestConfigBlock)257 .also { println(it) }258 .authentication()259 .basic(user, password)260 .responseObject(ZendeskResponseDeserializable2(responseType))261 .third262 .fold(263 { it.right() },...
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 applied65 */66 fun deserialize(reader: Reader): T? = null67 /**68 * Deserialize into [T] from a [ByteArray]69 *70 * @note it is more efficient to implement the [InputStream] variant.71 *72 * @param bytes [ByteArray] source bytes73 * @return [T] deserialized instance of [T] or null when not applied74 */75 fun deserialize(bytes: ByteArray): T? = null76 /**77 * Deserialize into [T] from a [String]78 *79 * @note it is more efficient to implement the [Reader] variant.80 *81 * @param content [String] source bytes82 * @return [T] deserialized instance of [T] or null when not applied83 */84 fun deserialize(content: String): T? = null85}86/**87 * Deserialize the [Response] to the [this] into a [T] using [U]88 *89 * @see ResponseResultHandler90 *91 * @param deserializable [U] the instance that performs deserialization92 * @param handler [ResponseResultHandler<T>] handler that has a [Result]93 * @return [CancellableRequest] the request that can be cancelled94 */95fun <T : Any, U : Deserializable<T>> Request.response(deserializable: U, handler: ResponseResultHandler<T>): CancellableRequest =96 response(deserializable,97 { request, response, value -> handler(request, response, Result.Success(value)) },98 { request, response, error -> handler(request, response, Result.Failure(error)) }99 )100/**101 * Deserialize the [Response] to the [this] into a [T] using [U]102 *103 * @see ResultHandler104 *105 * @param deserializable [U] the instance that performs deserialization106 * @param handler [ResultHandler<T>] handler that has a [Result]107 * @return [CancellableRequest] the request that can be cancelled108 */109fun <T : Any, U : Deserializable<T>> Request.response(deserializable: U, handler: ResultHandler<T>): CancellableRequest =110 response(deserializable,111 { _, _, value -> handler(Result.Success(value)) },112 { _, _, error -> handler(Result.Failure(error)) }113 )114/**115 * Deserialize the [Response] to the [this] into a [T] using [U]116 *117 * @see ResponseHandler118 *119 * @param deserializable [U] the instance that performs deserialization120 * @param handler [ResponseHandler<T>] handler that has dedicated paths for success and failure121 * @return [CancellableRequest] the request that can be cancelled122 */123fun <T : Any, U : Deserializable<T>> Request.response(deserializable: U, handler: ResponseHandler<T>): CancellableRequest =124 response(deserializable,125 { request, response, value -> handler.success(request, response, value) },126 { request, response, error -> handler.failure(request, response, error) }127 )128/**129 * Deserialize the [Response] to the [this] into a [T] using [U]130 *131 * @see Handler132 *133 * @param deserializable [U] the instance that performs deserialization134 * @param handler [Handler<T>] handler that has dedicated paths for success and failure135 * @return [CancellableRequest] the request that can be cancelled136 */137fun <T : Any, U : Deserializable<T>> Request.response(deserializable: U, handler: Handler<T>): CancellableRequest =138 response(deserializable,139 { _, _, value -> handler.success(value) },140 { _, _, error -> handler.failure(error) }141 )142/**143 * Deserialize the [Response] to the [this] into a [T] using [U]144 *145 * @note not async, use the variations with a handler instead.146 *147 * @throws Exception if there is an internal library error, not related to Network or Deserialization148 *149 * @param deserializable [U] the instance that performs deserialization150 * @return [ResponseResultOf<T>] the response result of151 */152fun <T : Any, U : Deserializable<T>> Request.response(deserializable: U): ResponseResultOf<T> {153 // First execute the network request and catch any issues154 val rawResponse = runCatching { toTask().call() }155 .onFailure { error ->156 FuelError.wrap(error, Response.error(url)).also {157 return Triple(this, it.response, Result.error(it))158 }159 }160 .getOrThrow()161 // By this time it should have a response, but deserialization might fail162 return runCatching { Triple(this, rawResponse, Result.Success(deserializable.deserialize(rawResponse))) }163 .recover { error -> Triple(this, rawResponse, Result.Failure(FuelError.wrap(error, rawResponse))) }164 .getOrThrow()165}166/**167 * Ignore the response result168 *169 * Use this method to avoid huge memory allocation when using [com.github.kittinunf.fuel.core.requests.download]170 * to a large download and without using the result [ByteArray]171 *172 * @see [com.github.kittinunf.fuel.core.Request.response]173 *174 * @note not async, use the variations with a handler instead.175 *176 * @throws Exception if there is an internal library error, not related to Network177 */178fun Request.responseUnit(): ResponseResultOf<Unit> = response(EmptyDeserializer)179private fun <T : Any, U : Deserializable<T>> Request.response(180 deserializable: U,181 success: (Request, Response, T) -> Unit,182 failure: (Request, Response, FuelError) -> Unit183): CancellableRequest {184 val asyncRequest = RequestTaskCallbacks(185 request = this,186 onSuccess = { response ->187 // The network succeeded but deserialization might fail188 val deliverable = Result.of<T, Exception> { deserializable.deserialize(response) }189 executionOptions.callback {190 deliverable.fold(191 { success(this, response, it) },192 { failure(this, response, FuelError.wrap(it, response).also { error ->193 Fuel.trace { "[Deserializable] unfold failure: \n\r$error" } })194 }195 )196 }197 },198 onFailure = { error, response ->199 executionOptions.callback {200 failure(this, response, error.also { error ->201 Fuel.trace { "[Deserializable] callback failure: \n\r$error" }202 })203 }204 }205 )206 return CancellableRequest.enableFor(this, future = executionOptions.submit(asyncRequest))207}208/**209 * Await [T] or throws [FuelError]210 * @return [T] the [T]211 */212@Throws(FuelError::class)213suspend fun <T : Any, U : Deserializable<T>> Request.await(deserializable: U): T {214 val response = suspendable().await()215 return runCatching { deserializable.deserialize(response) }216 .onFailure { throw FuelError.wrap(it, response) }217 .getOrThrow()218}219/**220 * Await the task or throws [FuelError] in current coroutine context.221 *222 * Use this method to avoid huge memory allocation when using [com.github.kittinunf.fuel.core.requests.download]223 * to a large file without using response result224 *225 * To run method in different coroutine context, use `com.github.kittinunf.fuel.coroutines.awaitUnit` in `fuel-coroutines` module226 */227@Throws(FuelError::class)228suspend fun Request.awaitUnit(): Unit = await(EmptyDeserializer)229/**230 * Await [T] or [FuelError]231 * @return [ResponseOf<T>] the [Result] of [T]232 */233@Throws(FuelError::class)234suspend fun <T : Any, U : Deserializable<T>> Request.awaitResponse(deserializable: U): ResponseOf<T> {235 val response = suspendable().await()236 return runCatching { Triple(this, response, deserializable.deserialize(response)) }237 .onFailure { throw FuelError.wrap(it, response) }238 .getOrThrow()239}240/**241 * Await [T] or [FuelError]242 * @return [Result<T>] the [Result] of [T]243 */244suspend fun <T : Any, U : Deserializable<T>> Request.awaitResult(deserializable: U): Result<T, FuelError> {245 val initialResult = suspendable().awaitResult()246 return serializeFor(initialResult, deserializable).map { (_, t) -> t }247}248/**249 * Await [T] or [FuelError]250 * @return [ResponseResultOf<T>] the [ResponseResultOf] of [T]251 */252suspend fun <T : Any, U : Deserializable<T>> Request.awaitResponseResult(deserializable: U): ResponseResultOf<T> {253 val initialResult = suspendable().awaitResult()254 return serializeFor(initialResult, deserializable).let {255 Triple(this,256 it.fold({ (response, _) -> response }, { error -> error.response }),257 it.map { (_, t) -> t }258 )259 }260}261private fun <T : Any, U : Deserializable<T>> serializeFor(result: Result<Response, FuelError>, deserializable: U) =262 result.map { (it to deserializable.deserialize(it)) }263 .mapError <Pair<Response, T>, Exception, FuelError> {264 FuelError.wrap(it, result.getOrElse { Response.error() })265 }...
FuelInitialiser.kt
Source:FuelInitialiser.kt
...42import java.security.Security43import javax.net.ssl.HostnameVerifier44import kotlin.ranges.CharRange.Companion.EMPTY45class DateTimeDeserializer : StdDeserializer<DateTime>(DateTime::class.java) {46 override fun deserialize(jp: JsonParser, ctxt: DeserializationContext?): DateTime {47 val date = jp.text48 return DateTime.parse(date, ISODateTimeFormat.dateTime())49 }50 fun deserialize(51 je: JsonElement, type: Type?,52 jdc: JsonDeserializationContext?53 ): DateTime? {54 return if (je.asString.isEmpty()) null else DATE_TIME_FORMATTER.parseDateTime(55 ISODateTimeFormat.dateTime().toString()56 )57 }58}59class DateTimeSerializer : StdSerializer<DateTime>(DateTime::class.java) {60 override fun serialize(value: DateTime?, gen: JsonGenerator?, provider: SerializerProvider?) {61 gen?.writeString(value?.toDateTimeISO()?.toString(ISODateTimeFormat.dateTime()))62 }63 fun serialize(64 src: DateTime?, typeOfSrc: Type?,...
ObjectTest.kt
Source:ObjectTest.kt
...21import java.util.UUID22private data class UUIDResponse(val uuid: String)23private object UUIDResponseDeserializer : ResponseDeserializable<UUIDResponse> {24 class NoValidFormat(m: String = "Not a UUID") : Exception(m)25 override fun deserialize(content: String): UUIDResponse {26 if (content.contains("=") || !content.contains("-")) {27 throw FuelError.wrap(NoValidFormat())28 }29 return UUIDResponse(content)30 }31}32class ObjectTest : MockHttpTestCase() {33 private fun randomUUID() = UUID.randomUUID()34 private fun getUUID(uuid: UUID, path: String = "uuid"): Request {35 mock.chain(36 request = mock.request().withPath("/$path"),37 response = mock.response().withBody(uuid.toString())38 )39 return Fuel.request(Method.GET, mock.path(path))...
RemotePostLoader.kt
Source:RemotePostLoader.kt
...83 /**84 * Class to turn an [InputStream] into a [Bitmap].85 */86 class BitmapDeserializer : ResponseDeserializable<Bitmap> {87 override fun deserialize(inputStream: InputStream) = BitmapFactory.decodeStream(inputStream)88 }89 override suspend fun requestNextPosts() = withContext(Dispatchers.IO) {90 if (postLoadingJob?.isActive != true) {91 loadMorePosts(20)92 }93 }94 var postLoadingJob: Job? = null95 /**96 * Requests new posts from the [ApiWrapper].97 * Results will be filtered according to the current rating settings,98 * The method will continue to request new posts until the given quantity was reached,99 * after every iteration the loaded post will get added to the post list100 * and a rangeChanged event will be fired.101 *...
Elgato.kt
Source:Elgato.kt
...97data class ElgatoStateResponse(98 val numberOfLights: Int,99 val lights: List<ElgatoLight>100) {101 /** Use GSON to deserialize the JSON data. */102 class Deserializer : ResponseDeserializable<ElgatoStateResponse> {103 override fun deserialize(content: String): ElgatoStateResponse =104 Gson().fromJson(content, ElgatoStateResponse::class.java)105 }106}107/** Data returned from the Elgato light for a single device. */108data class ElgatoLight(109 val on: Int,110 val brightness: Int,111 val temperature: Int112)...
RestService.kt
Source:RestService.kt
...10 */11class RestService(private val baseUrl: String) {12 /**13 * Posts a request to the REST API and parses the response.14 * The request is serialized to JSON and the response is deserialized from JSON.15 * If an error occurs, then a failure result is returned and an exception is created with the error information.16 * @param request Request to send to the API.17 * @param responseDeserializer Object that deserializes the expected (no error) response.18 * @return Result of the request.19 * If the request was successful, then the result will contain20 * the deserialized object produced by [responseDeserializer].21 * If the request failed, then the result will contain an exception with the error information.22 */23 fun <T: Any> post(request: Request, responseDeserializer: ResponseDeserializable<T>): Result<T, Exception> {24 val url = baseUrl + request.endpoint25 val body = request.serialize(JsonSerializer())26 val httpRequest = Fuel.post(url).header(Pair("Content-Type", "application/json")).body(body)27 val (_, response, result) = httpRequest.responseObject(responseDeserializer)28 result.fold(success = {29 // Return expected object type.30 return result31 }, failure = {32 // Error occurred, response data contains error.33 // Deserialize the error into something we can use.34 val content = String(response.data)35 val error = ErrorResponseDeserializer().deserialize(content)36 return Result.error(error.toException())37 })38 }39 /**40 * Posts a request to the REST API and checks if there was an error.41 * This method assumes that the response will be empty upon success.42 * If an error occurs, then a failure result is returned and an exception is created with the error information.43 * @param request Request to send to the API.44 * @return Result of the request.45 * If the request was successful, then the result will contain the value true and no error.46 * If the request failed, then the result will contain an exception with the error information.47 */48 fun post(request: Request): Result<Boolean, Exception> {49 // TODO: Remove duplicate code.50 val url = baseUrl + request.endpoint51 val body = request.serialize(JsonSerializer())52 val httpRequest = Fuel.post(url).header(Pair("Content-Type", "application/json")).body(body)53 val (_, response, result) = httpRequest.response()54 result.fold(success = {55 // Return expected object type.56 return Result.of(true)57 }, failure = {58 // Error occurred, response data contains error.59 // Deserialize the error into something we can use.60 val content = String(response.data)61 val error = ErrorResponseDeserializer().deserialize(content)62 return Result.error(error.toException())63 })64 }65}...
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.
You could also refer to video tutorials over LambdaTest YouTube channel to get step by step demonstration from industry experts.
Get 100 minutes of automation test minutes FREE!!