public static void main(String... args) throws IOException, InterruptedException { MockWebServer server = new MockWebServer(); server.enqueue(new MockResponse()); server.enqueue(new MockResponse()); server.start(); Retrofit retrofit = new Retrofit.Builder() .baseUrl(server.url("/")) .addConverterFactory(new ChunkingConverterFactory()) .addConverterFactory(GsonConverterFactory.create()) .build(); Service service = retrofit.create(Service.class); Repo retrofitRepo = new Repo("square", "retrofit"); service.sendNormal(retrofitRepo).execute(); RecordedRequest normalRequest = server.takeRequest(); System.out.println( "Normal @Body Transfer-Encoding: " + normalRequest.getHeader("Transfer-Encoding")); service.sendChunked(retrofitRepo).execute(); RecordedRequest chunkedRequest = server.takeRequest(); System.out.println( "@Chunked @Body Transfer-Encoding: " + chunkedRequest.getHeader("Transfer-Encoding")); server.shutdown(); } }
private MockResponse putRequest(RecordedRequest request, String expectedRequestContent) { assertTrue("Invalid request content-length", Integer.parseInt(request.getHeader("Content-Length")) > 0); String requestContentType = request.getHeader("Content-Type"); assertNotNull("No content-type", requestContentType); Charset charset = StandardCharsets.ISO_8859_1; if (requestContentType.contains("charset=")) { String charsetName = requestContentType.split("charset=")[1]; charset = Charset.forName(charsetName); } assertEquals("Invalid request body", expectedRequestContent, request.getBody().readString(charset)); return new MockResponse().setResponseCode(202); }
@Test public void testAppliesHeadersInGlideUrl() throws Exception { mockWebServer.enqueue(new MockResponse().setResponseCode(200)); String headerField = "field"; String headerValue = "value"; Map<String, String> headersMap = new HashMap<>(); headersMap.put(headerField, headerValue); Headers headers = mock(Headers.class); when(headers.getHeaders()).thenReturn(headersMap); getFetcher(headers).loadData(Priority.HIGH, callback); waitForResponseLatch.await(); assertThat(mockWebServer.takeRequest().getHeader(headerField)).isEqualTo(headerValue); }
@Test public void testAppliesHeadersInGlideUrl() throws Exception { mockWebServer.enqueue(new MockResponse().setResponseCode(200)); String headerField = "field"; String headerValue = "value"; Map<String, String> headersMap = new HashMap<>(); headersMap.put(headerField, headerValue); Headers headers = mock(Headers.class); when(headers.getHeaders()).thenReturn(headersMap); getFetcher(headers).loadData(Priority.HIGH, callback); assertThat(mockWebServer.takeRequest().getHeader(headerField)).isEqualTo(headerValue); }
private MockResponse formRequest(RecordedRequest request) { assertEquals("application/x-www-form-urlencoded;charset=UTF-8", request.getHeader("Content-Type")); String body = request.getBody().readUtf8(); assertThat(body, Matchers.containsString("name+1=value+1")); assertThat(body, Matchers.containsString("name+2=value+2%2B1")); assertThat(body, Matchers.containsString("name+2=value+2%2B2")); return new MockResponse().setResponseCode(200); }
private MockResponse jsonPostRequest(RecordedRequest request, String location, String contentType) { if (request.getBodySize() > 0) { assertTrue("Invalid request content-length", Integer.parseInt(request.getHeader("Content-Length")) > 0); assertNotNull("No content-type", request.getHeader("Content-Type")); } return new MockResponse() .setHeader("Location", baseUrl + location) .setHeader("Content-Type", contentType) .setHeader("Content-Length", request.getBody().size()) .setBody(request.getBody()) .setResponseCode(201); }
private MockResponse multipartRequest(RecordedRequest request) { MediaType mediaType = MediaType.parseMediaType(request.getHeader("Content-Type")); assertTrue(mediaType.isCompatibleWith(MediaType.MULTIPART_FORM_DATA)); String boundary = mediaType.getParameter("boundary"); Buffer body = request.getBody(); try { assertPart(body, "form-data", boundary, "name 1", "text/plain", "value 1"); assertPart(body, "form-data", boundary, "name 2", "text/plain", "value 2+1"); assertPart(body, "form-data", boundary, "name 2", "text/plain", "value 2+2"); assertFilePart(body, "form-data", boundary, "logo", "logo.jpg", "image/jpeg"); } catch (EOFException ex) { throw new IllegalStateException(ex); } return new MockResponse().setResponseCode(200); }
@Test public void shouldReceivePlainText() { prepareResponse(response -> response.setBody("Hello Spring!")); Mono<String> result = this.webClient.get() .uri("/greeting?name=Spring") .header("X-Test-Header", "testvalue") .retrieve() .bodyToMono(String.class); StepVerifier.create(result) .expectNext("Hello Spring!") .expectComplete().verify(Duration.ofSeconds(3)); expectRequestCount(1); expectRequest(request -> { assertEquals("testvalue", request.getHeader("X-Test-Header")); assertEquals("*/*", request.getHeader(HttpHeaders.ACCEPT)); assertEquals("/greeting?name=Spring", request.getPath()); }); }
@Test public void shouldReceivePlainTextFlux() throws Exception { prepareResponse(response -> response.setBody("Hello Spring!")); Flux<String> result = this.webClient.get() .uri("/greeting?name=Spring") .header("X-Test-Header", "testvalue") .exchange() .flatMapMany(response -> response.bodyToFlux(String.class)); StepVerifier.create(result) .expectNext("Hello Spring!") .expectComplete().verify(Duration.ofSeconds(3)); expectRequestCount(1); expectRequest(request -> { assertEquals("testvalue", request.getHeader("X-Test-Header")); assertEquals("*/*", request.getHeader(HttpHeaders.ACCEPT)); assertEquals("/greeting?name=Spring", request.getPath()); }); }
@Test public void shouldReceiveNotFoundEntity() { prepareResponse(response -> response.setResponseCode(404) .setHeader("Content-Type", "text/plain").setBody("Not Found")); Mono<ResponseEntity<String>> result = this.webClient.get() .uri("/greeting?name=Spring") .exchange() .flatMap(response -> response.toEntity(String.class)); StepVerifier.create(result) .consumeNextWith(response -> assertEquals(HttpStatus.NOT_FOUND, response.getStatusCode())) .expectComplete() .verify(Duration.ofSeconds(3)); expectRequestCount(1); expectRequest(request -> { assertEquals("*/*", request.getHeader(HttpHeaders.ACCEPT)); assertEquals("/greeting?name=Spring", request.getPath()); }); }
@Test public void shouldApplyCustomStatusHandlerParameterizedTypeReference() { prepareResponse(response -> response.setResponseCode(500) .setHeader("Content-Type", "text/plain").setBody("Internal Server error")); Mono<String> result = this.webClient.get() .uri("/greeting?name=Spring") .retrieve() .onStatus(HttpStatus::is5xxServerError, response -> Mono.just(new MyException("500 error!"))) .bodyToMono(new ParameterizedTypeReference<String>() {}); StepVerifier.create(result) .expectError(MyException.class) .verify(Duration.ofSeconds(3)); expectRequestCount(1); expectRequest(request -> { assertEquals("*/*", request.getHeader(HttpHeaders.ACCEPT)); assertEquals("/greeting?name=Spring", request.getPath()); }); }
@Test public void shouldApplyCustomStatusHandler() { prepareResponse(response -> response.setResponseCode(500) .setHeader("Content-Type", "text/plain").setBody("Internal Server error")); Mono<String> result = this.webClient.get() .uri("/greeting?name=Spring") .retrieve() .onStatus(HttpStatus::is5xxServerError, response -> Mono.just(new MyException("500 error!"))) .bodyToMono(String.class); StepVerifier.create(result) .expectError(MyException.class) .verify(Duration.ofSeconds(3)); expectRequestCount(1); expectRequest(request -> { assertEquals("*/*", request.getHeader(HttpHeaders.ACCEPT)); assertEquals("/greeting?name=Spring", request.getPath()); }); }
@Test // SPR-15946 public void shouldGetErrorSignalOnEmptyErrorResponse() { prepareResponse(response -> response.setResponseCode(404) .setHeader("Content-Type", "text/plain")); Mono<String> result = this.webClient.get().uri("/greeting") .retrieve() .bodyToMono(String.class); StepVerifier.create(result) .expectError(WebClientResponseException.class) .verify(Duration.ofSeconds(3)); expectRequestCount(1); expectRequest(request -> { assertEquals("*/*", request.getHeader(HttpHeaders.ACCEPT)); assertEquals("/greeting", request.getPath()); }); }
@Test public void shouldGetErrorSignalOn404() { prepareResponse(response -> response.setResponseCode(404) .setHeader("Content-Type", "text/plain").setBody("Not Found")); Mono<String> result = this.webClient.get() .uri("/greeting?name=Spring") .retrieve() .bodyToMono(String.class); StepVerifier.create(result) .expectError(WebClientResponseException.class) .verify(Duration.ofSeconds(3)); expectRequestCount(1); expectRequest(request -> { assertEquals("*/*", request.getHeader(HttpHeaders.ACCEPT)); assertEquals("/greeting?name=Spring", request.getPath()); }); }
@Test public void shouldReceive404Response() { prepareResponse(response -> response.setResponseCode(404) .setHeader("Content-Type", "text/plain").setBody("Not Found")); Mono<ClientResponse> result = this.webClient.get().uri("/greeting?name=Spring").exchange(); StepVerifier.create(result) .consumeNextWith(response -> assertEquals(HttpStatus.NOT_FOUND, response.statusCode())) .expectComplete() .verify(Duration.ofSeconds(3)); expectRequestCount(1); expectRequest(request -> { assertEquals("*/*", request.getHeader(HttpHeaders.ACCEPT)); assertEquals("/greeting?name=Spring", request.getPath()); }); }
@Test public void shouldReceiveJsonAsFluxString() { String content = "{\"bar\":\"barbar\",\"foo\":\"foofoo\"}"; prepareResponse(response -> response .setHeader("Content-Type", "application/json").setBody(content)); Flux<String> result = this.webClient.get() .uri("/json").accept(MediaType.APPLICATION_JSON) .retrieve() .bodyToFlux(String.class); StepVerifier.create(result) .expectNext(content) .expectComplete().verify(Duration.ofSeconds(3)); expectRequestCount(1); expectRequest(request -> { assertEquals("/json", request.getPath()); assertEquals("application/json", request.getHeader(HttpHeaders.ACCEPT)); }); }
@Test public void shouldSendCookies() { prepareResponse(response -> response .setHeader("Content-Type", "text/plain").setBody("test")); Mono<String> result = this.webClient.get() .uri("/test") .cookie("testkey", "testvalue") .retrieve() .bodyToMono(String.class); StepVerifier.create(result) .expectNext("test") .expectComplete() .verify(Duration.ofSeconds(3)); expectRequestCount(1); expectRequest(request -> { assertEquals("/test", request.getPath()); assertEquals("testkey=testvalue", request.getHeader(HttpHeaders.COOKIE)); }); }
@Test public void shouldReceiveJsonAsString() { String content = "{\"bar\":\"barbar\",\"foo\":\"foofoo\"}"; prepareResponse(response -> response .setHeader("Content-Type", "application/json").setBody(content)); Mono<String> result = this.webClient.get() .uri("/json").accept(MediaType.APPLICATION_JSON) .retrieve() .bodyToMono(String.class); StepVerifier.create(result) .expectNext(content) .expectComplete().verify(Duration.ofSeconds(3)); expectRequestCount(1); expectRequest(request -> { assertEquals("/json", request.getPath()); assertEquals("application/json", request.getHeader(HttpHeaders.ACCEPT)); }); }
@Test public void shouldReceiveJsonAsPojo() { prepareResponse(response -> response .setHeader("Content-Type", "application/json") .setBody("{\"bar\":\"barbar\",\"foo\":\"foofoo\"}")); Mono<Pojo> result = this.webClient.get() .uri("/pojo") .accept(MediaType.APPLICATION_JSON) .retrieve() .bodyToMono(Pojo.class); StepVerifier.create(result) .consumeNextWith(p -> assertEquals("barbar", p.getBar())) .expectComplete() .verify(Duration.ofSeconds(3)); expectRequestCount(1); expectRequest(request -> { assertEquals("/pojo", request.getPath()); assertEquals("application/json", request.getHeader(HttpHeaders.ACCEPT)); }); }
@Test public void shouldSupportUnknownStatusCode() { int errorStatus = 555; assertNull(HttpStatus.resolve(errorStatus)); String errorMessage = "Something went wrong"; prepareResponse(response -> response.setResponseCode(errorStatus) .setHeader("Content-Type", "text/plain").setBody(errorMessage)); Mono<ClientResponse> result = this.webClient.get() .uri("/unknownPage") .exchange(); StepVerifier.create(result) .consumeNextWith(response -> assertEquals(555, response.rawStatusCode())) .expectComplete() .verify(Duration.ofSeconds(3)); expectRequestCount(1); expectRequest(request -> { assertEquals("*/*", request.getHeader(HttpHeaders.ACCEPT)); assertEquals("/unknownPage", request.getPath()); }); }