How to use useHttpCache method of com.github.kittinunf.fuel.core.Request class

Best Fuel code snippet using com.github.kittinunf.fuel.core.Request.useHttpCache

Request.kt

Source:Request.kt

...59     * @note [Client] must implement this behaviour60     * @note The default client sends `Cache-Control: none` if this flag is false, defaults to true61     *62     * @see java.net.HttpURLConnection.setUseCaches63     * @param useHttpCache [Boolean] true if suggest client to allow cached responses, false otherwise64     */65    fun useHttpCache(useHttpCache: Boolean): Request66    /**67     * Follow redirects as handled by instances of RedirectInterceptors68     *  i.e. [com.github.kittinunf.fuel.core.interceptors.redirectResponseInterceptor]69     *70     * @param allowRedirects [Boolean] true if allowing, false if not71     * @return self72     */73    fun allowRedirects(allowRedirects: Boolean): Request74    /**75     * Returns a string representation of the request.76     *77     * @see com.github.kittinunf.fuel.core.extensions.httpString78     * @see com.github.kittinunf.fuel.core.extensions.cUrlString79     *...

DefaultRequest.kt

Source:DefaultRequest.kt

...340     * @note [com.github.kittinunf.fuel.core.Client] must implement this behaviour341     * @note The default client sends `Cache-Control: none` if this flag is false, defaults to true342     *343     * @see java.net.HttpURLConnection.setUseCaches344     * @param useHttpCache [Boolean] true if suggest client to allow cached responses, false otherwise345     */346    override fun useHttpCache(useHttpCache: Boolean) = request.also {347        it.executionOptions.useHttpCache = useHttpCache348    }349    /**350     * Overwrite [RequestExecutionOptions] response validator block351     *352     * @note The default responseValidator is to throw [com.github.kittinunf.fuel.core.HttpException]353     * @note if the response http status code is not in the range of (100 - 399) which should consider as failure response354     *355     * @param validator [ResponseValidator]356     * @return [Request] the modified request357     */358    override fun validate(validator: ResponseValidator) = request.also {359        it.executionOptions.responseValidator = validator360    }361    /**...

HttpClient.kt

Source:HttpClient.kt

...25import kotlin.coroutines.suspendCoroutine26import kotlin.math.max27class HttpClient(28    private val proxy: Proxy? = null,29    var useHttpCache: Boolean = true,30    var decodeContent: Boolean = true,31    var hook: Client.Hook32) : Client {33    override fun executeRequest(request: Request): Response {34        return try {35            doRequest(request)36        } catch (ioe: IOException) {37            hook.httpExchangeFailed(request, ioe)38            throw FuelError.wrap(ioe, Response(request.url))39        } catch (interrupted: InterruptedException) {40            throw FuelError.wrap(interrupted, Response(request.url))41        } finally {42            // As per Android documentation, a connection that is not explicitly disconnected43            // will be pooled and reused!  So, don't close it as we need inputStream later!44            // connection.disconnect()45        }46    }47    @Throws(InterruptedException::class)48    private fun ensureRequestActive(request: Request, connection: HttpURLConnection?) {49        val cancelled = request.isCancelled50        if (!cancelled && !Thread.currentThread().isInterrupted) {51            return52        }53        // Flush all the pipes. This is necessary because we don't want the other end to wait for a timeout or hang.54        // This interrupts the connection correctly and makes the connection available later. This does break any55        // keep-alive on this particular connection56        connection?.disconnect()57        throw InterruptedException("[HttpClient] could not ensure Request was active: cancelled=$cancelled")58    }59    override suspend fun awaitRequest(request: Request): Response = suspendCoroutine { continuation ->60        try {61            continuation.resume(doRequest(request))62        } catch (ioe: IOException) {63            hook.httpExchangeFailed(request, ioe)64            continuation.resumeWithException(FuelError.wrap(ioe, Response(request.url)))65        } catch (interrupted: InterruptedException) {66            continuation.resumeWithException(FuelError.wrap(interrupted, Response(request.url)))67        }68    }69    @Throws(IOException::class, InterruptedException::class)70    private fun doRequest(request: Request): Response {71        val connection = establishConnection(request)72        sendRequest(request, connection)73        return retrieveResponse(request, connection)74    }75    @Throws(IOException::class, InterruptedException::class)76    private fun sendRequest(request: Request, connection: HttpURLConnection) {77        ensureRequestActive(request, connection)78        connection.apply {79            connectTimeout = max(request.executionOptions.timeoutInMillisecond, 0)80            readTimeout = max(request.executionOptions.timeoutReadInMillisecond, 0)81            if (this is HttpsURLConnection) {82            	sslSocketFactory = request.executionOptions.socketFactory83            	hostnameVerifier = request.executionOptions.hostnameVerifier84            }85            if (request.executionOptions.forceMethods) {86                forceMethod(request.method)87                // If setting method via reflection failed, invoke "coerceMethod"88                // and set "X-HTTP-Method-Override" header89                if (this.requestMethod !== request.method.value) {90                    this.requestMethod = coerceMethod(request.method).value91                    this.setRequestProperty("X-HTTP-Method-Override", request.method.value)92                }93            } else {94                requestMethod = coerceMethod(request.method).value95                if (request.method.value == "PATCH") {96                    setRequestProperty("X-HTTP-Method-Override", request.method.value)97                }98            }99            doInput = true100            useCaches = request.executionOptions.useHttpCache ?: useHttpCache101            instanceFollowRedirects = false102            request.headers.transformIterate(103                { key, values -> setRequestProperty(key, values) },104                { key, value -> addRequestProperty(key, value) }105            )106            // By default, the Android implementation of HttpURLConnection requests that servers use gzip compression107            //   and it automatically decompresses the data for callers of URLConnection.getInputStream().108            //   The Content-Encoding and Content-Length response headers are cleared in this case. Gzip compression can109            //   be disabled by setting the acceptable encodings in the request header:110            //111            //      .header(Headers.ACCEPT_ENCODING, "identity")112            //113            // However, on the JVM, this behaviour might be different. Content-Encoding SHOULD NOT be used, in HTTP/1x114            //  to act as Transfer Encoding. In HTTP/2, Transfer-Encoding is not part of the Connection field and should...

HttpClientTest.kt

Source:HttpClientTest.kt

...147        val (_, _, result) = request.responseString()148        val (data, error) = result149        assertThat("Expected data, actual error $error", data, notNullValue())150        assertThat(data, equalTo("cached"))151        val (_, _, result2) = request.apply { executionOptions.useHttpCache = false }.responseString()152        val (data2, error2) = result2153        assertThat("Expected data, actual error $error2", data2, notNullValue())154        assertThat(data2, equalTo("fresh"))155    }156    @Test157    fun changeClientHook() {158        val request = Fuel.request(Method.GET, mock.path("change-hook")).apply {159            val httpClient = executionOptions.client as HttpClient160            httpClient.hook = TestHook()161        }162        val client = request.executionOptions.client as HttpClient163        assertThat(client.hook, instanceOf(TestHook::class.java))164    }165}...

RequestExecutionOptions.kt

Source:RequestExecutionOptions.kt

...23    var timeoutInMillisecond: Int = 15_00024    var timeoutReadInMillisecond: Int = 15_00025    var decodeContent: Boolean? = null26    var allowRedirects: Boolean? = null27    var useHttpCache: Boolean? = null28    var interruptCallbacks: MutableCollection<InterruptCallback> = mutableListOf()29    var forceMethods: Boolean = false30    var responseValidator: ResponseValidator = { response ->31        !(response.isServerError || response.isClientError)32    }33    /**34     * Executes a callback [f] onto the [Executor]35     *36     * @note this can be used to handle callbacks on a different Thread than the network request is made37     */38    fun callback(f: () -> Unit) = callbackExecutor.execute(f)39    /**40     * Submits the task to the [ExecutorService]41     *...

useHttpCache

Using AI Code Generation

1    fun useHttpCache() {2            Log.d("useHttpCache", "$request")3            Log.d("useHttpCache", "$response")4            Log.d("useHttpCache", "$result")5        }6    }7    fun cacheResponseCallback() {8            Log.d("cacheResponseCallback", "$request")9            Log.d("cacheResponseCallback", "$response")10        }.responseString { request, response, result ->11            Log.d("cacheResponseCallback", "$request")12            Log.d("cacheResponseCallback", "$response")13            Log.d("cacheResponseCallback", "$result")14        }15    }16    fun validateResponse() {17            Log.d("validateResponse", "$it")18        }.responseString { request, response, result ->19            Log.d("validateResponse", "$request")20            Log.d("validateResponse", "$response")21            Log.d("validateResponse", "$result")22        }23    }24    fun request() {25            Log.d("request", "$request")26        }.responseString { request, response, result ->27            Log.d("request", "$request")28            Log.d("request", "$response")29            Log.d("request", "$result")30        }31    }32    fun response() {33            Log.d("response", "$request")34            Log.d("response", "$response")35            Log.d("response", "$result")36        }37    }38    fun responseString() {

useHttpCache

Using AI Code Generation

1            result.fold({ d ->2            }, { err ->3            })4        }5    }6        result.fold({ d ->7        }, { err ->8        })9    }10}

useHttpCache

Using AI Code Generation

1fun enableCache(enable: Boolean) {2    FuelManager.instance.apply {3        if (enable) {4            cache = DefaultCache()5        } else {6        }7    }8}9fun enableCache(enable: Boolean) {10    FuelManager.instance.apply {11        if (enable) {12            cache = DefaultCache()13        } else {14        }15    }16}

useHttpCache

Using AI Code Generation

1        val result = request.useHttpCache().responseString()2        println(result)3    }4    fun testCacheControl() {5        val result = request.cacheControl(CacheControl("no-cache")).responseString()6        println(result)7    }8    fun testTimeout() {9        val result = request.timeout(10000).responseString()10        println(result)11    }12    fun testTimeoutRead() {13        val result = request.timeoutRead(10000).responseString()14        println(result)15    }16    fun testTimeoutWrite() {17        val result = request.timeoutWrite(10000).responseString()18        println(result)19    }20    fun testTimeoutConnect() {21        val result = request.timeoutConnect(10000).responseString()22        println(result)23    }24    fun testTimeoutReadInfinite() {25        val result = request.timeoutReadInfinite().responseString()26        println(result)27    }28    fun testTimeoutWriteInfinite() {29        val result = request.timeoutWriteInfinite().responseString()30        println(result)31    }32    fun testTimeoutConnectInfinite() {

useHttpCache

Using AI Code Generation

1        .httpCache(true, 5)2        .responseString { request, response, result ->3            result.fold({ data ->4                Log.d("MainActivity", data)5            }, { error ->6                Log.e("MainActivity", error.toString())7            })8        }

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.