/*
* Copyright (C) 2011 The Android Open Source Project
*
* 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 libcore.net.http;
import com.google.mockwebserver.MockResponse;
import com.google.mockwebserver.MockWebServer;
import com.google.mockwebserver.RecordedRequest;
import static com.google.mockwebserver.SocketPolicy.DISCONNECT_AT_END;
import java.io.BufferedReader;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.lang.reflect.InvocationHandler;
import java.net.CacheRequest;
import java.net.CacheResponse;
import java.net.CookieHandler;
import java.net.CookieManager;
import java.net.HttpCookie;
import java.net.HttpURLConnection;
import java.net.ResponseCache;
import java.net.SecureCacheResponse;
import java.net.URI;
import java.net.URISyntaxException;
import java.net.URL;
import java.net.URLConnection;
import java.security.Principal;
import java.security.cert.Certificate;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Date;
import java.util.Deque;
import java.util.Iterator;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.TimeZone;
import java.util.UUID;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicReference;
import java.util.zip.GZIPOutputStream;
import javax.net.ssl.HttpsURLConnection;
import junit.framework.TestCase;
import libcore.javax.net.ssl.TestSSLContext;
import tests.io.MockOs;
public final class HttpResponseCacheTest extends TestCase {
private MockWebServer server = new MockWebServer();
private HttpResponseCache cache;
private final MockOs mockOs = new MockOs();
private final CookieManager cookieManager = new CookieManager();
@Override protected void setUp() throws Exception {
super.setUp();
String tmp = System.getProperty("java.io.tmpdir");
File cacheDir = new File(tmp, "HttpCache-" + UUID.randomUUID());
cache = new HttpResponseCache(cacheDir, Integer.MAX_VALUE);
ResponseCache.setDefault(cache);
mockOs.install();
CookieHandler.setDefault(cookieManager);
}
@Override protected void tearDown() throws Exception {
mockOs.uninstall();
server.shutdown();
ResponseCache.setDefault(null);
cache.getCache().delete();
CookieHandler.setDefault(null);
super.tearDown();
}
/**
* Test that response caching is consistent with the RI and the spec.
* http://www.w3.org/Protocols/rfc2616/rfc2616-sec13.html#sec13.4
*/
public void testResponseCachingByResponseCode() throws Exception {
// Test each documented HTTP/1.1 code, plus the first unused value in each range.
// http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html
// We can't test 100 because it's not really a response.
// assertCached(false, 100);
assertCached(false, 101);
assertCached(false, 102);
assertCached(true, 200);
assertCached(false, 201);
assertCached(false, 202);
assertCached(true, 203);
assertCached(false, 204);
assertCached(false, 205);
assertCached(false, 206); // we don't cache partial responses
assertCached(false, 207);
assertCached(true, 300);
assertCached(true, 301);
for (int i = 302; i <= 308; ++i) {
assertCached(false, i);
}
for (int i = 400; i <= 406; ++i) {
assertCached(false, i);
}
// (See test_responseCaching_407.)
assertCached(false, 408);
assertCached(false, 409);
// (See test_responseCaching_410.)
for (int i = 411; i <= 418; ++i) {
assertCached(false, i);
}
for (int i = 500; i <= 506; ++i) {
assertCached(false, i);
}
}
/**
* Response code 407 should only come from proxy servers. Android's client
* throws if it is sent by an origin server.
*/
public void testOriginServerSends407() throws Exception {
server.enqueue(new MockResponse().setResponseCode(407));
server.play();
URL url = server.getUrl("/");
HttpURLConnection conn = (HttpURLConnection) url.openConnection();
try {
conn.getResponseCode();
fail();
} catch (IOException expected) {
}
}
public void test_responseCaching_410() throws Exception {
// the HTTP spec permits caching 410s, but the RI doesn't.
assertCached(true, 410);
}
private void assertCached(boolean shouldPut, int responseCode) throws Exception {
server = new MockWebServer();
MockResponse response = new MockResponse()
.addHeader("Last-Modified: " + formatDate(-1, TimeUnit.HOURS))
.addHeader("Expires: " + formatDate(1, TimeUnit.HOURS))
.setResponseCode(responseCode)
.setBody("ABCDE")
.addHeader("WWW-Authenticate: challenge");
if (responseCode == HttpURLConnection.HTTP_PROXY_AUTH) {
response.addHeader("Proxy-Authenticate: Basic realm=\"protected area\"");
} else if (responseCode == HttpURLConnection.HTTP_UNAUTHORIZED) {
response.addHeader("WWW-Authenticate: Basic realm=\"protected area\"");
}
server.enqueue(response);
server.play();
URL url = server.getUrl("/");
HttpURLConnection conn = (HttpURLConnection) url.openConnection();
assertEquals(responseCode, conn.getResponseCode());
// exhaust the content stream
readAscii(conn);
CacheResponse cached = cache.get(url.toURI(), "GET",
Collections.<String, List<String>>emptyMap());
if (shouldPut) {
assertNotNull(Integer.toString(responseCode), cached);
cached.getBody().close();
} else {
assertNull(Integer.toString(responseCode), cached);
}
server.shutdown(); // tearDown() isn't sufficient; this test starts multiple servers
}
/**
* Test that we can interrogate the response when the cache is being
* populated. http://code.google.com/p/android/issues/detail?id=7787
*/
public void testResponseCacheCallbackApis() throws Exception {
final String body = "ABCDE";
final AtomicInteger cacheCount = new AtomicInteger();
server.enqueue(new MockResponse()
.setStatus("HTTP/1.1 200 Fantastic")
.addHeader("fgh: ijk")
.setBody(body));
server.play();
ResponseCache.setDefault(new ResponseCache() {
@Override public CacheResponse get(URI uri, String requestMethod,
Map<String, List<String>> requestHeaders) throws IOException {
return null;
}
@Override public CacheRequest put(URI uri, URLConnection conn) throws IOException {
HttpURLConnection httpConnection = (HttpURLConnection) conn;
try {
httpConnection.getRequestProperties();
fail();
} catch (IllegalStateException expected) {
}
try {
httpConnection.addRequestProperty("K", "V");
fail();
} catch (IllegalStateException expected) {
}
assertEquals("HTTP/1.1 200 Fantastic", httpConnection.getHeaderField(null));
assertEquals(Arrays.asList("HTTP/1.1 200 Fantastic"),
httpConnection.getHeaderFields().get(null));
assertEquals(200, httpConnection.getResponseCode());
assertEquals("Fantastic", httpConnection.getResponseMessage());
assertEquals(body.length(), httpConnection.getContentLength());
assertEquals("ijk", httpConnection.getHeaderField("fgh"));
try {
httpConnection.getInputStream(); // the RI doesn't forbid this, but it should
fail();
} catch (IOException expected) {
}
cacheCount.incrementAndGet();
return null;
}
});
URL url = server.getUrl("/");
URLConnection connection = url.openConnection();
assertEquals(body, readAscii(connection));
assertEquals(1, cacheCount.get());
}
public void testResponseCachingAndInputStreamSkipWithFixedLength() throws IOException {
testResponseCaching(TransferKind.FIXED_LENGTH);
}
public void testResponseCachingAndInputStreamSkipWithChunkedEncoding() throws IOException {
testResponseCaching(TransferKind.CHUNKED);
}
public void testResponseCachingAndInputStreamSkipWithNoLengthHeaders() throws IOException {
testResponseCaching(TransferKind.END_OF_STREAM);
}
/**
* HttpURLConnection.getInputStream().skip(long) causes ResponseCache corruption
* http://code.google.com/p/android/issues/detail?id=8175
*/
private void testResponseCaching(TransferKind transferKind) throws IOException {
MockResponse response = new MockResponse()
.addHeader("Last-Modified: " + formatDate(-1, TimeUnit.HOURS))
.addHeader("Expires: " + formatDate(1, TimeUnit.HOURS))
.setStatus("HTTP/1.1 200 Fantastic");
transferKind.setBody(response, "I love puppies but hate spiders", 1);
server.enqueue(response);
server.play();
// Make sure that calling skip() doesn't omit bytes from the cache.
HttpURLConnection urlConnection = (HttpURLConnection) server.getUrl("/").openConnection();
InputStream in = urlConnection.getInputStream();
assertEquals("I love ", readAscii(urlConnection, "I love ".length()));
reliableSkip(in, "puppies but hate ".length());
assertEquals("spiders", readAscii(urlConnection, "spiders".length()));
assertEquals(-1, in.read());
in.close();
assertEquals(1, cache.getWriteSuccessCount());
assertEquals(0, cache.getWriteAbortCount());
urlConnection = (HttpURLConnection) server.getUrl("/").openConnection(); // cached!
in = urlConnection.getInputStream();
assertEquals("I love puppies but hate spiders",
readAscii(urlConnection, "I love puppies but hate spiders".length()));
assertEquals(200, urlConnection.getResponseCode());
assertEquals("Fantastic", urlConnection.getResponseMessage());
assertEquals(-1, in.read());
in.close();
assertEquals(1, cache.getWriteSuccessCount());
assertEquals(0, cache.getWriteAbortCount());
assertEquals(2, cache.getRequestCount());
assertEquals(1, cache.getHitCount());
}
public void testSecureResponseCaching() throws IOException {
TestSSLContext testSSLContext = TestSSLContext.create();
server.useHttps(testSSLContext.serverContext.getSocketFactory(), false);
server.enqueue(new MockResponse()
.addHeader("Last-Modified: " + formatDate(-1, TimeUnit.HOURS))
.addHeader("Expires: " + formatDate(1, TimeUnit.HOURS))
.setBody("ABC"));
server.play();
HttpsURLConnection connection = (HttpsURLConnection) server.getUrl("/").openConnection();
connection.setSSLSocketFactory(testSSLContext.clientContext.getSocketFactory());
assertEquals("ABC", readAscii(connection));
// OpenJDK 6 fails on this line, complaining that the connection isn't open yet
String suite = connection.getCipherSuite();
List<Certificate> localCerts = toListOrNull(connection.getLocalCertificates());
List<Certificate> serverCerts = toListOrNull(connection.getServerCertificates());
Principal peerPrincipal = connection.getPeerPrincipal();
Principal localPrincipal = connection.getLocalPrincipal();
connection = (HttpsURLConnection) server.getUrl("/").openConnection(); // cached!
connection.setSSLSocketFactory(testSSLContext.clientContext.getSocketFactory());
assertEquals("ABC", readAscii(connection));
assertEquals(2, cache.getRequestCount());
assertEquals(1, cache.getNetworkCount());
assertEquals(1, cache.getHitCount());
assertEquals(suite, connection.getCipherSuite());
assertEquals(localCerts, toListOrNull(connection.getLocalCertificates()));
assertEquals(serverCerts, toListOrNull(connection.getServerCertificates()));
assertEquals(peerPrincipal, connection.getPeerPrincipal());
assertEquals(localPrincipal, connection.getLocalPrincipal());
}
public void testCacheReturnsInsecureResponseForSecureRequest() throws IOException {
TestSSLContext testSSLContext = TestSSLContext.create();
server.useHttps(testSSLContext.serverContext.getSocketFactory(), false);
server.enqueue(new MockResponse().setBody("ABC"));
server.enqueue(new MockResponse().setBody("DEF"));
server.play();
ResponseCache.setDefault(new InsecureResponseCache());
HttpsURLConnection connection = (HttpsURLConnection) server.getUrl("/").openConnection();
connection.setSSLSocketFactory(testSSLContext.clientContext.getSocketFactory());
assertEquals("ABC", readAscii(connection));
connection = (HttpsURLConnection) server.getUrl("/").openConnection(); // not cached!
connection.setSSLSocketFactory(testSSLContext.clientContext.getSocketFactory());
assertEquals("DEF", readAscii(connection));
}
public void testResponseCachingAndRedirects() throws Exception {
server.enqueue(new MockResponse()
.addHeader("Last-Modified: " + formatDate(-1, TimeUnit.HOURS))
.addHeader("Expires: " + formatDate(1, TimeUnit.HOURS))
.setResponseCode(HttpURLConnection.HTTP_MOVED_PERM)
.addHeader("Location: /foo"));
server.enqueue(new MockResponse()
.addHeader("Last-Modified: " + formatDate(-1, TimeUnit.HOURS))
.addHeader("Expires: " + formatDate(1, TimeUnit.HOURS))
.setBody("ABC"));
server.enqueue(new MockResponse().setBody("DEF"));
server.play();
URLConnection connection = server.getUrl("/").openConnection();
assertEquals("ABC", readAscii(connection));
connection = server.getUrl("/").openConnection(); // cached!
assertEquals("ABC", readAscii(connection));
assertEquals(4, cache.getRequestCount()); // 2 requests + 2 redirects
assertEquals(2, cache.getNetworkCount());
assertEquals(2, cache.getHitCount());
}
public void testRedirectToCachedResult() throws Exception {
server.enqueue(new MockResponse()
.addHeader("Cache-Control: max-age=60")
.setBody("ABC"));
server.enqueue(new MockResponse()
.setResponseCode(HttpURLConnection.HTTP_MOVED_PERM)
.addHeader("Location: /foo"));
server.enqueue(new MockResponse().setBody("DEF"));
server.play();
assertEquals("ABC", readAscii(server.getUrl("/foo").openConnection()));
RecordedRequest request1 = server.takeRequest();
assertEquals("GET /foo HTTP/1.1", request1.getRequestLine());
assertEquals(0, request1.getSequenceNumber());
assertEquals("ABC", readAscii(server.getUrl("/bar").openConnection()));
RecordedRequest request2 = server.takeRequest();
assertEquals("GET /bar HTTP/1.1", request2.getRequestLine());
assertEquals(1, request2.getSequenceNumber());
// an unrelated request should reuse the pooled connection
assertEquals("DEF", readAscii(server.getUrl("/baz").openConnection()));
RecordedRequest request3 = server.takeRequest();
assertEquals("GET /baz HTTP/1.1", request3.getRequestLine());
assertEquals(2, request3.getSequenceNumber());
}
public void testSecureResponseCachingAndRedirects() throws IOException {
TestSSLContext testSSLContext = TestSSLContext.create();
server.useHttps(testSSLContext.serverContext.getSocketFactory(), false);
server.enqueue(new MockResponse()
.addHeader("Last-Modified: " + formatDate(-1, TimeUnit.HOURS))
.addHeader("Expires: " + formatDate(1, TimeUnit.HOURS))
.setResponseCode(HttpURLConnection.HTTP_MOVED_PERM)
.addHeader("Location: /foo"));
server.enqueue(new MockResponse()
.addHeader("Last-Modified: " + formatDate(-1, TimeUnit.HOURS))
.addHeader("Expires: " + formatDate(1, TimeUnit.HOURS))
.setBody("ABC"));
server.enqueue(new MockResponse().setBody("DEF"));
server.play();
HttpsURLConnection connection = (HttpsURLConnection) server.getUrl("/").openConnection();
connection.setSSLSocketFactory(testSSLContext.clientContext.getSocketFactory());
assertEquals("ABC", readAscii(connection));
connection = (HttpsURLConnection) server.getUrl("/").openConnection(); // cached!
connection.setSSLSocketFactory(testSSLContext.clientContext.getSocketFactory());
assertEquals("ABC", readAscii(connection));
assertEquals(4, cache.getRequestCount()); // 2 direct + 2 redirect = 4
assertEquals(2, cache.getHitCount());
}
public void testResponseCacheRequestHeaders() throws IOException, URISyntaxException {
server.enqueue(new MockResponse().setBody("ABC"));
server.play();
final AtomicReference<Map<String, List<String>>> requestHeadersRef
= new AtomicReference<Map<String, List<String>>>();
ResponseCache.setDefault(new ResponseCache() {
@Override public CacheResponse get(URI uri, String requestMethod,
Map<String, List<String>> requestHeaders) throws IOException {
requestHeadersRef.set(requestHeaders);
return null;
}
@Override public CacheRequest put(URI uri, URLConnection conn) throws IOException {
return null;
}
});
URL url = server.getUrl("/");
URLConnection urlConnection = url.openConnection();
urlConnection.addRequestProperty("A", "android");
readAscii(urlConnection);
assertEquals(Arrays.asList("android"), requestHeadersRef.get().get("A"));
}
public void testServerDisconnectsPrematurelyWithContentLengthHeader() throws IOException {
testServerPrematureDisconnect(TransferKind.FIXED_LENGTH);
}
public void testServerDisconnectsPrematurelyWithChunkedEncoding() throws IOException {
testServerPrematureDisconnect(TransferKind.CHUNKED);
}
public void testServerDisconnectsPrematurelyWithNoLengthHeaders() throws IOException {
/*
* Intentionally empty. This case doesn't make sense because there's no
* such thing as a premature disconnect when the disconnect itself
* indicates the end of the data stream.
*/
}
private void testServerPrematureDisconnect(TransferKind transferKind) throws IOException {
MockResponse response = new MockResponse();
transferKind.setBody(response, "ABCDE\nFGHIJKLMNOPQRSTUVWXYZ", 16);
server.enqueue(truncateViolently(response, 16));
server.enqueue(new MockResponse().setBody("Request #2"));
server.play();
BufferedReader reader = new BufferedReader(new InputStreamReader(
server.getUrl("/").openConnection().getInputStream()));
assertEquals("ABCDE", reader.readLine());
try {
reader.readLine();
fail("This implementation silently ignored a truncated HTTP body.");
} catch (IOException expected) {
} finally {
reader.close();
}
assertEquals(1, cache.getWriteAbortCount());
assertEquals(0, cache.getWriteSuccessCount());
URLConnection connection = server.getUrl("/").openConnection();
assertEquals("Request #2", readAscii(connection));
assertEquals(1, cache.getWriteAbortCount());
assertEquals(1, cache.getWriteSuccessCount());
}
public void testClientPrematureDisconnectWithContentLengthHeader() throws IOException {
testClientPrematureDisconnect(TransferKind.FIXED_LENGTH);
}
public void testClientPrematureDisconnectWithChunkedEncoding() throws IOException {
testClientPrematureDisconnect(TransferKind.CHUNKED);
}
public void testClientPrematureDisconnectWithNoLengthHeaders() throws IOException {
testClientPrematureDisconnect(TransferKind.END_OF_STREAM);
}
private void testClientPrematureDisconnect(TransferKind transferKind) throws IOException {
MockResponse response = new MockResponse();
transferKind.setBody(response, "ABCDE\nFGHIJKLMNOPQRSTUVWXYZ", 1024);
server.enqueue(response);
server.enqueue(new MockResponse().setBody("Request #2"));
server.play();
URLConnection connection = server.getUrl("/").openConnection();
InputStream in = connection.getInputStream();
assertEquals("ABCDE", readAscii(connection, 5));
in.close();
try {
in.read();
fail("Expected an IOException because the stream is closed.");
} catch (IOException expected) {
}
assertEquals(1, cache.getWriteAbortCount());
assertEquals(0, cache.getWriteSuccessCount());
connection = server.getUrl("/").openConnection();
assertEquals("Request #2", readAscii(connection));
assertEquals(1, cache.getWriteAbortCount());
assertEquals(1, cache.getWriteSuccessCount());
}
public void testDefaultExpirationDateFullyCachedForLessThan24Hours() throws Exception {
// last modified: 105 seconds ago
// served: 5 seconds ago
// default lifetime: (105 - 5) / 10 = 10 seconds
// expires: 10 seconds from served date = 5 seconds from now
server.enqueue(new MockResponse()
.addHeader("Last-Modified: " + formatDate(-105, TimeUnit.SECONDS))
.addHeader("Date: " + formatDate(-5, TimeUnit.SECONDS))
.setBody("A"));
server.play();
URL url = server.getUrl("/");
assertEquals("A", readAscii(url.openConnection()));
URLConnection connection = url.openConnection();
assertEquals("A", readAscii(connection));
assertNull(connection.getHeaderField("Warning"));
}
public void testDefaultExpirationDateConditionallyCached() throws Exception {
// last modified: 115 seconds ago
// served: 15 seconds ago
// default lifetime: (115 - 15) / 10 = 10 seconds
// expires: 10 seconds from served date = 5 seconds ago
String lastModifiedDate = formatDate(-115, TimeUnit.SECONDS);
RecordedRequest conditionalRequest = assertConditionallyCached(new MockResponse()
.addHeader("Last-Modified: " + lastModifiedDate)
.addHeader("Date: " + formatDate(-15, TimeUnit.SECONDS)));
List<String> headers = conditionalRequest.getHeaders();
assertTrue(headers.contains("If-Modified-Since: " + lastModifiedDate));
}
public void testDefaultExpirationDateFullyCachedForMoreThan24Hours() throws Exception {
// last modified: 105 days ago
// served: 5 days ago
// default lifetime: (105 - 5) / 10 = 10 days
// expires: 10 days from served date = 5 days from now
server.enqueue(new MockResponse()
.addHeader("Last-Modified: " + formatDate(-105, TimeUnit.DAYS))
.addHeader("Date: " + formatDate(-5, TimeUnit.DAYS))
.setBody("A"));
server.play();
assertEquals("A", readAscii(server.getUrl("/").openConnection()));
URLConnection connection = server.getUrl("/").openConnection();
assertEquals("A", readAscii(connection));
assertEquals("113 HttpURLConnection \"Heuristic expiration\"",
connection.getHeaderField("Warning"));
}
public void testNoDefaultExpirationForUrlsWithQueryString() throws Exception {
server.enqueue(new MockResponse()
.addHeader("Last-Modified: " + formatDate(-105, TimeUnit.SECONDS))
.addHeader("Date: " + formatDate(-5, TimeUnit.SECONDS))
.setBody("A"));
server.enqueue(new MockResponse().setBody("B"));
server.play();
URL url = server.getUrl("/?foo=bar");
assertEquals("A", readAscii(url.openConnection()));
assertEquals("B", readAscii(url.openConnection()));
}
public void testExpirationDateInThePastWithLastModifiedHeader() throws Exception {
String lastModifiedDate = formatDate(-2, TimeUnit.HOURS);
RecordedRequest conditionalRequest = assertConditionallyCached(new MockResponse()
.addHeader("Last-Modified: " + lastModifiedDate)
.addHeader("Expires: " + formatDate(-1, TimeUnit.HOURS)));
List<String> headers = conditionalRequest.getHeaders();
assertTrue(headers.contains("If-Modified-Since: " + lastModifiedDate));
}
public void testExpirationDateInThePastWithNoLastModifiedHeader() throws Exception {
assertNotCached(new MockResponse()
.addHeader("Expires: " + formatDate(-1, TimeUnit.HOURS)));
}
public void testExpirationDateInTheFuture() throws Exception {
assertFullyCached(new MockResponse()
.addHeader("Expires: " + formatDate(1, TimeUnit.HOURS)));
}
public void testMaxAgePreferredWithMaxAgeAndExpires() throws Exception {
assertFullyCached(new MockResponse()
.addHeader("Date: " + formatDate(0, TimeUnit.HOURS))
.addHeader("Expires: " + formatDate(-1, TimeUnit.HOURS))
.addHeader("Cache-Control: max-age=60"));
}
public void testMaxAgeInThePastWithDateAndLastModifiedHeaders() throws Exception {
String lastModifiedDate = formatDate(-2, TimeUnit.HOURS);
RecordedRequest conditionalRequest = assertConditionallyCached(new MockResponse()
.addHeader("Date: " + formatDate(-120, TimeUnit.SECONDS))
.addHeader("Last-Modified: " + lastModifiedDate)
.addHeader("Cache-Control: max-age=60"));
List<String> headers = conditionalRequest.getHeaders();
assertTrue(headers.contains("If-Modified-Since: " + lastModifiedDate));
}
public void testMaxAgeInThePastWithDateHeaderButNoLastModifiedHeader() throws Exception {
/*
* Chrome interprets max-age relative to the local clock. Both our cache
* and Firefox both use the earlier of the local and server's clock.
*/
assertNotCached(new MockResponse()
.addHeader("Date: " + formatDate(-120, TimeUnit.SECONDS))
.addHeader("Cache-Control: max-age=60"));
}
public void testMaxAgeInTheFutureWithDateHeader() throws Exception {
assertFullyCached(new MockResponse()
.addHeader("Date: " + formatDate(0, TimeUnit.HOURS))
.addHeader("Cache-Control: max-age=60"));
}
public void testMaxAgeInTheFutureWithNoDateHeader() throws Exception {
assertFullyCached(new MockResponse()
.addHeader("Cache-Control: max-age=60"));
}
public void testMaxAgeWithLastModifiedButNoServedDate() throws Exception {
assertFullyCached(new MockResponse()
.addHeader("Last-Modified: " + formatDate(-120, TimeUnit.SECONDS))
.addHeader("Cache-Control: max-age=60"));
}
public void testMaxAgeInTheFutureWithDateAndLastModifiedHeaders() throws Exception {
assertFullyCached(new MockResponse()
.addHeader("Last-Modified: " + formatDate(-120, TimeUnit.SECONDS))
.addHeader("Date: " + formatDate(0, TimeUnit.SECONDS))
.addHeader("Cache-Control: max-age=60"));
}
public void testMaxAgePreferredOverLowerSharedMaxAge() throws Exception {
assertFullyCached(new MockResponse()
.addHeader("Date: " + formatDate(-2, TimeUnit.MINUTES))
.addHeader("Cache-Control: s-maxage=60")
.addHeader("Cache-Control: max-age=180"));
}
public void testMaxAgePreferredOverHigherMaxAge() throws Exception {
assertNotCached(new MockResponse()
.addHeader("Date: " + formatDate(-2, TimeUnit.MINUTES))
.addHeader("Cache-Control: s-maxage=180")
.addHeader("Cache-Control: max-age=60"));
}
public void testRequestMethodOptionsIsNotCached() throws Exception {
testRequestMethod("OPTIONS", false);
}
public void testRequestMethodGetIsCached() throws Exception {
testRequestMethod("GET", true);
}
public void testRequestMethodHeadIsNotCached() throws Exception {
// We could support this but choose not to for implementation simplicity
testRequestMethod("HEAD", false);
}
public void testRequestMethodPostIsNotCached() throws Exception {
// We could support this but choose not to for implementation simplicity
testRequestMethod("POST", false);
}
public void testRequestMethodPutIsNotCached() throws Exception {
testRequestMethod("PUT", false);
}
public void testRequestMethodDeleteIsNotCached() throws Exception {
testRequestMethod("DELETE", false);
}
public void testRequestMethodTraceIsNotCached() throws Exception {
testRequestMethod("TRACE", false);
}
private void testRequestMethod(String requestMethod, boolean expectCached) throws Exception {
/*
* 1. seed the cache (potentially)
* 2. expect a cache hit or miss
*/
server.enqueue(new MockResponse()
.addHeader("Expires: " + formatDate(1, TimeUnit.HOURS))
.addHeader("X-Response-ID: 1"));
server.enqueue(new MockResponse()
.addHeader("X-Response-ID: 2"));
server.play();
URL url = server.getUrl("/");
HttpURLConnection request1 = (HttpURLConnection) url.openConnection();
request1.setRequestMethod(requestMethod);
addRequestBodyIfNecessary(requestMethod, request1);
assertEquals("1", request1.getHeaderField("X-Response-ID"));
URLConnection request2 = url.openConnection();
if (expectCached) {
assertEquals("1", request1.getHeaderField("X-Response-ID"));
} else {
assertEquals("2", request2.getHeaderField("X-Response-ID"));
}
}
public void testPostInvalidatesCache() throws Exception {
testMethodInvalidates("POST");
}
public void testPutInvalidatesCache() throws Exception {
testMethodInvalidates("PUT");
}
public void testDeleteMethodInvalidatesCache() throws Exception {
testMethodInvalidates("DELETE");
}
private void testMethodInvalidates(String requestMethod) throws Exception {
/*
* 1. seed the cache
* 2. invalidate it
* 3. expect a cache miss
*/
server.enqueue(new MockResponse().setBody("A")
.addHeader("Expires: " + formatDate(1, TimeUnit.HOURS)));
server.enqueue(new MockResponse().setBody("B"));
server.enqueue(new MockResponse().setBody("C"));
server.play();
URL url = server.getUrl("/");
assertEquals("A", readAscii(url.openConnection()));
HttpURLConnection invalidate = (HttpURLConnection) url.openConnection();
invalidate.setRequestMethod(requestMethod);
addRequestBodyIfNecessary(requestMethod, invalidate);
assertEquals("B", readAscii(invalidate));
assertEquals("C", readAscii(url.openConnection()));
}
public void testEtag() throws Exception {
RecordedRequest conditionalRequest = assertConditionallyCached(new MockResponse()
.addHeader("ETag: v1"));
assertTrue(conditionalRequest.getHeaders().contains("If-None-Match: v1"));
}
public void testEtagAndExpirationDateInThePast() throws Exception {
String lastModifiedDate = formatDate(-2, TimeUnit.HOURS);
RecordedRequest conditionalRequest = assertConditionallyCached(new MockResponse()
.addHeader("ETag: v1")
.addHeader("Last-Modified: " + lastModifiedDate)
.addHeader("Expires: " + formatDate(-1, TimeUnit.HOURS)));
List<String> headers = conditionalRequest.getHeaders();
assertTrue(headers.contains("If-None-Match: v1"));
assertTrue(headers.contains("If-Modified-Since: " + lastModifiedDate));
}
public void testEtagAndExpirationDateInTheFuture() throws Exception {
assertFullyCached(new MockResponse()
.addHeader("ETag: v1")
.addHeader("Last-Modified: " + formatDate(-2, TimeUnit.HOURS))
.addHeader("Expires: " + formatDate(1, TimeUnit.HOURS)));
}
public void testCacheControlNoCache() throws Exception {
assertNotCached(new MockResponse().addHeader("Cache-Control: no-cache"));
}
public void testCacheControlNoCacheAndExpirationDateInTheFuture() throws Exception {
String lastModifiedDate = formatDate(-2, TimeUnit.HOURS);
RecordedRequest conditionalRequest = assertConditionallyCached(new MockResponse()
.addHeader("Last-Modified: " + lastModifiedDate)
.addHeader("Expires: " + formatDate(1, TimeUnit.HOURS))
.addHeader("Cache-Control: no-cache"));
List<String> headers = conditionalRequest.getHeaders();
assertTrue(headers.contains("If-Modified-Since: " + lastModifiedDate));
}
public void testPragmaNoCache() throws Exception {
assertNotCached(new MockResponse().addHeader("Pragma: no-cache"));
}
public void testPragmaNoCacheAndExpirationDateInTheFuture() throws Exception {
String lastModifiedDate = formatDate(-2, TimeUnit.HOURS);
RecordedRequest conditionalRequest = assertConditionallyCached(new MockResponse()
.addHeader("Last-Modified: " + lastModifiedDate)
.addHeader("Expires: " + formatDate(1, TimeUnit.HOURS))
.addHeader("Pragma: no-cache"));
List<String> headers = conditionalRequest.getHeaders();
assertTrue(headers.contains("If-Modified-Since: " + lastModifiedDate));
}
public void testCacheControlNoStore() throws Exception {
assertNotCached(new MockResponse().addHeader("Cache-Control: no-store"));
}
public void testCacheControlNoStoreAndExpirationDateInTheFuture() throws Exception {
assertNotCached(new MockResponse()
.addHeader("Last-Modified: " + formatDate(-2, TimeUnit.HOURS))
.addHeader("Expires: " + formatDate(1, TimeUnit.HOURS))
.addHeader("Cache-Control: no-store"));
}
public void testPartialRangeResponsesDoNotCorruptCache() throws Exception {
/*
* 1. request a range
* 2. request a full document, expecting a cache miss
*/
server.enqueue(new MockResponse().setBody("AA")
.setResponseCode(HttpURLConnection.HTTP_PARTIAL)
.addHeader("Expires: " + formatDate(1, TimeUnit.HOURS))
.addHeader("Content-Range: bytes 1000-1001/2000"));
server.enqueue(new MockResponse().setBody("BB"));
server.play();
URL url = server.getUrl("/");
URLConnection range = url.openConnection();
range.addRequestProperty("Range", "bytes=1000-1001");
assertEquals("AA", readAscii(range));
assertEquals("BB", readAscii(url.openConnection()));
}
public void testServerReturnsDocumentOlderThanCache() throws Exception {
server.enqueue(new MockResponse().setBody("A")
.addHeader("Last-Modified: " + formatDate(-2, TimeUnit.HOURS))
.addHeader("Expires: " + formatDate(-1, TimeUnit.HOURS)));
server.enqueue(new MockResponse().setBody("B")
.addHeader("Last-Modified: " + formatDate(-4, TimeUnit.HOURS)));
server.play();
URL url = server.getUrl("/");
assertEquals("A", readAscii(url.openConnection()));
assertEquals("A", readAscii(url.openConnection()));
}
public void testNonIdentityEncodingAndConditionalCache() throws Exception {
assertNonIdentityEncodingCached(new MockResponse()
.addHeader("Last-Modified: " + formatDate(-2, TimeUnit.HOURS))
.addHeader("Expires: " + formatDate(-1, TimeUnit.HOURS)));
}
public void testNonIdentityEncodingAndFullCache() throws Exception {
assertNonIdentityEncodingCached(new MockResponse()
.addHeader("Last-Modified: " + formatDate(-2, TimeUnit.HOURS))
.addHeader("Expires: " + formatDate(1, TimeUnit.HOURS)));
}
private void assertNonIdentityEncodingCached(MockResponse response) throws Exception {
server.enqueue(response
.setBody(gzip("ABCABCABC".getBytes("UTF-8")))
.addHeader("Content-Encoding: gzip"));
server.enqueue(new MockResponse().setResponseCode(HttpURLConnection.HTTP_NOT_MODIFIED));
server.play();
assertEquals("ABCABCABC", readAscii(server.getUrl("/").openConnection()));
assertEquals("ABCABCABC", readAscii(server.getUrl("/").openConnection()));
}
public void testExpiresDateBeforeModifiedDate() throws Exception {
assertConditionallyCached(new MockResponse()
.addHeader("Last-Modified: " + formatDate(-1, TimeUnit.HOURS))
.addHeader("Expires: " + formatDate(-2, TimeUnit.HOURS)));
}
public void testRequestMaxAge() throws IOException {
server.enqueue(new MockResponse().setBody("A")
.addHeader("Last-Modified: " + formatDate(-2, TimeUnit.HOURS))
.addHeader("Date: " + formatDate(-1, TimeUnit.MINUTES))
.addHeader("Expires: " + formatDate(1, TimeUnit.HOURS)));
server.enqueue(new MockResponse().setBody("B"));
server.play();
assertEquals("A", readAscii(server.getUrl("/").openConnection()));
URLConnection connection = server.getUrl("/").openConnection();
connection.addRequestProperty("Cache-Control", "max-age=30");
assertEquals("B", readAscii(connection));
}
public void testRequestMinFresh() throws IOException {
server.enqueue(new MockResponse().setBody("A")
.addHeader("Cache-Control: max-age=60")
.addHeader("Date: " + formatDate(0, TimeUnit.MINUTES)));
server.enqueue(new MockResponse().setBody("B"));
server.play();
assertEquals("A", readAscii(server.getUrl("/").openConnection()));
URLConnection connection = server.getUrl("/").openConnection();
connection.addRequestProperty("Cache-Control", "min-fresh=120");
assertEquals("B", readAscii(connection));
}
public void testRequestMaxStale() throws IOException {
server.enqueue(new MockResponse().setBody("A")
.addHeader("Cache-Control: max-age=120")
.addHeader("Date: " + formatDate(-4, TimeUnit.MINUTES)));
server.enqueue(new MockResponse().setBody("B"));
server.play();
assertEquals("A", readAscii(server.getUrl("/").openConnection()));
URLConnection connection = server.getUrl("/").openConnection();
connection.addRequestProperty("Cache-Control", "max-stale=180");
assertEquals("A", readAscii(connection));
assertEquals("110 HttpURLConnection \"Response is stale\"",
connection.getHeaderField("Warning"));
}
public void testRequestMaxStaleNotHonoredWithMustRevalidate() throws IOException {
server.enqueue(new MockResponse().setBody("A")
.addHeader("Cache-Control: max-age=120, must-revalidate")
.addHeader("Date: " + formatDate(-4, TimeUnit.MINUTES)));
server.enqueue(new MockResponse().setBody("B"));
server.play();
assertEquals("A", readAscii(server.getUrl("/").openConnection()));
URLConnection connection = server.getUrl("/").openConnection();
connection.addRequestProperty("Cache-Control", "max-stale=180");
assertEquals("B", readAscii(connection));
}
public void testRequestOnlyIfCachedWithNoResponseCached() throws IOException {
// (no responses enqueued)
server.play();
HttpURLConnection connection = (HttpURLConnection) server.getUrl("/").openConnection();
connection.addRequestProperty("Cache-Control", "only-if-cached");
assertGatewayTimeout(connection);
}
public void testRequestOnlyIfCachedWithFullResponseCached() throws IOException {
server.enqueue(new MockResponse().setBody("A")
.addHeader("Cache-Control: max-age=30")
.addHeader("Date: " + formatDate(0, TimeUnit.MINUTES)));
server.play();
assertEquals("A", readAscii(server.getUrl("/").openConnection()));
URLConnection connection = server.getUrl("/").openConnection();
connection.addRequestProperty("Cache-Control", "only-if-cached");
assertEquals("A", readAscii(server.getUrl("/").openConnection()));
}
public void testRequestOnlyIfCachedWithConditionalResponseCached() throws IOException {
server.enqueue(new MockResponse().setBody("A")
.addHeader("Cache-Control: max-age=30")
.addHeader("Date: " + formatDate(-1, TimeUnit.MINUTES)));
server.play();
assertEquals("A", readAscii(server.getUrl("/").openConnection()));
HttpURLConnection connection = (HttpURLConnection) server.getUrl("/").openConnection();
connection.addRequestProperty("Cache-Control", "only-if-cached");
assertGatewayTimeout(connection);
}
public void testRequestOnlyIfCachedWithUnhelpfulResponseCached() throws IOException {
server.enqueue(new MockResponse().setBody("A"));
server.play();
assertEquals("A", readAscii(server.getUrl("/").openConnection()));
HttpURLConnection connection = (HttpURLConnection) server.getUrl("/").openConnection();
connection.addRequestProperty("Cache-Control", "only-if-cached");
assertGatewayTimeout(connection);
}
public void testRequestCacheControlNoCache() throws Exception {
server.enqueue(new MockResponse()
.addHeader("Last-Modified: " + formatDate(-120, TimeUnit.SECONDS))
.addHeader("Date: " + formatDate(0, TimeUnit.SECONDS))
.addHeader("Cache-Control: max-age=60")
.setBody("A"));
server.enqueue(new MockResponse().setBody("B"));
server.play();
URL url = server.getUrl("/");
assertEquals("A", readAscii(url.openConnection()));
URLConnection connection = url.openConnection();
connection.setRequestProperty("Cache-Control", "no-cache");
assertEquals("B", readAscii(connection));
}
public void testRequestPragmaNoCache() throws Exception {
server.enqueue(new MockResponse()
.addHeader("Last-Modified: " + formatDate(-120, TimeUnit.SECONDS))
.addHeader("Date: " + formatDate(0, TimeUnit.SECONDS))
.addHeader("Cache-Control: max-age=60")
.setBody("A"));
server.enqueue(new MockResponse().setBody("B"));
server.play();
URL url = server.getUrl("/");
assertEquals("A", readAscii(url.openConnection()));
URLConnection connection = url.openConnection();
connection.setRequestProperty("Pragma", "no-cache");
assertEquals("B", readAscii(connection));
}
public void testClientSuppliedIfModifiedSinceWithCachedResult() throws Exception {
MockResponse response = new MockResponse()
.addHeader("ETag: v3")
.addHeader("Cache-Control: max-age=0");
String ifModifiedSinceDate = formatDate(-24, TimeUnit.HOURS);
RecordedRequest request = assertClientSuppliedCondition(
response, "If-Modified-Since", ifModifiedSinceDate);
List<String> headers = request.getHeaders();
assertTrue(headers.contains("If-Modified-Since: " + ifModifiedSinceDate));
assertFalse(headers.contains("If-None-Match: v3"));
}
public void testClientSuppliedIfNoneMatchSinceWithCachedResult() throws Exception {
String lastModifiedDate = formatDate(-3, TimeUnit.MINUTES);
MockResponse response = new MockResponse()
.addHeader("Last-Modified: " + lastModifiedDate)
.addHeader("Date: " + formatDate(-2, TimeUnit.MINUTES))
.addHeader("Cache-Control: max-age=0");
RecordedRequest request = assertClientSuppliedCondition(
response, "If-None-Match", "v1");
List<String> headers = request.getHeaders();
assertTrue(headers.contains("If-None-Match: v1"));
assertFalse(headers.contains("If-Modified-Since: " + lastModifiedDate));
}
private RecordedRequest assertClientSuppliedCondition(MockResponse seed, String conditionName,
String conditionValue) throws Exception {
server.enqueue(seed.setBody("A"));
server.enqueue(new MockResponse().setResponseCode(HttpURLConnection.HTTP_NOT_MODIFIED));
server.play();
URL url = server.getUrl("/");
assertEquals("A", readAscii(url.openConnection()));
HttpURLConnection connection = (HttpURLConnection) url.openConnection();
connection.addRequestProperty(conditionName, conditionValue);
assertEquals(HttpURLConnection.HTTP_NOT_MODIFIED, connection.getResponseCode());
assertEquals("", readAscii(connection));
server.takeRequest(); // seed
return server.takeRequest();
}
public void testSetIfModifiedSince() throws Exception {
Date since = new Date();
server.enqueue(new MockResponse().setBody("A"));
server.play();
URL url = server.getUrl("/");
URLConnection connection = url.openConnection();
connection.setIfModifiedSince(since.getTime());
assertEquals("A", readAscii(connection));
RecordedRequest request = server.takeRequest();
assertTrue(request.getHeaders().contains("If-Modified-Since: " + formatDate(since)));
}
public void testClientSuppliedConditionWithoutCachedResult() throws Exception {
server.enqueue(new MockResponse()
.setResponseCode(HttpURLConnection.HTTP_NOT_MODIFIED));
server.play();
HttpURLConnection connection = (HttpURLConnection) server.getUrl("/").openConnection();
String clientIfModifiedSince = formatDate(-24, TimeUnit.HOURS);
connection.addRequestProperty("If-Modified-Since", clientIfModifiedSince);
assertEquals(HttpURLConnection.HTTP_NOT_MODIFIED, connection.getResponseCode());
assertEquals("", readAscii(connection));
}
public void testAuthorizationRequestHeaderPreventsCaching() throws Exception {
server.enqueue(new MockResponse()
.addHeader("Last-Modified: " + formatDate(-2, TimeUnit.MINUTES))
.addHeader("Cache-Control: max-age=60")
.setBody("A"));
server.enqueue(new MockResponse().setBody("B"));
server.play();
URL url = server.getUrl("/");
URLConnection connection = url.openConnection();
connection.addRequestProperty("Authorization", "password");
assertEquals("A", readAscii(connection));
assertEquals("B", readAscii(url.openConnection()));
}
public void testAuthorizationResponseCachedWithSMaxAge() throws Exception {
assertAuthorizationRequestFullyCached(new MockResponse()
.addHeader("Cache-Control: s-maxage=60"));
}
public void testAuthorizationResponseCachedWithPublic() throws Exception {
assertAuthorizationRequestFullyCached(new MockResponse()
.addHeader("Cache-Control: public"));
}
public void testAuthorizationResponseCachedWithMustRevalidate() throws Exception {
assertAuthorizationRequestFullyCached(new MockResponse()
.addHeader("Cache-Control: must-revalidate"));
}
public void assertAuthorizationRequestFullyCached(MockResponse response) throws Exception {
server.enqueue(response
.addHeader("Cache-Control: max-age=60")
.setBody("A"));
server.enqueue(new MockResponse().setBody("B"));
server.play();
URL url = server.getUrl("/");
URLConnection connection = url.openConnection();
connection.addRequestProperty("Authorization", "password");
assertEquals("A", readAscii(connection));
assertEquals("A", readAscii(url.openConnection()));
}
public void testContentLocationDoesNotPopulateCache() throws Exception {
server.enqueue(new MockResponse()
.addHeader("Cache-Control: max-age=60")
.addHeader("Content-Location: /bar")
.setBody("A"));
server.enqueue(new MockResponse().setBody("B"));
server.play();
assertEquals("A", readAscii(server.getUrl("/foo").openConnection()));
assertEquals("B", readAscii(server.getUrl("/bar").openConnection()));
}
public void testUseCachesFalseDoesNotWriteToCache() throws Exception {
server.enqueue(new MockResponse()
.addHeader("Cache-Control: max-age=60")
.setBody("A").setBody("A"));
server.enqueue(new MockResponse().setBody("B"));
server.play();
URLConnection connection = server.getUrl("/").openConnection();
connection.setUseCaches(false);
assertEquals("A", readAscii(connection));
assertEquals("B", readAscii(server.getUrl("/").openConnection()));
}
public void testUseCachesFalseDoesNotReadFromCache() throws Exception {
server.enqueue(new MockResponse()
.addHeader("Cache-Control: max-age=60")
.setBody("A").setBody("A"));
server.enqueue(new MockResponse().setBody("B"));
server.play();
assertEquals("A", readAscii(server.getUrl("/").openConnection()));
URLConnection connection = server.getUrl("/").openConnection();
connection.setUseCaches(false);
assertEquals("B", readAscii(connection));
}
public void testDefaultUseCachesSetsInitialValueOnly() throws Exception {
URL url = new URL("http://localhost/");
URLConnection c1 = url.openConnection();
URLConnection c2 = url.openConnection();
assertTrue(c1.getDefaultUseCaches());
c1.setDefaultUseCaches(false);
try {
assertTrue(c1.getUseCaches());
assertTrue(c2.getUseCaches());
URLConnection c3 = url.openConnection();
assertFalse(c3.getUseCaches());
} finally {
c1.setDefaultUseCaches(true);
}
}
public void testConnectionIsReturnedToPoolAfterConditionalSuccess() throws Exception {
server.enqueue(new MockResponse()
.addHeader("Last-Modified: " + formatDate(-1, TimeUnit.HOURS))
.addHeader("Cache-Control: max-age=0")
.setBody("A"));
server.enqueue(new MockResponse().setResponseCode(HttpURLConnection.HTTP_NOT_MODIFIED));
server.enqueue(new MockResponse().setBody("B"));
server.play();
assertEquals("A", readAscii(server.getUrl("/a").openConnection()));
assertEquals("A", readAscii(server.getUrl("/a").openConnection()));
assertEquals("B", readAscii(server.getUrl("/b").openConnection()));
assertEquals(0, server.takeRequest().getSequenceNumber());
assertEquals(1, server.takeRequest().getSequenceNumber());
assertEquals(2, server.takeRequest().getSequenceNumber());
}
public void testStatisticsConditionalCacheMiss() throws Exception {
server.enqueue(new MockResponse()
.addHeader("Last-Modified: " + formatDate(-1, TimeUnit.HOURS))
.addHeader("Cache-Control: max-age=0")
.setBody("A"));
server.enqueue(new MockResponse().setBody("B"));
server.enqueue(new MockResponse().setBody("C"));
server.play();
assertEquals("A", readAscii(server.getUrl("/").openConnection()));
assertEquals(1, cache.getRequestCount());
assertEquals(1, cache.getNetworkCount());
assertEquals(0, cache.getHitCount());
assertEquals("B", readAscii(server.getUrl("/").openConnection()));
assertEquals("C", readAscii(server.getUrl("/").openConnection()));
assertEquals(3, cache.getRequestCount());
assertEquals(3, cache.getNetworkCount());
assertEquals(0, cache.getHitCount());
}
public void testStatisticsConditionalCacheHit() throws Exception {
server.enqueue(new MockResponse()
.addHeader("Last-Modified: " + formatDate(-1, TimeUnit.HOURS))
.addHeader("Cache-Control: max-age=0")
.setBody("A"));
server.enqueue(new MockResponse().setResponseCode(HttpURLConnection.HTTP_NOT_MODIFIED));
server.enqueue(new MockResponse().setResponseCode(HttpURLConnection.HTTP_NOT_MODIFIED));
server.play();
assertEquals("A", readAscii(server.getUrl("/").openConnection()));
assertEquals(1, cache.getRequestCount());
assertEquals(1, cache.getNetworkCount());
assertEquals(0, cache.getHitCount());
assertEquals("A", readAscii(server.getUrl("/").openConnection()));
assertEquals("A", readAscii(server.getUrl("/").openConnection()));
assertEquals(3, cache.getRequestCount());
assertEquals(3, cache.getNetworkCount());
assertEquals(2, cache.getHitCount());
}
public void testStatisticsFullCacheHit() throws Exception {
server.enqueue(new MockResponse()
.addHeader("Cache-Control: max-age=60")
.setBody("A"));
server.play();
assertEquals("A", readAscii(server.getUrl("/").openConnection()));
assertEquals(1, cache.getRequestCount());
assertEquals(1, cache.getNetworkCount());
assertEquals(0, cache.getHitCount());
assertEquals("A", readAscii(server.getUrl("/").openConnection()));
assertEquals("A", readAscii(server.getUrl("/").openConnection()));
assertEquals(3, cache.getRequestCount());
assertEquals(1, cache.getNetworkCount());
assertEquals(2, cache.getHitCount());
}
public void testVaryMatchesChangedRequestHeaderField() throws Exception {
server.enqueue(new MockResponse()
.addHeader("Cache-Control: max-age=60")
.addHeader("Vary: Accept-Language")
.setBody("A"));
server.enqueue(new MockResponse().setBody("B"));
server.play();
URL url = server.getUrl("/");
HttpURLConnection frConnection = (HttpURLConnection) url.openConnection();
frConnection.addRequestProperty("Accept-Language", "fr-CA");
assertEquals("A", readAscii(frConnection));
HttpURLConnection enConnection = (HttpURLConnection) url.openConnection();
enConnection.addRequestProperty("Accept-Language", "en-US");
assertEquals("B", readAscii(enConnection));
}
public void testVaryMatchesUnchangedRequestHeaderField() throws Exception {
server.enqueue(new MockResponse()
.addHeader("Cache-Control: max-age=60")
.addHeader("Vary: Accept-Language")
.setBody("A"));
server.enqueue(new MockResponse().setBody("B"));
server.play();
URL url = server.getUrl("/");
URLConnection connection1 = url.openConnection();
connection1.addRequestProperty("Accept-Language", "fr-CA");
assertEquals("A", readAscii(connection1));
URLConnection connection2 = url.openConnection();
connection2.addRequestProperty("Accept-Language", "fr-CA");
assertEquals("A", readAscii(connection2));
}
public void testVaryMatchesAbsentRequestHeaderField() throws Exception {
server.enqueue(new MockResponse()
.addHeader("Cache-Control: max-age=60")
.addHeader("Vary: Foo")
.setBody("A"));
server.enqueue(new MockResponse().setBody("B"));
server.play();
assertEquals("A", readAscii(server.getUrl("/").openConnection()));
assertEquals("A", readAscii(server.getUrl("/").openConnection()));
}
public void testVaryMatchesAddedRequestHeaderField() throws Exception {
server.enqueue(new MockResponse()
.addHeader("Cache-Control: max-age=60")
.addHeader("Vary: Foo")
.setBody("A"));
server.enqueue(new MockResponse().setBody("B"));
server.play();
assertEquals("A", readAscii(server.getUrl("/").openConnection()));
URLConnection fooConnection = server.getUrl("/").openConnection();
fooConnection.addRequestProperty("Foo", "bar");
assertEquals("B", readAscii(fooConnection));
}
public void testVaryMatchesRemovedRequestHeaderField() throws Exception {
server.enqueue(new MockResponse()
.addHeader("Cache-Control: max-age=60")
.addHeader("Vary: Foo")
.setBody("A"));
server.enqueue(new MockResponse().setBody("B"));
server.play();
URLConnection fooConnection = server.getUrl("/").openConnection();
fooConnection.addRequestProperty("Foo", "bar");
assertEquals("A", readAscii(fooConnection));
assertEquals("B", readAscii(server.getUrl("/").openConnection()));
}
public void testVaryFieldsAreCaseInsensitive() throws Exception {
server.enqueue(new MockResponse()
.addHeader("Cache-Control: max-age=60")
.addHeader("Vary: ACCEPT-LANGUAGE")
.setBody("A"));
server.enqueue(new MockResponse().setBody("B"));
server.play();
URL url = server.getUrl("/");
URLConnection connection1 = url.openConnection();
connection1.addRequestProperty("Accept-Language", "fr-CA");
assertEquals("A", readAscii(connection1));
URLConnection connection2 = url.openConnection();
connection2.addRequestProperty("accept-language", "fr-CA");
assertEquals("A", readAscii(connection2));
}
public void testVaryMultipleFieldsWithMatch() throws Exception {
server.enqueue(new MockResponse()
.addHeader("Cache-Control: max-age=60")
.addHeader("Vary: Accept-Language, Accept-Charset")
.addHeader("Vary: Accept-Encoding")
.setBody("A"));
server.enqueue(new MockResponse().setBody("B"));
server.play();
URL url = server.getUrl("/");
URLConnection connection1 = url.openConnection();
connection1.addRequestProperty("Accept-Language", "fr-CA");
connection1.addRequestProperty("Accept-Charset", "UTF-8");
connection1.addRequestProperty("Accept-Encoding", "identity");
assertEquals("A", readAscii(connection1));
URLConnection connection2 = url.openConnection();
connection2.addRequestProperty("Accept-Language", "fr-CA");
connection2.addRequestProperty("Accept-Charset", "UTF-8");
connection2.addRequestProperty("Accept-Encoding", "identity");
assertEquals("A", readAscii(connection2));
}
public void testVaryMultipleFieldsWithNoMatch() throws Exception {
server.enqueue(new MockResponse()
.addHeader("Cache-Control: max-age=60")
.addHeader("Vary: Accept-Language, Accept-Charset")
.addHeader("Vary: Accept-Encoding")
.setBody("A"));
server.enqueue(new MockResponse().setBody("B"));
server.play();
URL url = server.getUrl("/");
URLConnection frConnection = url.openConnection();
frConnection.addRequestProperty("Accept-Language", "fr-CA");
frConnection.addRequestProperty("Accept-Charset", "UTF-8");
frConnection.addRequestProperty("Accept-Encoding", "identity");
assertEquals("A", readAscii(frConnection));
URLConnection enConnection = url.openConnection();
enConnection.addRequestProperty("Accept-Language", "en-CA");
enConnection.addRequestProperty("Accept-Charset", "UTF-8");
enConnection.addRequestProperty("Accept-Encoding", "identity");
assertEquals("B", readAscii(enConnection));
}
public void testVaryMultipleFieldValuesWithMatch() throws Exception {
server.enqueue(new MockResponse()
.addHeader("Cache-Control: max-age=60")
.addHeader("Vary: Accept-Language")
.setBody("A"));
server.enqueue(new MockResponse().setBody("B"));
server.play();
URL url = server.getUrl("/");
URLConnection connection1 = url.openConnection();
connection1.addRequestProperty("Accept-Language", "fr-CA, fr-FR");
connection1.addRequestProperty("Accept-Language", "en-US");
assertEquals("A", readAscii(connection1));
URLConnection connection2 = url.openConnection();
connection2.addRequestProperty("Accept-Language", "fr-CA, fr-FR");
connection2.addRequestProperty("Accept-Language", "en-US");
assertEquals("A", readAscii(connection2));
}
public void testVaryMultipleFieldValuesWithNoMatch() throws Exception {
server.enqueue(new MockResponse()
.addHeader("Cache-Control: max-age=60")
.addHeader("Vary: Accept-Language")
.setBody("A"));
server.enqueue(new MockResponse().setBody("B"));
server.play();
URL url = server.getUrl("/");
URLConnection connection1 = url.openConnection();
connection1.addRequestProperty("Accept-Language", "fr-CA, fr-FR");
connection1.addRequestProperty("Accept-Language", "en-US");
assertEquals("A", readAscii(connection1));
URLConnection connection2 = url.openConnection();
connection2.addRequestProperty("Accept-Language", "fr-CA");
connection2.addRequestProperty("Accept-Language", "en-US");
assertEquals("B", readAscii(connection2));
}
public void testVaryAsterisk() throws Exception {
server.enqueue(new MockResponse()
.addHeader("Cache-Control: max-age=60")
.addHeader("Vary: *")
.setBody("A"));
server.enqueue(new MockResponse().setBody("B"));
server.play();
assertEquals("A", readAscii(server.getUrl("/").openConnection()));
assertEquals("B", readAscii(server.getUrl("/").openConnection()));
}
public void testVaryAndHttps() throws Exception {
TestSSLContext testSSLContext = TestSSLContext.create();
server.useHttps(testSSLContext.serverContext.getSocketFactory(), false);
server.enqueue(new MockResponse()
.addHeader("Cache-Control: max-age=60")
.addHeader("Vary: Accept-Language")
.setBody("A"));
server.enqueue(new MockResponse().setBody("B"));
server.play();
URL url = server.getUrl("/");
HttpsURLConnection connection1 = (HttpsURLConnection) url.openConnection();
connection1.setSSLSocketFactory(testSSLContext.clientContext.getSocketFactory());
connection1.addRequestProperty("Accept-Language", "en-US");
assertEquals("A", readAscii(connection1));
HttpsURLConnection connection2 = (HttpsURLConnection) url.openConnection();
connection2.setSSLSocketFactory(testSSLContext.clientContext.getSocketFactory());
connection2.addRequestProperty("Accept-Language", "en-US");
assertEquals("A", readAscii(connection2));
}
public void testDiskWriteFailureCacheDegradation() throws Exception {
Deque<InvocationHandler> writeHandlers = mockOs.getHandlers("write");
int i = 0;
boolean hasMoreScenarios = true;
while (hasMoreScenarios) {
mockOs.enqueueNormal("write", i++);
mockOs.enqueueFault("write");
exercisePossiblyFaultyCache(false);
hasMoreScenarios = writeHandlers.isEmpty();
writeHandlers.clear();
}
System.out.println("Exercising the cache performs " + (i - 1) + " writes.");
}
public void testDiskReadFailureCacheDegradation() throws Exception {
Deque<InvocationHandler> readHandlers = mockOs.getHandlers("read");
int i = 0;
boolean hasMoreScenarios = true;
while (hasMoreScenarios) {
mockOs.enqueueNormal("read", i++);
mockOs.enqueueFault("read");
exercisePossiblyFaultyCache(true);
hasMoreScenarios = readHandlers.isEmpty();
readHandlers.clear();
}
System.out.println("Exercising the cache performs " + (i - 1) + " reads.");
}
public void testCachePlusCookies() throws Exception {
server.enqueue(new MockResponse()
.addHeader("Set-Cookie: a=FIRST; domain=" + server.getCookieDomain() + ";")
.addHeader("Last-Modified: " + formatDate(-1, TimeUnit.HOURS))
.addHeader("Cache-Control: max-age=0")
.setBody("A"));
server.enqueue(new MockResponse()
.addHeader("Set-Cookie: a=SECOND; domain=" + server.getCookieDomain() + ";")
.setResponseCode(HttpURLConnection.HTTP_NOT_MODIFIED));
server.play();
URL url = server.getUrl("/");
assertEquals("A", readAscii(url.openConnection()));
assertCookies(url, "a=FIRST");
assertEquals("A", readAscii(url.openConnection()));
assertCookies(url, "a=SECOND");
}
public void testGetHeadersReturnsNetworkEndToEndHeaders() throws Exception {
server.enqueue(new MockResponse()
.addHeader("Allow: GET, HEAD")
.addHeader("Last-Modified: " + formatDate(-1, TimeUnit.HOURS))
.addHeader("Cache-Control: max-age=0")
.setBody("A"));
server.enqueue(new MockResponse()
.addHeader("Allow: GET, HEAD, PUT")
.setResponseCode(HttpURLConnection.HTTP_NOT_MODIFIED));
server.play();
URLConnection connection1 = server.getUrl("/").openConnection();
assertEquals("A", readAscii(connection1));
assertEquals("GET, HEAD", connection1.getHeaderField("Allow"));
URLConnection connection2 = server.getUrl("/").openConnection();
assertEquals("A", readAscii(connection2));
assertEquals("GET, HEAD, PUT", connection2.getHeaderField("Allow"));
}
public void testGetHeadersReturnsCachedHopByHopHeaders() throws Exception {
server.enqueue(new MockResponse()
.addHeader("Transfer-Encoding: identity")
.addHeader("Last-Modified: " + formatDate(-1, TimeUnit.HOURS))
.addHeader("Cache-Control: max-age=0")
.setBody("A"));
server.enqueue(new MockResponse()
.addHeader("Transfer-Encoding: none")
.setResponseCode(HttpURLConnection.HTTP_NOT_MODIFIED));
server.play();
URLConnection connection1 = server.getUrl("/").openConnection();
assertEquals("A", readAscii(connection1));
assertEquals("identity", connection1.getHeaderField("Transfer-Encoding"));
URLConnection connection2 = server.getUrl("/").openConnection();
assertEquals("A", readAscii(connection2));
assertEquals("identity", connection2.getHeaderField("Transfer-Encoding"));
}
public void testGetHeadersDeletesCached100LevelWarnings() throws Exception {
server.enqueue(new MockResponse()
.addHeader("Warning: 199 test danger")
.addHeader("Last-Modified: " + formatDate(-1, TimeUnit.HOURS))
.addHeader("Cache-Control: max-age=0")
.setBody("A"));
server.enqueue(new MockResponse()
.setResponseCode(HttpURLConnection.HTTP_NOT_MODIFIED));
server.play();
URLConnection connection1 = server.getUrl("/").openConnection();
assertEquals("A", readAscii(connection1));
assertEquals("199 test danger", connection1.getHeaderField("Warning"));
URLConnection connection2 = server.getUrl("/").openConnection();
assertEquals("A", readAscii(connection2));
assertEquals(null, connection2.getHeaderField("Warning"));
}
public void testGetHeadersRetainsCached200LevelWarnings() throws Exception {
server.enqueue(new MockResponse()
.addHeader("Warning: 299 test danger")
.addHeader("Last-Modified: " + formatDate(-1, TimeUnit.HOURS))
.addHeader("Cache-Control: max-age=0")
.setBody("A"));
server.enqueue(new MockResponse()
.setResponseCode(HttpURLConnection.HTTP_NOT_MODIFIED));
server.play();
URLConnection connection1 = server.getUrl("/").openConnection();
assertEquals("A", readAscii(connection1));
assertEquals("299 test danger", connection1.getHeaderField("Warning"));
URLConnection connection2 = server.getUrl("/").openConnection();
assertEquals("A", readAscii(connection2));
assertEquals("299 test danger", connection2.getHeaderField("Warning"));
}
public void assertCookies(URL url, String... expectedCookies) throws Exception {
List<String> actualCookies = new ArrayList<String>();
for (HttpCookie cookie : cookieManager.getCookieStore().get(url.toURI())) {
actualCookies.add(cookie.toString());
}
assertEquals(Arrays.asList(expectedCookies), actualCookies);
}
public void testCachePlusRange() throws Exception {
assertNotCached(new MockResponse()
.setResponseCode(HttpURLConnection.HTTP_PARTIAL)
.addHeader("Date: " + formatDate(0, TimeUnit.HOURS))
.addHeader("Content-Range: bytes 100-100/200")
.addHeader("Cache-Control: max-age=60"));
}
public void testConditionalHitUpdatesCache() throws Exception {
server.enqueue(new MockResponse()
.addHeader("Last-Modified: " + formatDate(0, TimeUnit.SECONDS))
.addHeader("Cache-Control: max-age=0")
.setBody("A"));
server.enqueue(new MockResponse()
.addHeader("Cache-Control: max-age=30")
.addHeader("Allow: GET, HEAD")
.setResponseCode(HttpURLConnection.HTTP_NOT_MODIFIED));
server.enqueue(new MockResponse().setBody("B"));
server.play();
// cache miss; seed the cache
HttpURLConnection connection1 = (HttpURLConnection) server.getUrl("/a").openConnection();
assertEquals("A", readAscii(connection1));
assertEquals(null, connection1.getHeaderField("Allow"));
// conditional cache hit; update the cache
HttpURLConnection connection2 = (HttpURLConnection) server.getUrl("/a").openConnection();
assertEquals(HttpURLConnection.HTTP_OK, connection2.getResponseCode());
assertEquals("A", readAscii(connection2));
assertEquals("GET, HEAD", connection2.getHeaderField("Allow"));
// full cache hit
HttpURLConnection connection3 = (HttpURLConnection) server.getUrl("/a").openConnection();
assertEquals("A", readAscii(connection3));
assertEquals("GET, HEAD", connection3.getHeaderField("Allow"));
assertEquals(2, server.getRequestCount());
}
/**
* @param delta the offset from the current date to use. Negative
* values yield dates in the past; positive values yield dates in the
* future.
*/
private String formatDate(long delta, TimeUnit timeUnit) {
return formatDate(new Date(System.currentTimeMillis() + timeUnit.toMillis(delta)));
}
private String formatDate(Date date) {
DateFormat rfc1123 = new SimpleDateFormat("EEE, dd MMM yyyy HH:mm:ss zzz", Locale.US);
rfc1123.setTimeZone(TimeZone.getTimeZone("UTC"));
return rfc1123.format(date);
}
private void addRequestBodyIfNecessary(String requestMethod, HttpURLConnection invalidate)
throws IOException {
if (requestMethod.equals("POST") || requestMethod.equals("PUT")) {
invalidate.setDoOutput(true);
OutputStream requestBody = invalidate.getOutputStream();
requestBody.write('x');
requestBody.close();
}
}
private void assertNotCached(MockResponse response) throws Exception {
server.enqueue(response.setBody("A"));
server.enqueue(new MockResponse().setBody("B"));
server.play();
URL url = server.getUrl("/");
assertEquals("A", readAscii(url.openConnection()));
assertEquals("B", readAscii(url.openConnection()));
}
private void exercisePossiblyFaultyCache(boolean permitReadBodyFailures) throws Exception {
server.shutdown();
server = new MockWebServer();
server.enqueue(new MockResponse()
.addHeader("Cache-Control: max-age=60")
.setBody("A"));
server.enqueue(new MockResponse().setBody("B"));
server.play();
URL url = server.getUrl("/" + UUID.randomUUID());
assertEquals("A", readAscii(url.openConnection()));
URLConnection connection = url.openConnection();
InputStream in = connection.getInputStream();
try {
int bodyChar = in.read();
assertTrue(bodyChar == 'A' || bodyChar == 'B');
assertEquals(-1, in.read());
} catch (IOException e) {
if (!permitReadBodyFailures) {
throw e;
}
}
}
/**
* @return the request with the conditional get headers.
*/
private RecordedRequest assertConditionallyCached(MockResponse response) throws Exception {
// scenario 1: condition succeeds
server.enqueue(response.setBody("A").setStatus("HTTP/1.1 200 A-OK"));
server.enqueue(new MockResponse().setResponseCode(HttpURLConnection.HTTP_NOT_MODIFIED));
// scenario 2: condition fails
server.enqueue(response.setBody("B").setStatus("HTTP/1.1 200 B-OK"));
server.enqueue(new MockResponse().setStatus("HTTP/1.1 200 C-OK").setBody("C"));
server.play();
URL valid = server.getUrl("/valid");
HttpURLConnection connection1 = (HttpURLConnection) valid.openConnection();
assertEquals("A", readAscii(connection1));
assertEquals(HttpURLConnection.HTTP_OK, connection1.getResponseCode());
assertEquals("A-OK", connection1.getResponseMessage());
HttpURLConnection connection2 = (HttpURLConnection) valid.openConnection();
assertEquals("A", readAscii(connection2));
assertEquals(HttpURLConnection.HTTP_OK, connection2.getResponseCode());
assertEquals("A-OK", connection2.getResponseMessage());
URL invalid = server.getUrl("/invalid");
HttpURLConnection connection3 = (HttpURLConnection) invalid.openConnection();
assertEquals("B", readAscii(connection3));
assertEquals(HttpURLConnection.HTTP_OK, connection3.getResponseCode());
assertEquals("B-OK", connection3.getResponseMessage());
HttpURLConnection connection4 = (HttpURLConnection) invalid.openConnection();
assertEquals("C", readAscii(connection4));
assertEquals(HttpURLConnection.HTTP_OK, connection4.getResponseCode());
assertEquals("C-OK", connection4.getResponseMessage());
server.takeRequest(); // regular get
return server.takeRequest(); // conditional get
}
private void assertFullyCached(MockResponse response) throws Exception {
server.enqueue(response.setBody("A"));
server.enqueue(response.setBody("B"));
server.play();
URL url = server.getUrl("/");
assertEquals("A", readAscii(url.openConnection()));
assertEquals("A", readAscii(url.openConnection()));
}
/**
* Shortens the body of {@code response} but not the corresponding headers.
* Only useful to test how clients respond to the premature conclusion of
* the HTTP body.
*/
private MockResponse truncateViolently(MockResponse response, int numBytesToKeep) {
response.setSocketPolicy(DISCONNECT_AT_END);
List<String> headers = new ArrayList<String>(response.getHeaders());
response.setBody(Arrays.copyOfRange(response.getBody(), 0, numBytesToKeep));
response.getHeaders().clear();
response.getHeaders().addAll(headers);
return response;
}
/**
* Reads {@code count} characters from the stream. If the stream is
* exhausted before {@code count} characters can be read, the remaining
* characters are returned and the stream is closed.
*/
private String readAscii(URLConnection connection, int count) throws IOException {
HttpURLConnection httpConnection = (HttpURLConnection) connection;
InputStream in = httpConnection.getResponseCode() < HttpURLConnection.HTTP_BAD_REQUEST
? connection.getInputStream()
: httpConnection.getErrorStream();
StringBuilder result = new StringBuilder();
for (int i = 0; i < count; i++) {
int value = in.read();
if (value == -1) {
in.close();
break;
}
result.append((char) value);
}
return result.toString();
}
private String readAscii(URLConnection connection) throws IOException {
return readAscii(connection, Integer.MAX_VALUE);
}
private void reliableSkip(InputStream in, int length) throws IOException {
while (length > 0) {
length -= in.skip(length);
}
}
private void assertGatewayTimeout(HttpURLConnection connection) throws IOException {
try {
connection.getInputStream();
fail();
} catch (FileNotFoundException expected) {
}
assertEquals(504, connection.getResponseCode());
assertEquals(-1, connection.getErrorStream().read());
}
enum TransferKind {
CHUNKED() {
@Override void setBody(MockResponse response, byte[] content, int chunkSize)
throws IOException {
response.setChunkedBody(content, chunkSize);
}
},
FIXED_LENGTH() {
@Override void setBody(MockResponse response, byte[] content, int chunkSize) {
response.setBody(content);
}
},
END_OF_STREAM() {
@Override void setBody(MockResponse response, byte[] content, int chunkSize) {
response.setBody(content);
response.setSocketPolicy(DISCONNECT_AT_END);
for (Iterator<String> h = response.getHeaders().iterator(); h.hasNext(); ) {
if (h.next().startsWith("Content-Length:")) {
h.remove();
break;
}
}
}
};
abstract void setBody(MockResponse response, byte[] content, int chunkSize)
throws IOException;
void setBody(MockResponse response, String content, int chunkSize) throws IOException {
setBody(response, content.getBytes("UTF-8"), chunkSize);
}
}
private <T> List<T> toListOrNull(T[] arrayOrNull) {
return arrayOrNull != null ? Arrays.asList(arrayOrNull) : null;
}
/**
* Returns a gzipped copy of {@code bytes}.
*/
public byte[] gzip(byte[] bytes) throws IOException {
ByteArrayOutputStream bytesOut = new ByteArrayOutputStream();
OutputStream gzippedOut = new GZIPOutputStream(bytesOut);
gzippedOut.write(bytes);
gzippedOut.close();
return bytesOut.toByteArray();
}
private class InsecureResponseCache extends ResponseCache {
@Override public CacheRequest put(URI uri, URLConnection connection) throws IOException {
return cache.put(uri, connection);
}
@Override public CacheResponse get(URI uri, String requestMethod,
Map<String, List<String>> requestHeaders) throws IOException {
final CacheResponse response = cache.get(uri, requestMethod, requestHeaders);
if (response instanceof SecureCacheResponse) {
return new CacheResponse() {
@Override public InputStream getBody() throws IOException {
return response.getBody();
}
@Override public Map<String, List<String>> getHeaders() throws IOException {
return response.getHeaders();
}
};
}
return response;
}
}
}