HTTPCLIENT-2277: Aligned ResponseCachingPolicy with the specification requirements per RFC 9111 section 3
This commit is contained in:
Oleg Kalnichevski
parent
fcb86dae11
commit
99eb13934f
|
|
@ -462,6 +462,11 @@ class AsyncCachingExec extends CachingExecBase implements AsyncExecChainHandler
|
|||
}
|
||||
|
||||
});
|
||||
if (isResponseTooBig(entityDetails)) {
|
||||
LOG.debug("Backend response is known to be too big");
|
||||
return asyncExecCallback.handleResponse(backendResponse, entityDetails);
|
||||
}
|
||||
|
||||
final ResponseCacheControl responseCacheControl = CacheControlHeaderParser.INSTANCE.parse(backendResponse);
|
||||
final boolean cacheable = responseCachingPolicy.isResponseCacheable(responseCacheControl, request, backendResponse);
|
||||
if (cacheable) {
|
||||
|
|
|
|||
|
|
@ -368,6 +368,10 @@ class CachingExec extends CachingExecBase implements ExecChainHandler {
|
|||
final ClassicHttpResponse backendResponse) throws IOException {
|
||||
|
||||
responseCache.evictInvalidatedEntries(target, request, backendResponse);
|
||||
if (isResponseTooBig(backendResponse.getEntity())) {
|
||||
LOG.debug("Backend response is known to be too big");
|
||||
return backendResponse;
|
||||
}
|
||||
final ResponseCacheControl responseCacheControl = CacheControlHeaderParser.INSTANCE.parse(backendResponse);
|
||||
final boolean cacheable = responseCachingPolicy.isResponseCacheable(responseCacheControl, request, backendResponse);
|
||||
if (cacheable) {
|
||||
|
|
|
|||
|
|
@ -35,6 +35,7 @@ import org.apache.hc.client5.http.cache.CacheResponseStatus;
|
|||
import org.apache.hc.client5.http.cache.HttpCacheContext;
|
||||
import org.apache.hc.client5.http.cache.HttpCacheEntry;
|
||||
import org.apache.hc.client5.http.cache.ResourceIOException;
|
||||
import org.apache.hc.core5.http.EntityDetails;
|
||||
import org.apache.hc.core5.http.Header;
|
||||
import org.apache.hc.core5.http.HttpHeaders;
|
||||
import org.apache.hc.core5.http.HttpHost;
|
||||
|
|
@ -85,7 +86,6 @@ public class CachingExecBase {
|
|||
this.cacheableRequestPolicy = new CacheableRequestPolicy();
|
||||
this.suitabilityChecker = new CachedResponseSuitabilityChecker(this.validityPolicy, this.cacheConfig);
|
||||
this.responseCachingPolicy = new ResponseCachingPolicy(
|
||||
this.cacheConfig.getMaxObjectSize(),
|
||||
this.cacheConfig.isSharedCache(),
|
||||
this.cacheConfig.isNeverCacheHTTP10ResponsesWithQuery(),
|
||||
this.cacheConfig.isNeverCacheHTTP11ResponsesWithQuery(),
|
||||
|
|
@ -282,4 +282,16 @@ public class CachingExecBase {
|
|||
}
|
||||
}
|
||||
|
||||
boolean isResponseTooBig(final EntityDetails entityDetails) {
|
||||
if (entityDetails == null) {
|
||||
return false;
|
||||
}
|
||||
final long contentLength = entityDetails.getContentLength();
|
||||
if (contentLength == -1) {
|
||||
return false;
|
||||
}
|
||||
final long maxObjectSize = cacheConfig.getMaxObjectSize();
|
||||
return contentLength > maxObjectSize;
|
||||
}
|
||||
|
||||
}
|
||||
|
|
|
|||
|
|
@ -33,8 +33,6 @@ import java.util.Set;
|
|||
|
||||
import org.apache.hc.client5.http.cache.HttpCacheEntry;
|
||||
import org.apache.hc.client5.http.utils.DateUtils;
|
||||
import org.apache.hc.core5.http.Header;
|
||||
import org.apache.hc.core5.http.HeaderElement;
|
||||
import org.apache.hc.core5.http.HttpHeaders;
|
||||
import org.apache.hc.core5.http.HttpRequest;
|
||||
import org.apache.hc.core5.http.HttpResponse;
|
||||
|
|
@ -43,7 +41,6 @@ import org.apache.hc.core5.http.HttpVersion;
|
|||
import org.apache.hc.core5.http.Method;
|
||||
import org.apache.hc.core5.http.ProtocolVersion;
|
||||
import org.apache.hc.core5.http.message.BasicTokenIterator;
|
||||
import org.apache.hc.core5.http.message.MessageSupport;
|
||||
import org.slf4j.Logger;
|
||||
import org.slf4j.LoggerFactory;
|
||||
|
||||
|
|
@ -63,7 +60,6 @@ class ResponseCachingPolicy {
|
|||
|
||||
private static final Logger LOG = LoggerFactory.getLogger(ResponseCachingPolicy.class);
|
||||
|
||||
private final long maxObjectSizeBytes;
|
||||
private final boolean sharedCache;
|
||||
private final boolean neverCache1_0ResponsesWithQueryString;
|
||||
private final boolean neverCache1_1ResponsesWithQueryString;
|
||||
|
|
@ -79,8 +75,6 @@ class ResponseCachingPolicy {
|
|||
/**
|
||||
* Constructs a new ResponseCachingPolicy with the specified cache policy settings and stale-if-error support.
|
||||
*
|
||||
* @param maxObjectSizeBytes the maximum size of objects, in bytes, that should be stored
|
||||
* in the cache
|
||||
* @param sharedCache whether to behave as a shared cache (true) or a
|
||||
* non-shared/private cache (false)
|
||||
* @param neverCache1_0ResponsesWithQueryString {@code true} to never cache HTTP 1.0 responses with a query string,
|
||||
|
|
@ -92,19 +86,86 @@ class ResponseCachingPolicy {
|
|||
* results in an error, {@code false} to disable this feature.
|
||||
* @since 5.3
|
||||
*/
|
||||
public ResponseCachingPolicy(final long maxObjectSizeBytes,
|
||||
public ResponseCachingPolicy(
|
||||
final boolean sharedCache,
|
||||
final boolean neverCache1_0ResponsesWithQueryString,
|
||||
final boolean neverCache1_1ResponsesWithQueryString,
|
||||
final boolean staleIfErrorEnabled) {
|
||||
this.maxObjectSizeBytes = maxObjectSizeBytes;
|
||||
this.sharedCache = sharedCache;
|
||||
this.neverCache1_0ResponsesWithQueryString = neverCache1_0ResponsesWithQueryString;
|
||||
this.neverCache1_1ResponsesWithQueryString = neverCache1_1ResponsesWithQueryString;
|
||||
this.staleIfErrorEnabled = staleIfErrorEnabled;
|
||||
}
|
||||
|
||||
boolean isResponseCacheable(final ResponseCacheControl cacheControl, final String httpMethod, final HttpResponse response) {
|
||||
/**
|
||||
* Determine if the {@link HttpResponse} gotten from the origin is a
|
||||
* cacheable response.
|
||||
*
|
||||
* @return {@code true} if response is cacheable
|
||||
*/
|
||||
public boolean isResponseCacheable(final ResponseCacheControl cacheControl, final HttpRequest request, final HttpResponse response) {
|
||||
final ProtocolVersion version = request.getVersion() != null ? request.getVersion() : HttpVersion.DEFAULT;
|
||||
if (version.compareToVersion(HttpVersion.HTTP_1_1) > 0) {
|
||||
if (LOG.isDebugEnabled()) {
|
||||
LOG.debug("Protocol version {} is non-cacheable", version);
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
// Presently only GET and HEAD methods are supported
|
||||
final String httpMethod = request.getMethod();
|
||||
if (!Method.GET.isSame(httpMethod) && !Method.HEAD.isSame(httpMethod)) {
|
||||
if (LOG.isDebugEnabled()) {
|
||||
LOG.debug("{} method response is not cacheable", httpMethod);
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
final int code = response.getCode();
|
||||
|
||||
// Should never happen but better be defensive
|
||||
if (code <= HttpStatus.SC_INFORMATIONAL) {
|
||||
return false;
|
||||
}
|
||||
|
||||
if (isKnownNonCacheableStatusCode(code)) {
|
||||
if (LOG.isDebugEnabled()) {
|
||||
LOG.debug("{} response is not cacheable", code);
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
if (request.getPath().contains("?")) {
|
||||
if (neverCache1_0ResponsesWithQueryString && from1_0Origin(response)) {
|
||||
LOG.debug("Response is not cacheable as it had a query string");
|
||||
return false;
|
||||
} else if (!neverCache1_1ResponsesWithQueryString && !isExplicitlyCacheable(cacheControl, response)) {
|
||||
LOG.debug("Response is not cacheable as it is missing explicit caching headers");
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
if (cacheControl.isMustUnderstand() && !understoodStatusCode(code)) {
|
||||
// must-understand cache directive overrides no-store
|
||||
LOG.debug("Response contains a status code that the cache does not understand, so it's not cacheable");
|
||||
return false;
|
||||
}
|
||||
|
||||
if (isExplicitlyNonCacheable(cacheControl)) {
|
||||
LOG.debug("Response is explicitly non-cacheable per cache control directive");
|
||||
return false;
|
||||
}
|
||||
|
||||
if (sharedCache) {
|
||||
if (request.containsHeader(HttpHeaders.AUTHORIZATION) &&
|
||||
cacheControl.getSharedMaxAge() == -1 &&
|
||||
!cacheControl.isPublic()) {
|
||||
LOG.debug("Request contains private credentials");
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
// See if the response is tainted
|
||||
if (response.countHeaders(HttpHeaders.EXPIRES) > 1) {
|
||||
LOG.debug("Multiple Expires headers");
|
||||
return false;
|
||||
|
|
@ -123,79 +184,19 @@ class ResponseCachingPolicy {
|
|||
return false;
|
||||
}
|
||||
|
||||
boolean cacheable = false;
|
||||
|
||||
if (!Method.GET.isSame(httpMethod) && !Method.HEAD.isSame(httpMethod) && !Method.POST.isSame((httpMethod))) {
|
||||
if (LOG.isDebugEnabled()) {
|
||||
LOG.debug("{} method response is not cacheable", httpMethod);
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
final int status = response.getCode();
|
||||
if (isKnownCacheableStatusCode(status)) {
|
||||
// these response codes MAY be cached
|
||||
cacheable = true;
|
||||
} else if (isKnownNonCacheableStatusCode(status)) {
|
||||
if (LOG.isDebugEnabled()) {
|
||||
LOG.debug("{} response is not cacheable", status);
|
||||
}
|
||||
return false;
|
||||
} else if (isUnknownStatusCode(status)) {
|
||||
// a response with an unknown status code MUST NOT be
|
||||
// cached
|
||||
if (LOG.isDebugEnabled()) {
|
||||
LOG.debug("{} response is unknown", status);
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
final Header contentLength = response.getFirstHeader(HttpHeaders.CONTENT_LENGTH);
|
||||
if (contentLength != null) {
|
||||
final long contentLengthValue = Long.parseLong(contentLength.getValue());
|
||||
if (contentLengthValue > this.maxObjectSizeBytes) {
|
||||
if (LOG.isDebugEnabled()) {
|
||||
LOG.debug("Response content length exceeds {}", this.maxObjectSizeBytes);
|
||||
}
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
final Iterator<HeaderElement> it = MessageSupport.iterate(response, HttpHeaders.VARY);
|
||||
// Treat responses with `Vary: *` as essentially non-cacheable.
|
||||
final Iterator<String> it = new BasicTokenIterator(response.headerIterator(HttpHeaders.VARY));
|
||||
while (it.hasNext()) {
|
||||
final HeaderElement elem = it.next();
|
||||
if ("*".equals(elem.getName())) {
|
||||
final String token = it.next();
|
||||
if ("*".equals(token)) {
|
||||
if (LOG.isDebugEnabled()) {
|
||||
LOG.debug("Vary * found");
|
||||
LOG.debug("Vary: * found");
|
||||
}
|
||||
return false;
|
||||
}
|
||||
}
|
||||
if (isExplicitlyNonCacheable(cacheControl)) {
|
||||
LOG.debug("Response is explicitly non-cacheable");
|
||||
return false;
|
||||
}
|
||||
|
||||
final Duration freshnessLifetime = calculateFreshnessLifetime(cacheControl, responseDate, responseExpires);
|
||||
|
||||
// If the 'immutable' directive is present and the response is still fresh,
|
||||
// then the response is considered cacheable without further validation
|
||||
if (cacheControl.isImmutable() && responseIsStillFresh(responseDate, freshnessLifetime)) {
|
||||
if (LOG.isDebugEnabled()) {
|
||||
LOG.debug("Response is immutable and fresh, considered cacheable without further validation");
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
// calculate freshness lifetime
|
||||
if (freshnessLifetime.isNegative() || freshnessLifetime.isZero()) {
|
||||
if (LOG.isDebugEnabled()) {
|
||||
LOG.debug("Freshness lifetime is invalid");
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
return cacheable || isExplicitlyCacheable(cacheControl, response);
|
||||
return isExplicitlyCacheable(cacheControl, response) || isHeuristicallyCacheable(cacheControl, code, responseDate, responseExpires);
|
||||
}
|
||||
|
||||
private static boolean isKnownCacheableStatusCode(final int status) {
|
||||
|
|
@ -253,62 +254,59 @@ class ResponseCachingPolicy {
|
|||
}
|
||||
|
||||
protected boolean isExplicitlyCacheable(final ResponseCacheControl cacheControl, final HttpResponse response) {
|
||||
if (cacheControl.isPublic()) {
|
||||
return true;
|
||||
}
|
||||
if (!sharedCache && cacheControl.isCachePrivate()) {
|
||||
return true;
|
||||
}
|
||||
if (response.containsHeader(HttpHeaders.EXPIRES)) {
|
||||
return true;
|
||||
}
|
||||
return cacheControl.getMaxAge() > 0 || cacheControl.getSharedMaxAge()>0 ||
|
||||
cacheControl.isMustRevalidate() || cacheControl.isProxyRevalidate() || (cacheControl.isPublic());
|
||||
if (cacheControl.getMaxAge() > 0) {
|
||||
return true;
|
||||
}
|
||||
if (sharedCache && cacheControl.getSharedMaxAge() > 0) {
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Determine if the {@link HttpResponse} gotten from the origin is a
|
||||
* cacheable response.
|
||||
*
|
||||
* @return {@code true} if response is cacheable
|
||||
*/
|
||||
public boolean isResponseCacheable(final ResponseCacheControl cacheControl, final HttpRequest request, final HttpResponse response) {
|
||||
final ProtocolVersion version = request.getVersion() != null ? request.getVersion() : HttpVersion.DEFAULT;
|
||||
if (version.compareToVersion(HttpVersion.HTTP_1_1) > 0) {
|
||||
protected boolean isHeuristicallyCacheable(final ResponseCacheControl cacheControl,
|
||||
final int status,
|
||||
final Instant responseDate,
|
||||
final Instant responseExpires) {
|
||||
if (isKnownCacheableStatusCode(status)) {
|
||||
final Duration freshnessLifetime = calculateFreshnessLifetime(cacheControl, responseDate, responseExpires);
|
||||
// calculate freshness lifetime
|
||||
if (freshnessLifetime.isNegative()) {
|
||||
if (LOG.isDebugEnabled()) {
|
||||
LOG.debug("Protocol version {} is non-cacheable", version);
|
||||
LOG.debug("Freshness lifetime is invalid");
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
if (cacheControl.isMustUnderstand() && cacheControl.isNoStore() && !understoodStatusCode(response.getCode())) {
|
||||
// must-understand cache directive overrides no-store
|
||||
LOG.debug("Response contains a status code that the cache does not understand, so it's not cacheable");
|
||||
// If the 'immutable' directive is present and the response is still fresh,
|
||||
// then the response is considered cacheable without further validation
|
||||
if (cacheControl.isImmutable() && responseIsStillFresh(responseDate, freshnessLifetime)) {
|
||||
if (LOG.isDebugEnabled()) {
|
||||
LOG.debug("Response is immutable and fresh, considered cacheable without further validation");
|
||||
}
|
||||
return true;
|
||||
}
|
||||
if (freshnessLifetime.compareTo(Duration.ZERO) > 0) {
|
||||
return true;
|
||||
}
|
||||
} else if (isUnknownStatusCode(status)) {
|
||||
// a response with an unknown status code MUST NOT be
|
||||
// cached
|
||||
if (LOG.isDebugEnabled()) {
|
||||
LOG.debug("{} response is unknown", status);
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
if (!cacheControl.isMustUnderstand() && cacheControl.isNoStore()) {
|
||||
LOG.debug("Response is explicitly non-cacheable per cache control directive");
|
||||
return false;
|
||||
}
|
||||
|
||||
|
||||
if (request.getRequestUri().contains("?")) {
|
||||
if (neverCache1_0ResponsesWithQueryString && from1_0Origin(response)) {
|
||||
LOG.debug("Response is not cacheable as it had a query string");
|
||||
return false;
|
||||
} else if (!neverCache1_1ResponsesWithQueryString && !isExplicitlyCacheable(cacheControl, response)) {
|
||||
LOG.debug("Response is not cacheable as it is missing explicit caching headers");
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
if (sharedCache) {
|
||||
if (request.countHeaders(HttpHeaders.AUTHORIZATION) > 0
|
||||
&& !(cacheControl.getSharedMaxAge() > -1 || cacheControl.isMustRevalidate() || cacheControl.isPublic())) {
|
||||
LOG.debug("Request contains private credentials");
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
final String method = request.getMethod();
|
||||
return isResponseCacheable(cacheControl, method, response);
|
||||
}
|
||||
|
||||
private boolean expiresHeaderLessOrEqualToDateHeaderAndNoCacheControl(final ResponseCacheControl cacheControl, final Instant responseDate, final Instant expires) {
|
||||
if (!cacheControl.isUndefined()) {
|
||||
return false;
|
||||
|
|
@ -316,7 +314,7 @@ class ResponseCachingPolicy {
|
|||
if (expires == null || responseDate == null) {
|
||||
return false;
|
||||
}
|
||||
return expires.equals(responseDate) || expires.isBefore(responseDate);
|
||||
return expires.compareTo(responseDate) <= 0;
|
||||
}
|
||||
|
||||
private boolean from1_0Origin(final HttpResponse response) {
|
||||
|
|
|
|||
|
|
@ -42,6 +42,7 @@ import org.apache.hc.core5.http.HttpRequest;
|
|||
import org.apache.hc.core5.http.HttpResponse;
|
||||
import org.apache.hc.core5.http.HttpStatus;
|
||||
import org.apache.hc.core5.http.HttpVersion;
|
||||
import org.apache.hc.core5.http.Method;
|
||||
import org.apache.hc.core5.http.message.BasicHttpRequest;
|
||||
import org.apache.hc.core5.http.message.BasicHttpResponse;
|
||||
import org.junit.jupiter.api.Assertions;
|
||||
|
|
@ -67,7 +68,7 @@ public class TestResponseCachingPolicy {
|
|||
sixSecondsAgo = now.minusSeconds(6);
|
||||
tenSecondsFromNow = now.plusSeconds(10);
|
||||
|
||||
policy = new ResponseCachingPolicy(0, true, false, false, false);
|
||||
policy = new ResponseCachingPolicy(true, false, false, false);
|
||||
request = new BasicHttpRequest("GET","/");
|
||||
response = new BasicHttpResponse(HttpStatus.SC_OK, "");
|
||||
response.setHeader("Date", DateUtils.formatStandardDate(Instant.now()));
|
||||
|
|
@ -76,14 +77,26 @@ public class TestResponseCachingPolicy {
|
|||
}
|
||||
|
||||
@Test
|
||||
public void testIsGetCacheable() {
|
||||
Assertions.assertTrue(policy.isResponseCacheable(responseCacheControl, "GET", response));
|
||||
public void testGetCacheable() {
|
||||
policy = new ResponseCachingPolicy(true, false, false, true);
|
||||
request = new BasicHttpRequest(Method.GET, "/");
|
||||
Assertions.assertTrue(policy.isResponseCacheable(responseCacheControl, request, response));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testIsHeadCacheable() {
|
||||
policy = new ResponseCachingPolicy(0, true, false, false, true);
|
||||
Assertions.assertTrue(policy.isResponseCacheable(responseCacheControl, "HEAD", response));
|
||||
public void testHeadCacheable() {
|
||||
policy = new ResponseCachingPolicy(true, false, false, true);
|
||||
request = new BasicHttpRequest(Method.HEAD, "/");
|
||||
Assertions.assertTrue(policy.isResponseCacheable(responseCacheControl, request, response));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testArbitraryMethodNotCacheable() {
|
||||
request = new BasicHttpRequest("PUT", "/");
|
||||
Assertions.assertFalse(policy.isResponseCacheable(responseCacheControl, request, response));
|
||||
|
||||
request = new BasicHttpRequest("huh", "/");
|
||||
Assertions.assertFalse(policy.isResponseCacheable(responseCacheControl, request, response));
|
||||
}
|
||||
|
||||
@Test
|
||||
|
|
@ -95,7 +108,7 @@ public class TestResponseCachingPolicy {
|
|||
|
||||
@Test
|
||||
public void testResponsesToRequestsWithAuthorizationHeadersAreCacheableByNonSharedCache() {
|
||||
policy = new ResponseCachingPolicy(0, false, false, false, true);
|
||||
policy = new ResponseCachingPolicy(false, false, false, true);
|
||||
request = new BasicHttpRequest("GET","/");
|
||||
request.setHeader("Authorization", StandardAuthScheme.BASIC + " dXNlcjpwYXNzd2Q=");
|
||||
Assertions.assertTrue(policy.isResponseCacheable(responseCacheControl, request, response));
|
||||
|
|
@ -112,16 +125,6 @@ public class TestResponseCachingPolicy {
|
|||
Assertions.assertTrue(policy.isResponseCacheable(responseCacheControl, request, response));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testAuthorizedResponsesWithMustRevalidateAreCacheable() {
|
||||
request = new BasicHttpRequest("GET","/");
|
||||
request.setHeader("Authorization", StandardAuthScheme.BASIC + " dXNlcjpwYXNzd2Q=");
|
||||
responseCacheControl = ResponseCacheControl.builder()
|
||||
.setMustRevalidate(true)
|
||||
.build();
|
||||
Assertions.assertTrue(policy.isResponseCacheable(responseCacheControl, request, response));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testAuthorizedResponsesWithCacheControlPublicAreCacheable() {
|
||||
request = new BasicHttpRequest("GET","/");
|
||||
|
|
@ -145,65 +148,53 @@ public class TestResponseCachingPolicy {
|
|||
@Test
|
||||
public void test203ResponseCodeIsCacheable() {
|
||||
response.setCode(HttpStatus.SC_NON_AUTHORITATIVE_INFORMATION);
|
||||
Assertions.assertTrue(policy.isResponseCacheable(responseCacheControl, "GET", response));
|
||||
Assertions.assertTrue(policy.isResponseCacheable(responseCacheControl, request, response));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void test206ResponseCodeIsNotCacheable() {
|
||||
response.setCode(HttpStatus.SC_PARTIAL_CONTENT);
|
||||
Assertions.assertFalse(policy.isResponseCacheable(responseCacheControl, "GET", response));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void test206ResponseCodeIsNotCacheableUsingSharedPublicCache() {
|
||||
policy = new ResponseCachingPolicy(0, true, false, false, true);
|
||||
|
||||
request.setHeader("Authorization", StandardAuthScheme.BASIC + " QWxhZGRpbjpvcGVuIHNlc2FtZQ==");
|
||||
response.setCode(HttpStatus.SC_PARTIAL_CONTENT);
|
||||
responseCacheControl = ResponseCacheControl.builder()
|
||||
.setCachePublic(true)
|
||||
.build();
|
||||
Assertions.assertFalse(policy.isResponseCacheable(responseCacheControl, request, response));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void test300ResponseCodeIsCacheable() {
|
||||
response.setCode(HttpStatus.SC_MULTIPLE_CHOICES);
|
||||
Assertions.assertTrue(policy.isResponseCacheable(responseCacheControl, "GET", response));
|
||||
Assertions.assertTrue(policy.isResponseCacheable(responseCacheControl, request, response));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void test301ResponseCodeIsCacheable() {
|
||||
response.setCode(HttpStatus.SC_MOVED_PERMANENTLY);
|
||||
Assertions.assertTrue(policy.isResponseCacheable(responseCacheControl, "GET", response));
|
||||
Assertions.assertTrue(policy.isResponseCacheable(responseCacheControl, request, response));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void test410ResponseCodeIsCacheable() {
|
||||
response.setCode(HttpStatus.SC_GONE);
|
||||
Assertions.assertTrue(policy.isResponseCacheable(responseCacheControl, "GET", response));
|
||||
Assertions.assertTrue(policy.isResponseCacheable(responseCacheControl, request, response));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testPlain302ResponseCodeIsNotCacheable() {
|
||||
response.setCode(HttpStatus.SC_MOVED_TEMPORARILY);
|
||||
response.removeHeaders("Expires");
|
||||
Assertions.assertFalse(policy.isResponseCacheable(responseCacheControl, "GET", response));
|
||||
Assertions.assertFalse(policy.isResponseCacheable(responseCacheControl, request, response));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testPlain303ResponseCodeIsNotCacheableUnderDefaultBehavior() {
|
||||
response.setCode(HttpStatus.SC_SEE_OTHER);
|
||||
response.removeHeaders("Expires");
|
||||
Assertions.assertFalse(policy.isResponseCacheable(responseCacheControl, "GET", response));
|
||||
Assertions.assertFalse(policy.isResponseCacheable(responseCacheControl, request, response));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testPlain303ResponseCodeIsNotCacheableEvenIf303CachingEnabled() {
|
||||
policy = new ResponseCachingPolicy(0, true, false, true, true);
|
||||
policy = new ResponseCachingPolicy(true, false, true, true);
|
||||
response.setCode(HttpStatus.SC_SEE_OTHER);
|
||||
response.removeHeaders("Expires");
|
||||
Assertions.assertFalse(policy.isResponseCacheable(responseCacheControl, "GET", response));
|
||||
Assertions.assertFalse(policy.isResponseCacheable(responseCacheControl, request, response));
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -211,7 +202,7 @@ public class TestResponseCachingPolicy {
|
|||
public void testPlain307ResponseCodeIsNotCacheable() {
|
||||
response.setCode(HttpStatus.SC_TEMPORARY_REDIRECT);
|
||||
response.removeHeaders("Expires");
|
||||
Assertions.assertFalse(policy.isResponseCacheable(responseCacheControl, "GET", response));
|
||||
Assertions.assertFalse(policy.isResponseCacheable(responseCacheControl, request, response));
|
||||
}
|
||||
|
||||
@Test
|
||||
|
|
@ -219,7 +210,7 @@ public class TestResponseCachingPolicy {
|
|||
final int status = getRandomStatus();
|
||||
response.setCode(status);
|
||||
response.setHeader("Expires", DateUtils.formatStandardDate(Instant.now().plus(1, ChronoUnit.HOURS)));
|
||||
Assertions.assertTrue(policy.isResponseCacheable(responseCacheControl, "GET", response));
|
||||
Assertions.assertTrue(policy.isResponseCacheable(responseCacheControl, request, response));
|
||||
}
|
||||
|
||||
@Test
|
||||
|
|
@ -229,7 +220,7 @@ public class TestResponseCachingPolicy {
|
|||
responseCacheControl = ResponseCacheControl.builder()
|
||||
.setMaxAge(0)
|
||||
.build();
|
||||
Assertions.assertFalse(policy.isResponseCacheable(responseCacheControl, "GET", response));
|
||||
Assertions.assertFalse(policy.isResponseCacheable(responseCacheControl, request, response));
|
||||
}
|
||||
|
||||
@Test
|
||||
|
|
@ -237,7 +228,7 @@ public class TestResponseCachingPolicy {
|
|||
final int status = getRandomStatus();
|
||||
response.setCode(status);
|
||||
response.removeHeaders(HttpHeaders.CACHE_CONTROL);
|
||||
Assertions.assertTrue(policy.isResponseCacheable(responseCacheControl, "GET", response));
|
||||
Assertions.assertTrue(policy.isResponseCacheable(responseCacheControl, request, response));
|
||||
}
|
||||
|
||||
@Test
|
||||
|
|
@ -247,7 +238,7 @@ public class TestResponseCachingPolicy {
|
|||
responseCacheControl = ResponseCacheControl.builder()
|
||||
.setSharedMaxAge(1)
|
||||
.build();
|
||||
Assertions.assertTrue(policy.isResponseCacheable(responseCacheControl, "GET", response));
|
||||
Assertions.assertTrue(policy.isResponseCacheable(responseCacheControl, request, response));
|
||||
}
|
||||
|
||||
@Test
|
||||
|
|
@ -257,7 +248,7 @@ public class TestResponseCachingPolicy {
|
|||
responseCacheControl = ResponseCacheControl.builder()
|
||||
.setMustRevalidate(true)
|
||||
.build();
|
||||
Assertions.assertTrue(policy.isResponseCacheable(responseCacheControl, "GET", response));
|
||||
Assertions.assertTrue(policy.isResponseCacheable(responseCacheControl, request, response));
|
||||
}
|
||||
|
||||
@Test
|
||||
|
|
@ -267,7 +258,7 @@ public class TestResponseCachingPolicy {
|
|||
responseCacheControl = ResponseCacheControl.builder()
|
||||
.setProxyRevalidate(true)
|
||||
.build();
|
||||
Assertions.assertTrue(policy.isResponseCacheable(responseCacheControl, "GET", response));
|
||||
Assertions.assertTrue(policy.isResponseCacheable(responseCacheControl, request, response));
|
||||
}
|
||||
|
||||
@Test
|
||||
|
|
@ -277,7 +268,7 @@ public class TestResponseCachingPolicy {
|
|||
responseCacheControl = ResponseCacheControl.builder()
|
||||
.setCachePublic(true)
|
||||
.build();
|
||||
Assertions.assertTrue(policy.isResponseCacheable(responseCacheControl, "GET", response));
|
||||
Assertions.assertTrue(policy.isResponseCacheable(responseCacheControl, request, response));
|
||||
}
|
||||
|
||||
@Test
|
||||
|
|
@ -287,146 +278,86 @@ public class TestResponseCachingPolicy {
|
|||
responseCacheControl = ResponseCacheControl.builder()
|
||||
.setCachePrivate(true)
|
||||
.build();
|
||||
Assertions.assertFalse(policy.isResponseCacheable(responseCacheControl, "GET", response));
|
||||
Assertions.assertFalse(policy.isResponseCacheable(responseCacheControl, request, response));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void test200ResponseWithPrivateCacheControlIsCacheableByNonSharedCache() {
|
||||
policy = new ResponseCachingPolicy(0, false, false, false, true);
|
||||
policy = new ResponseCachingPolicy(false, false, false, true);
|
||||
response.setCode(HttpStatus.SC_OK);
|
||||
responseCacheControl = ResponseCacheControl.builder()
|
||||
.setCachePrivate(true)
|
||||
.build();
|
||||
Assertions.assertTrue(policy.isResponseCacheable(responseCacheControl, "GET", response));
|
||||
Assertions.assertTrue(policy.isResponseCacheable(responseCacheControl, request, response));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testIsGetWithNoCacheCacheable() {
|
||||
public void testControlNoCacheCacheable() {
|
||||
responseCacheControl = ResponseCacheControl.builder()
|
||||
.setNoCache(true)
|
||||
.build();
|
||||
|
||||
Assertions.assertTrue(policy.isResponseCacheable(responseCacheControl, "GET", response));
|
||||
Assertions.assertTrue(policy.isResponseCacheable(responseCacheControl, request, response));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testIsHeadWithNoCacheCacheable() {
|
||||
responseCacheControl = ResponseCacheControl.builder()
|
||||
.setNoCache(true)
|
||||
.build();
|
||||
|
||||
Assertions.assertTrue(policy.isResponseCacheable(responseCacheControl, "HEAD", response));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testIsGetWithNoStoreCacheable() {
|
||||
public void testControlNoStoreNotCacheable() {
|
||||
responseCacheControl = ResponseCacheControl.builder()
|
||||
.setNoStore(true)
|
||||
.build();
|
||||
|
||||
Assertions.assertFalse(policy.isResponseCacheable(responseCacheControl, "GET", response));
|
||||
Assertions.assertFalse(policy.isResponseCacheable(responseCacheControl, request, response));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testIsHeadWithNoStoreCacheable() {
|
||||
responseCacheControl = ResponseCacheControl.builder()
|
||||
.setNoStore(true)
|
||||
.build();
|
||||
|
||||
Assertions.assertFalse(policy.isResponseCacheable(responseCacheControl, "HEAD", response));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testIsGetWithNoStoreEmbeddedInListCacheable() {
|
||||
public void testControlNoStoreEmbeddedInListCacheable() {
|
||||
responseCacheControl = ResponseCacheControl.builder()
|
||||
.setCachePublic(true)
|
||||
.setNoStore(true)
|
||||
.build();
|
||||
|
||||
Assertions.assertFalse(policy.isResponseCacheable(responseCacheControl, "GET", response));
|
||||
Assertions.assertFalse(policy.isResponseCacheable(responseCacheControl, request, response));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testIsHeadWithNoStoreEmbeddedInListCacheable() {
|
||||
responseCacheControl = ResponseCacheControl.builder()
|
||||
.setCachePublic(true)
|
||||
.setNoStore(true)
|
||||
.build();
|
||||
|
||||
Assertions.assertFalse(policy.isResponseCacheable(responseCacheControl, "HEAD", response));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testIsGetWithNoCacheEmbeddedInListCacheable() {
|
||||
public void testControlNoCacheEmbeddedInListCacheable() {
|
||||
responseCacheControl = ResponseCacheControl.builder()
|
||||
.setCachePublic(true)
|
||||
.setNoCache(true)
|
||||
.build();
|
||||
|
||||
Assertions.assertTrue(policy.isResponseCacheable(responseCacheControl, "GET", response));
|
||||
Assertions.assertTrue(policy.isResponseCacheable(responseCacheControl, request, response));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testIsHeadWithNoCacheEmbeddedInListCacheable() {
|
||||
responseCacheControl = ResponseCacheControl.builder()
|
||||
.setCachePublic(true)
|
||||
.setNoCache(true)
|
||||
.build();
|
||||
|
||||
Assertions.assertTrue(policy.isResponseCacheable(responseCacheControl, "HEAD", response));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testIsGetWithNoCacheEmbeddedInListAfterFirstHeaderCacheable() {
|
||||
public void testControlNoCacheEmbeddedInListAfterFirstHeaderCacheable() {
|
||||
responseCacheControl = ResponseCacheControl.builder()
|
||||
.setMaxAge(20)
|
||||
.setCachePublic(true)
|
||||
.setNoCache(true)
|
||||
.build();
|
||||
|
||||
Assertions.assertTrue(policy.isResponseCacheable(responseCacheControl, "GET", response));
|
||||
Assertions.assertTrue(policy.isResponseCacheable(responseCacheControl, request, response));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testIsHeadWithNoCacheEmbeddedInListAfterFirstHeaderCacheable() {
|
||||
responseCacheControl = ResponseCacheControl.builder()
|
||||
.setMaxAge(20)
|
||||
.setCachePublic(true)
|
||||
.setNoCache(true)
|
||||
.build();
|
||||
|
||||
Assertions.assertTrue(policy.isResponseCacheable(responseCacheControl, "HEAD", response));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testIsGetWithNoStoreEmbeddedInListAfterFirstHeaderCacheable() {
|
||||
public void testControlNoStoreEmbeddedInListAfterFirstHeaderCacheable() {
|
||||
responseCacheControl = ResponseCacheControl.builder()
|
||||
.setMaxAge(20)
|
||||
.setCachePublic(true)
|
||||
.setNoStore(true)
|
||||
.build();
|
||||
|
||||
Assertions.assertFalse(policy.isResponseCacheable(responseCacheControl, "GET", response));
|
||||
Assertions.assertFalse(policy.isResponseCacheable(responseCacheControl, request, response));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testIsHeadWithNoStoreEmbeddedInListAfterFirstHeaderCacheable() {
|
||||
responseCacheControl = ResponseCacheControl.builder()
|
||||
.setMaxAge(20)
|
||||
.setCachePublic(true)
|
||||
.setNoStore(true)
|
||||
.build();
|
||||
|
||||
Assertions.assertFalse(policy.isResponseCacheable(responseCacheControl, "HEAD", response));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testIsGetWithAnyCacheControlCacheable() {
|
||||
public void testControlAnyCacheControlCacheable() {
|
||||
responseCacheControl = ResponseCacheControl.builder()
|
||||
.setMaxAge(10)
|
||||
.build();
|
||||
|
||||
Assertions.assertTrue(policy.isResponseCacheable(responseCacheControl, "GET", response));
|
||||
Assertions.assertTrue(policy.isResponseCacheable(responseCacheControl, request, response));
|
||||
|
||||
response = new BasicHttpResponse(HttpStatus.SC_OK, "");
|
||||
response.setHeader("Date", DateUtils.formatStandardDate(Instant.now()));
|
||||
|
|
@ -434,58 +365,29 @@ public class TestResponseCachingPolicy {
|
|||
responseCacheControl = ResponseCacheControl.builder()
|
||||
.build();
|
||||
|
||||
Assertions.assertTrue(policy.isResponseCacheable(responseCacheControl, "GET", response));
|
||||
Assertions.assertTrue(policy.isResponseCacheable(responseCacheControl, request, response));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testIsHeadWithAnyCacheControlCacheable() {
|
||||
policy = new ResponseCachingPolicy(0, true, false, false, true);
|
||||
responseCacheControl = ResponseCacheControl.builder()
|
||||
.setMaxAge(10)
|
||||
.build();
|
||||
|
||||
Assertions.assertTrue(policy.isResponseCacheable(responseCacheControl, "HEAD", response));
|
||||
|
||||
response = new BasicHttpResponse(HttpStatus.SC_OK, "");
|
||||
response.setHeader("Date", DateUtils.formatStandardDate(Instant.now()));
|
||||
response.setHeader("Content-Length", "0");
|
||||
responseCacheControl = ResponseCacheControl.builder()
|
||||
.build();
|
||||
|
||||
Assertions.assertTrue(policy.isResponseCacheable(responseCacheControl, "HEAD", response));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testIsGetWithout200Cacheable() {
|
||||
public void testControlWithout200Cacheable() {
|
||||
HttpResponse response404 = new BasicHttpResponse(HttpStatus.SC_NOT_FOUND, "");
|
||||
|
||||
Assertions.assertFalse(policy.isResponseCacheable(responseCacheControl, "GET", response404));
|
||||
Assertions.assertFalse(policy.isResponseCacheable(responseCacheControl, request, response404));
|
||||
|
||||
response404 = new BasicHttpResponse(HttpStatus.SC_GATEWAY_TIMEOUT, "");
|
||||
|
||||
Assertions.assertFalse(policy.isResponseCacheable(responseCacheControl, "GET", response404));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testIsHeadWithout200Cacheable() {
|
||||
HttpResponse response404 = new BasicHttpResponse(HttpStatus.SC_NOT_FOUND, "");
|
||||
|
||||
Assertions.assertFalse(policy.isResponseCacheable(responseCacheControl, "HEAD", response404));
|
||||
|
||||
response404 = new BasicHttpResponse(HttpStatus.SC_GATEWAY_TIMEOUT, "");
|
||||
|
||||
Assertions.assertFalse(policy.isResponseCacheable(responseCacheControl, "HEAD", response404));
|
||||
Assertions.assertFalse(policy.isResponseCacheable(responseCacheControl, request, response404));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testVaryStarIsNotCacheable() {
|
||||
response.setHeader("Vary", "*");
|
||||
Assertions.assertFalse(policy.isResponseCacheable(responseCacheControl, "GET", response));
|
||||
Assertions.assertFalse(policy.isResponseCacheable(responseCacheControl, request, response));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testVaryStarIsNotCacheableUsingSharedPublicCache() {
|
||||
policy = new ResponseCachingPolicy(0, true, false, false, true);
|
||||
policy = new ResponseCachingPolicy(true, false, false, true);
|
||||
|
||||
request.setHeader("Authorization", StandardAuthScheme.BASIC + " QWxhZGRpbjpvcGVuIHNlc2FtZQ==");
|
||||
response.setHeader("Vary", "*");
|
||||
|
|
@ -496,29 +398,14 @@ public class TestResponseCachingPolicy {
|
|||
}
|
||||
|
||||
@Test
|
||||
public void testIsGetWithVaryHeaderCacheable() {
|
||||
public void testRequestWithVaryHeaderCacheable() {
|
||||
response.addHeader("Vary", "Accept-Encoding");
|
||||
Assertions.assertTrue(policy.isResponseCacheable(responseCacheControl, "GET", response));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testIsHeadWithVaryHeaderCacheable() {
|
||||
policy = new ResponseCachingPolicy(0, true, false, false, true);
|
||||
response.addHeader("Vary", "Accept-Encoding");
|
||||
Assertions.assertTrue(policy.isResponseCacheable(responseCacheControl, "HEAD", response));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testIsArbitraryMethodCacheable() {
|
||||
|
||||
Assertions.assertFalse(policy.isResponseCacheable(responseCacheControl, "PUT", response));
|
||||
|
||||
Assertions.assertFalse(policy.isResponseCacheable(responseCacheControl, "huh", response));
|
||||
Assertions.assertTrue(policy.isResponseCacheable(responseCacheControl, request, response));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testIsArbitraryMethodCacheableUsingSharedPublicCache() {
|
||||
policy = new ResponseCachingPolicy(0, true, false, false, true);
|
||||
policy = new ResponseCachingPolicy(true, false, false, true);
|
||||
|
||||
request = new HttpOptions("http://foo.example.com/");
|
||||
request.setHeader("Authorization", StandardAuthScheme.BASIC + " QWxhZGRpbjpvcGVuIHNlc2FtZQ==");
|
||||
|
|
@ -534,12 +421,12 @@ public class TestResponseCachingPolicy {
|
|||
public void testResponsesWithMultipleAgeHeadersAreCacheable() {
|
||||
response.addHeader("Age", "3");
|
||||
response.addHeader("Age", "5");
|
||||
Assertions.assertTrue(policy.isResponseCacheable(responseCacheControl, "GET", response));
|
||||
Assertions.assertTrue(policy.isResponseCacheable(responseCacheControl, request, response));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testResponsesWithMultipleAgeHeadersAreNotCacheableUsingSharedPublicCache() {
|
||||
policy = new ResponseCachingPolicy(0, true, false, false, true);
|
||||
policy = new ResponseCachingPolicy(true, false, false, true);
|
||||
|
||||
request.setHeader("Authorization", StandardAuthScheme.BASIC + " QWxhZGRpbjpvcGVuIHNlc2FtZQ==");
|
||||
response.addHeader("Age", "3");
|
||||
|
|
@ -554,12 +441,12 @@ public class TestResponseCachingPolicy {
|
|||
public void testResponsesWithMultipleDateHeadersAreNotCacheable() {
|
||||
response.addHeader("Date", DateUtils.formatStandardDate(now));
|
||||
response.addHeader("Date", DateUtils.formatStandardDate(sixSecondsAgo));
|
||||
Assertions.assertFalse(policy.isResponseCacheable(responseCacheControl, "GET", response));
|
||||
Assertions.assertFalse(policy.isResponseCacheable(responseCacheControl, request, response));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testResponsesWithMultipleDateHeadersAreNotCacheableUsingSharedPublicCache() {
|
||||
policy = new ResponseCachingPolicy(0, true, false, false, true);
|
||||
policy = new ResponseCachingPolicy(true, false, false, true);
|
||||
|
||||
request.setHeader("Authorization", StandardAuthScheme.BASIC + " QWxhZGRpbjpvcGVuIHNlc2FtZQ==");
|
||||
response.addHeader("Date", DateUtils.formatStandardDate(now));
|
||||
|
|
@ -573,12 +460,12 @@ public class TestResponseCachingPolicy {
|
|||
@Test
|
||||
public void testResponsesWithMalformedDateHeadersAreNotCacheable() {
|
||||
response.addHeader("Date", "garbage");
|
||||
Assertions.assertFalse(policy.isResponseCacheable(responseCacheControl, "GET", response));
|
||||
Assertions.assertFalse(policy.isResponseCacheable(responseCacheControl, request, response));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testResponsesWithMalformedDateHeadersAreNotCacheableUsingSharedPublicCache() {
|
||||
policy = new ResponseCachingPolicy(0, true, false, false, true);
|
||||
policy = new ResponseCachingPolicy(true, false, false, true);
|
||||
|
||||
request.setHeader("Authorization", StandardAuthScheme.BASIC + " QWxhZGRpbjpvcGVuIHNlc2FtZQ==");
|
||||
response.addHeader("Date", "garbage");
|
||||
|
|
@ -592,12 +479,12 @@ public class TestResponseCachingPolicy {
|
|||
public void testResponsesWithMultipleExpiresHeadersAreNotCacheable() {
|
||||
response.addHeader("Expires", DateUtils.formatStandardDate(now));
|
||||
response.addHeader("Expires", DateUtils.formatStandardDate(sixSecondsAgo));
|
||||
Assertions.assertFalse(policy.isResponseCacheable(responseCacheControl, "GET", response));
|
||||
Assertions.assertFalse(policy.isResponseCacheable(responseCacheControl, request, response));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testResponsesWithMultipleExpiresHeadersAreNotCacheableUsingSharedPublicCache() {
|
||||
policy = new ResponseCachingPolicy(0, true, false, false, true);
|
||||
policy = new ResponseCachingPolicy(true, false, false, true);
|
||||
|
||||
request.setHeader("Authorization", StandardAuthScheme.BASIC + " QWxhZGRpbjpvcGVuIHNlc2FtZQ==");
|
||||
response.addHeader("Expires", DateUtils.formatStandardDate(now));
|
||||
|
|
@ -608,28 +495,10 @@ public class TestResponseCachingPolicy {
|
|||
Assertions.assertFalse(policy.isResponseCacheable(responseCacheControl, request, response));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testResponseThatHasTooMuchContentIsNotCacheable() {
|
||||
response.setHeader("Content-Length", "9000");
|
||||
Assertions.assertFalse(policy.isResponseCacheable(responseCacheControl, "GET", response));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testResponseThatHasTooMuchContentIsNotCacheableUsingSharedPublicCache() {
|
||||
policy = new ResponseCachingPolicy(0, true, false, false, true);
|
||||
|
||||
request.setHeader("Authorization", StandardAuthScheme.BASIC + " QWxhZGRpbjpvcGVuIHNlc2FtZQ==");
|
||||
response.setHeader("Content-Length", "9000");
|
||||
responseCacheControl = ResponseCacheControl.builder()
|
||||
.setCachePublic(true)
|
||||
.build();
|
||||
Assertions.assertFalse(policy.isResponseCacheable(responseCacheControl, request, response));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testResponsesThatAreSmallEnoughAreCacheable() {
|
||||
response.setHeader("Content-Length", "0");
|
||||
Assertions.assertTrue(policy.isResponseCacheable(responseCacheControl, "GET", response));
|
||||
Assertions.assertTrue(policy.isResponseCacheable(responseCacheControl, request, response));
|
||||
}
|
||||
|
||||
@Test
|
||||
|
|
@ -646,14 +515,14 @@ public class TestResponseCachingPolicy {
|
|||
|
||||
@Test
|
||||
public void testResponsesToGETWithQueryParamsButNoExplicitCachingAreNotCacheableEvenWhen1_0QueryCachingDisabled() {
|
||||
policy = new ResponseCachingPolicy(0, true, true, false, false);
|
||||
policy = new ResponseCachingPolicy(true, true, false, false);
|
||||
request = new BasicHttpRequest("GET", "/foo?s=bar");
|
||||
Assertions.assertFalse(policy.isResponseCacheable(responseCacheControl, request, response));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testResponsesToHEADWithQueryParamsButNoExplicitCachingAreNotCacheableEvenWhen1_0QueryCachingDisabled() {
|
||||
policy = new ResponseCachingPolicy(0, true, true, false, false);
|
||||
policy = new ResponseCachingPolicy(true, true, false, false);
|
||||
request = new BasicHttpRequest("HEAD", "/foo?s=bar");
|
||||
Assertions.assertFalse(policy.isResponseCacheable(responseCacheControl, request, response));
|
||||
}
|
||||
|
|
@ -668,7 +537,7 @@ public class TestResponseCachingPolicy {
|
|||
|
||||
@Test
|
||||
public void testResponsesToHEADWithQueryParamsAndExplicitCachingAreCacheable() {
|
||||
policy = new ResponseCachingPolicy(0, true, false, false, true);
|
||||
policy = new ResponseCachingPolicy(true, false, false, true);
|
||||
request = new BasicHttpRequest("HEAD", "/foo?s=bar");
|
||||
response.setHeader("Date", DateUtils.formatStandardDate(now));
|
||||
response.setHeader("Expires", DateUtils.formatStandardDate(tenSecondsFromNow));
|
||||
|
|
@ -677,7 +546,7 @@ public class TestResponseCachingPolicy {
|
|||
|
||||
@Test
|
||||
public void testResponsesToGETWithQueryParamsAndExplicitCachingAreCacheableEvenWhen1_0QueryCachingDisabled() {
|
||||
policy = new ResponseCachingPolicy(0, true, true, false, true);
|
||||
policy = new ResponseCachingPolicy(true, true, false, true);
|
||||
request = new BasicHttpRequest("GET", "/foo?s=bar");
|
||||
response.setHeader("Date", DateUtils.formatStandardDate(now));
|
||||
response.setHeader("Expires", DateUtils.formatStandardDate(tenSecondsFromNow));
|
||||
|
|
@ -686,7 +555,7 @@ public class TestResponseCachingPolicy {
|
|||
|
||||
@Test
|
||||
public void testResponsesToHEADWithQueryParamsAndExplicitCachingAreCacheableEvenWhen1_0QueryCachingDisabled() {
|
||||
policy = new ResponseCachingPolicy(0, true, true, false, true);
|
||||
policy = new ResponseCachingPolicy(true, true, false, true);
|
||||
request = new BasicHttpRequest("HEAD", "/foo?s=bar");
|
||||
response.setHeader("Date", DateUtils.formatStandardDate(now));
|
||||
response.setHeader("Expires", DateUtils.formatStandardDate(tenSecondsFromNow));
|
||||
|
|
@ -711,7 +580,7 @@ public class TestResponseCachingPolicy {
|
|||
|
||||
@Test
|
||||
public void getsWithQueryParametersDirectlyFrom1_0OriginsAreNotCacheableEvenWithSetting() {
|
||||
policy = new ResponseCachingPolicy(0, true, true, false, true);
|
||||
policy = new ResponseCachingPolicy(true, true, false, true);
|
||||
request = new BasicHttpRequest("GET", "/foo?s=bar");
|
||||
response = new BasicHttpResponse(HttpStatus.SC_OK, "OK");
|
||||
response.setVersion(HttpVersion.HTTP_1_0);
|
||||
|
|
@ -720,7 +589,7 @@ public class TestResponseCachingPolicy {
|
|||
|
||||
@Test
|
||||
public void headsWithQueryParametersDirectlyFrom1_0OriginsAreNotCacheableEvenWithSetting() {
|
||||
policy = new ResponseCachingPolicy(0, true, true, false, true);
|
||||
policy = new ResponseCachingPolicy(true, true, false, true);
|
||||
request = new BasicHttpRequest("HEAD", "/foo?s=bar");
|
||||
response = new BasicHttpResponse(HttpStatus.SC_OK, "OK");
|
||||
response.setVersion(HttpVersion.HTTP_1_0);
|
||||
|
|
@ -739,7 +608,7 @@ public class TestResponseCachingPolicy {
|
|||
|
||||
@Test
|
||||
public void headsWithQueryParametersDirectlyFrom1_0OriginsAreCacheableWithExpires() {
|
||||
policy = new ResponseCachingPolicy(0, true, false, false, true);
|
||||
policy = new ResponseCachingPolicy(true, false, false, true);
|
||||
request = new BasicHttpRequest("HEAD", "/foo?s=bar");
|
||||
response = new BasicHttpResponse(HttpStatus.SC_OK, "OK");
|
||||
response.setVersion(HttpVersion.HTTP_1_0);
|
||||
|
|
@ -750,7 +619,7 @@ public class TestResponseCachingPolicy {
|
|||
|
||||
@Test
|
||||
public void getsWithQueryParametersDirectlyFrom1_0OriginsCanBeNotCacheableEvenWithExpires() {
|
||||
policy = new ResponseCachingPolicy(0, true, true, false, true);
|
||||
policy = new ResponseCachingPolicy(true, true, false, true);
|
||||
request = new BasicHttpRequest("GET", "/foo?s=bar");
|
||||
response = new BasicHttpResponse(HttpStatus.SC_OK, "OK");
|
||||
response.setVersion(HttpVersion.HTTP_1_0);
|
||||
|
|
@ -761,7 +630,7 @@ public class TestResponseCachingPolicy {
|
|||
|
||||
@Test
|
||||
public void headsWithQueryParametersDirectlyFrom1_0OriginsCanBeNotCacheableEvenWithExpires() {
|
||||
policy = new ResponseCachingPolicy(0, true, true, false, true);
|
||||
policy = new ResponseCachingPolicy(true, true, false, true);
|
||||
request = new BasicHttpRequest("HEAD", "/foo?s=bar");
|
||||
response = new BasicHttpResponse(HttpStatus.SC_OK, "OK");
|
||||
response.setVersion(HttpVersion.HTTP_1_0);
|
||||
|
|
@ -795,7 +664,7 @@ public class TestResponseCachingPolicy {
|
|||
|
||||
@Test
|
||||
public void headsWithQueryParametersFrom1_0OriginsViaProxiesAreCacheableWithExpires() {
|
||||
policy = new ResponseCachingPolicy(0, true, false, false, true);
|
||||
policy = new ResponseCachingPolicy(true, false, false, true);
|
||||
request = new BasicHttpRequest("HEAD", "/foo?s=bar");
|
||||
response.setHeader("Date", DateUtils.formatStandardDate(now));
|
||||
response.setHeader("Expires", DateUtils.formatStandardDate(tenSecondsFromNow));
|
||||
|
|
@ -805,7 +674,7 @@ public class TestResponseCachingPolicy {
|
|||
|
||||
@Test
|
||||
public void getsWithQueryParametersFrom1_0OriginsViaProxiesCanNotBeCacheableEvenWithExpires() {
|
||||
policy = new ResponseCachingPolicy(0, true, true, true, true);
|
||||
policy = new ResponseCachingPolicy(true, true, true, true);
|
||||
request = new BasicHttpRequest("GET", "/foo?s=bar");
|
||||
response.setHeader("Date", DateUtils.formatStandardDate(now));
|
||||
response.setHeader("Expires", DateUtils.formatStandardDate(tenSecondsFromNow));
|
||||
|
|
@ -815,7 +684,7 @@ public class TestResponseCachingPolicy {
|
|||
|
||||
@Test
|
||||
public void headsWithQueryParametersFrom1_0OriginsViaProxiesCanNotBeCacheableEvenWithExpires() {
|
||||
policy = new ResponseCachingPolicy(0, true, true, true, true);
|
||||
policy = new ResponseCachingPolicy(true, true, true, true);
|
||||
request = new BasicHttpRequest("HEAD", "/foo?s=bar");
|
||||
response.setHeader("Date", DateUtils.formatStandardDate(now));
|
||||
response.setHeader("Expires", DateUtils.formatStandardDate(tenSecondsFromNow));
|
||||
|
|
@ -834,7 +703,7 @@ public class TestResponseCachingPolicy {
|
|||
|
||||
@Test
|
||||
public void headsWithQueryParametersFrom1_0OriginsViaExplicitProxiesAreCacheableWithExpires() {
|
||||
policy = new ResponseCachingPolicy(0, true, false, false, false);
|
||||
policy = new ResponseCachingPolicy(true, false, false, false);
|
||||
request = new BasicHttpRequest("HEAD", "/foo?s=bar");
|
||||
response.setHeader("Date", DateUtils.formatStandardDate(now));
|
||||
response.setHeader("Expires", DateUtils.formatStandardDate(tenSecondsFromNow));
|
||||
|
|
@ -844,7 +713,7 @@ public class TestResponseCachingPolicy {
|
|||
|
||||
@Test
|
||||
public void getsWithQueryParametersFrom1_0OriginsViaExplicitProxiesCanNotBeCacheableEvenWithExpires() {
|
||||
policy = new ResponseCachingPolicy(0, true, true, true, true);
|
||||
policy = new ResponseCachingPolicy(true, true, true, true);
|
||||
request = new BasicHttpRequest("GET", "/foo?s=bar");
|
||||
response.setHeader("Date", DateUtils.formatStandardDate(now));
|
||||
response.setHeader("Expires", DateUtils.formatStandardDate(tenSecondsFromNow));
|
||||
|
|
@ -854,7 +723,7 @@ public class TestResponseCachingPolicy {
|
|||
|
||||
@Test
|
||||
public void headsWithQueryParametersFrom1_0OriginsViaExplicitProxiesCanNotBeCacheableEvenWithExpires() {
|
||||
policy = new ResponseCachingPolicy(0, true, true, true, true);
|
||||
policy = new ResponseCachingPolicy(true, true, true, true);
|
||||
request = new BasicHttpRequest("HEAD", "/foo?s=bar");
|
||||
response.setHeader("Date", DateUtils.formatStandardDate(now));
|
||||
response.setHeader("Expires", DateUtils.formatStandardDate(tenSecondsFromNow));
|
||||
|
|
@ -875,7 +744,7 @@ public class TestResponseCachingPolicy {
|
|||
|
||||
@Test
|
||||
public void headsWithQueryParametersFrom1_1OriginsVia1_0ProxiesAreCacheableWithExpires() {
|
||||
policy = new ResponseCachingPolicy(0, true, false, false, true);
|
||||
policy = new ResponseCachingPolicy(true, false, false, true);
|
||||
request = new BasicHttpRequest("HEAD", "/foo?s=bar");
|
||||
response = new BasicHttpResponse(HttpStatus.SC_OK, "OK");
|
||||
response.setVersion(HttpVersion.HTTP_1_0);
|
||||
|
|
@ -914,7 +783,7 @@ public class TestResponseCachingPolicy {
|
|||
public void test303WithExplicitCachingHeadersWhenPermittedByConfig() {
|
||||
// HTTPbis working group says ok if explicitly indicated by
|
||||
// response headers
|
||||
policy = new ResponseCachingPolicy(0, true, false, true, true);
|
||||
policy = new ResponseCachingPolicy(true, false, true, true);
|
||||
response.setCode(HttpStatus.SC_SEE_OTHER);
|
||||
response.setHeader("Date", DateUtils.formatStandardDate(now));
|
||||
responseCacheControl = ResponseCacheControl.builder()
|
||||
|
|
@ -955,8 +824,8 @@ public class TestResponseCachingPolicy {
|
|||
|
||||
|
||||
// Create ResponseCachingPolicy instance and test the method
|
||||
policy = new ResponseCachingPolicy(0, true, false, false, false);
|
||||
request = new BasicHttpRequest("POST", "/foo");
|
||||
policy = new ResponseCachingPolicy(true, false, false, false);
|
||||
request = new BasicHttpRequest("GET", "/foo");
|
||||
assertTrue(policy.isResponseCacheable(responseCacheControl, request, response));
|
||||
}
|
||||
|
||||
|
|
@ -973,8 +842,8 @@ public class TestResponseCachingPolicy {
|
|||
|
||||
|
||||
// Create ResponseCachingPolicy instance and test the method
|
||||
policy = new ResponseCachingPolicy(0, true, false, false, false);
|
||||
request = new BasicHttpRequest("POST", "/foo");
|
||||
policy = new ResponseCachingPolicy(true, false, false, false);
|
||||
request = new BasicHttpRequest("GET", "/foo");
|
||||
responseCacheControl = ResponseCacheControl.builder()
|
||||
.setMaxAge(60)
|
||||
.build();
|
||||
|
|
@ -993,8 +862,8 @@ public class TestResponseCachingPolicy {
|
|||
|
||||
|
||||
// Create ResponseCachingPolicy instance and test the method
|
||||
policy = new ResponseCachingPolicy(0, true, false, false,false);
|
||||
request = new BasicHttpRequest("POST", "/foo");
|
||||
policy = new ResponseCachingPolicy(true, false, false,false);
|
||||
request = new BasicHttpRequest("GET", "/foo");
|
||||
responseCacheControl = ResponseCacheControl.builder()
|
||||
.setMaxAge(60)
|
||||
.build();
|
||||
|
|
@ -1013,8 +882,8 @@ public class TestResponseCachingPolicy {
|
|||
|
||||
|
||||
// Create ResponseCachingPolicy instance and test the method
|
||||
policy = new ResponseCachingPolicy(0, true, false, false,false);
|
||||
request = new BasicHttpRequest("POST", "/foo");
|
||||
policy = new ResponseCachingPolicy(true, false, false,false);
|
||||
request = new BasicHttpRequest("GET", "/foo");
|
||||
assertTrue(policy.isResponseCacheable(responseCacheControl, request, response));
|
||||
}
|
||||
|
||||
|
|
@ -1029,7 +898,7 @@ public class TestResponseCachingPolicy {
|
|||
request = new BasicHttpRequest("GET","/foo?s=bar");
|
||||
// HTTPbis working group says ok if explicitly indicated by
|
||||
// response headers
|
||||
policy = new ResponseCachingPolicy(0, true, false, true, true);
|
||||
policy = new ResponseCachingPolicy(true, false, true, true);
|
||||
response.setCode(HttpStatus.SC_OK);
|
||||
response.setHeader("Date", DateUtils.formatStandardDate(now));
|
||||
assertTrue(policy.isResponseCacheable(responseCacheControl, request, response));
|
||||
|
|
@ -1042,7 +911,7 @@ public class TestResponseCachingPolicy {
|
|||
response.setHeader(HttpHeaders.DATE, DateUtils.formatStandardDate(Instant.now()));
|
||||
|
||||
// Create ResponseCachingPolicy instance and test the method
|
||||
policy = new ResponseCachingPolicy(0, true, false, false, true);
|
||||
policy = new ResponseCachingPolicy(true, false, false, true);
|
||||
request = new BasicHttpRequest("GET", "/foo");
|
||||
responseCacheControl = ResponseCacheControl.builder()
|
||||
.setNoCache(true)
|
||||
|
|
@ -1057,7 +926,7 @@ public class TestResponseCachingPolicy {
|
|||
response.setHeader(HttpHeaders.DATE, DateUtils.formatStandardDate(Instant.now()));
|
||||
|
||||
// Create ResponseCachingPolicy instance and test the method
|
||||
policy = new ResponseCachingPolicy(0, true, false, false, false);
|
||||
policy = new ResponseCachingPolicy(true, false, false, false);
|
||||
request = new BasicHttpRequest("GET", "/foo");
|
||||
responseCacheControl = ResponseCacheControl.builder()
|
||||
.setNoStore(true)
|
||||
|
|
@ -1072,6 +941,6 @@ public class TestResponseCachingPolicy {
|
|||
.setMaxAge(3600) // set this to a value that ensures the response is still fresh
|
||||
.build();
|
||||
|
||||
Assertions.assertTrue(policy.isResponseCacheable(responseCacheControl, "GET", response));
|
||||
Assertions.assertTrue(policy.isResponseCacheable(responseCacheControl, request, response));
|
||||
}
|
||||
}
|
||||
Loading…
Reference in New Issue