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 }
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!!