The caller may read the response body with the response's + * {@link Response#body} method. To facilitate connection recycling, callers + * should always {@link Response.Body#close() close the response body}. + * + *
Note that transport-layer success (receiving a HTTP response code, + * headers and body) does not necessarily indicate application-layer + * success: {@code response} may still indicate an unhappy HTTP response + * code like 404 or 500. + * + *
Receivers do not need to block while waiting for the response body to + * download. Instead, they can get called back as data arrives. Use {@link + * Response.Body#ready} to check if bytes should be read immediately. While + * there is data ready, read it. + * + *
The current implementation of {@link Response.Body#ready} always + * returns true when the underlying transport is HTTP/1. This results in + * blocking on that transport. For effective non-blocking your server must + * support {@link Protocol#SPDY_3} or {@link Protocol#HTTP_2}. + * + * @throws IOException when the request could not be executed due to a + * connectivity problem or timeout. Because networks can fail during an + * exchange, it is possible that the remote server accepted the request + * before the failure. + */ + public Response execute(Request request) throws IOException { + // Copy the client. Otherwise changes (socket factory, redirect policy, + // etc.) may incorrectly be reflected in the request when it is executed. + OkHttpClient client = copyWithDefaults(); + Job job = new Job(dispatcher, client, request, null); + Response result = job.getResponse(); // Since we don't cancel, this won't be null. + job.engine.releaseConnection(); // Transfer ownership of the body to the caller. + return result; + } + /** * Schedules {@code request} to be executed at some point in the future. The * {@link #getDispatcher dispatcher} defines when the request will run: diff --git a/okhttp/src/main/java/com/squareup/okhttp/internal/http/HttpEngine.java b/okhttp/src/main/java/com/squareup/okhttp/internal/http/HttpEngine.java index 3bec0b608..e053d8844 100644 --- a/okhttp/src/main/java/com/squareup/okhttp/internal/http/HttpEngine.java +++ b/okhttp/src/main/java/com/squareup/okhttp/internal/http/HttpEngine.java @@ -266,6 +266,10 @@ public class HttpEngine { return response != null; } + public final ResponseSource responseSource() { + return responseSource; + } + public final Request getRequest() { return request; } diff --git a/okhttp/src/test/java/com/squareup/okhttp/SyncApiTest.java b/okhttp/src/test/java/com/squareup/okhttp/SyncApiTest.java new file mode 100644 index 000000000..ae3c7434f --- /dev/null +++ b/okhttp/src/test/java/com/squareup/okhttp/SyncApiTest.java @@ -0,0 +1,268 @@ +/* + * Copyright (C) 2014 Square, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.squareup.okhttp; + +import com.squareup.okhttp.internal.RecordingHostnameVerifier; +import com.squareup.okhttp.internal.SslContextBuilder; +import com.squareup.okhttp.mockwebserver.MockResponse; +import com.squareup.okhttp.mockwebserver.MockWebServer; +import com.squareup.okhttp.mockwebserver.RecordedRequest; +import com.squareup.okhttp.mockwebserver.SocketPolicy; +import java.io.File; +import java.io.IOException; +import java.net.HttpURLConnection; +import java.util.UUID; +import javax.net.ssl.SSLContext; +import org.junit.After; +import org.junit.Before; +import org.junit.Test; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNull; +import static org.junit.Assert.assertTrue; +import static org.junit.Assert.fail; + +public final class SyncApiTest { + private MockWebServer server = new MockWebServer(); + private OkHttpClient client = new OkHttpClient(); + + private static final SSLContext sslContext = SslContextBuilder.localhost(); + private HttpResponseCache cache; + + @Before public void setUp() throws Exception { + String tmp = System.getProperty("java.io.tmpdir"); + File cacheDir = new File(tmp, "HttpCache-" + UUID.randomUUID()); + cache = new HttpResponseCache(cacheDir, Integer.MAX_VALUE); + } + + @After public void tearDown() throws Exception { + server.shutdown(); + cache.delete(); + } + + @Test public void get() throws Exception { + server.enqueue(new MockResponse() + .setBody("abc") + .addHeader("Content-Type: text/plain")); + server.play(); + + Request request = new Request.Builder() + .url(server.getUrl("/")) + .header("User-Agent", "SyncApiTest") + .build(); + + onSuccess(request) + .assertCode(200) + .assertContainsHeaders("Content-Type: text/plain") + .assertBody("abc"); + + assertTrue(server.takeRequest().getHeaders().contains("User-Agent: SyncApiTest")); + } + + @Test public void connectionPooling() throws Exception { + server.enqueue(new MockResponse().setBody("abc")); + server.enqueue(new MockResponse().setBody("def")); + server.enqueue(new MockResponse().setBody("ghi")); + server.play(); + + onSuccess(new Request.Builder().url(server.getUrl("/a")).build()) + .assertBody("abc"); + + onSuccess(new Request.Builder().url(server.getUrl("/b")).build()) + .assertBody("def"); + + onSuccess(new Request.Builder().url(server.getUrl("/c")).build()) + .assertBody("ghi"); + + assertEquals(0, server.takeRequest().getSequenceNumber()); + assertEquals(1, server.takeRequest().getSequenceNumber()); + assertEquals(2, server.takeRequest().getSequenceNumber()); + } + + @Test public void tls() throws Exception { + server.useHttps(sslContext.getSocketFactory(), false); + server.enqueue(new MockResponse() + .setBody("abc") + .addHeader("Content-Type: text/plain")); + server.play(); + + client.setSslSocketFactory(sslContext.getSocketFactory()); + client.setHostnameVerifier(new RecordingHostnameVerifier()); + + onSuccess(new Request.Builder().url(server.getUrl("/")).build()) + .assertHandshake(); + } + + @Test public void recoverFromTlsHandshakeFailure() throws Exception { + server.useHttps(sslContext.getSocketFactory(), false); + server.enqueue(new MockResponse().setSocketPolicy(SocketPolicy.FAIL_HANDSHAKE)); + server.enqueue(new MockResponse().setBody("abc")); + server.play(); + + client.setSslSocketFactory(sslContext.getSocketFactory()); + client.setHostnameVerifier(new RecordingHostnameVerifier()); + + onSuccess(new Request.Builder().url(server.getUrl("/")).build()) + .assertBody("abc"); + } + + @Test public void post() throws Exception { + server.enqueue(new MockResponse().setBody("abc")); + server.play(); + + Request request = new Request.Builder() + .url(server.getUrl("/")) + .post(Request.Body.create(MediaType.parse("text/plain"), "def")) + .build(); + + onSuccess(request) + .assertCode(200) + .assertBody("abc"); + + RecordedRequest recordedRequest = server.takeRequest(); + assertEquals("def", recordedRequest.getUtf8Body()); + assertEquals("3", recordedRequest.getHeader("Content-Length")); + assertEquals("text/plain; charset=utf-8", recordedRequest.getHeader("Content-Type")); + } + + @Test public void cache() throws Exception { + server.enqueue(new MockResponse().setBody("A").addHeader("ETag: v1")); + server.enqueue(new MockResponse().setResponseCode(HttpURLConnection.HTTP_NOT_MODIFIED)); + server.play(); + + client.setOkResponseCache(cache); + + onSuccess(new Request.Builder().url(server.getUrl("/")).build()) + .assertCode(200).assertBody("A"); + assertNull(server.takeRequest().getHeader("If-None-Match")); + + onSuccess(new Request.Builder().url(server.getUrl("/")).build()) + .assertCode(200).assertBody("A"); + assertEquals("v1", server.takeRequest().getHeader("If-None-Match")); + } + + @Test public void redirect() throws Exception { + server.enqueue(new MockResponse() + .setResponseCode(301) + .addHeader("Location: /b") + .addHeader("Test", "Redirect from /a to /b") + .setBody("/a has moved!")); + server.enqueue(new MockResponse() + .setResponseCode(302) + .addHeader("Location: /c") + .addHeader("Test", "Redirect from /b to /c") + .setBody("/b has moved!")); + server.enqueue(new MockResponse().setBody("C")); + server.play(); + + onSuccess(new Request.Builder().url(server.getUrl("/a")).build()) + .assertCode(200) + .assertBody("C") + .redirectedBy() + .assertCode(302) + .assertContainsHeaders("Test: Redirect from /b to /c") + .redirectedBy() + .assertCode(301) + .assertContainsHeaders("Test: Redirect from /a to /b"); + + assertEquals(0, server.takeRequest().getSequenceNumber()); // New connection. + assertEquals(1, server.takeRequest().getSequenceNumber()); // Connection reused. + assertEquals(2, server.takeRequest().getSequenceNumber()); // Connection reused again! + } + + @Test public void redirectWithRedirectsDisabled() throws Exception { + client.setFollowProtocolRedirects(false); + server.enqueue(new MockResponse() + .setResponseCode(301) + .addHeader("Location: /b") + .addHeader("Test", "Redirect from /a to /b") + .setBody("/a has moved!")); + server.play(); + + onSuccess(new Request.Builder().url(server.getUrl("/a")).build()) + .assertCode(301) + .assertBody("/a has moved!") + .assertContainsHeaders("Location: /b"); + } + + @Test public void follow20Redirects() throws Exception { + for (int i = 0; i < 20; i++) { + server.enqueue(new MockResponse() + .setResponseCode(301) + .addHeader("Location: /" + (i + 1)) + .setBody("Redirecting to /" + (i + 1))); + } + server.enqueue(new MockResponse().setBody("Success!")); + server.play(); + + onSuccess(new Request.Builder().url(server.getUrl("/0")).build()) + .assertCode(200) + .assertBody("Success!"); + } + + @Test public void doesNotFollow21Redirects() throws Exception { + for (int i = 0; i < 21; i++) { + server.enqueue(new MockResponse() + .setResponseCode(301) + .addHeader("Location: /" + (i + 1)) + .setBody("Redirecting to /" + (i + 1))); + } + server.play(); + + try { + client.execute(new Request.Builder().url(server.getUrl("/0")).build()); + fail(); + } catch (IOException e) { + assertEquals("Too many redirects: 21", e.getMessage()); + } + } + + @Test public void postBodyRetransmittedOnRedirect() throws Exception { + server.enqueue(new MockResponse() + .setResponseCode(302) + .addHeader("Location: /b") + .setBody("Moved to /b !")); + server.enqueue(new MockResponse() + .setBody("This is b.")); + server.play(); + + Request request = new Request.Builder() + .url(server.getUrl("/")) + .post(Request.Body.create(MediaType.parse("text/plain"), "body!")) + .build(); + + onSuccess(request) + .assertCode(200) + .assertBody("This is b."); + + RecordedRequest request1 = server.takeRequest(); + assertEquals("body!", request1.getUtf8Body()); + assertEquals("5", request1.getHeader("Content-Length")); + assertEquals("text/plain; charset=utf-8", request1.getHeader("Content-Type")); + assertEquals(0, request1.getSequenceNumber()); + + RecordedRequest request2 = server.takeRequest(); + assertEquals("body!", request2.getUtf8Body()); + assertEquals("5", request2.getHeader("Content-Length")); + assertEquals("text/plain; charset=utf-8", request2.getHeader("Content-Type")); + assertEquals(1, request2.getSequenceNumber()); + } + + private RecordedResponse onSuccess(Request request) throws IOException { + Response response = client.execute(request); + return new RecordedResponse(request, response, response.body().string(), null); + } +}