How to use mocked404 method of com.github.kittinunf.fuel.core.requests.private class

...37            response = mock.response().withBody(uuid.toString())38        )39        return Fuel.request(Method.GET, mock.path(path))40    }41    private fun mocked404(method: Method = Method.GET, path: String = "invalid/url"): Request {42        mock.chain(43            request = mock.request().withPath("/$path"),44            response = mock.response().withStatusCode(HttpURLConnection.HTTP_NOT_FOUND)45        )46        return Fuel.request(method, mock.path(path))47    }48    @Test49    fun response() {50        val uuid = randomUUID()51        val (request, response, result) = getUUID(uuid).response(UUIDResponseDeserializer)52        val (data, error) = result53        assertThat("Expected data, actual error $error", data, notNullValue())54        assertThat(data!!.uuid, equalTo(uuid.toString()))55        assertThat("Expected request to be not null", request, notNullValue())56        assertThat("Expected response to be not null", response, notNullValue())57    }58    @Test59    fun responseFailure() {60        val (_, _, result) = mocked404().responseString()61        val (data, error) = result62        assertThat("Expected error, actual data $data", error, notNullValue())63    }64    @Test65    fun responseHandler() {66        val uuid = randomUUID()67        val running = getUUID(uuid).response(UUIDResponseDeserializer, object : Handler<UUIDResponse> {68            override fun success(value: UUIDResponse) {69                assertThat(value.uuid, equalTo(uuid.toString()))70            }71            override fun failure(error: FuelError) {72                fail("Expected data, actual error $error")73            }74        })75        running.join()76    }77    @Test78    fun responseHandlerFailure() {79        val running = mocked404().response(UUIDResponseDeserializer, object : Handler<UUIDResponse> {80            override fun success(value: UUIDResponse) {81                fail("Expected error, actual data $value")82            }83            override fun failure(error: FuelError) {84                assertThat(error, notNullValue())85                assertThat(error.exception as? HttpException, isA(HttpException::class.java))86            }87        })88        running.join()89    }90    @Test91    fun responseResponseHandler() {92        val uuid = randomUUID()93        val running = getUUID(uuid).response(UUIDResponseDeserializer, object : ResponseHandler<UUIDResponse> {94            override fun success(request: Request, response: Response, value: UUIDResponse) {95                assertThat("Expected data to be not null", value, notNullValue())96                assertThat(value.uuid, equalTo(uuid.toString()))97                assertThat("Expected request to be not null", request, notNullValue())98                assertThat("Expected response to be not null", response, notNullValue())99            }100            override fun failure(request: Request, response: Response, error: FuelError) {101                fail("Expected data, actual error $error")102            }103        })104        running.join()105    }106    @Test107    fun responseResponseHandlerFailure() {108        val running = mocked404().response(UUIDResponseDeserializer, object : ResponseHandler<UUIDResponse> {109            override fun success(request: Request, response: Response, value: UUIDResponse) {110                fail("Expected error, actual data $value")111            }112            override fun failure(request: Request, response: Response, error: FuelError) {113                assertThat(error, notNullValue())114                assertThat(error.exception as? HttpException, isA(HttpException::class.java))115                assertThat("Expected request to be not null", request, notNullValue())116                assertThat("Expected response to be not null", response, notNullValue())117            }118        })119        running.join()120    }121    @Test122    fun responseResultHandler() {123        val uuid = randomUUID()124        val running = getUUID(uuid).response(UUIDResponseDeserializer) { result: Result<UUIDResponse, FuelError> ->125            val (data, error) = result126            assertThat("Expected data, actual error $error", data, notNullValue())127            assertThat(data!!.uuid, equalTo(uuid.toString()))128        }129        running.join()130    }131    @Test132    fun responseResultHandlerFailure() {133        val running = mocked404().response(UUIDResponseDeserializer) { result: Result<UUIDResponse, FuelError> ->134            val (data, error) = result135            assertThat("Expected error, actual data $data", error, notNullValue())136        }137        running.join()138    }139    @Test140    fun responseResponseResultHandler() {141        val uuid = randomUUID()142        val running = getUUID(uuid).response(UUIDResponseDeserializer) { request, response, result ->143            val (data, error) = result144            assertThat("Expected data, actual error $error", data, notNullValue())145            assertThat(data!!.uuid, equalTo(uuid.toString()))146            assertThat("Expected request to be not null", request, notNullValue())147            assertThat("Expected response to be not null", response, notNullValue())148        }149        running.join()150    }151    @Test152    fun responseResponseResultHandlerFailure() {153        val running = mocked404().response(UUIDResponseDeserializer) { request, response, result ->154            val (data, error) = result155            assertThat("Expected error, actual data $data", error, notNullValue())156            assertThat(error!!.exception as? HttpException, isA(HttpException::class.java))157            assertThat("Expected request to be not null", request, notNullValue())158            assertThat("Expected response to be not null", response, notNullValue())159        }160        running.join()161    }162}...

...25            response = mock.response().withBody(string)26        )27        return Fuel.request(Method.GET, mock.path(path))28    }29    private fun mocked404(method: Method = Method.GET, path: String = "invalid/url"): Request {30        mock.chain(31            request = mock.request().withPath("/$path"),32            response = mock.response().withStatusCode(HttpURLConnection.HTTP_NOT_FOUND)33        )34        return Fuel.request(method, mock.path(path))35    }36    @Test37    fun response() {38        val string = randomString()39        val (request, response, result) = getString(string).responseString()40        val (data, error) = result41        assertThat("Expected data, actual error $error", data, notNullValue())42        assertThat(data, equalTo(string))43        assertThat("Expected request to be not null", request, notNullValue())44        assertThat("Expected response to be not null", response, notNullValue())45    }46    @Test47    fun responseFailure() {48        val (_, _, result) = mocked404().responseString()49        val (data, error) = result50        assertThat("Expected error, actual data $data", error, notNullValue())51    }52    @Test53    fun responseHandler() {54        val string = randomString()55        val running = getString(string).responseString(object : Handler<String> {56            override fun success(value: String) {57                assertThat(value, equalTo(string))58            }59            override fun failure(error: FuelError) {60                fail("Expected data, actual error $error")61            }62        })63        running.join()64    }65    @Test66    fun responseHandlerFailure() {67        val running = mocked404().responseString(object : Handler<String> {68            override fun success(value: String) {69                fail("Expected error, actual data $value")70            }71            override fun failure(error: FuelError) {72                assertThat(error, notNullValue())73                assertThat(error.exception as? HttpException, isA(HttpException::class.java))74            }75        })76        running.join()77    }78    @Test79    fun responseResponseHandler() {80        val string = randomString()81        val running = getString(string).responseString(object : ResponseHandler<String> {82            override fun success(request: Request, response: Response, value: String) {83                assertThat("Expected data to be not null", value, notNullValue())84                assertThat(value, equalTo(string))85                assertThat("Expected request to be not null", request, notNullValue())86                assertThat("Expected response to be not null", response, notNullValue())87            }88            override fun failure(request: Request, response: Response, error: FuelError) {89                fail("Expected data, actual error $error")90            }91        })92        running.join()93    }94    @Test95    fun responseResponseHandlerFailure() {96        val running = mocked404().responseString(object : ResponseHandler<String> {97            override fun success(request: Request, response: Response, value: String) {98                fail("Expected error, actual data $value")99            }100            override fun failure(request: Request, response: Response, error: FuelError) {101                assertThat(error, notNullValue())102                assertThat(error.exception as? HttpException, isA(HttpException::class.java))103                assertThat("Expected request to be not null", request, notNullValue())104                assertThat("Expected response to be not null", response, notNullValue())105            }106        })107        running.join()108    }109    @Test110    fun responseResultHandler() {111        val string = randomString()112        val running = getString(string).responseString { result: Result<String, FuelError> ->113            val (data, error) = result114            assertThat("Expected data, actual error $error", data, notNullValue())115            assertThat(data, equalTo(string))116        }117        running.join()118    }119    @Test120    fun responseResultHandlerFailure() {121        val running = mocked404().responseString { result: Result<String, FuelError> ->122            val (data, error) = result123            assertThat("Expected error, actual data $data", error, notNullValue())124        }125        running.join()126    }127    @Test128    fun responseResponseResultHandler() {129        val string = randomString()130        val running = getString(string).responseString { request, response, result ->131            val (data, error) = result132            assertThat("Expected data, actual error $error", data, notNullValue())133            assertThat(data, equalTo(string))134            assertThat("Expected request to be not null", request, notNullValue())135            assertThat("Expected response to be not null", response, notNullValue())136        }137        running.join()138    }139    @Test140    fun responseResponseResultHandlerFailure() {141        val running = mocked404().responseString { request, response, result ->142            val (data, error) = result143            assertThat("Expected error, actual data $data", error, notNullValue())144            assertThat(error!!.exception as? HttpException, isA(HttpException::class.java))145            assertThat("Expected request to be not null", request, notNullValue())146            assertThat("Expected response to be not null", response, notNullValue())147        }148        running.join()149    }150}...

...25            response = mock.response().withBody(bytes)26        )27        return Fuel.request(Method.GET, mock.path(path))28    }29    private fun mocked404(method: Method = Method.GET, path: String = "invalid/url"): Request {30        mock.chain(31            request = mock.request().withPath("/$path"),32            response = mock.response().withStatusCode(HttpURLConnection.HTTP_NOT_FOUND)33        )34        return Fuel.request(method, mock.path(path))35    }36    @Test37    fun response() {38        val bytes = randomBytes()39        val (request, response, result) = getBytes(bytes).response()40        val (data, error) = result41        assertThat("Expected data, actual error $error", data, notNullValue())42        assertThat(data, equalTo(bytes))43        assertThat("Expected request to be not null", request, notNullValue())44        assertThat("Expected response to be not null", response, notNullValue())45    }46    @Test47    fun responseFailure() {48        val (_, _, result) = mocked404().response()49        val (data, error) = result50        assertThat("Expected error, actual data $data", error, notNullValue())51    }52    @Test53    fun responseHandler() {54        val bytes = randomBytes()55        val running = getBytes(bytes).response(object : Handler<ByteArray> {56            override fun success(value: ByteArray) {57                assertThat(value, equalTo(bytes))58            }59            override fun failure(error: FuelError) {60                fail("Expected data, actual error $error")61            }62        })63        running.join()64    }65    @Test66    fun responseHandlerFailure() {67        val running = mocked404().response(object : Handler<ByteArray> {68            override fun success(value: ByteArray) {69                fail("Expected error, actual data $value")70            }71            override fun failure(error: FuelError) {72                assertThat(error, notNullValue())73                assertThat(error.exception as? HttpException, isA(HttpException::class.java))74            }75        })76        running.join()77    }78    @Test79    fun responseResponseHandler() {80        val bytes = randomBytes()81        val running = getBytes(bytes).response(object : ResponseHandler<ByteArray> {82            override fun success(request: Request, response: Response, value: ByteArray) {83                assertThat("Expected data to be not null", value, notNullValue())84                assertThat(value, equalTo(bytes))85                assertThat("Expected request to be not null", request, notNullValue())86                assertThat("Expected response to be not null", response, notNullValue())87            }88            override fun failure(request: Request, response: Response, error: FuelError) {89                fail("Expected data, actual error $error")90            }91        })92        running.join()93    }94    @Test95    fun responseResponseHandlerFailure() {96        val running = mocked404().response(object : ResponseHandler<ByteArray> {97            override fun success(request: Request, response: Response, value: ByteArray) {98                fail("Expected error, actual data $value")99            }100            override fun failure(request: Request, response: Response, error: FuelError) {101                assertThat(error, notNullValue())102                assertThat(error.exception as? HttpException, isA(HttpException::class.java))103                assertThat("Expected request to be not null", request, notNullValue())104                assertThat("Expected response to be not null", response, notNullValue())105            }106        })107        running.join()108    }109    @Test110    fun responseResultHandler() {111        val bytes = randomBytes()112        val running = getBytes(bytes).response { result: Result<ByteArray, FuelError> ->113            val (data, error) = result114            assertThat("Expected data, actual error $error", data, notNullValue())115            assertThat(data, equalTo(bytes))116        }117        running.join()118    }119    @Test120    fun responseResultHandlerFailure() {121        val running = mocked404().response { result: Result<ByteArray, FuelError> ->122            val (data, error) = result123            assertThat("Expected error, actual data $data", error, notNullValue())124        }125        running.join()126    }127    @Test128    fun responseResponseResultHandler() {129        val bytes = randomBytes()130        val running = getBytes(bytes).response { request, response, result ->131            val (data, error) = result132            assertThat("Expected data, actual error $error", data, notNullValue())133            assertThat(data, equalTo(bytes))134            assertThat("Expected request to be not null", request, notNullValue())135            assertThat("Expected response to be not null", response, notNullValue())136        }137        running.join()138    }139    @Test140    fun responseResponseResultHandlerFailure() {141        val running = mocked404().response { request, response, result ->142            val (data, error) = result143            assertThat("Expected error, actual data $data", error, notNullValue())144            assertThat(error!!.exception as? HttpException, isA(HttpException::class.java))145            assertThat("Expected request to be not null", request, notNullValue())146            assertThat("Expected response to be not null", response, notNullValue())147        }148        running.join()149    }150}...

1    private fun mock404() = FuelError(404, "Not found")2    private fun mock200() = FuelError(200, "OK")3    fun `test 404`() {4        val mock = mock404()5        assertEquals(404, mock.response.statusCode)6        assertEquals("Not found", mock.response.responseMessage)7    }8    fun `test 200`() {9        val mock = mock200()10        assertEquals(200, mock.response.statusCode)11        assertEquals("OK", mock.response.responseMessage)12    }13}

1    fun `mocked 404`() {2        val (request, response, result) = "/404".mocked404().httpGet().responseString()3        assertEquals(404, response.statusCode)4        assertEquals("Not Found", response.responseMessage)5        assertEquals("Not Found", result.get())6    }7    fun `mocked 200`() {8        val (request, response, result) = "/200".mocked200().httpGet().responseString()9        assertEquals(200, response.statusCode)10        assertEquals("OK", response.responseMessage)11        assertEquals("OK", result.get())12    }13    fun `mocked 500`() {14        val (request, response, result) = "/500".mocked500().httpGet().responseString()15        assertEquals(500, response.statusCode)16        assertEquals("Internal Server Error", response.responseMessage)17        assertEquals("Internal Server Error", result.get())18    }19    fun `mocked`() {20        val (request, response, result) = "/mocked".mocked(200, "mocked").httpGet().responseString()21        assertEquals(200, response.statusCode)22        assertEquals("OK", response.responseMessage)23        assertEquals("mocked", result.get())24    }25    fun `mocked with headers`() {26        val (request, response, result) = "/mocked".mocked(200, "mocked", mapOf("Content-Type" to "application/json")).httpGet().responseString()27        assertEquals(200, response.statusCode)28        assertEquals("OK", response.responseMessage)29        assertEquals("application/json", response.headers["Content-Type"])30        assertEquals("mocked", result.get())31    }

1import com.github.kittinunf.fuel.core.requests.MockedRequest2fun mocked404(request: Request): MockedRequest {3val response = Response(4headers = mapOf("Content-Type" to "application/json; charset=utf-8"),5data = ByteArray(0)6return MockedRequest(request, response)7}8fun testMocked404() {9FuelManager.instance.mock {10return@mock mocked404(chain.request)11}12result.fold({ data ->13println(data)14}, { error ->15println(error)16})17}18}19result.fold({ data ->20println(data)21}, { error ->22println(error)23})24}25}26}27result.fold({ data ->28println(data)29}, { error ->30println(error)31})32}33}34}35result.fold({ data ->36println(data)37}, { error ->38println(error)39})40}41}42}43result.fold({ data ->44println(data)45}, { error ->46println(error)47})48}49}50}51result.fold({ data ->52println(data)53}, { error ->54println(error)55})56}57}58}59result.fold({ data ->60println(data)61}, { error ->62println(error)63})64}65}66}67result.fold({ data ->68println(data)69}, { error ->70println(error)71})72}73}74}75result.fold({ data ->76println(data)77}, { error ->78println(error)79})80}81}82}