public MockResponse setResponseCode(int code) { String reason = "Mock Response"; if (code >= 100 && code < 200) { reason = "Informational"; } else if (code >= 200 && code < 300) { reason = "OK"; } else if (code >= 300 && code < 400) { reason = "Redirection"; } else if (code >= 400 && code < 500) { reason = "Client Error"; } else if (code >= 500 && code < 600) { reason = "Server Error"; } return setStatus("HTTP/1.1 " + code + " " + reason); }
private MockResponse directoryToResponse(String basePath, File directory) { if (!basePath.endsWith("/")) basePath += "/"; StringBuilder response = new StringBuilder(); response.append(String.format("<html><head><title>%s</title></head><body>", basePath)); response.append(String.format("<h1>%s</h1>", basePath)); for (String file : directory.list()) { response.append(String.format("<div class='file'><a href='%s'>%s</a></div>", basePath + file, file)); } response.append("</body></html>"); return new MockResponse() .setStatus("HTTP/1.1 200") .addHeader("content-type: text/html; charset=utf-8") .setBody(response.toString()); }
/** * Attempts to perform a web socket upgrade on the connection. This will overwrite any previously * set status or body. */ public MockResponse withWebSocketUpgrade(WebSocketListener listener) { setStatus("HTTP/1.1 101 Switching Protocols"); setHeader("Connection", "Upgrade"); setHeader("Upgrade", "websocket"); body = null; webSocketListener = listener; return this; }
@Override public MockResponse dispatch(RecordedRequest request) { String path = request.getPath(); try { if (!path.startsWith("/") || path.contains("..")) throw new FileNotFoundException(); File file = new File(root + path); return file.isDirectory() ? directoryToResponse(path, file) : fileToResponse(path, file); } catch (FileNotFoundException e) { return new MockResponse() .setStatus("HTTP/1.1 404") .addHeader("content-type: text/plain; charset=utf-8") .setBody("NOT FOUND: " + path); } catch (IOException e) { return new MockResponse() .setStatus("HTTP/1.1 500") .addHeader("content-type: text/plain; charset=utf-8") .setBody("SERVER ERROR: " + e); } }
private MockResponse fileToResponse(String path, File file) throws IOException { return new MockResponse() .setStatus("HTTP/1.1 200") .setBody(fileToBytes(file)) .addHeader("content-type: " + contentType(path)); }
private MockResponse createMockBadResponse() { MockResponse response = new MockResponse(); response.setStatus("HTTP/1.1 500 Internal server error"); response.setBody("Uh-oh. Server Error."); return response; }
@Test public void testRetryEventuallyReturnsTheRightException() throws Exception { MockResponse errorResponse = new MockResponse(); errorResponse.setStatus("HTTP/1.1 500 Internal server error"); errorResponse.setBody("Uh-oh. Server Error."); // Enqueue some error responses. for (int i = 0; i < 10; i++) { server.enqueue(errorResponse); } server.start(); // Wire the mock web server to the context setMockBaseUrl(); builder.retryTimeout(5, TimeUnit.SECONDS); try { builder.build().get(new ApiConfig("/"), GeocodingApi.Response.class, "k", "v").await(); } catch (IOException ioe) { // Ensure the message matches the status line in the mock responses. assertEquals("Server Error: 500 Internal server error", ioe.getMessage()); return; } fail("Internal server error was expected but not observed."); }
@Test(expected = IOException.class) public void testRetryCanBeDisabled() throws Exception { // Set up 2 mock responses, an error that shouldn't be retried and a success MockResponse errorResponse = new MockResponse(); errorResponse.setStatus("HTTP/1.1 500 Internal server error"); errorResponse.setBody("Uh-oh. Server Error."); server.enqueue(errorResponse); MockResponse goodResponse = new MockResponse(); goodResponse.setResponseCode(200); goodResponse.setBody("{\n \"results\" : [],\n \"status\" : \"ZERO_RESULTS\"\n}"); server.enqueue(goodResponse); server.start(); setMockBaseUrl(); // This should disable the retry, ensuring that the success response is NOT returned builder.disableRetries(); // We should get the error response here, not the success response. builder.build().get(new ApiConfig("/"), GeocodingApi.Response.class, "k", "v").await(); }
@Test public void testToggleIfExceptionIsAllowedToRetry() throws Exception { // Enqueue some error responses, although only the first should be used because the response's // exception is not allowed to be retried. MockResponse overQueryLimitResponse = new MockResponse(); overQueryLimitResponse.setStatus("HTTP/1.1 400 Internal server error"); overQueryLimitResponse.setBody(TestUtils.retrieveBody("OverQueryLimitResponse.json")); server.enqueue(overQueryLimitResponse); server.enqueue(overQueryLimitResponse); server.enqueue(overQueryLimitResponse); server.start(); builder.retryTimeout(1, TimeUnit.MILLISECONDS); builder.maxRetries(10); builder.setIfExceptionIsAllowedToRetry(OverQueryLimitException.class, false); setMockBaseUrl(); try { builder .build() .get(new ApiConfig("/"), GeocodingApi.Response.class, "any-key", "any-value") .await(); } catch (OverQueryLimitException e) { assertEquals(1, server.getRequestCount()); return; } fail("OverQueryLimitException was expected but not observed."); }
public MockResponse setResponseCode(int code) { String reason = "Mock Response"; if (code >= 100 && code < 200) { reason = "Informational"; } else if (code >= 200 && code < 300) { reason = "OK"; } else if (code >= 300 && code < 400) { reason = "Redirection"; } else if (code >= 400 && code < 500) { reason = "Client Error"; } else if (code >= 500 && code < 600) { reason = "Server Error"; } return setStatus("HTTP/1.1 " + code + " " + reason); }
@Test public void testParseOkHttpClientExecuteWithGZIPResponse() throws Exception { // Make mock response Buffer buffer = new Buffer(); final ByteArrayOutputStream byteOut = new ByteArrayOutputStream(); GZIPOutputStream gzipOut = new GZIPOutputStream(byteOut); gzipOut.write("content".getBytes()); gzipOut.close(); buffer.write(byteOut.toByteArray()); MockResponse mockResponse = new MockResponse() .setStatus("HTTP/1.1 " + 201 + " " + "OK") .setBody(buffer) .setHeader("Content-Encoding", "gzip"); // Start mock server server.enqueue(mockResponse); server.start(); ParseHttpClient client = ParseHttpClient.createClient(new OkHttpClient.Builder()); // We do not need to add Accept-Encoding header manually, httpClient library should do that. String requestUrl = server.url("/").toString(); ParseHttpRequest parseRequest = new ParseHttpRequest.Builder() .setUrl(requestUrl) .setMethod(ParseHttpRequest.Method.GET) .build(); // Execute request ParseHttpResponse parseResponse = client.execute(parseRequest); // Make sure the response we get is ungziped by OkHttp library byte[] content = ParseIOUtils.toByteArray(parseResponse.getContent()); assertArrayEquals("content".getBytes(), content); server.shutdown(); }
buffer.write(byteOut.toByteArray()); MockResponse mockResponse = new MockResponse() .setStatus("HTTP/1.1 " + responseCode + " " + responseStatus) .setBody(buffer) .setHeader("Content-Encoding", "gzip");
.setStatus("HTTP/1.1 " + responseCode + " " + responseStatus) .setBody(responseContent);
/** * Attempts to perform a web socket upgrade on the connection. This will overwrite any previously * set status or body. */ public MockResponse withWebSocketUpgrade(WebSocketListener listener) { setStatus("HTTP/1.1 101 Switching Protocols"); setHeader("Connection", "Upgrade"); setHeader("Upgrade", "websocket"); body = null; webSocketListener = listener; return this; }
private void setUpMockServerResponse(int responseCode, String responseMessage, String responseBody) { MockResponse mockResponse = new MockResponse() .addHeader("Content-Type", "application/json; charset=utf-8") .setBody(responseBody) .setStatus(String.format("HTTP/1.1 %s %s", responseCode, responseMessage)); mockServer.enqueue(mockResponse); }
@Test public void http205SkipsConverter() throws IOException { final Converter<ResponseBody, String> converter = spy( new Converter<ResponseBody, String>() { @Override public String convert(ResponseBody value) throws IOException { return value.string(); } }); Retrofit retrofit = new Retrofit.Builder() .baseUrl(mServer.url("/")) .addConverterFactory(new ToStringConverterFactory() { @Override public Converter<ResponseBody, ?> responseBodyConverter( Type type, Annotation[] annotations, Retrofit retrofit) { return converter; } }) .addCallAdapterFactory(buildSmartCacheFactory()) .build(); Service example = retrofit.create(Service.class); mServer.enqueue(new MockResponse().setStatus("HTTP/1.1 205 Nothin")); Response<String> response = example.getString().execute(); assertThat(response.code()).isEqualTo(205); assertThat(response.body()).isNull(); verifyNoMoreInteractions(converter); }
@Test public void http204SkipsConverter() throws IOException { final Converter<ResponseBody, String> converter = spy(new Converter<ResponseBody, String>() { @Override public String convert(ResponseBody value) throws IOException { return value.string(); } }); Retrofit retrofit = new Retrofit.Builder() .baseUrl(mServer.url("/")) .addConverterFactory(new ToStringConverterFactory() { @Override public Converter<ResponseBody, ?> responseBodyConverter( Type type, Annotation[] annotations, Retrofit retrofit) { return converter; } }) .addCallAdapterFactory(buildSmartCacheFactory()) .build(); Service example = retrofit.create(Service.class); mServer.enqueue(new MockResponse().setStatus("HTTP/1.1 204 Nothin")); Response<String> response = example.getString().execute(); assertThat(response.code()).isEqualTo(204); assertThat(response.body()).isNull(); verifyNoMoreInteractions(converter); }