Apache
/
httpcomponents-client
mirror of https://github.com/apache/httpcomponents-client.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

HTTPCLIENT-427: CacheEntry made immutable 

Contributed by David Mays <david_mays at comcast.com>


git-svn-id: https://svn.apache.org/repos/asf/httpcomponents/httpclient/trunk@941886 13f79535-47bb-0310-9956-ffa450edef68
This commit is contained in:
Oleg Kalnichevski 2010-05-06 20:02:22 +00:00
parent 2b9d94af67
commit 1d1df0174d
36 changed files with 793 additions and 563 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
httpclient-cache/src/main/java/org/apache/http/client/cache/impl/BasicHttpCache.java vendored
View File

@ -31,9 +31,9 @@ import java.util.LinkedHashMap;
import java.util.Map;
import org.apache.http.annotation.ThreadSafe;
import org.apache.http.client.cache.HttpCache;
import org.apache.http.client.cache.HttpCacheOperationException;
import org.apache.http.client.cache.HttpCacheUpdateCallback;
import org.apache.http.client.cache.HttpCache;
/**
* Implements {@link HttpCache} using LinkedHashMap for backing store

142
httpclient-cache/src/main/java/org/apache/http/client/cache/impl/CacheEntry.java vendored
View File

@ -30,7 +30,6 @@ import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Date;
import java.util.HashSet;
@ -41,7 +40,7 @@ import org.apache.http.HeaderElement;
import org.apache.http.HttpRequest;
import org.apache.http.HttpResponse;
import org.apache.http.ProtocolVersion;
import org.apache.http.StatusLine;
import org.apache.http.annotation.Immutable;
import org.apache.http.impl.cookie.DateParseException;
import org.apache.http.impl.cookie.DateUtils;
import org.apache.http.message.BasicHeader;
@ -51,56 +50,73 @@ import org.apache.http.message.BasicHeader;
*
* @since 4.1
*/
@Immutable
public class CacheEntry implements Serializable {
private static final long serialVersionUID = -6300496422359477413L;
public static final long MAX_AGE = 2147483648L;
private transient Header[] responseHeaders;
private byte[] body;
private ProtocolVersion version;
private int status;
private String reason;
private Date requestDate;
private Date responseDate;
private Set<String> variantURIs = new HashSet<String>();
/**
* Default constructor
*/
public CacheEntry() {
}
private final Date requestDate;
private final Date responseDate;
private final ProtocolVersion version;
private final int status;
private final String reason;
private final CachedHeaderGroup responseHeaders = new CachedHeaderGroup();
private final byte[] body;
private final Set<String> variantURIs = new HashSet<String>();
/**
*
* @param requestDate
* Date/time when the request was made (Used for age
* Date/time when the request was made (Used for age
* calculations)
* @param responseDate
* Date/time that the response came back (Used for age
* Date/time that the response came back (Used for age
* calculations)
* @param response
* original {@link HttpResponse}
* @param version
* HTTP Response Version
* @param responseHeaders
* Header[] from original HTTP Response
* @param responseBytes
* Byte array containing the body of the response
* @throws IOException
* Does not attempt to handle IOExceptions
* Byte array containing the body of the response
* @param status
* Numeric HTTP Status Code
* @param reason
* String message from HTTP Status Line
*/
public CacheEntry(Date requestDate, Date responseDate, HttpResponse response,
byte[] responseBytes) throws IOException {
public CacheEntry(Date requestDate, Date responseDate, ProtocolVersion version, Header[] responseHeaders, byte[] responseBytes, int status, String reason){
super();
this.requestDate = requestDate;
this.responseDate = responseDate;
version = response.getProtocolVersion();
responseHeaders = response.getAllHeaders();
StatusLine sl = response.getStatusLine();
status = sl.getStatusCode();
reason = sl.getReasonPhrase();
body = responseBytes;
this.version = version;
this.responseHeaders.setHeaders(responseHeaders);
this.status = status;
this.reason = reason;
this.body = responseBytes;
}
public void setProtocolVersion(ProtocolVersion version) {
this.version = version;
/**
* Constructor used to create a copy of an existing entry, while adding another variant URI to it.
* @param toCopy CacheEntry to be duplicated
* @param variantURI URI to add
*/
private CacheEntry(CacheEntry toCopy, String variantURI){
this(toCopy.getRequestDate(),
toCopy.getResponseDate(),
toCopy.getProtocolVersion(),
toCopy.getAllHeaders(),
toCopy.getBody(),
toCopy.getStatusCode(),
toCopy.getReasonPhrase());
this.variantURIs.addAll(toCopy.getVariantURIs());
this.variantURIs.add(variantURI);
}
public CacheEntry addVariantURI(String variantURI){
return new CacheEntry(this,variantURI);
}
public ProtocolVersion getProtocolVersion() {
@ -115,61 +131,28 @@ public class CacheEntry implements Serializable {
return this.status;
}
public void setRequestDate(Date requestDate) {
this.requestDate = requestDate;
}
public Date getRequestDate() {
return requestDate;
}
public void setResponseDate(Date responseDate) {
this.responseDate = responseDate;
}
public Date getResponseDate() {
return this.responseDate;
}
public void setBody(byte[] body) {
this.body = body;
}
public byte[] getBody() {
return body;
}
public Header[] getAllHeaders() {
return responseHeaders;
}
public void setResponseHeaders(Header[] responseHeaders) {
this.responseHeaders = responseHeaders;
return responseHeaders.getAllHeaders();
}
public Header getFirstHeader(String name) {
for (Header h : responseHeaders) {
if (h.getName().equals(name))
return h;
}
return null;
return responseHeaders.getFirstHeader(name);
}
public Header[] getHeaders(String name) {
ArrayList<Header> headers = new ArrayList<Header>();
for (Header h : this.responseHeaders) {
if (h.getName().equals(name))
headers.add(h);
}
Header[] headerArray = new Header[headers.size()];
headers.toArray(headerArray);
return headerArray;
return responseHeaders.getHeaders(name);
}
/**
@ -377,12 +360,14 @@ public class CacheEntry implements Serializable {
out.defaultWriteObject();
// write (non-serializable) responseHeaders
if (null == responseHeaders || responseHeaders.length < 1)
if (null == responseHeaders || responseHeaders.getAllHeaders().length < 1)
return;
String[][] sheaders = new String[responseHeaders.length][2];
for (int i = 0; i < responseHeaders.length; i++) {
sheaders[i][0] = responseHeaders[i].getName();
sheaders[i][1] = responseHeaders[i].getValue();
int headerCount = responseHeaders.getAllHeaders().length;
Header[] headers = responseHeaders.getAllHeaders();
String[][] sheaders = new String[headerCount][2];
for (int i = 0; i < headerCount; i++) {
sheaders[i][0] = headers[i].getName();
sheaders[i][1] = headers[i].getValue();
}
out.writeObject(sheaders);
@ -402,15 +387,12 @@ public class CacheEntry implements Serializable {
String[] sheader = sheaders[i];
headers[i] = new BasicHeader(sheader[0], sheader[1]);
}
this.responseHeaders = headers;
}
public void addVariantURI(String URI) {
this.variantURIs.add(URI);
this.responseHeaders.setHeaders(headers);
}
public Set<String> getVariantURIs() {
return Collections.unmodifiableSet(this.variantURIs);
}
}

12
httpclient-cache/src/main/java/org/apache/http/client/cache/impl/CacheEntryGenerator.java vendored
View File

@ -33,6 +33,8 @@ import org.apache.http.HttpResponse;
import org.apache.http.annotation.Immutable;
/**
* Generates a {@link CacheEntry} from a {@link HttpResponse}
*
* @since 4.1
*/
@Immutable
@ -41,7 +43,15 @@ public class CacheEntryGenerator {
public CacheEntry generateEntry(Date requestDate, Date responseDate, HttpResponse response,
byte[] responseBytes) throws IOException {
return new CacheEntry(requestDate, responseDate, response, responseBytes);
return new CacheEntry(requestDate,
responseDate,
response.getProtocolVersion(),
response.getAllHeaders(),
responseBytes,
response.getStatusLine().getStatusCode(),
response.getStatusLine().getReasonPhrase());
}
}

37
httpclient-cache/src/main/java/org/apache/http/client/cache/impl/CacheEntryUpdater.java vendored
View File

@ -39,19 +39,39 @@ import org.apache.http.impl.cookie.DateParseException;
import org.apache.http.impl.cookie.DateUtils;
/**
* Update a {@link CacheEntry} with new or updated information based on the latest
* 200 or 304 status responses from the Server. Use the {@link HttpResponse} to perform
* the update.
*
* @since 4.1
*/
@Immutable
public class CacheEntryUpdater {
public void updateCacheEntry(CacheEntry entry, Date requestDate, Date responseDate,
HttpResponse response) {
entry.setRequestDate(requestDate);
entry.setResponseDate(responseDate);
mergeHeaders(entry, response);
/**
* Update the entry with the new information from the response.
*
* @param entry The cache Entry to be updated
* @param requestDate When the request was performed
* @param responseDate When the response was gotten
* @param response The HttpResponse from the backend server call
* @return CacheEntry an updated version of the cache entry
*/
public CacheEntry updateCacheEntry(CacheEntry entry, Date requestDate, Date responseDate, HttpResponse response) {
Header[] mergedHeaders = mergeHeaders(entry, response);
CacheEntry updated = new CacheEntry(requestDate, responseDate,
entry.getProtocolVersion(),
mergedHeaders,
entry.getBody(),
entry.getStatusCode(),
entry.getReasonPhrase());
return updated;
}
protected void mergeHeaders(CacheEntry entry, HttpResponse response) {
protected Header[] mergeHeaders(CacheEntry entry, HttpResponse response) {
List<Header> cacheEntryHeaderList = new ArrayList<Header>(Arrays.asList(entry
.getAllHeaders()));
@ -60,7 +80,7 @@ public class CacheEntryUpdater {
// Don't merge Headers, keep the entries headers as they are newer.
removeCacheEntry1xxWarnings(cacheEntryHeaderList, entry);
return;
return cacheEntryHeaderList.toArray(new Header[cacheEntryHeaderList.size()]);
}
removeCacheHeadersThatMatchResponse(cacheEntryHeaderList, response);
@ -68,8 +88,7 @@ public class CacheEntryUpdater {
cacheEntryHeaderList.addAll(Arrays.asList(response.getAllHeaders()));
removeCacheEntry1xxWarnings(cacheEntryHeaderList, entry);
entry.setResponseHeaders(cacheEntryHeaderList.toArray(new Header[cacheEntryHeaderList
.size()]));
return cacheEntryHeaderList.toArray(new Header[cacheEntryHeaderList.size()]);
}
private void removeCacheHeadersThatMatchResponse(List<Header> cacheEntryHeaderList,

22
httpclient-cache/src/main/java/org/apache/http/client/cache/impl/CacheInvalidator.java vendored
View File

@ -33,8 +33,8 @@ import org.apache.http.HeaderElement;
import org.apache.http.HttpHost;
import org.apache.http.HttpRequest;
import org.apache.http.annotation.Immutable;
import org.apache.http.client.cache.HttpCacheOperationException;
import org.apache.http.client.cache.HttpCache;
import org.apache.http.client.cache.HttpCacheOperationException;
/**
* Given a particular HttpRequest, flush any cache entries that this request
@ -48,19 +48,30 @@ public class CacheInvalidator {
private final HttpCache<CacheEntry> cache;
private final URIExtractor uriExtractor;
private static final Log LOG = LogFactory.getLog(CacheInvalidator.class);
private final Log LOG = LogFactory.getLog(CacheInvalidator.class);
/**
*
* @param uriExtractor
* @param cache
*/
public CacheInvalidator(URIExtractor uriExtractor, HttpCache<CacheEntry> cache) {
this.uriExtractor = uriExtractor;
this.cache = cache;
}
/**
* Remove cache entries from the cache that are no longer fresh or
* have been invalidated in some way.
*
* @param host The backend host we are talking to
* @param req The HttpRequest to that host
*/
public void flushInvalidatedCacheEntries(HttpHost host, HttpRequest req) {
LOG.debug("CacheInvalidator: flushInvalidatedCacheEntries, BEGIN");
if (requestShouldNotBeCached(req)) {
LOG
.debug("CacheInvalidator: flushInvalidatedCacheEntries, Request should not be cached");
LOG.debug("CacheInvalidator: flushInvalidatedCacheEntries, Request should not be cached");
try {
String theUri = uriExtractor.getURI(host, req);
@ -76,6 +87,7 @@ public class CacheInvalidator {
cache.removeEntry(theUri);
}
} catch (HttpCacheOperationException coe) {
LOG.warn("Cache: Was unable to REMOVE an entry from the cache based on the uri provided.", coe);
// TODO: track failed state
}
}
@ -124,4 +136,4 @@ public class CacheInvalidator {
return false;
}
}
}

2
httpclient-cache/src/main/java/org/apache/http/client/cache/impl/CacheableRequestPolicy.java vendored
View File

@ -42,7 +42,7 @@ import org.apache.http.annotation.Immutable;
@Immutable
public class CacheableRequestPolicy {
private static final Log LOG = LogFactory.getLog(CacheableRequestPolicy.class);
private final Log LOG = LogFactory.getLog(CacheableRequestPolicy.class);
/**
* Determines if an HttpRequest can be served from the cache.

11
httpclient-cache/src/main/java/org/apache/http/client/cache/impl/CachedHeaderGroup.java vendored Normal file
View File

@ -0,0 +1,11 @@
package org.apache.http.client.cache.impl;
import java.io.Serializable;
import org.apache.http.message.HeaderGroup;
/**
*/
public class CachedHeaderGroup extends HeaderGroup implements Serializable {
private static final long serialVersionUID = -4572663568087431896L;
}

35
httpclient-cache/src/main/java/org/apache/http/client/cache/impl/CachedResponseSuitabilityChecker.java vendored
View File

@ -35,14 +35,15 @@ import org.apache.http.HttpRequest;
import org.apache.http.annotation.Immutable;
/**
* Determines whether a given response can be cached.
* Determines whether a given {@link CacheEntry} is suitable to be
* used as a response for a given {@link HttpRequest}.
*
* @since 4.1
*/
@Immutable
public class CachedResponseSuitabilityChecker {
private static final Log LOG = LogFactory.getLog(CachedResponseSuitabilityChecker.class);
private final Log LOG = LogFactory.getLog(CachedResponseSuitabilityChecker.class);
/**
* @param host
@ -60,28 +61,24 @@ public class CachedResponseSuitabilityChecker {
}
if (!entry.contentLengthHeaderMatchesActualLength()) {
LOG
.debug("CachedResponseSuitabilityChecker: Cache Entry Content Length and header information DO NOT match.");
LOG.debug("CachedResponseSuitabilityChecker: Cache Entry Content Length and header information DO NOT match.");
return false;
}
if (entry.modifiedSince(request)) {
LOG
.debug("CachedResponseSuitabilityChecker: Cache Entry modified times didn't line up. Cache Entry should NOT be used.");
LOG.debug("CachedResponseSuitabilityChecker: Cache Entry modified times didn't line up. Cache Entry should NOT be used.");
return false;
}
for (Header ccHdr : request.getHeaders(HeaderConstants.CACHE_CONTROL)) {
for (HeaderElement elt : ccHdr.getElements()) {
if (HeaderConstants.CACHE_CONTROL_NO_CACHE.equals(elt.getName())) {
LOG
.debug("CachedResponseSuitabilityChecker: Response contained NO CACHE directive, cache was NOT suitable.");
LOG.debug("CachedResponseSuitabilityChecker: Response contained NO CACHE directive, cache was NOT suitable.");
return false;
}
if (HeaderConstants.CACHE_CONTROL_NO_STORE.equals(elt.getName())) {
LOG
.debug("CachedResponseSuitabilityChecker: Response contained NO SORE directive, cache was NOT suitable.");
LOG.debug("CachedResponseSuitabilityChecker: Response contained NO SORE directive, cache was NOT suitable.");
return false;
}
@ -89,14 +86,12 @@ public class CachedResponseSuitabilityChecker {
try {
int maxage = Integer.parseInt(elt.getValue());
if (entry.getCurrentAgeSecs() > maxage) {
LOG
.debug("CachedResponseSuitabilityChecker: Response from cache was NOT suitable.");
LOG.debug("CachedResponseSuitabilityChecker: Response from cache was NOT suitable due to max age.");
return false;
}
} catch (NumberFormatException nfe) {
// err conservatively
LOG
.debug("CachedResponseSuitabilityChecker: Response from cache was NOT suitable.");
LOG.debug("CachedResponseSuitabilityChecker: Response from cache was NOT suitable. "+nfe);
return false;
}
}
@ -105,14 +100,12 @@ public class CachedResponseSuitabilityChecker {
try {
int maxstale = Integer.parseInt(elt.getValue());
if (entry.getFreshnessLifetimeSecs() > maxstale) {
LOG
.debug("CachedResponseSuitabilityChecker: Response from cache was NOT suitable.");
LOG.debug("CachedResponseSuitabilityChecker: Response from cache was NOT suitable due to Max stale freshness");
return false;
}
} catch (NumberFormatException nfe) {
// err conservatively
LOG
.debug("CachedResponseSuitabilityChecker: Response from cache was NOT suitable.");
LOG.debug("CachedResponseSuitabilityChecker: Response from cache was NOT suitable. "+nfe);
return false;
}
}
@ -121,14 +114,12 @@ public class CachedResponseSuitabilityChecker {
try {
int minfresh = Integer.parseInt(elt.getValue());
if (entry.getFreshnessLifetimeSecs() < minfresh) {
LOG
.debug("CachedResponseSuitabilityChecker: Response from cache was NOT suitable.");
LOG.debug("CachedResponseSuitabilityChecker: Response from cache was NOT suitable due to min fresh freshness requirement");
return false;
}
} catch (NumberFormatException nfe) {
// err conservatively
LOG
.debug("CachedResponseSuitabilityChecker: Response from cache was NOT suitable.");
LOG.debug("CachedResponseSuitabilityChecker: Response from cache was NOT suitable. " + nfe);
return false;
}
}

209
httpclient-cache/src/main/java/org/apache/http/client/cache/impl/CachingHttpClient.java vendored
View File

@ -30,6 +30,7 @@ import java.io.IOException;
import java.net.URI;
import java.util.Date;
import java.util.List;
import java.util.concurrent.atomic.AtomicLong;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
@ -44,9 +45,9 @@ import org.apache.http.StatusLine;
import org.apache.http.client.ClientProtocolException;
import org.apache.http.client.HttpClient;
import org.apache.http.client.ResponseHandler;
import org.apache.http.client.cache.HttpCache;
import org.apache.http.client.cache.HttpCacheOperationException;
import org.apache.http.client.cache.HttpCacheUpdateCallback;
import org.apache.http.client.cache.HttpCache;
import org.apache.http.client.methods.HttpUriRequest;
import org.apache.http.conn.ClientConnectionManager;
import org.apache.http.impl.client.DefaultHttpClient;
@ -60,7 +61,6 @@ import org.apache.http.protocol.HttpContext;
*/
public class CachingHttpClient implements HttpClient {
private static final Log LOG = LogFactory.getLog(CachingHttpClient.class);
private final static int MAX_CACHE_ENTRIES = 1000;
private final static int DEFAULT_MAX_OBJECT_SIZE_BYTES = 8192;
@ -82,12 +82,15 @@ public class CachingHttpClient implements HttpClient {
private final int maxObjectSizeBytes;
private final CacheEntryUpdater cacheEntryUpdater;
private volatile long cacheHits;
private volatile long cacheMisses;
private volatile long cacheUpdates;
private volatile AtomicLong cacheHits = new AtomicLong();
private volatile AtomicLong cacheMisses = new AtomicLong();
private volatile AtomicLong cacheUpdates = new AtomicLong();
private final ResponseProtocolCompliance responseCompliance;
private final RequestProtocolCompliance requestCompliance;
private final Log LOG = LogFactory.getLog(CachingHttpClient.class);
public CachingHttpClient() {
this.backend = new DefaultHttpClient();
this.maxObjectSizeBytes = DEFAULT_MAX_OBJECT_SIZE_BYTES;
@ -142,13 +145,13 @@ public class CachingHttpClient implements HttpClient {
}
public CachingHttpClient(HttpClient backend, ResponseCachingPolicy responseCachingPolicy,
CacheEntryGenerator cacheEntryGenerator, URIExtractor uriExtractor,
HttpCache<CacheEntry> responseCache, CachedHttpResponseGenerator responseGenerator,
CacheInvalidator cacheInvalidator, CacheableRequestPolicy cacheableRequestPolicy,
CachedResponseSuitabilityChecker suitabilityChecker,
ConditionalRequestBuilder conditionalRequestBuilder, CacheEntryUpdater entryUpdater,
ResponseProtocolCompliance responseCompliance,
RequestProtocolCompliance requestCompliance) {
CacheEntryGenerator cacheEntryGenerator, URIExtractor uriExtractor,
HttpCache<CacheEntry> responseCache, CachedHttpResponseGenerator responseGenerator,
CacheInvalidator cacheInvalidator, CacheableRequestPolicy cacheableRequestPolicy,
CachedResponseSuitabilityChecker suitabilityChecker,
ConditionalRequestBuilder conditionalRequestBuilder, CacheEntryUpdater entryUpdater,
ResponseProtocolCompliance responseCompliance,
RequestProtocolCompliance requestCompliance) {
this.maxObjectSizeBytes = DEFAULT_MAX_OBJECT_SIZE_BYTES;
this.backend = backend;
this.responseCachingPolicy = responseCachingPolicy;
@ -165,60 +168,153 @@ public class CachingHttpClient implements HttpClient {
this.requestCompliance = requestCompliance;
}
/**
* Return the number of times that the cache successfully answered an HttpRequest
* for a document of information from the server.
*
* @return long the number of cache successes
*/
public long getCacheHits() {
return cacheHits;
return cacheHits.get();
}
/**
* Return the number of times that the cache was unable to answer an HttpRequest
* for a document of information from the server.
*
* @return long the number of cache failures/misses
*/
public long getCacheMisses() {
return cacheMisses;
return cacheMisses.get();
}
/**
* Return the number of times that the cache was able to revalidate
* an existing cache entry for a document of information from the server.
*
* @return long the number of cache revalidations
*/
public long getCacheUpdates() {
return cacheUpdates;
return cacheUpdates.get();
}
/**
* Execute an {@link HttpRequest} @ a given {@link HttpHost}
*
* @param target the target host for the request.
* Implementations may accept <code>null</code>
* if they can still determine a route, for example
* to a default target or by inspecting the request.
* @param request the request to execute
* @return HttpResponse The cached entry or the result of a backend call
* @throws IOException
*/
public HttpResponse execute(HttpHost target, HttpRequest request) throws IOException {
HttpContext defaultContext = null;
return execute(target, request, defaultContext);
}
/**
* Execute an {@link HttpRequest} @ a given {@link HttpHost} with a specified
* {@link ResponseHandler} that will deal with the result of the call.
*
* @param target the target host for the request.
* Implementations may accept <code>null</code>
* if they can still determine a route, for example
* to a default target or by inspecting the request.
* @param request the request to execute
* @param responseHandler the response handler
* @param <T> The Return Type Identified by the generic type of the {@link ResponseHandler}
* @return T The response type as handled by ResponseHandler
* @throws IOException
*/
public <T> T execute(HttpHost target, HttpRequest request,
ResponseHandler<? extends T> responseHandler) throws IOException {
ResponseHandler<? extends T> responseHandler) throws IOException {
return execute(target, request, responseHandler, null);
}
/**
* Execute an {@link HttpRequest} @ a given {@link HttpHost} with a specified
* {@link ResponseHandler} that will deal with the result of the call using
* a specific {@link HttpContext}
*
* @param target the target host for the request.
* Implementations may accept <code>null</code>
* if they can still determine a route, for example
* to a default target or by inspecting the request.
* @param request the request to execute
* @param responseHandler the response handler
* @param context the context to use for the execution, or
* <code>null</code> to use the default context
* @param <T> The Return Type Identified by the generic type of the {@link ResponseHandler}
* @return T The response type as handled by ResponseHandler
* @throws IOException
*/
public <T> T execute(HttpHost target, HttpRequest request,
ResponseHandler<? extends T> responseHandler, HttpContext context) throws IOException {
ResponseHandler<? extends T> responseHandler, HttpContext context) throws IOException {
HttpResponse resp = execute(target, request, context);
return responseHandler.handleResponse(resp);
}
/**
* @param request the request to execute
* @return HttpResponse The cached entry or the result of a backend call
* @throws IOException
*/
public HttpResponse execute(HttpUriRequest request) throws IOException {
HttpContext context = null;
return execute(request, context);
}
/**
* @param request the request to execute
* @param context the context to use for the execution, or
* <code>null</code> to use the default context
* @return HttpResponse The cached entry or the result of a backend call
* @throws IOException
*/
public HttpResponse execute(HttpUriRequest request, HttpContext context) throws IOException {
URI uri = request.getURI();
HttpHost httpHost = new HttpHost(uri.getHost(), uri.getPort(), uri.getScheme());
return execute(httpHost, request, context);
}
/**
* @param request the request to execute
* @param responseHandler the response handler
* @param <T> The Return Type Identified by the generic type of the {@link ResponseHandler}
* @return T The response type as handled by ResponseHandler
* @throws IOException
*/
public <T> T execute(HttpUriRequest request, ResponseHandler<? extends T> responseHandler)
throws IOException {
return execute(request, responseHandler, null);
}
/**
* @param request the request to execute
* @param responseHandler the response handler
* @param context
* @param <T> The Return Type Identified by the generic type of the {@link ResponseHandler}
* @return T The response type as handled by ResponseHandler
* @throws IOException
*/
public <T> T execute(HttpUriRequest request, ResponseHandler<? extends T> responseHandler,
HttpContext context) throws IOException {
HttpContext context) throws IOException {
HttpResponse resp = execute(request, context);
return responseHandler.handleResponse(resp);
}
/**
* @return
*/
public ClientConnectionManager getConnectionManager() {
return backend.getConnectionManager();
}
/**
* @return
*/
public HttpParams getParams() {
return backend.getParams();
}
@ -233,7 +329,7 @@ public class CachingHttpClient implements HttpClient {
try {
entry = responseCache.getEntry(uri);
} catch (HttpCacheOperationException probablyIgnore) {
// TODO: do something useful with this exception
LOG.warn("Cache: Was unable to get an entry from the cache based on the uri provided.", probablyIgnore);
}
if (entry == null || !entry.hasVariants())
@ -247,6 +343,17 @@ public class CachingHttpClient implements HttpClient {
}
}
/**
* @param target the target host for the request.
* Implementations may accept <code>null</code>
* if they can still determine a route, for example
* to a default target or by inspecting the request.
* @param request the request to execute
* @param context the context to use for the execution, or
* <code>null</code> to use the default context
* @return
* @throws IOException
*/
public HttpResponse execute(HttpHost target, HttpRequest request, HttpContext context)
throws IOException {
@ -254,8 +361,7 @@ public class CachingHttpClient implements HttpClient {
return new OptionsHttp11Response();
}
List<RequestProtocolError> fatalError = requestCompliance
.requestIsFatallyNonCompliant(request);
List<RequestProtocolError> fatalError = requestCompliance.requestIsFatallyNonCompliant(request);
for (RequestProtocolError error : fatalError) {
return requestCompliance.getErrorForRequest(error);
@ -275,13 +381,13 @@ public class CachingHttpClient implements HttpClient {
CacheEntry entry = getCacheEntry(target, request);
if (entry == null) {
cacheMisses++;
cacheMisses.getAndIncrement();
LOG.debug("CLIENT: Cache Miss.");
return callBackend(target, request, context);
}
LOG.debug("CLIENT: Cache HIT.");
cacheHits++;
cacheHits.getAndIncrement();
if (suitabilityChecker.canCachedResponseBeUsed(target, request, entry)) {
return responseGenerator.generateResponse(entry);
@ -294,8 +400,8 @@ public class CachingHttpClient implements HttpClient {
return revalidateCacheEntry(target, request, context, entry);
} catch (IOException ioex) {
HttpResponse response = responseGenerator.generateResponse(entry);
response.addHeader(HeaderConstants.WARNING, "111 Revalidation Failed - "
+ ioex.getMessage());
response.addHeader(HeaderConstants.WARNING, "111 Revalidation Failed - " + ioex.getMessage());
LOG.debug("111 revalidation failed due to exception: " + ioex);
return response;
} catch (ProtocolException e) {
throw new ClientProtocolException(e);
@ -328,7 +434,7 @@ public class CachingHttpClient implements HttpClient {
LOG.debug("CLIENT: Calling the backend.");
HttpResponse backendResponse = backend.execute(target, request, context);
return handleBackendResponse(target, request, requestDate, getCurrentDate(),
backendResponse);
backendResponse);
} catch (ClientProtocolException cpex) {
throw cpex;
} catch (IOException ex) {
@ -340,9 +446,8 @@ public class CachingHttpClient implements HttpClient {
}
protected HttpResponse revalidateCacheEntry(HttpHost target, HttpRequest request,
HttpContext context, CacheEntry cacheEntry) throws IOException, ProtocolException {
HttpRequest conditionalRequest = conditionalRequestBuilder.buildConditionalRequest(request,
cacheEntry);
HttpContext context, CacheEntry cacheEntry) throws IOException, ProtocolException {
HttpRequest conditionalRequest = conditionalRequestBuilder.buildConditionalRequest(request, cacheEntry);
Date requestDate = getCurrentDate();
HttpResponse backendResponse = backend.execute(target, conditionalRequest, context);
@ -351,15 +456,14 @@ public class CachingHttpClient implements HttpClient {
int statusCode = backendResponse.getStatusLine().getStatusCode();
if (statusCode == HttpStatus.SC_NOT_MODIFIED || statusCode == HttpStatus.SC_OK) {
cacheUpdates++;
cacheEntryUpdater.updateCacheEntry(cacheEntry, requestDate, responseDate,
backendResponse);
storeInCache(target, request, cacheEntry);
return responseGenerator.generateResponse(cacheEntry);
cacheUpdates.getAndIncrement();
CacheEntry updatedEntry = cacheEntryUpdater.updateCacheEntry(cacheEntry, requestDate, responseDate, backendResponse);
storeInCache(target, request, updatedEntry);
return responseGenerator.generateResponse(updatedEntry);
}
return handleBackendResponse(target, conditionalRequest, requestDate, responseDate,
backendResponse);
backendResponse);
}
protected void storeInCache(HttpHost target, HttpRequest request, CacheEntry entry) {
@ -369,7 +473,7 @@ public class CachingHttpClient implements HttpClient {
HttpCacheUpdateCallback<CacheEntry> callback = storeVariantEntry(target, request, entry);
responseCache.updateCacheEntry(uri, callback);
} catch (HttpCacheOperationException probablyIgnore) {
// TODO: do something useful with this exception
LOG.warn("Cache: Was unable to PUT/UPDATE an entry into the cache based on the uri provided.", probablyIgnore);
}
} else {
storeNonVariantEntry(target, request, entry);
@ -381,31 +485,35 @@ public class CachingHttpClient implements HttpClient {
try {
responseCache.putEntry(uri, entry);
} catch (HttpCacheOperationException probablyIgnore) {
// TODO: do something useful with this exception
LOG.warn("Cache: Was unable to PUT an entry into the cache based on the uri provided.", probablyIgnore);
}
}
protected HttpCacheUpdateCallback<CacheEntry> storeVariantEntry(final HttpHost target, final HttpRequest req,
final CacheEntry entry) {
final CacheEntry entry) {
return new HttpCacheUpdateCallback<CacheEntry>() {
public CacheEntry getUpdatedEntry(CacheEntry existing) throws HttpCacheOperationException {
String variantURI = uriExtractor.getVariantURI(target, req, entry);
responseCache.putEntry(variantURI, entry);
if (existing != null) {
existing.addVariantURI(variantURI);
return existing;
} else {
entry.addVariantURI(variantURI);
return entry;
}
return doGetUpdatedParentEntry(existing, target, req, entry);
}
};
}
protected CacheEntry doGetUpdatedParentEntry(CacheEntry existing, HttpHost target, HttpRequest req, CacheEntry entry) throws HttpCacheOperationException {
String variantURI = uriExtractor.getVariantURI(target, req, entry);
responseCache.putEntry(variantURI, entry);
if (existing != null) {
return existing.addVariantURI(variantURI);
} else {
return entry.addVariantURI(variantURI);
}
}
protected HttpResponse handleBackendResponse(HttpHost target, HttpRequest request,
Date requestDate, Date responseDate, HttpResponse backendResponse) throws IOException {
Date requestDate, Date responseDate, HttpResponse backendResponse) throws IOException {
LOG.debug("CLIENT: Handling Backend response.");
responseCompliance.ensureProtocolCompliance(request, backendResponse);
@ -421,7 +529,7 @@ public class CachingHttpClient implements HttpClient {
}
CacheEntry entry = cacheEntryGenerator.generateEntry(requestDate, responseDate,
backendResponse, responseReader.getResponseBytes());
backendResponse, responseReader.getResponseBytes());
storeInCache(target, request, entry);
return responseGenerator.generateResponse(entry);
}
@ -430,6 +538,7 @@ public class CachingHttpClient implements HttpClient {
try {
responseCache.removeEntry(uri);
} catch (HttpCacheOperationException coe) {
LOG.warn("Cache: Was unable to remove an entry from the cache based on the uri provided.", coe);
// TODO: track failed state
}
return backendResponse;

2
httpclient-cache/src/main/java/org/apache/http/client/cache/impl/CombinedInputStream.java vendored
View File

@ -40,6 +40,8 @@ class CombinedInputStream extends InputStream {
private final InputStream inputStream2;
/**
* Take two inputstreams and produce an object that makes them appear as if they
* are actually a 'single' input stream.
*
* @param inputStream1
* First stream to read

11
httpclient-cache/src/main/java/org/apache/http/client/cache/impl/ConditionalRequestBuilder.java vendored
View File

@ -38,16 +38,23 @@ import org.apache.http.impl.client.RequestWrapper;
@Immutable
public class ConditionalRequestBuilder {
/**
*
* @param request
* @param cacheEntry
* @return
* @throws ProtocolException
*/
public HttpRequest buildConditionalRequest(HttpRequest request, CacheEntry cacheEntry)
throws ProtocolException {
RequestWrapper wrapperRequest = new RequestWrapper(request);
wrapperRequest.resetHeaders();
Header eTag = cacheEntry.getFirstHeader(HeaderConstants.ETAG);
if (eTag != null) {
wrapperRequest.setHeader("If-None-Match", eTag.getValue());
wrapperRequest.setHeader(HeaderConstants.IF_NONE_MATCH, eTag.getValue());
} else {
Header lastModified = cacheEntry.getFirstHeader(HeaderConstants.LAST_MODIFIED);
wrapperRequest.setHeader("If-Modified-Since", lastModified.getValue());
wrapperRequest.setHeader(HeaderConstants.IF_MODIFIED_SINCE, lastModified.getValue());
}
return wrapperRequest;

14
httpclient-cache/src/main/java/org/apache/http/client/cache/impl/DefaultCacheEntrySerializer.java vendored
View File

@ -46,6 +46,12 @@ import org.apache.http.client.cache.HttpCacheEntrySerializer;
@Immutable
public class DefaultCacheEntrySerializer implements HttpCacheEntrySerializer<CacheEntry> {
/**
*
* @param cacheEntry
* @param os
* @throws IOException
*/
public void writeTo(CacheEntry cacheEntry, OutputStream os) throws IOException {
ObjectOutputStream oos = null;
@ -77,6 +83,12 @@ public class DefaultCacheEntrySerializer implements HttpCacheEntrySerializer<Cac
}
/**
*
* @param is
* @return
* @throws IOException
*/
public CacheEntry readFrom(InputStream is) throws IOException {
ObjectInputStream ois = null;
@ -112,4 +124,4 @@ public class DefaultCacheEntrySerializer implements HttpCacheEntrySerializer<Cac
}
}
}

2
httpclient-cache/src/main/java/org/apache/http/client/cache/impl/HeaderConstants.java vendored
View File

@ -42,6 +42,8 @@ public class HeaderConstants {
public static final String TRACE_METHOD = "TRACE";
public static final String LAST_MODIFIED = "Last-Modified";
public static final String IF_MATCH = "If-Match";
public static final String IF_RANGE = "If-Range";
public static final String IF_UNMODIFIED_SINCE = "If-Unmodified-Since";
public static final String IF_MODIFIED_SINCE = "If-Modified-Since";
public static final String IF_NONE_MATCH = "If-None-Match";

6
httpclient-cache/src/main/java/org/apache/http/client/cache/impl/OptionsHttp11Response.java vendored
View File

@ -35,6 +35,7 @@ import org.apache.http.HttpResponse;
import org.apache.http.HttpStatus;
import org.apache.http.ProtocolVersion;
import org.apache.http.StatusLine;
import org.apache.http.annotation.Immutable;
import org.apache.http.message.AbstractHttpMessage;
import org.apache.http.message.BasicStatusLine;
import org.apache.http.params.BasicHttpParams;
@ -43,11 +44,12 @@ import org.apache.http.params.HttpParams;
/**
* @since 4.1
*/
@Immutable
public final class OptionsHttp11Response extends AbstractHttpMessage implements HttpResponse {
StatusLine statusLine = new BasicStatusLine(CachingHttpClient.HTTP_1_1,
private final StatusLine statusLine = new BasicStatusLine(CachingHttpClient.HTTP_1_1,
HttpStatus.SC_NOT_IMPLEMENTED, "");
ProtocolVersion version = CachingHttpClient.HTTP_1_1;
private final ProtocolVersion version = CachingHttpClient.HTTP_1_1;
public StatusLine getStatusLine() {
return statusLine;

22
httpclient-cache/src/main/java/org/apache/http/client/cache/impl/RequestProtocolCompliance.java vendored
View File

@ -50,6 +50,11 @@ import org.apache.http.message.BasicStatusLine;
@Immutable
public class RequestProtocolCompliance {
/**
*
* @param request
* @return
*/
public List<RequestProtocolError> requestIsFatallyNonCompliant(HttpRequest request) {
List<RequestProtocolError> theErrors = new ArrayList<RequestProtocolError>();
@ -71,6 +76,12 @@ public class RequestProtocolCompliance {
return theErrors;
}
/**
*
* @param request
* @return
* @throws ProtocolException
*/
public HttpRequest makeRequestCompliant(HttpRequest request) throws ProtocolException {
if (requestMustNotHaveEntity(request)) {
((HttpEntityEnclosingRequest) request).setEntity(null);
@ -250,11 +261,11 @@ public class RequestProtocolCompliance {
return null;
}
Header range = request.getFirstHeader("Range");
Header range = request.getFirstHeader(HeaderConstants.RANGE);
if (range == null)
return null;
Header ifRange = request.getFirstHeader("If-Range");
Header ifRange = request.getFirstHeader(HeaderConstants.IF_RANGE);
if (ifRange == null)
return null;
@ -267,8 +278,7 @@ public class RequestProtocolCompliance {
}
private RequestProtocolError requestHasWeekETagForPUTOrDELETEIfMatch(HttpRequest request) {
// TODO: Should these be looking at all the headers marked as
// If-Match/If-None-Match?
// TODO: Should these be looking at all the headers marked as If-Match/If-None-Match?
String method = request.getRequestLine().getMethod();
if (!(HeaderConstants.PUT_METHOD.equals(method) || HeaderConstants.DELETE_METHOD
@ -276,14 +286,14 @@ public class RequestProtocolCompliance {
return null;
}
Header ifMatch = request.getFirstHeader("If-Match");
Header ifMatch = request.getFirstHeader(HeaderConstants.IF_MATCH);
if (ifMatch != null) {
String val = ifMatch.getValue();
if (val.startsWith("W/")) {
return RequestProtocolError.WEAK_ETAG_ON_PUTDELETE_METHOD_ERROR;
}
} else {
Header ifNoneMatch = request.getFirstHeader("If-None-Match");
Header ifNoneMatch = request.getFirstHeader(HeaderConstants.IF_NONE_MATCH);
if (ifNoneMatch == null)
return null;

6
httpclient-cache/src/main/java/org/apache/http/client/cache/impl/ResponseCachingPolicy.java vendored
View File

@ -46,8 +46,12 @@ import org.apache.http.impl.cookie.DateUtils;
public class ResponseCachingPolicy {
private final int maxObjectSizeBytes;
private static final Log LOG = LogFactory.getLog(ResponseCachingPolicy.class);
private final Log LOG = LogFactory.getLog(ResponseCachingPolicy.class);
/**
*
* @param maxObjectSizeBytes
*/
public ResponseCachingPolicy(int maxObjectSizeBytes) {
this.maxObjectSizeBytes = maxObjectSizeBytes;
}

6
httpclient-cache/src/main/java/org/apache/http/client/cache/impl/ResponseProtocolCompliance.java vendored
View File

@ -44,6 +44,12 @@ import org.apache.http.impl.cookie.DateUtils;
@Immutable
public class ResponseProtocolCompliance {
/**
*
* @param request
* @param response
* @throws ClientProtocolException
*/
public void ensureProtocolCompliance(HttpRequest request, HttpResponse response)
throws ClientProtocolException {
if (backendResponseMustNotHaveBody(request, response)) {

11
httpclient-cache/src/main/java/org/apache/http/client/cache/impl/SizeLimitedResponseReader.java vendored
View File

@ -52,12 +52,17 @@ public class SizeLimitedResponseReader {
private byte[] sizeLimitedContent;
private boolean outputStreamConsumed;
/**
*
* @param maxResponseSizeBytes
* @param response
*/
public SizeLimitedResponseReader(int maxResponseSizeBytes, HttpResponse response) {
this.maxResponseSizeBytes = maxResponseSizeBytes;
this.response = response;
}
public boolean isResponseTooLarge() throws IOException {
protected boolean isResponseTooLarge() throws IOException {
if (!responseIsConsumed)
isTooLarge = consumeResponse();
@ -108,14 +113,14 @@ public class SizeLimitedResponseReader {
outputStreamConsumed = true;
}
public byte[] getResponseBytes() {
protected byte[] getResponseBytes() {
if (!outputStreamConsumed)
consumeOutputStream();
return sizeLimitedContent;
}
public HttpResponse getReconstructedResponse() {
protected HttpResponse getReconstructedResponse() {
InputStream combinedStream = getCombinedInputStream();

2
httpclient-cache/src/test/java/org/apache/http/client/cache/impl/DoNotTestProtocolRequirements.java vendored
View File

@ -41,8 +41,6 @@ import org.apache.http.ProtocolVersion;
import org.apache.http.client.ClientProtocolException;
import org.apache.http.client.HttpClient;
import org.apache.http.client.cache.HttpCache;
import org.apache.http.client.cache.impl.BasicHttpCache;
import org.apache.http.client.cache.impl.CachingHttpClient;
import org.apache.http.entity.ByteArrayEntity;
import org.apache.http.impl.cookie.DateUtils;
import org.apache.http.message.BasicHttpRequest;

190
httpclient-cache/src/test/java/org/apache/http/client/cache/impl/TestCacheEntry.java vendored
View File

@ -26,11 +26,13 @@
*/
package org.apache.http.client.cache.impl;
import static junit.framework.Assert.assertFalse;
import java.util.Date;
import java.util.Set;
import org.apache.http.Header;
import org.apache.http.client.cache.impl.CacheEntry;
import org.apache.http.ProtocolVersion;
import org.apache.http.impl.cookie.DateUtils;
import org.apache.http.message.BasicHeader;
import org.junit.Assert;
@ -38,22 +40,26 @@ import org.junit.Test;
public class TestCacheEntry {
private static ProtocolVersion HTTP_1_1 = new ProtocolVersion("HTTP",1,1);
@Test
public void testGetHeadersReturnsCorrectHeaders() {
Header[] headers = new Header[] { new BasicHeader("foo", "fooValue"),
new BasicHeader("bar", "barValue1"), new BasicHeader("bar", "barValue2") };
CacheEntry entry = new CacheEntry();
entry.setResponseHeaders(headers);
CacheEntry entry = getEntry(headers);
Assert.assertEquals(2, entry.getHeaders("bar").length);
}
private CacheEntry getEntry(Header[] headers) {
return getEntry(new Date(), new Date(), headers);
}
@Test
public void testGetFirstHeaderReturnsCorrectHeader() {
Header[] headers = new Header[] { new BasicHeader("foo", "fooValue"),
new BasicHeader("bar", "barValue1"), new BasicHeader("bar", "barValue2") };
CacheEntry entry = getEntry(headers);
CacheEntry entry = new CacheEntry();
entry.setResponseHeaders(headers);
Assert.assertEquals("barValue1", entry.getFirstHeader("bar").getValue());
}
@ -62,8 +68,8 @@ public class TestCacheEntry {
Header[] headers = new Header[] { new BasicHeader("foo", "fooValue"),
new BasicHeader("bar", "barValue1"), new BasicHeader("bar", "barValue2") };
CacheEntry entry = new CacheEntry();
entry.setResponseHeaders(headers);
CacheEntry entry = getEntry(headers);
Assert.assertEquals(0, entry.getHeaders("baz").length);
}
@ -72,9 +78,8 @@ public class TestCacheEntry {
public void testGetFirstHeaderReturnsNullIfNoneMatch() {
Header[] headers = new Header[] { new BasicHeader("foo", "fooValue"),
new BasicHeader("bar", "barValue1"), new BasicHeader("bar", "barValue2") };
CacheEntry entry = getEntry(headers);
CacheEntry entry = new CacheEntry();
entry.setResponseHeaders(headers);
Assert.assertEquals(null, entry.getFirstHeader("quux"));
}
@ -82,8 +87,7 @@ public class TestCacheEntry {
@Test
public void testApparentAgeIsMaxIntIfDateHeaderNotPresent() {
Header[] headers = new Header[0];
CacheEntry entry = new CacheEntry();
entry.setResponseHeaders(headers);
CacheEntry entry = getEntry(headers);
Assert.assertEquals(2147483648L, entry.getApparentAgeSecs());
}
@ -96,13 +100,17 @@ public class TestCacheEntry {
Header[] headers = new Header[] { new BasicHeader("Date", DateUtils
.formatDate(tenSecondsAgo)) };
CacheEntry entry = new CacheEntry();
entry.setResponseHeaders(headers);
entry.setResponseDate(sixSecondsAgo);
CacheEntry entry = getEntry(now, sixSecondsAgo, headers);
Assert.assertEquals(4, entry.getApparentAgeSecs());
}
private CacheEntry getEntry(Date requestDate, Date responseDate, Header[] headers) {
return new CacheEntry(requestDate,responseDate,HTTP_1_1,headers,new byte[]{},200,"OK");
}
@Test
public void testNegativeApparentAgeIsBroughtUpToZero() {
Date now = new Date();
@ -112,17 +120,14 @@ public class TestCacheEntry {
Header[] headers = new Header[] { new BasicHeader("Date", DateUtils
.formatDate(sixSecondsAgo)) };
CacheEntry entry = new CacheEntry();
entry.setResponseHeaders(headers);
entry.setResponseDate(tenSecondsAgo);
CacheEntry entry = getEntry(now,tenSecondsAgo,headers);
Assert.assertEquals(0, entry.getApparentAgeSecs());
}
@Test
public void testCorrectedReceivedAgeIsAgeHeaderIfLarger() {
Header[] headers = new Header[] { new BasicHeader("Age", "10"), };
CacheEntry entry = new CacheEntry() {
CacheEntry entry = new CacheEntry(new Date(),new Date(),HTTP_1_1,headers, new byte[]{},200,"OK") {
private static final long serialVersionUID = 1L;
@Override
@ -130,7 +135,7 @@ public class TestCacheEntry {
return 6;
}
};
entry.setResponseHeaders(headers);
Assert.assertEquals(10, entry.getCorrectedReceivedAgeSecs());
}
@ -138,7 +143,7 @@ public class TestCacheEntry {
@Test
public void testCorrectedReceivedAgeIsApparentAgeIfLarger() {
Header[] headers = new Header[] { new BasicHeader("Age", "6"), };
CacheEntry entry = new CacheEntry() {
CacheEntry entry = new CacheEntry(new Date(),new Date(),HTTP_1_1,headers, new byte[]{},200,"OK") {
private static final long serialVersionUID = 1L;
@Override
@ -146,7 +151,6 @@ public class TestCacheEntry {
return 10;
}
};
entry.setResponseHeaders(headers);
Assert.assertEquals(10, entry.getCorrectedReceivedAgeSecs());
}
@ -157,16 +161,17 @@ public class TestCacheEntry {
Date sixSecondsAgo = new Date(now.getTime() - 6 * 1000L);
Date tenSecondsAgo = new Date(now.getTime() - 10 * 1000L);
CacheEntry entry = new CacheEntry();
entry.setRequestDate(tenSecondsAgo);
entry.setResponseDate(sixSecondsAgo);
Header[] headers = new Header[]{};
CacheEntry entry = new CacheEntry(tenSecondsAgo,sixSecondsAgo,new ProtocolVersion("HTTP",1,1),headers,new byte[]{},200,"OK");
Assert.assertEquals(4, entry.getResponseDelaySecs());
}
@Test
public void testCorrectedInitialAgeIsCorrectedReceivedAgePlusResponseDelay() {
CacheEntry entry = new CacheEntry() {
CacheEntry entry = new CacheEntry(new Date(),new Date(),HTTP_1_1,new Header[]{}, new byte[]{},200,"OK") {
private static final long serialVersionUID = 1L;
@Override
@ -187,7 +192,7 @@ public class TestCacheEntry {
final Date now = new Date();
Date sixSecondsAgo = new Date(now.getTime() - 6 * 1000L);
CacheEntry entry = new CacheEntry() {
CacheEntry entry = new CacheEntry(new Date(),sixSecondsAgo,HTTP_1_1,new Header[]{}, new byte[]{},200,"OK") {
private static final long serialVersionUID = 1L;
@Override
@ -195,14 +200,13 @@ public class TestCacheEntry {
return now;
}
};
entry.setResponseDate(sixSecondsAgo);
Assert.assertEquals(6, entry.getResidentTimeSecs());
}
@Test
public void testCurrentAgeIsCorrectedInitialAgePlusResidentTime() {
CacheEntry entry = new CacheEntry() {
CacheEntry entry = new CacheEntry(new Date(),new Date(),HTTP_1_1,new Header[]{}, new byte[]{},200,"OK") {
private static final long serialVersionUID = 1L;
@Override
@ -221,16 +225,14 @@ public class TestCacheEntry {
@Test
public void testFreshnessLifetimeIsSMaxAgeIfPresent() {
Header[] headers = new Header[] { new BasicHeader("Cache-Control", "s-maxage=10") };
CacheEntry entry = new CacheEntry();
entry.setResponseHeaders(headers);
CacheEntry entry = getEntry(headers);
Assert.assertEquals(10, entry.getFreshnessLifetimeSecs());
}
@Test
public void testFreshnessLifetimeIsMaxAgeIfPresent() {
Header[] headers = new Header[] { new BasicHeader("Cache-Control", "max-age=10") };
CacheEntry entry = new CacheEntry();
entry.setResponseHeaders(headers);
CacheEntry entry = getEntry(headers);
Assert.assertEquals(10, entry.getFreshnessLifetimeSecs());
}
@ -238,14 +240,12 @@ public class TestCacheEntry {
public void testFreshnessLifetimeIsMostRestrictiveOfMaxAgeAndSMaxAge() {
Header[] headers = new Header[] { new BasicHeader("Cache-Control", "max-age=10"),
new BasicHeader("Cache-Control", "s-maxage=20") };
CacheEntry entry = new CacheEntry();
entry.setResponseHeaders(headers);
CacheEntry entry = getEntry(headers);
Assert.assertEquals(10, entry.getFreshnessLifetimeSecs());
headers = new Header[] { new BasicHeader("Cache-Control", "max-age=20"),
new BasicHeader("Cache-Control", "s-maxage=10") };
entry = new CacheEntry();
entry.setResponseHeaders(headers);
entry = getEntry(headers);
Assert.assertEquals(10, entry.getFreshnessLifetimeSecs());
}
@ -258,8 +258,7 @@ public class TestCacheEntry {
new BasicHeader("Date", DateUtils.formatDate(tenSecondsAgo)),
new BasicHeader("Expires", DateUtils.formatDate(sixSecondsAgo)) };
CacheEntry entry = new CacheEntry();
entry.setResponseHeaders(headers);
CacheEntry entry = getEntry(headers);
Assert.assertEquals(10, entry.getFreshnessLifetimeSecs());
}
@ -272,8 +271,7 @@ public class TestCacheEntry {
new BasicHeader("Date", DateUtils.formatDate(tenSecondsAgo)),
new BasicHeader("Expires", DateUtils.formatDate(sixSecondsAgo)) };
CacheEntry entry = new CacheEntry();
entry.setResponseHeaders(headers);
CacheEntry entry = getEntry(headers);
Assert.assertEquals(10, entry.getFreshnessLifetimeSecs());
}
@ -286,14 +284,13 @@ public class TestCacheEntry {
new BasicHeader("Date", DateUtils.formatDate(tenSecondsAgo)),
new BasicHeader("Expires", DateUtils.formatDate(sixSecondsAgo)) };
CacheEntry entry = new CacheEntry();
entry.setResponseHeaders(headers);
CacheEntry entry = getEntry(headers);
Assert.assertEquals(4, entry.getFreshnessLifetimeSecs());
}
@Test
public void testResponseIsFreshIfFreshnessLifetimeExceedsCurrentAge() {
CacheEntry entry = new CacheEntry() {
CacheEntry entry = new CacheEntry(new Date(),new Date(),HTTP_1_1,new Header[]{}, new byte[]{},200,"OK") {
private static final long serialVersionUID = 1L;
@Override
@ -312,7 +309,7 @@ public class TestCacheEntry {
@Test
public void testResponseIsNotFreshIfFreshnessLifetimeEqualsCurrentAge() {
CacheEntry entry = new CacheEntry() {
CacheEntry entry = new CacheEntry(new Date(),new Date(),HTTP_1_1,new Header[]{}, new byte[]{},200,"OK") {
private static final long serialVersionUID = 1L;
@Override
@ -331,7 +328,7 @@ public class TestCacheEntry {
@Test
public void testResponseIsNotFreshIfCurrentAgeExceedsFreshnessLifetime() {
CacheEntry entry = new CacheEntry() {
CacheEntry entry = new CacheEntry(new Date(),new Date(),HTTP_1_1,new Header[]{}, new byte[]{},200,"OK") {
private static final long serialVersionUID = 1L;
@Override
@ -350,46 +347,53 @@ public class TestCacheEntry {
@Test
public void testCacheEntryIsRevalidatableIfHeadersIncludeETag() {
CacheEntry entry = new CacheEntry();
entry.setResponseHeaders(new Header[] {
Header[] headers = {
new BasicHeader("Expires", DateUtils.formatDate(new Date())),
new BasicHeader("ETag", "somevalue") });
new BasicHeader("ETag", "somevalue")};
CacheEntry entry = getEntry(headers);
Assert.assertTrue(entry.isRevalidatable());
}
@Test
public void testCacheEntryIsRevalidatableIfHeadersIncludeLastModifiedDate() {
CacheEntry entry = new CacheEntry();
entry.setResponseHeaders(new Header[] {
Header[] headers = {
new BasicHeader("Expires", DateUtils.formatDate(new Date())),
new BasicHeader("Last-Modified", DateUtils.formatDate(new Date())) });
new BasicHeader("Last-Modified", DateUtils.formatDate(new Date())) };
CacheEntry entry = getEntry(headers);
Assert.assertTrue(entry.isRevalidatable());
}
@Test
public void testCacheEntryIsNotRevalidatableIfNoAppropriateHeaders() {
CacheEntry entry = new CacheEntry();
entry.setResponseHeaders(new Header[] {
Header[] headers = {
new BasicHeader("Expires", DateUtils.formatDate(new Date())),
new BasicHeader("Cache-Control", "public") });
new BasicHeader("Cache-Control", "public") };
CacheEntry entry = getEntry(headers);
assertFalse(entry.isRevalidatable());
}
@Test
public void testCacheEntryWithNoVaryHeaderDoesNotHaveVariants() {
Header[] headers = new Header[0];
CacheEntry entry = new CacheEntry();
entry.setResponseHeaders(headers);
CacheEntry entry = getEntry(headers);
Assert.assertFalse(entry.hasVariants());
}
@Test
public void testCacheEntryWithOneVaryHeaderHasVariants() {
Header[] headers = { new BasicHeader("Vary", "User-Agent") };
CacheEntry entry = new CacheEntry();
entry.setResponseHeaders(headers);
CacheEntry entry = getEntry(headers);
Assert.assertTrue(entry.hasVariants());
}
@ -397,20 +401,27 @@ public class TestCacheEntry {
public void testCacheEntryWithMultipleVaryHeadersHasVariants() {
Header[] headers = { new BasicHeader("Vary", "User-Agent"),
new BasicHeader("Vary", "Accept-Encoding") };
CacheEntry entry = new CacheEntry();
entry.setResponseHeaders(headers);
CacheEntry entry = getEntry(headers);
Assert.assertTrue(entry.hasVariants());
}
@Test
public void testCacheEntryWithVaryStarHasVariants(){
Header[] headers = { new BasicHeader("Vary", "*") };
CacheEntry entry = getEntry(headers);
Assert.assertTrue(entry.hasVariants());
}
@Test
public void testCacheEntryCanStoreMultipleVariantUris() {
CacheEntry entry = new CacheEntry();
Header[] headers = new Header[]{};
CacheEntry entry = getEntry(headers);
entry.addVariantURI("foo");
entry.addVariantURI("bar");
CacheEntry addedOne = entry.addVariantURI("foo");
CacheEntry addedTwo = addedOne.addVariantURI("bar");
Set<String> variants = entry.getVariantURIs();
Set<String> variants = addedTwo.getVariantURIs();
Assert.assertTrue(variants.contains("foo"));
Assert.assertTrue(variants.contains("bar"));
@ -419,76 +430,67 @@ public class TestCacheEntry {
@Test
public void testMalformedDateHeaderIsIgnored() {
Header[] h = new Header[] { new BasicHeader("Date", "asdf") };
CacheEntry e = new CacheEntry();
e.setResponseHeaders(h);
Header[] headers = new Header[] { new BasicHeader("Date", "asdf") };
CacheEntry entry = getEntry(headers);
Date d = e.getDateValue();
Date d = entry.getDateValue();
Assert.assertNull(d);
}
@Test
public void testMalformedContentLengthReturnsNegativeOne() {
Header[] h = new Header[] { new BasicHeader("Content-Length", "asdf") };
CacheEntry e = new CacheEntry();
e.setResponseHeaders(h);
Header[] headers = new Header[] { new BasicHeader("Content-Length", "asdf") };
CacheEntry entry = getEntry(headers);
long length = e.getContentLengthValue();
long length = entry.getContentLengthValue();
Assert.assertEquals(-1, length);
}
@Test
public void testNegativeAgeHeaderValueReturnsMaxAge() {
Header[] h = new Header[] { new BasicHeader("Age", "-100") };
CacheEntry e = new CacheEntry();
e.setResponseHeaders(h);
Header[] headers = new Header[] { new BasicHeader("Age", "-100") };
CacheEntry entry = getEntry(headers);
long length = e.getAgeValue();
long length = entry.getAgeValue();
Assert.assertEquals(CacheEntry.MAX_AGE, length);
}
@Test
public void testMalformedAgeHeaderValueReturnsMaxAge() {
Header[] h = new Header[] { new BasicHeader("Age", "asdf") };
CacheEntry e = new CacheEntry();
e.setResponseHeaders(h);
Header[] headers = new Header[] { new BasicHeader("Age", "asdf") };
CacheEntry entry = getEntry(headers);
long length = e.getAgeValue();
long length = entry.getAgeValue();
Assert.assertEquals(CacheEntry.MAX_AGE, length);
}
@Test
public void testMalformedCacheControlMaxAgeHeaderReturnsZero() {
Header[] h = new Header[] { new BasicHeader("Cache-Control", "max-age=asdf") };
CacheEntry e = new CacheEntry();
e.setResponseHeaders(h);
Header[] headers = new Header[] { new BasicHeader("Cache-Control", "max-age=asdf") };
CacheEntry entry = getEntry(headers);
long maxage = e.getMaxAge();
long maxage = entry.getMaxAge();
Assert.assertEquals(0, maxage);
}
@Test
public void testMalformedExpirationDateReturnsNull() {
Header[] h = new Header[] { new BasicHeader("Expires", "asdf") };
CacheEntry e = new CacheEntry();
e.setResponseHeaders(h);
Header[] headers = new Header[] { new BasicHeader("Expires", "asdf") };
CacheEntry entry = getEntry(headers);
Date expirationDate = e.getExpirationDate();
Date expirationDate = entry.getExpirationDate();
Assert.assertNull(expirationDate);
}
}

2
httpclient-cache/src/test/java/org/apache/http/client/cache/impl/TestCacheEntryGenerator.java vendored
View File

@ -33,8 +33,6 @@ import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.HttpStatus;
import org.apache.http.ProtocolVersion;
import org.apache.http.client.cache.impl.CacheEntry;
import org.apache.http.client.cache.impl.CacheEntryGenerator;
import org.apache.http.entity.ByteArrayEntity;
import org.apache.http.message.BasicHttpResponse;
import org.junit.Assert;

128
httpclient-cache/src/test/java/org/apache/http/client/cache/impl/TestCacheEntryUpdater.java vendored
View File

@ -26,14 +26,15 @@
*/
package org.apache.http.client.cache.impl;
import static junit.framework.Assert.assertEquals;
import static junit.framework.Assert.assertNotSame;
import java.util.Date;
import org.apache.http.Header;
import org.apache.http.HttpResponse;
import org.apache.http.HttpStatus;
import org.apache.http.ProtocolVersion;
import org.apache.http.client.cache.impl.CacheEntry;
import org.apache.http.client.cache.impl.CacheEntryUpdater;
import org.apache.http.impl.cookie.DateUtils;
import org.apache.http.message.BasicHeader;
import org.apache.http.message.BasicHttpResponse;
@ -45,6 +46,10 @@ import org.junit.Test;
public class TestCacheEntryUpdater {
private static ProtocolVersion HTTP_1_1 = new ProtocolVersion("HTTP", 1, 1);
private HttpResponse mockResponse;
private CacheEntry mockCacheEntry;
private Date requestDate;
@ -81,92 +86,125 @@ public class TestCacheEntryUpdater {
}
@Test
public void testUpdateCacheEntry() {
mockImplMethods("mergeHeaders");
mockCacheEntry.setRequestDate(requestDate);
mockCacheEntry.setResponseDate(responseDate);
impl.mergeHeaders(mockCacheEntry, mockResponse);
public void testUpdateCacheEntryReturnsDifferentEntryInstance() {
CacheEntry entry = getEntry(new Header[]{});
BasicHttpResponse response = new BasicHttpResponse(HTTP_1_1, 200, "OK");
replayMocks();
impl.updateCacheEntry(mockCacheEntry, requestDate, responseDate, mockResponse);
CacheEntry newEntry = impl.updateCacheEntry(entry, requestDate, responseDate, response);
verifyMocks();
assertNotSame(newEntry, entry);
}
@Test
public void testExistingHeadersNotInResponseDontChange() {
public void testHeadersAreMergedCorrectly() {
CacheEntry cacheEntry = new CacheEntry();
cacheEntry.setResponseHeaders(new Header[] {
Header[] headers = {
new BasicHeader("Date", DateUtils.formatDate(responseDate)),
new BasicHeader("ETag", "eTag") });
new BasicHeader("ETag", "\"etag\"")};
CacheEntry cacheEntry = getEntry(headers);
HttpResponse response = new BasicHttpResponse(new BasicStatusLine(new ProtocolVersion(
"http", 1, 1), HttpStatus.SC_NOT_MODIFIED, ""));
response.setHeaders(new Header[] {});
response.setHeaders(new Header[]{});
impl.mergeHeaders(cacheEntry, response);
CacheEntry updatedEntry = impl.updateCacheEntry(cacheEntry, new Date(), new Date(), response);
Assert.assertEquals(2, cacheEntry.getAllHeaders().length);
Assert.assertEquals(2, updatedEntry.getAllHeaders().length);
headersContain(cacheEntry.getAllHeaders(), "Date", DateUtils.formatDate(responseDate));
headersContain(cacheEntry.getAllHeaders(), "ETag", "eTag");
headersContain(updatedEntry.getAllHeaders(), "Date", DateUtils.formatDate(responseDate));
headersContain(updatedEntry.getAllHeaders(), "ETag", "\"etag\"");
}
@Test
public void testNewerHeadersReplaceExistingHeaders() {
CacheEntry cacheEntry = new CacheEntry();
cacheEntry.setResponseHeaders(new Header[] {
Header[] headers = {
new BasicHeader("Date", DateUtils.formatDate(requestDate)),
new BasicHeader("Cache-Control", "private"), new BasicHeader("ETag", "eTag"),
new BasicHeader("Cache-Control", "private"), new BasicHeader("ETag", "\"etag\""),
new BasicHeader("Last-Modified", DateUtils.formatDate(requestDate)),
new BasicHeader("Cache-Control", "max-age=0"), });
new BasicHeader("Cache-Control", "max-age=0"),};
CacheEntry cacheEntry = getEntry(headers);
HttpResponse response = new BasicHttpResponse(new BasicStatusLine(new ProtocolVersion(
"http", 1, 1), HttpStatus.SC_NOT_MODIFIED, ""));
response.setHeaders(new Header[] {
response.setHeaders(new Header[]{
new BasicHeader("Last-Modified", DateUtils.formatDate(responseDate)),
new BasicHeader("Cache-Control", "public"), });
new BasicHeader("Cache-Control", "public"),});
impl.mergeHeaders(cacheEntry, response);
CacheEntry updatedEntry = impl.updateCacheEntry(cacheEntry, new Date(), new Date(), response);
Assert.assertEquals(4, cacheEntry.getAllHeaders().length);
headersContain(cacheEntry.getAllHeaders(), "Date", DateUtils.formatDate(requestDate));
headersContain(cacheEntry.getAllHeaders(), "ETag", "eTag");
headersContain(cacheEntry.getAllHeaders(), "Last-Modified", DateUtils
Assert.assertEquals(4, updatedEntry.getAllHeaders().length);
headersContain(updatedEntry.getAllHeaders(), "Date", DateUtils.formatDate(requestDate));
headersContain(updatedEntry.getAllHeaders(), "ETag", "\"etag\"");
headersContain(updatedEntry.getAllHeaders(), "Last-Modified", DateUtils
.formatDate(responseDate));
headersContain(cacheEntry.getAllHeaders(), "Cache-Control", "public");
headersContain(updatedEntry.getAllHeaders(), "Cache-Control", "public");
}
@Test
public void testNewHeadersAreAddedByMerge() {
CacheEntry cacheEntry = new CacheEntry();
cacheEntry.setResponseHeaders(new Header[] {
Header[] headers = {
new BasicHeader("Date", DateUtils.formatDate(requestDate)),
new BasicHeader("ETag", "eTag"), });
new BasicHeader("ETag", "\"etag\"")};
CacheEntry cacheEntry = getEntry(headers);
HttpResponse response = new BasicHttpResponse(new BasicStatusLine(new ProtocolVersion(
"http", 1, 1), HttpStatus.SC_NOT_MODIFIED, ""));
response.setHeaders(new Header[] {
response.setHeaders(new Header[]{
new BasicHeader("Last-Modified", DateUtils.formatDate(responseDate)),
new BasicHeader("Cache-Control", "public"), });
new BasicHeader("Cache-Control", "public"),});
impl.mergeHeaders(cacheEntry, response);
CacheEntry updatedEntry = impl.updateCacheEntry(cacheEntry, new Date(), new Date(), response);
Assert.assertEquals(4, cacheEntry.getAllHeaders().length);
headersContain(cacheEntry.getAllHeaders(), "Date", DateUtils.formatDate(requestDate));
headersContain(cacheEntry.getAllHeaders(), "ETag", "eTag");
headersContain(cacheEntry.getAllHeaders(), "Last-Modified", DateUtils
Assert.assertEquals(4, updatedEntry.getAllHeaders().length);
headersContain(updatedEntry.getAllHeaders(), "Date", DateUtils.formatDate(requestDate));
headersContain(updatedEntry.getAllHeaders(), "ETag", "\"etag\"");
headersContain(updatedEntry.getAllHeaders(), "Last-Modified", DateUtils
.formatDate(responseDate));
headersContain(cacheEntry.getAllHeaders(), "Cache-Control", "public");
headersContain(updatedEntry.getAllHeaders(), "Cache-Control", "public");
}
@Test
public void testUpdatedEntryHasLatestRequestAndResponseDates() {
Date now = new Date();
Date tenSecondsAgo = new Date(now.getTime() - 10000L);
Date eightSecondsAgo = new Date(now.getTime() - 8000L);
Date twoSecondsAgo = new Date(now.getTime() - 2000L);
Date oneSecondAgo = new Date(now.getTime() - 1000L);
Header[] headers = new Header[]{};
CacheEntry entry = new CacheEntry(tenSecondsAgo, eightSecondsAgo, HTTP_1_1, headers, new byte[]{}, 200, "OK");
HttpResponse response = new BasicHttpResponse(HTTP_1_1, 200, "OK");
CacheEntry updated = impl.updateCacheEntry(entry, twoSecondsAgo, oneSecondAgo, response);
assertEquals(twoSecondsAgo, updated.getRequestDate());
assertEquals(oneSecondAgo, updated.getResponseDate());
}
// UTILITY
private void headersContain(Header[] headers, String name, String value) {
for (Header header : headers) {
if (header.getName().equals(name)) {
@ -178,10 +216,12 @@ public class TestCacheEntryUpdater {
Assert.fail("Header [" + name + ": " + value + "] not found in headers.");
}
private void mockImplMethods(String... methods) {
implMocked = true;
impl = EasyMock.createMockBuilder(CacheEntryUpdater.class).addMockedMethods(methods)
.createMock();
private CacheEntry getEntry(Header[] headers) {
return getEntry(new Date(), new Date(), headers);
}
private CacheEntry getEntry(Date requestDate, Date responseDate, Header[] headers) {
return new CacheEntry(requestDate, responseDate, HTTP_1_1, headers, new byte[]{}, 200, "OK");
}
}

5
httpclient-cache/src/test/java/org/apache/http/client/cache/impl/TestCacheInvalidator.java vendored
View File

@ -34,11 +34,8 @@ import org.apache.http.HeaderElement;
import org.apache.http.HttpHost;
import org.apache.http.HttpRequest;
import org.apache.http.RequestLine;
import org.apache.http.client.cache.HttpCacheOperationException;
import org.apache.http.client.cache.HttpCache;
import org.apache.http.client.cache.impl.CacheEntry;
import org.apache.http.client.cache.impl.CacheInvalidator;
import org.apache.http.client.cache.impl.URIExtractor;
import org.apache.http.client.cache.HttpCacheOperationException;
import org.easymock.classextension.EasyMock;
import org.junit.Before;
import org.junit.Test;

1
httpclient-cache/src/test/java/org/apache/http/client/cache/impl/TestCacheableRequestPolicy.java vendored
View File

@ -26,7 +26,6 @@
*/
package org.apache.http.client.cache.impl;
import org.apache.http.client.cache.impl.CacheableRequestPolicy;
import org.apache.http.message.BasicHttpRequest;
import org.junit.Assert;
import org.junit.Before;

83
httpclient-cache/src/test/java/org/apache/http/client/cache/impl/TestCachedHttpResponseGenerator.java vendored
View File

@ -31,8 +31,6 @@ import java.util.Date;
import org.apache.http.Header;
import org.apache.http.HttpResponse;
import org.apache.http.ProtocolVersion;
import org.apache.http.client.cache.impl.CacheEntry;
import org.apache.http.client.cache.impl.CachedHttpResponseGenerator;
import org.apache.http.impl.cookie.DateUtils;
import org.apache.http.message.BasicHeader;
import org.junit.Assert;
@ -43,14 +41,9 @@ public class TestCachedHttpResponseGenerator {
@Test
public void testResponseHasContentLength() {
CacheEntry entry = new CacheEntry();
Header[] hdrs = new Header[] {};
byte[] buf = new byte[] { 1, 2, 3, 4, 5 };
entry.setResponseHeaders(hdrs);
entry.setProtocolVersion(new ProtocolVersion("HTTP", 1, 1));
entry.setBody(buf);
entry.setResponseDate(new Date());
entry.setRequestDate(new Date());
CacheEntry entry = new CacheEntry(new Date(),new Date(),new ProtocolVersion("HTTP", 1, 1),hdrs,buf,200,"OK");
CachedHttpResponseGenerator gen = new CachedHttpResponseGenerator();
HttpResponse response = gen.generateResponse(entry);
@ -64,14 +57,11 @@ public class TestCachedHttpResponseGenerator {
@Test
public void testContentLengthIsNotAddedWhenTransferEncodingIsPresent() {
CacheEntry entry = new CacheEntry();
Header[] hdrs = new Header[] { new BasicHeader("Transfer-Encoding", "chunked") };
byte[] buf = new byte[] { 1, 2, 3, 4, 5 };
entry.setResponseHeaders(hdrs);
entry.setProtocolVersion(new ProtocolVersion("HTTP", 1, 1));
entry.setBody(buf);
entry.setResponseDate(new Date());
entry.setRequestDate(new Date());
CacheEntry entry = new CacheEntry(new Date(),new Date(),new ProtocolVersion("HTTP", 1, 1),hdrs,buf,200,"OK");
CachedHttpResponseGenerator gen = new CachedHttpResponseGenerator();
HttpResponse response = gen.generateResponse(entry);
@ -83,8 +73,7 @@ public class TestCachedHttpResponseGenerator {
@Test
public void testResponseMatchesCacheEntry() {
CacheEntry entry = new CacheEntry();
buildEntry(entry);
CacheEntry entry = buildEntry();
CachedHttpResponseGenerator gen = new CachedHttpResponseGenerator();
HttpResponse response = gen.generateResponse(entry);
@ -98,8 +87,7 @@ public class TestCachedHttpResponseGenerator {
@Test
public void testResponseStatusCodeMatchesCacheEntry() {
CacheEntry entry = new CacheEntry();
buildEntry(entry);
CacheEntry entry = buildEntry();
CachedHttpResponseGenerator gen = new CachedHttpResponseGenerator();
HttpResponse response = gen.generateResponse(entry);
@ -110,16 +98,8 @@ public class TestCachedHttpResponseGenerator {
@Test
public void testAgeHeaderIsPopulatedWithCurrentAgeOfCacheEntryIfNonZero() {
final long currAge = 10L;
CacheEntry entry = new CacheEntry() {
private static final long serialVersionUID = 1L;
@Override
public long getCurrentAgeSecs() {
return currAge;
}
};
buildEntry(entry);
CacheEntry entry = buildEntryWithCurrentAge(currAge);
CachedHttpResponseGenerator gen = new CachedHttpResponseGenerator();
HttpResponse response = gen.generateResponse(entry);
@ -132,15 +112,8 @@ public class TestCachedHttpResponseGenerator {
@Test
public void testAgeHeaderIsNotPopulatedIfCurrentAgeOfCacheEntryIsZero() {
final long currAge = 0L;
CacheEntry entry = new CacheEntry() {
private static final long serialVersionUID = 1L;
@Override
public long getCurrentAgeSecs() {
return currAge;
}
};
buildEntry(entry);
CacheEntry entry = buildEntryWithCurrentAge(currAge);
CachedHttpResponseGenerator gen = new CachedHttpResponseGenerator();
HttpResponse response = gen.generateResponse(entry);
@ -151,16 +124,8 @@ public class TestCachedHttpResponseGenerator {
@Test
public void testAgeHeaderIsPopulatedWithMaxAgeIfCurrentAgeTooBig() {
final long currAge = CacheEntry.MAX_AGE + 1L;
CacheEntry entry = new CacheEntry() {
private static final long serialVersionUID = 1L;
@Override
public long getCurrentAgeSecs() {
return currAge;
}
};
buildEntry(entry);
CacheEntry entry = buildEntryWithCurrentAge(CacheEntry.MAX_AGE + 1L);
CachedHttpResponseGenerator gen = new CachedHttpResponseGenerator();
HttpResponse response = gen.generateResponse(entry);
@ -170,7 +135,7 @@ public class TestCachedHttpResponseGenerator {
Assert.assertEquals(CacheEntry.MAX_AGE, Long.parseLong(ageHdr.getValue()));
}
private CacheEntry buildEntry(CacheEntry entry) {
private CacheEntry buildEntry() {
Date now = new Date();
Date sixSecondsAgo = new Date(now.getTime() - 6 * 1000L);
Date eightSecondsAgo = new Date(now.getTime() - 8 * 1000L);
@ -179,14 +144,30 @@ public class TestCachedHttpResponseGenerator {
Header[] hdrs = { new BasicHeader("Date", DateUtils.formatDate(eightSecondsAgo)),
new BasicHeader("Expires", DateUtils.formatDate(tenSecondsFromNow)),
new BasicHeader("Content-Length", "150") };
entry.setRequestDate(tenSecondsAgo);
entry.setResponseDate(sixSecondsAgo);
entry.setBody(new byte[] {});
entry.setResponseHeaders(hdrs);
entry.setProtocolVersion(new ProtocolVersion("HTTP", 1, 1));
return new CacheEntry(tenSecondsAgo,sixSecondsAgo,new ProtocolVersion("HTTP", 1, 1),hdrs,new byte[]{},200,"OK");
}
return entry;
private CacheEntry buildEntryWithCurrentAge(final long currAge){
Date now = new Date();
Date sixSecondsAgo = new Date(now.getTime() - 6 * 1000L);
Date eightSecondsAgo = new Date(now.getTime() - 8 * 1000L);
Date tenSecondsAgo = new Date(now.getTime() - 10 * 1000L);
Date tenSecondsFromNow = new Date(now.getTime() + 10 * 1000L);
Header[] hdrs = { new BasicHeader("Date", DateUtils.formatDate(eightSecondsAgo)),
new BasicHeader("Expires", DateUtils.formatDate(tenSecondsFromNow)),
new BasicHeader("Content-Length", "150") };
return new CacheEntry(tenSecondsAgo,sixSecondsAgo,new ProtocolVersion("HTTP", 1, 1),hdrs,new byte[]{},200,"OK"){
private static final long serialVersionUID = 1L;
@Override
public long getCurrentAgeSecs() {
return currAge;
}
};
}
}

2
httpclient-cache/src/test/java/org/apache/http/client/cache/impl/TestCachedResponseSuitabilityChecker.java vendored
View File

@ -29,8 +29,6 @@ package org.apache.http.client.cache.impl;
import org.apache.http.Header;
import org.apache.http.HttpHost;
import org.apache.http.HttpRequest;
import org.apache.http.client.cache.impl.CacheEntry;
import org.apache.http.client.cache.impl.CachedResponseSuitabilityChecker;
import org.apache.http.message.BasicHeader;
import org.apache.http.message.BasicHttpRequest;
import org.easymock.classextension.EasyMock;

176
httpclient-cache/src/test/java/org/apache/http/client/cache/impl/TestCachingHttpClient.java vendored
View File

@ -26,6 +26,8 @@
*/
package org.apache.http.client.cache.impl;
import static junit.framework.Assert.assertTrue;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.net.URI;
@ -33,34 +35,19 @@ import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import org.apache.http.Header;
import org.apache.http.HttpHost;
import org.apache.http.HttpRequest;
import org.apache.http.HttpResponse;
import org.apache.http.HttpStatus;
import org.apache.http.ProtocolException;
import org.apache.http.ProtocolVersion;
import org.apache.http.RequestLine;
import org.apache.http.StatusLine;
import org.apache.http.client.ClientProtocolException;
import org.apache.http.client.HttpClient;
import org.apache.http.client.ResponseHandler;
import org.apache.http.client.cache.HttpCacheUpdateCallback;
import org.apache.http.client.cache.HttpCache;
import org.apache.http.client.cache.impl.BasicHttpCache;
import org.apache.http.client.cache.impl.CacheEntry;
import org.apache.http.client.cache.impl.CacheEntryGenerator;
import org.apache.http.client.cache.impl.CacheEntryUpdater;
import org.apache.http.client.cache.impl.CacheInvalidator;
import org.apache.http.client.cache.impl.CacheableRequestPolicy;
import org.apache.http.client.cache.impl.CachedHttpResponseGenerator;
import org.apache.http.client.cache.impl.CachedResponseSuitabilityChecker;
import org.apache.http.client.cache.impl.CachingHttpClient;
import org.apache.http.client.cache.impl.ConditionalRequestBuilder;
import org.apache.http.client.cache.impl.RequestProtocolCompliance;
import org.apache.http.client.cache.impl.RequestProtocolError;
import org.apache.http.client.cache.impl.ResponseCachingPolicy;
import org.apache.http.client.cache.impl.ResponseProtocolCompliance;
import org.apache.http.client.cache.impl.SizeLimitedResponseReader;
import org.apache.http.client.cache.impl.URIExtractor;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpUriRequest;
import org.apache.http.conn.ClientConnectionManager;
@ -80,6 +67,8 @@ import org.junit.Test;
public class TestCachingHttpClient {
private static ProtocolVersion HTTP_1_1 = new ProtocolVersion("HTTP",1,1);
private static final String GET_CURRENT_DATE = "getCurrentDate";
private static final String HANDLE_BACKEND_RESPONSE = "handleBackendResponse";
@ -106,6 +95,7 @@ public class TestCachingHttpClient {
private HttpResponse mockBackendResponse;
private CacheEntry mockCacheEntry;
private CacheEntry mockVariantCacheEntry;
private CacheEntry mockUpdatedCacheEntry;
private URIExtractor mockExtractor;
private CacheEntryGenerator mockEntryGenerator;
private CachedHttpResponseGenerator mockResponseGenerator;
@ -153,6 +143,7 @@ public class TestCachingHttpClient {
mockBackendResponse = EasyMock.createMock(HttpResponse.class);
mockUriRequest = EasyMock.createMock(HttpUriRequest.class);
mockCacheEntry = EasyMock.createMock(CacheEntry.class);
mockUpdatedCacheEntry = EasyMock.createMock(CacheEntry.class);
mockVariantCacheEntry = EasyMock.createMock(CacheEntry.class);
mockExtractor = EasyMock.createMock(URIExtractor.class);
mockEntryGenerator = EasyMock.createMock(CacheEntryGenerator.class);
@ -168,14 +159,15 @@ public class TestCachingHttpClient {
mockRequestProtocolCompliance = EasyMock.createMock(RequestProtocolCompliance.class);
mockRequestLine = EasyMock.createMock(RequestLine.class);
requestDate = new Date(System.currentTimeMillis() - 1000);
responseDate = new Date();
host = new HttpHost("foo.example.com");
impl = new CachingHttpClient(mockBackend, mockResponsePolicy, mockEntryGenerator,
mockExtractor, mockCache, mockResponseGenerator, mockInvalidator,
mockRequestPolicy, mockSuitabilityChecker, mockConditionalRequestBuilder,
mockCacheEntryUpdater, mockResponseProtocolCompliance,
mockRequestProtocolCompliance);
mockExtractor, mockCache, mockResponseGenerator, mockInvalidator,
mockRequestPolicy, mockSuitabilityChecker, mockConditionalRequestBuilder,
mockCacheEntryUpdater, mockResponseProtocolCompliance,
mockRequestProtocolCompliance);
}
private void replayMocks() {
@ -264,7 +256,7 @@ public class TestCachingHttpClient {
replayMocks();
HttpResponse result = impl.handleBackendResponse(host, mockRequest, requestDate,
responseDate, mockBackendResponse);
responseDate, mockBackendResponse);
verifyMocks();
Assert.assertSame(mockCachedResponse, result);
@ -317,25 +309,24 @@ public class TestCachingHttpClient {
}
@Test
public void testCacheUpdateCallbackCreatesNewParentEntryWhenParentEntryNull() throws Exception {
public void testCacheUpdateAddsVariantURIToParentEntry() throws Exception {
final String variantURI = "variantURI";
extractVariantURI(variantURI);
putInCache(variantURI);
final CacheEntry entry = new CacheEntry(new Date(), new Date(),HTTP_1_1,new Header[]{},new byte[]{},200,"OK");
variantURIAddedToCacheEntry(variantURI);
extractVariantURI(variantURI, entry);
putInCache(variantURI, entry);
replayMocks();
HttpCacheUpdateCallback<CacheEntry> callbackImpl = impl
.storeVariantEntry(host, mockRequest, mockCacheEntry);
callbackImpl.getUpdatedEntry(null);
CacheEntry updatedEntry = impl.doGetUpdatedParentEntry(null, host, mockRequest, entry);
verifyMocks();
assertTrue(updatedEntry.getVariantURIs().contains(variantURI));
}
private void variantURIAddedToCacheEntry(String variantURI) {
mockCacheEntry.addVariantURI(variantURI);
}
@Test
public void testCacheMissCausesBackendRequest() throws Exception {
@ -417,15 +408,15 @@ public class TestCachingHttpClient {
getCurrentDateReturns(responseDate);
backendResponseCodeIs(HttpStatus.SC_OK);
cacheEntryUpdaterCalled();
cacheEntryHasVariants(false);
cacheEntryHasVariants(false, mockUpdatedCacheEntry);
extractTheURI("http://foo.example.com");
putInCache("http://foo.example.com");
responseIsGeneratedFromCache();
putInCache("http://foo.example.com", mockUpdatedCacheEntry);
responseIsGeneratedFromCache(mockUpdatedCacheEntry);
replayMocks();
HttpResponse result = impl.revalidateCacheEntry(host, mockRequest, mockContext,
mockCacheEntry);
mockCacheEntry);
verifyMocks();
@ -446,14 +437,13 @@ public class TestCachingHttpClient {
backendResponseCodeIs(HttpStatus.SC_NOT_MODIFIED);
cacheEntryUpdaterCalled();
storeInCacheWasCalled();
storeInCacheWasCalled(mockUpdatedCacheEntry);
responseIsGeneratedFromCache();
responseIsGeneratedFromCache(mockUpdatedCacheEntry);
replayMocks();
HttpResponse result = impl.revalidateCacheEntry(host, mockRequest, mockContext,
mockCacheEntry);
HttpResponse result = impl.revalidateCacheEntry(host, mockRequest, mockContext, mockCacheEntry);
verifyMocks();
@ -509,7 +499,7 @@ public class TestCachingHttpClient {
replayMocks();
HttpResponse result = impl.handleBackendResponse(host, mockRequest, currentDate,
currentDate, mockBackendResponse);
currentDate, mockBackendResponse);
verifyMocks();
Assert.assertSame(mockBackendResponse, result);
@ -628,10 +618,10 @@ public class TestCachingHttpClient {
final HttpRequest theRequest = mockRequest;
final HttpResponse theResponse = mockBackendResponse;
impl = new CachingHttpClient(mockBackend, mockResponsePolicy, mockEntryGenerator,
mockExtractor, mockCache, mockResponseGenerator, mockInvalidator,
mockRequestPolicy, mockSuitabilityChecker, mockConditionalRequestBuilder,
mockCacheEntryUpdater, mockResponseProtocolCompliance,
mockRequestProtocolCompliance) {
mockExtractor, mockCache, mockResponseGenerator, mockInvalidator,
mockRequestPolicy, mockSuitabilityChecker, mockConditionalRequestBuilder,
mockCacheEntryUpdater, mockResponseProtocolCompliance,
mockRequestProtocolCompliance) {
@Override
public HttpResponse execute(HttpHost target, HttpRequest request, HttpContext context) {
Assert.assertSame(theHost, target);
@ -660,13 +650,13 @@ public class TestCachingHttpClient {
final ResponseHandler<Object> theHandler = mockHandler;
final Object value = new Object();
impl = new CachingHttpClient(mockBackend, mockResponsePolicy, mockEntryGenerator,
mockExtractor, mockCache, mockResponseGenerator, mockInvalidator,
mockRequestPolicy, mockSuitabilityChecker, mockConditionalRequestBuilder,
mockCacheEntryUpdater, mockResponseProtocolCompliance,
mockRequestProtocolCompliance) {
mockExtractor, mockCache, mockResponseGenerator, mockInvalidator,
mockRequestPolicy, mockSuitabilityChecker, mockConditionalRequestBuilder,
mockCacheEntryUpdater, mockResponseProtocolCompliance,
mockRequestProtocolCompliance) {
@Override
public <T> T execute(HttpHost target, HttpRequest request,
ResponseHandler<? extends T> rh, HttpContext context) {
ResponseHandler<? extends T> rh, HttpContext context) {
Assert.assertSame(theHost, target);
Assert.assertSame(theRequest, request);
Assert.assertSame(theHandler, rh);
@ -700,10 +690,10 @@ public class TestCachingHttpClient {
final HttpResponse theResponse = mockBackendResponse;
final HttpContext theContext = mockContext;
impl = new CachingHttpClient(mockBackend, mockResponsePolicy, mockEntryGenerator,
mockExtractor, mockCache, mockResponseGenerator, mockInvalidator,
mockRequestPolicy, mockSuitabilityChecker, mockConditionalRequestBuilder,
mockCacheEntryUpdater, mockResponseProtocolCompliance,
mockRequestProtocolCompliance) {
mockExtractor, mockCache, mockResponseGenerator, mockInvalidator,
mockRequestPolicy, mockSuitabilityChecker, mockConditionalRequestBuilder,
mockCacheEntryUpdater, mockResponseProtocolCompliance,
mockRequestProtocolCompliance) {
@Override
public HttpResponse execute(HttpHost target, HttpRequest request, HttpContext context) {
Assert.assertSame(theHost, target);
@ -732,10 +722,10 @@ public class TestCachingHttpClient {
final HttpUriRequest theRequest = mockUriRequest;
final HttpResponse theResponse = mockBackendResponse;
impl = new CachingHttpClient(mockBackend, mockResponsePolicy, mockEntryGenerator,
mockExtractor, mockCache, mockResponseGenerator, mockInvalidator,
mockRequestPolicy, mockSuitabilityChecker, mockConditionalRequestBuilder,
mockCacheEntryUpdater, mockResponseProtocolCompliance,
mockRequestProtocolCompliance) {
mockExtractor, mockCache, mockResponseGenerator, mockInvalidator,
mockRequestPolicy, mockSuitabilityChecker, mockConditionalRequestBuilder,
mockCacheEntryUpdater, mockResponseProtocolCompliance,
mockRequestProtocolCompliance) {
@Override
public HttpResponse execute(HttpUriRequest request, HttpContext context) {
Assert.assertSame(theRequest, request);
@ -762,10 +752,10 @@ public class TestCachingHttpClient {
final HttpContext theContext = mockContext;
final HttpResponse theResponse = mockBackendResponse;
impl = new CachingHttpClient(mockBackend, mockResponsePolicy, mockEntryGenerator,
mockExtractor, mockCache, mockResponseGenerator, mockInvalidator,
mockRequestPolicy, mockSuitabilityChecker, mockConditionalRequestBuilder,
mockCacheEntryUpdater, mockResponseProtocolCompliance,
mockRequestProtocolCompliance) {
mockExtractor, mockCache, mockResponseGenerator, mockInvalidator,
mockRequestPolicy, mockSuitabilityChecker, mockConditionalRequestBuilder,
mockCacheEntryUpdater, mockResponseProtocolCompliance,
mockRequestProtocolCompliance) {
@Override
public HttpResponse execute(HttpHost hh, HttpRequest req, HttpContext ctx) {
Assert.assertEquals("sch", hh.getSchemeName());
@ -795,13 +785,13 @@ public class TestCachingHttpClient {
final HttpResponse theResponse = mockBackendResponse;
final Object theValue = new Object();
impl = new CachingHttpClient(mockBackend, mockResponsePolicy, mockEntryGenerator,
mockExtractor, mockCache, mockResponseGenerator, mockInvalidator,
mockRequestPolicy, mockSuitabilityChecker, mockConditionalRequestBuilder,
mockCacheEntryUpdater, mockResponseProtocolCompliance,
mockRequestProtocolCompliance) {
mockExtractor, mockCache, mockResponseGenerator, mockInvalidator,
mockRequestPolicy, mockSuitabilityChecker, mockConditionalRequestBuilder,
mockCacheEntryUpdater, mockResponseProtocolCompliance,
mockRequestProtocolCompliance) {
@Override
public <T> T execute(HttpUriRequest request, ResponseHandler<? extends T> handler,
HttpContext context) throws IOException {
HttpContext context) throws IOException {
Assert.assertSame(theRequest, request);
Assert.assertNull(context);
c.incr();
@ -830,10 +820,10 @@ public class TestCachingHttpClient {
final HttpResponse theResponse = mockBackendResponse;
final Object theValue = new Object();
impl = new CachingHttpClient(mockBackend, mockResponsePolicy, mockEntryGenerator,
mockExtractor, mockCache, mockResponseGenerator, mockInvalidator,
mockRequestPolicy, mockSuitabilityChecker, mockConditionalRequestBuilder,
mockCacheEntryUpdater, mockResponseProtocolCompliance,
mockRequestProtocolCompliance) {
mockExtractor, mockCache, mockResponseGenerator, mockInvalidator,
mockRequestPolicy, mockSuitabilityChecker, mockConditionalRequestBuilder,
mockCacheEntryUpdater, mockResponseProtocolCompliance,
mockRequestProtocolCompliance) {
@Override
public HttpResponse execute(HttpUriRequest request, HttpContext context)
throws IOException {
@ -949,7 +939,7 @@ public class TestCachingHttpClient {
response.getEntity().writeTo(s1);
return s1.toByteArray();
} catch (Exception ex) {
return new byte[] {};
return new byte[]{};
}
@ -976,8 +966,9 @@ public class TestCachingHttpClient {
}
private void cacheEntryUpdaterCalled() {
mockCacheEntryUpdater.updateCacheEntry(mockCacheEntry, requestDate, responseDate,
mockBackendResponse);
EasyMock.expect(
mockCacheEntryUpdater.updateCacheEntry(mockCacheEntry, requestDate, responseDate,
mockBackendResponse)).andReturn(mockUpdatedCacheEntry);
}
private void getCacheEntryReturns(CacheEntry entry) {
@ -1061,43 +1052,64 @@ public class TestCachingHttpClient {
org.easymock.EasyMock.expect(mockCacheEntry.hasVariants()).andReturn(b);
}
private void cacheEntryHasVariants(boolean b, CacheEntry entry) {
EasyMock.expect(entry.hasVariants()).andReturn(b);
}
private void responseIsGeneratedFromCache() {
org.easymock.EasyMock.expect(mockResponseGenerator.generateResponse(mockCacheEntry))
.andReturn(mockCachedResponse);
}
private void responseIsGeneratedFromCache(CacheEntry entry) {
org.easymock.EasyMock.expect(mockResponseGenerator.generateResponse(entry))
.andReturn(mockCachedResponse);
}
private void extractTheURI(String theURI) {
org.easymock.EasyMock.expect(mockExtractor.getURI(host, mockRequest)).andReturn(theURI);
}
private void extractVariantURI(String variantURI) {
extractVariantURI(variantURI,mockCacheEntry);
}
private void extractVariantURI(String variantURI, CacheEntry entry){
org.easymock.EasyMock
.expect(mockExtractor.getVariantURI(host, mockRequest, mockCacheEntry)).andReturn(
variantURI);
.expect(mockExtractor.getVariantURI(host, mockRequest, entry)).andReturn(
variantURI);
}
private void putInCache(String theURI) throws Exception {
mockCache.putEntry(theURI, mockCacheEntry);
}
private void putInCache(String theURI, CacheEntry entry) throws Exception {
mockCache.putEntry(theURI, entry);
}
private void generateCacheEntry(Date requestDate, Date responseDate, byte[] bytes)
throws IOException {
org.easymock.EasyMock.expect(
mockEntryGenerator.generateEntry(requestDate, responseDate, mockBackendResponse,
bytes)).andReturn(mockCacheEntry);
bytes)).andReturn(mockCacheEntry);
}
private void handleBackendResponseReturnsResponse(HttpRequest request, HttpResponse response)
throws IOException {
org.easymock.EasyMock.expect(
impl.handleBackendResponse(host, request, requestDate, responseDate,
mockBackendResponse)).andReturn(response);
mockBackendResponse)).andReturn(response);
}
private void storeInCacheWasCalled() {
impl.storeInCache(host, mockRequest, mockCacheEntry);
}
private void storeInCacheWasCalled(CacheEntry entry) {
impl.storeInCache(host, mockRequest, entry);
}
private void responseProtocolValidationIsCalled() throws ClientProtocolException {
mockResponseProtocolCompliance.ensureProtocolCompliance(mockRequest, mockBackendResponse);
}
@ -1117,10 +1129,10 @@ public class TestCachingHttpClient {
private void mockImplMethods(String... methods) {
mockedImpl = true;
impl = EasyMock.createMockBuilder(CachingHttpClient.class).withConstructor(mockBackend,
mockResponsePolicy, mockEntryGenerator, mockExtractor, mockCache,
mockResponseGenerator, mockInvalidator, mockRequestPolicy, mockSuitabilityChecker,
mockConditionalRequestBuilder, mockCacheEntryUpdater,
mockResponseProtocolCompliance, mockRequestProtocolCompliance).addMockedMethods(
mockResponsePolicy, mockEntryGenerator, mockExtractor, mockCache,
mockResponseGenerator, mockInvalidator, mockRequestPolicy, mockSuitabilityChecker,
mockConditionalRequestBuilder, mockCacheEntryUpdater,
mockResponseProtocolCompliance, mockRequestProtocolCompliance).addMockedMethods(
methods).createMock();
}
}

1
httpclient-cache/src/test/java/org/apache/http/client/cache/impl/TestCombinedInputStream.java vendored
View File

@ -29,7 +29,6 @@ package org.apache.http.client.cache.impl;
import java.io.ByteArrayInputStream;
import java.io.InputStream;
import org.apache.http.client.cache.impl.CombinedInputStream;
import org.easymock.classextension.EasyMock;
import org.junit.Assert;
import org.junit.Before;

17
httpclient-cache/src/test/java/org/apache/http/client/cache/impl/TestConditionalRequestBuilder.java vendored
View File

@ -31,8 +31,7 @@ import java.util.Date;
import org.apache.http.Header;
import org.apache.http.HttpRequest;
import org.apache.http.ProtocolException;
import org.apache.http.client.cache.impl.CacheEntry;
import org.apache.http.client.cache.impl.ConditionalRequestBuilder;
import org.apache.http.ProtocolVersion;
import org.apache.http.impl.cookie.DateUtils;
import org.apache.http.message.BasicHeader;
import org.apache.http.message.BasicHttpRequest;
@ -58,11 +57,11 @@ public class TestConditionalRequestBuilder {
HttpRequest request = new BasicHttpRequest(theMethod, theUri);
request.addHeader("Accept-Encoding", "gzip");
CacheEntry cacheEntry = new CacheEntry();
cacheEntry.setResponseHeaders(new Header[] {
Header[] headers = new Header[] {
new BasicHeader("Date", DateUtils.formatDate(new Date())),
new BasicHeader("Last-Modified", lastModified) });
new BasicHeader("Last-Modified", lastModified) };
CacheEntry cacheEntry = new CacheEntry(new Date(),new Date(),new ProtocolVersion("HTTP",1,1),headers, new byte[]{},200,"OK");
HttpRequest newRequest = impl.buildConditionalRequest(request, cacheEntry);
Assert.assertNotSame(request, newRequest);
@ -89,11 +88,13 @@ public class TestConditionalRequestBuilder {
HttpRequest request = new BasicHttpRequest(theMethod, theUri);
request.addHeader("Accept-Encoding", "gzip");
CacheEntry cacheEntry = new CacheEntry();
cacheEntry.setResponseHeaders(new Header[] {
Header[] headers = new Header[] {
new BasicHeader("Date", DateUtils.formatDate(new Date())),
new BasicHeader("Last-Modified", DateUtils.formatDate(new Date())),
new BasicHeader("ETag", theETag) });
new BasicHeader("ETag", theETag) };
CacheEntry cacheEntry = new CacheEntry(new Date(),new Date(),new ProtocolVersion("HTTP",1,1),headers, new byte[]{},200,"OK");
HttpRequest newRequest = impl.buildConditionalRequest(request, cacheEntry);

9
httpclient-cache/src/test/java/org/apache/http/client/cache/impl/TestDefaultCacheEntrySerializer.java vendored
View File

@ -35,8 +35,6 @@ import org.apache.http.Header;
import org.apache.http.HttpVersion;
import org.apache.http.ProtocolVersion;
import org.apache.http.client.cache.HttpCacheEntrySerializer;
import org.apache.http.client.cache.impl.CacheEntry;
import org.apache.http.client.cache.impl.DefaultCacheEntrySerializer;
import org.apache.http.message.BasicHeader;
import org.junit.Assert;
import org.junit.Test;
@ -64,7 +62,6 @@ public class TestDefaultCacheEntrySerializer {
private CacheEntry newCacheEntry() {
CacheEntry cacheEntry = new CacheEntry();
Header[] headers = new Header[5];
for (int i = 0; i < headers.length; i++) {
@ -73,11 +70,7 @@ public class TestDefaultCacheEntrySerializer {
ProtocolVersion version = new HttpVersion(1, 1);
String body = "Lorem ipsum dolor sit amet";
cacheEntry.setResponseHeaders(headers);
cacheEntry.setProtocolVersion(version);
cacheEntry.setRequestDate(new Date());
cacheEntry.setResponseDate(new Date());
cacheEntry.setBody(body.getBytes());
CacheEntry cacheEntry = new CacheEntry(new Date(),new Date(), version, headers, body.getBytes(),200,"OK");
return cacheEntry;

2
httpclient-cache/src/test/java/org/apache/http/client/cache/impl/TestProtocolDeviations.java vendored
View File

@ -39,8 +39,6 @@ import org.apache.http.ProtocolVersion;
import org.apache.http.client.ClientProtocolException;
import org.apache.http.client.HttpClient;
import org.apache.http.client.cache.HttpCache;
import org.apache.http.client.cache.impl.BasicHttpCache;
import org.apache.http.client.cache.impl.CachingHttpClient;
import org.apache.http.entity.ByteArrayEntity;
import org.apache.http.impl.cookie.DateUtils;
import org.apache.http.message.BasicHttpEntityEnclosingRequest;

139
httpclient-cache/src/test/java/org/apache/http/client/cache/impl/TestProtocolRequirements.java vendored
View File

@ -43,15 +43,14 @@ import org.apache.http.ProtocolVersion;
import org.apache.http.client.ClientProtocolException;
import org.apache.http.client.HttpClient;
import org.apache.http.client.cache.HttpCache;
import org.apache.http.client.cache.impl.BasicHttpCache;
import org.apache.http.client.cache.impl.CacheEntry;
import org.apache.http.client.cache.impl.CachingHttpClient;
import org.apache.http.entity.ByteArrayEntity;
import org.apache.http.impl.client.RequestWrapper;
import org.apache.http.impl.cookie.DateUtils;
import org.apache.http.message.BasicHeader;
import org.apache.http.message.BasicHttpEntityEnclosingRequest;
import org.apache.http.message.BasicHttpRequest;
import org.apache.http.message.BasicHttpResponse;
import org.apache.http.message.HeaderGroup;
import org.apache.http.protocol.HttpContext;
import org.easymock.Capture;
import org.easymock.IExpectationSetters;
@ -2063,52 +2062,53 @@ public class TestProtocolRequirements {
public void testCacheEntryIsUpdatedWithNewFieldValuesIn304Response() throws Exception {
Date now = new Date();
Date inOneSecond = new Date(now.getTime() + 1000L);
HttpRequest req1 = new BasicHttpRequest("GET", "/", HTTP_1_1);
HttpResponse resp1 = make200Response();
resp1.setHeader("Cache-Control", "max-age=3600");
resp1.setHeader("ETag", "\"etag\"");
Date inFiveSeconds = new Date(now.getTime() + 5000L);
HttpRequest req2 = new BasicHttpRequest("GET", "/", HTTP_1_1);
req2.setHeader("Cache-Control", "max-age=0,max-stale=0");
HttpRequest initialRequest = new BasicHttpRequest("GET", "/", HTTP_1_1);
HttpRequest conditionalValidation = new BasicHttpRequest("GET", "/", HTTP_1_1);
conditionalValidation.setHeader("If-None-Match", "\"etag\"");
HttpResponse cachedResponse = make200Response();
cachedResponse.setHeader("Cache-Control", "max-age=3600");
cachedResponse.setHeader("ETag", "\"etag\"");
HttpRequest unconditionalValidation = new BasicHttpRequest("GET", "/", HTTP_1_1);
HttpRequest secondRequest = new BasicHttpRequest("GET", "/", HTTP_1_1);
secondRequest.setHeader("Cache-Control", "max-age=0,max-stale=0");
HttpRequest conditionalValidationRequest = new BasicHttpRequest("GET", "/", HTTP_1_1);
conditionalValidationRequest.setHeader("If-None-Match", "\"etag\"");
HttpRequest unconditionalValidationRequest = new BasicHttpRequest("GET", "/", HTTP_1_1);
// to be used if the cache generates a conditional validation
HttpResponse resp2 = new BasicHttpResponse(HTTP_1_1, HttpStatus.SC_NOT_MODIFIED,
"Not Modified");
resp2.setHeader("Date", DateUtils.formatDate(inOneSecond));
resp2.setHeader("Server", "MockUtils/1.0");
resp2.setHeader("ETag", "\"etag\"");
resp2.setHeader("X-Extra", "junk");
HttpResponse conditionalResponse = new BasicHttpResponse(HTTP_1_1, HttpStatus.SC_NOT_MODIFIED, "Not Modified");
conditionalResponse.setHeader("Date", DateUtils.formatDate(inFiveSeconds));
conditionalResponse.setHeader("Server", "MockUtils/1.0");
conditionalResponse.setHeader("ETag", "\"etag\"");
conditionalResponse.setHeader("X-Extra", "junk");
// to be used if the cache generates an unconditional validation
HttpResponse resp3 = make200Response();
resp3.setHeader("Date", DateUtils.formatDate(inOneSecond));
resp3.setHeader("ETag", "\"etag\"");
HttpResponse unconditionalResponse = make200Response();
unconditionalResponse.setHeader("Date", DateUtils.formatDate(inFiveSeconds));
unconditionalResponse.setHeader("ETag", "\"etag\"");
Capture<HttpRequest> cap1 = new Capture<HttpRequest>();
Capture<HttpRequest> cap2 = new Capture<HttpRequest>();
EasyMock.expect(
mockBackend.execute(EasyMock.isA(HttpHost.class), EasyMock.isA(HttpRequest.class),
(HttpContext) EasyMock.isNull())).andReturn(resp1);
(HttpContext) EasyMock.isNull())).andReturn(cachedResponse);
EasyMock.expect(
mockBackend.execute(EasyMock.eq(host), EasyMock.and(
eqRequest(conditionalValidation), EasyMock.capture(cap1)),
(HttpContext) EasyMock.isNull())).andReturn(resp2).times(0, 1);
eqRequest(conditionalValidationRequest), EasyMock.capture(cap1)),
(HttpContext) EasyMock.isNull())).andReturn(conditionalResponse).times(0, 1);
EasyMock.expect(
mockBackend.execute(EasyMock.eq(host), EasyMock.and(
eqRequest(unconditionalValidation), EasyMock.capture(cap2)),
(HttpContext) EasyMock.isNull())).andReturn(resp3).times(0, 1);
eqRequest(unconditionalValidationRequest), EasyMock.capture(cap2)),
(HttpContext) EasyMock.isNull())).andReturn(unconditionalResponse).times(0, 1);
replayMocks();
impl.execute(host, req1);
HttpResponse result = impl.execute(host, req2);
impl.execute(host, initialRequest);
HttpResponse result = impl.execute(host, secondRequest);
verifyMocks();
@ -2116,7 +2116,7 @@ public class TestProtocolRequirements {
|| (!cap1.hasCaptured() && cap2.hasCaptured()));
if (cap1.hasCaptured()) {
Assert.assertEquals(DateUtils.formatDate(inOneSecond), result.getFirstHeader("Date")
Assert.assertEquals(DateUtils.formatDate(inFiveSeconds), result.getFirstHeader("Date")
.getValue());
Assert.assertEquals("junk", result.getFirstHeader("X-Extra").getValue());
}
@ -2297,17 +2297,20 @@ public class TestProtocolRequirements {
Date nineSecondsAgo = new Date(now.getTime() - 9 * 1000L);
Date eightSecondsAgo = new Date(now.getTime() - 8 * 1000L);
originResponse.setHeader("Date", DateUtils.formatDate(nineSecondsAgo));
originResponse.setHeader("Cache-Control", "max-age=0");
originResponse.setHeader("ETag", "\"etag\"");
originResponse.setHeader("Content-Length", "128");
FakeHeaderGroup headerGroup = new FakeHeaderGroup();
headerGroup.addHeader("Date", DateUtils.formatDate(nineSecondsAgo));
headerGroup.addHeader("Cache-Control", "max-age=0");
headerGroup.addHeader("ETag", "\"etag\"");
headerGroup.addHeader("Content-Length", "128");
byte[] bytes = new byte[128];
(new Random()).nextBytes(bytes);
CacheEntry entry = new CacheEntry(tenSecondsAgo, eightSecondsAgo, originResponse, bytes);
CacheEntry entry = new CacheEntry(tenSecondsAgo, eightSecondsAgo, HTTP_1_1, headerGroup.getAllHeaders(),bytes,200,"OK");
mockCache.putEntry("http://foo.example.com/thing", entry);
mockCache.putEntry(EasyMock.eq("http://foo.example.com/thing"), EasyMock.isA(CacheEntry.class));
impl = new CachingHttpClient(mockBackend, mockCache, MAX_BYTES);
@ -2339,14 +2342,18 @@ public class TestProtocolRequirements {
Date tenSecondsAgo = new Date(now.getTime() - 10 * 1000L);
Date nineSecondsAgo = new Date(now.getTime() - 9 * 1000L);
Date eightSecondsAgo = new Date(now.getTime() - 8 * 1000L);
FakeHeaderGroup headerGroup = new FakeHeaderGroup();
originResponse.setHeader("Date", DateUtils.formatDate(nineSecondsAgo));
originResponse.setHeader("Cache-Control", "max-age=3600");
originResponse.setHeader("Content-Length", "128");
headerGroup.addHeader("Date", DateUtils.formatDate(nineSecondsAgo));
headerGroup.addHeader("Cache-Control", "max-age=3600");
headerGroup.addHeader("Content-Length", "128");
byte[] bytes = new byte[128];
(new Random()).nextBytes(bytes);
CacheEntry entry = new CacheEntry(tenSecondsAgo, eightSecondsAgo, originResponse, bytes);
CacheEntry entry = new CacheEntry(tenSecondsAgo, eightSecondsAgo, HTTP_1_1, headerGroup.getAllHeaders(),bytes,200,"OK");
impl = new CachingHttpClient(mockBackend, mockCache, MAX_BYTES);
@ -2377,14 +2384,18 @@ public class TestProtocolRequirements {
Date nineSecondsAgo = new Date(now.getTime() - 9 * 1000L);
Date eightSecondsAgo = new Date(now.getTime() - 8 * 1000L);
originResponse.setHeader("Date", DateUtils.formatDate(nineSecondsAgo));
originResponse.setHeader("Cache-Control", "max-age=0");
originResponse.setHeader("Content-Length", "128");
originResponse.setHeader("Last-Modified", DateUtils.formatDate(tenSecondsAgo));
FakeHeaderGroup headerGroup = new FakeHeaderGroup();
headerGroup.addHeader("Date", DateUtils.formatDate(nineSecondsAgo));
headerGroup.addHeader("Cache-Control", "max-age=0");
headerGroup.addHeader("Content-Length", "128");
headerGroup.addHeader("Last-Modified", DateUtils.formatDate(tenSecondsAgo));
byte[] bytes = new byte[128];
(new Random()).nextBytes(bytes);
CacheEntry entry = new CacheEntry(tenSecondsAgo, eightSecondsAgo, originResponse, bytes);
CacheEntry entry = new CacheEntry(tenSecondsAgo, eightSecondsAgo, HTTP_1_1, headerGroup.getAllHeaders(),bytes,200,"OK");
impl = new CachingHttpClient(mockBackend, mockCache, MAX_BYTES);
@ -2558,14 +2569,16 @@ public class TestProtocolRequirements {
Date nineSecondsAgo = new Date(now.getTime() - 9 * 1000L);
Date eightSecondsAgo = new Date(now.getTime() - 8 * 1000L);
originResponse.setHeader("Date", DateUtils.formatDate(nineSecondsAgo));
originResponse.setHeader("Cache-Control", "max-age=3600");
originResponse.setHeader("Content-Length", "128");
FakeHeaderGroup headerGroup = new FakeHeaderGroup();
headerGroup.setHeader("Date", DateUtils.formatDate(nineSecondsAgo));
headerGroup.setHeader("Cache-Control", "max-age=3600");
headerGroup.setHeader("Content-Length", "128");
byte[] bytes = new byte[128];
(new Random()).nextBytes(bytes);
originResponse.setEntity(new ByteArrayEntity(bytes));
CacheEntry entry = new CacheEntry(tenSecondsAgo, eightSecondsAgo, originResponse, bytes);
CacheEntry entry = new CacheEntry(tenSecondsAgo, eightSecondsAgo, HTTP_1_1, headerGroup.getAllHeaders(),bytes,200,"OK");
impl = new CachingHttpClient(mockBackend, mockCache, MAX_BYTES);
@ -2599,15 +2612,17 @@ public class TestProtocolRequirements {
Date requestTime = new Date(thirtySixHoursAgo.getTime() - 1000L);
Date responseTime = new Date(thirtySixHoursAgo.getTime() + 1000L);
originResponse.setHeader("Date", DateUtils.formatDate(thirtySixHoursAgo));
originResponse.setHeader("Cache-Control", "public");
originResponse.setHeader("Last-Modified", DateUtils.formatDate(oneYearAgo));
originResponse.setHeader("Content-Length", "128");
FakeHeaderGroup headerGroup = new FakeHeaderGroup();
headerGroup.setHeader("Date", DateUtils.formatDate(thirtySixHoursAgo));
headerGroup.setHeader("Cache-Control", "public");
headerGroup.setHeader("Last-Modified", DateUtils.formatDate(oneYearAgo));
headerGroup.setHeader("Content-Length", "128");
byte[] bytes = new byte[128];
(new Random()).nextBytes(bytes);
originResponse.setEntity(new ByteArrayEntity(bytes));
CacheEntry entry = new CacheEntry(requestTime, responseTime, originResponse, bytes);
CacheEntry entry = new CacheEntry(requestTime, responseTime, HTTP_1_1, headerGroup.getAllHeaders(),bytes,200,"OK");
impl = new CachingHttpClient(mockBackend, mockCache, MAX_BYTES);
@ -3139,4 +3154,16 @@ public class TestProtocolRequirements {
testDoesNotAddHeaderOnCacheHit("Last-Modified");
}
private class FakeHeaderGroup extends HeaderGroup{
public void addHeader(String name, String value){
this.addHeader(new BasicHeader(name,value));
}
public void setHeader(String name, String value){
addHeader(name,value);
}
}
}

43
httpclient-cache/src/test/java/org/apache/http/client/cache/impl/TestResponseCache.java vendored
View File

@ -28,35 +28,35 @@ package org.apache.http.client.cache.impl;
import org.apache.http.client.cache.HttpCacheOperationException;
import org.apache.http.client.cache.HttpCacheUpdateCallback;
import org.apache.http.client.cache.impl.BasicHttpCache;
import org.apache.http.client.cache.impl.CacheEntry;
import org.easymock.classextension.EasyMock;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Ignore;
import org.junit.Test;
public class TestResponseCache {
private BasicHttpCache cache;
private CacheEntry mockEntry;
@Before
public void setUp() {
cache = new BasicHttpCache(5);
mockEntry = EasyMock.createMock(CacheEntry.class);
}
@Test
public void testEntryRemainsInCacheWhenPutThere() {
CacheEntry entry = new CacheEntry();
cache.putEntry("foo", entry);
cache.putEntry("foo", mockEntry);
CacheEntry cachedEntry = cache.getEntry("foo");
Assert.assertSame(entry, cachedEntry);
Assert.assertSame(mockEntry, cachedEntry);
}
@Test
public void testRemovedEntriesDoNotExistAnymore() {
CacheEntry entry = new CacheEntry();
cache.putEntry("foo", entry);
cache.putEntry("foo", mockEntry);
cache.removeEntry("foo");
@ -69,13 +69,13 @@ public class TestResponseCache {
public void testCacheHoldsNoMoreThanSpecifiedMaxEntries() {
BasicHttpCache cache = new BasicHttpCache(1);
CacheEntry entry1 = new CacheEntry();
CacheEntry entry1 = EasyMock.createMock(CacheEntry.class);
cache.putEntry("foo", entry1);
CacheEntry entry2 = new CacheEntry();
CacheEntry entry2 = EasyMock.createMock(CacheEntry.class);
cache.putEntry("bar", entry2);
CacheEntry entry3 = new CacheEntry();
CacheEntry entry3 = EasyMock.createMock(CacheEntry.class);
cache.putEntry("baz", entry3);
CacheEntry e1 = cache.getEntry("foo");
@ -96,7 +96,7 @@ public class TestResponseCache {
// fill the cache with entries
for (int i = 0; i < max_size; i++) {
CacheEntry entry = new CacheEntry();
CacheEntry entry = EasyMock.createMock(CacheEntry.class);
cache.putEntry("entry" + i, entry);
}
@ -105,7 +105,7 @@ public class TestResponseCache {
// add another entry, which kicks out the eldest (should be the 2nd one
// created), and becomes the new MRU entry
CacheEntry newMru = new CacheEntry();
CacheEntry newMru = EasyMock.createMock(CacheEntry.class);
cache.putEntry("newMru", newMru);
// get the original second eldest
@ -123,7 +123,7 @@ public class TestResponseCache {
public void testZeroMaxSizeCacheDoesNotStoreAnything() {
BasicHttpCache cache = new BasicHttpCache(0);
CacheEntry entry = new CacheEntry();
CacheEntry entry = EasyMock.createMock(CacheEntry.class);
cache.putEntry("foo", entry);
CacheEntry gone = cache.getEntry("foo");
@ -132,12 +132,13 @@ public class TestResponseCache {
}
@Test
@Ignore
public void testCacheEntryCallbackUpdatesCacheEntry() throws HttpCacheOperationException {
final byte[] expectedArray = new byte[] { 1, 2, 3, 4, 5 };
CacheEntry entry = new CacheEntry();
CacheEntry entry2 = new CacheEntry();
CacheEntry entry = EasyMock.createMock(CacheEntry.class);
CacheEntry entry2 = EasyMock.createMock(CacheEntry.class);
cache.putEntry("foo", entry);
cache.putEntry("bar", entry2);
@ -145,10 +146,16 @@ public class TestResponseCache {
cache.updateCacheEntry("foo", new HttpCacheUpdateCallback<CacheEntry>() {
public CacheEntry getUpdatedEntry(CacheEntry existing) {
existing.setBody(expectedArray);
CacheEntry updated = new CacheEntry(
existing.getRequestDate(),
existing.getRequestDate(),
existing.getProtocolVersion(),
existing.getAllHeaders(),
expectedArray,
existing.getStatusCode(),
existing.getReasonPhrase());
cache.removeEntry("bar");
return existing;
return updated;
}
});

1
httpclient-cache/src/test/java/org/apache/http/client/cache/impl/TestResponseCachingPolicy.java vendored
View File

@ -33,7 +33,6 @@ import org.apache.http.HttpRequest;
import org.apache.http.HttpResponse;
import org.apache.http.HttpStatus;
import org.apache.http.ProtocolVersion;
import org.apache.http.client.cache.impl.ResponseCachingPolicy;
import org.apache.http.impl.cookie.DateUtils;
import org.apache.http.message.BasicHttpRequest;
import org.apache.http.message.BasicHttpResponse;

1
httpclient-cache/src/test/java/org/apache/http/client/cache/impl/TestSizeLimitedResponseReader.java vendored
View File

@ -34,7 +34,6 @@ import org.apache.http.Header;
import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.ProtocolVersion;
import org.apache.http.client.cache.impl.SizeLimitedResponseReader;
import org.easymock.classextension.EasyMock;
import org.junit.Assert;
import org.junit.Before;

2
httpclient-cache/src/test/java/org/apache/http/client/cache/impl/TestURIExtractor.java vendored
View File

@ -29,8 +29,6 @@ package org.apache.http.client.cache.impl;
import org.apache.http.Header;
import org.apache.http.HttpHost;
import org.apache.http.HttpRequest;
import org.apache.http.client.cache.impl.CacheEntry;
import org.apache.http.client.cache.impl.URIExtractor;
import org.apache.http.message.BasicHeader;
import org.apache.http.message.BasicHttpRequest;
import org.easymock.classextension.EasyMock;