You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@hc.apache.org by ol...@apache.org on 2023/03/12 09:33:24 UTC
[httpcomponents-client] 01/01: Allow certain responses from a POST to be cacheable.
This is an automated email from the ASF dual-hosted git repository.
olegk pushed a commit to branch 5.3.x
in repository https://gitbox.apache.org/repos/asf/httpcomponents-client.git
commit c3efc6e8702c4735c734b99fc8b1dc8638472aa7
Author: Arturo Bernal <ar...@gmail.com>
AuthorDate: Sat Mar 4 19:55:40 2023 +0100
Allow certain responses from a POST to be cacheable.
Update ResponseCachingPolicy to allow caching of responses to POST requests under certain circumstances, as specified in RFC 2616 and explained in more detail in draft-ietf-httpbis-p2-semantics-20#section-2.3.4. This change extends the cacheability of responses beyond GET and HEAD methods, improving the cache's efficiency and reducing network traffic.
---
.../hc/client5/http/cache/HeaderConstants.java | 1 +
.../hc/client5/http/impl/cache/CacheControl.java | 111 +++++++++++++
.../http/impl/cache/CacheControlHeaderParser.java | 173 +++++++++++++++++++++
.../http/impl/cache/ResponseCachingPolicy.java | 103 +++++++++++-
.../http/impl/cache/CacheControlParserTest.java | 109 +++++++++++++
.../http/impl/cache/TestCachingExecChain.java | 12 +-
.../http/impl/cache/TestResponseCachingPolicy.java | 130 +++++++++++++++-
7 files changed, 630 insertions(+), 9 deletions(-)
diff --git a/httpclient5-cache/src/main/java/org/apache/hc/client5/http/cache/HeaderConstants.java b/httpclient5-cache/src/main/java/org/apache/hc/client5/http/cache/HeaderConstants.java
index e2c6cdb77..4cf20ddf6 100644
--- a/httpclient5-cache/src/main/java/org/apache/hc/client5/http/cache/HeaderConstants.java
+++ b/httpclient5-cache/src/main/java/org/apache/hc/client5/http/cache/HeaderConstants.java
@@ -39,6 +39,7 @@ public class HeaderConstants {
public static final String PUT_METHOD = "PUT";
public static final String DELETE_METHOD = "DELETE";
public static final String TRACE_METHOD = "TRACE";
+ public static final String POST_METHOD = "POST";
public static final String LAST_MODIFIED = "Last-Modified";
public static final String IF_MATCH = "If-Match";
diff --git a/httpclient5-cache/src/main/java/org/apache/hc/client5/http/impl/cache/CacheControl.java b/httpclient5-cache/src/main/java/org/apache/hc/client5/http/impl/cache/CacheControl.java
new file mode 100644
index 000000000..b026da2f4
--- /dev/null
+++ b/httpclient5-cache/src/main/java/org/apache/hc/client5/http/impl/cache/CacheControl.java
@@ -0,0 +1,111 @@
+/*
+ * ====================================================================
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ * ====================================================================
+ *
+ * This software consists of voluntary contributions made by many
+ * individuals on behalf of the Apache Software Foundation. For more
+ * information on the Apache Software Foundation, please see
+ * <http://www.apache.org/>.
+ *
+ */
+
+package org.apache.hc.client5.http.impl.cache;
+
+import org.apache.hc.core5.annotation.Contract;
+import org.apache.hc.core5.annotation.Internal;
+import org.apache.hc.core5.annotation.ThreadingBehavior;
+
+/**
+ * Represents the values of the Cache-Control header in an HTTP response, which indicate whether and for how long
+ * the response can be cached by the client and intermediary proxies.
+ * <p>
+ * The class provides methods to retrieve the maximum age of the response and the maximum age that applies to shared
+ * caches. The values are expressed in seconds, with -1 indicating that the value was not specified in the header.
+ * <p>
+ * Instances of this class are immutable, meaning that their values cannot be changed once they are set. To create an
+ * instance, use one of the constructors that take the desired values as arguments. Alternatively, use the default
+ * constructor to create an instance with both values set to -1, indicating that the header was not present in the
+ * response.
+ * <p>
+ * Example usage:
+ * <pre>
+ * HttpResponse response = httpClient.execute(httpGet);
+ * CacheControlHeader cacheControlHeader = CacheControlHeaderParser.INSTANCE.parse(response.getHeaders("Cache-Control"));
+ * long maxAge = cacheControlHeader.getMaxAge();
+ * long sharedMaxAge = cacheControlHeader.getSharedMaxAge();
+ * </pre>
+ * @since 5.3
+ */
+@Internal
+@Contract(threading = ThreadingBehavior.IMMUTABLE)
+final class CacheControl {
+
+ /**
+ * The max-age directive value.
+ */
+ private final long maxAge;
+ /**
+ * The shared-max-age directive value.
+ */
+ private final long sharedMaxAge;
+
+
+ /**
+ * Creates a new instance of {@code CacheControlHeader} with the specified max-age and shared-max-age values.
+ *
+ * @param maxAge The max-age value from the Cache-Control header.
+ * @param sharedMaxAge The shared-max-age value from the Cache-Control header.
+ */
+ public CacheControl(final long maxAge, final long sharedMaxAge) {
+ this.maxAge = maxAge;
+ this.sharedMaxAge = sharedMaxAge;
+ }
+
+ /**
+ * Returns the max-age value from the Cache-Control header.
+ *
+ * @return The max-age value.
+ */
+ public long getMaxAge() {
+ return maxAge;
+ }
+
+ /**
+ * Returns the shared-max-age value from the Cache-Control header.
+ *
+ * @return The shared-max-age value.
+ */
+ public long getSharedMaxAge() {
+ return sharedMaxAge;
+ }
+
+
+ /**
+ * Returns a string representation of the {@code CacheControlHeader} object, including the max-age and shared-max-age values.
+ *
+ * @return A string representation of the object.
+ */
+ @Override
+ public String toString() {
+ return "CacheControl{" +
+ "maxAge=" + maxAge +
+ ", sharedMaxAge=" + sharedMaxAge +
+ '}';
+ }
+}
\ No newline at end of file
diff --git a/httpclient5-cache/src/main/java/org/apache/hc/client5/http/impl/cache/CacheControlHeaderParser.java b/httpclient5-cache/src/main/java/org/apache/hc/client5/http/impl/cache/CacheControlHeaderParser.java
new file mode 100644
index 000000000..c2afaffdd
--- /dev/null
+++ b/httpclient5-cache/src/main/java/org/apache/hc/client5/http/impl/cache/CacheControlHeaderParser.java
@@ -0,0 +1,173 @@
+/*
+ * ====================================================================
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ * ====================================================================
+ *
+ * This software consists of voluntary contributions made by many
+ * individuals on behalf of the Apache Software Foundation. For more
+ * information on the Apache Software Foundation, please see
+ * <http://www.apache.org/>.
+ *
+ */
+package org.apache.hc.client5.http.impl.cache;
+
+import java.util.BitSet;
+
+import org.apache.hc.core5.annotation.Contract;
+import org.apache.hc.core5.annotation.Internal;
+import org.apache.hc.core5.annotation.ThreadingBehavior;
+import org.apache.hc.core5.http.FormattedHeader;
+import org.apache.hc.core5.http.Header;
+import org.apache.hc.core5.util.Args;
+import org.apache.hc.core5.util.CharArrayBuffer;
+import org.apache.hc.core5.util.Tokenizer;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+
+/**
+ * A parser for the HTTP Cache-Control header that can be used to extract information about caching directives.
+ * <p>
+ * This class is thread-safe and has a singleton instance ({@link #INSTANCE}).
+ * </p>
+ * <p>
+ * The {@link #parse(Header)} method takes an HTTP header and returns a {@link CacheControl} object containing
+ * the relevant caching directives. The header can be either a {@link FormattedHeader} object, which contains a
+ * pre-parsed {@link CharArrayBuffer}, or a plain {@link Header} object, in which case the value will be parsed and
+ * stored in a new {@link CharArrayBuffer}.
+ * </p>
+ * <p>
+ * This parser only supports two directives: "max-age" and "s-maxage". If either of these directives are present in the
+ * header, their values will be parsed and stored in the {@link CacheControl} object. If both directives are
+ * present, the value of "s-maxage" takes precedence.
+ * </p>
+ */
+@Internal
+@Contract(threading = ThreadingBehavior.SAFE)
+class CacheControlHeaderParser {
+
+ /**
+ * The singleton instance of this parser.
+ */
+ public static final CacheControlHeaderParser INSTANCE = new CacheControlHeaderParser();
+
+ /**
+ * The logger for this class.
+ */
+ private static final Logger LOG = LoggerFactory.getLogger(CacheControlHeaderParser.class);
+
+
+ /**
+ * The character used to indicate a parameter's value in the Cache-Control header.
+ */
+ private final static char EQUAL_CHAR = '=';
+
+ /**
+ * The set of characters that can delimit a token in the header.
+ */
+ private static final BitSet TOKEN_DELIMS = Tokenizer.INIT_BITSET(EQUAL_CHAR, ',');
+
+ /**
+ * The set of characters that can delimit a value in the header.
+ */
+ private static final BitSet VALUE_DELIMS = Tokenizer.INIT_BITSET(EQUAL_CHAR, ',');
+
+ /**
+ * The token parser used to extract values from the header.
+ */
+ private final Tokenizer tokenParser;
+
+ /**
+ * Constructs a new instance of this parser.
+ */
+ protected CacheControlHeaderParser() {
+ super();
+ this.tokenParser = Tokenizer.INSTANCE;
+ }
+
+ /**
+ * Parses the specified header and returns a new {@link CacheControl} instance containing the relevant caching
+ * <p>
+ * directives.
+ *
+ * <p>The returned {@link CacheControl} instance will contain the values for "max-age" and "s-maxage" caching
+ * directives parsed from the input header. If the input header does not contain any caching directives or if the
+ * <p>
+ * directives are malformed, the returned {@link CacheControl} instance will have default values for "max-age" and
+ * <p>
+ * "s-maxage" (-1).</p>
+ *
+ * @param header the header to parse, cannot be {@code null}
+ * @return a new {@link CacheControl} instance containing the relevant caching directives parsed from the header
+ * @throws IllegalArgumentException if the input header is {@code null}
+ */
+ public final CacheControl parse(final Header header) {
+ Args.notNull(header, "Header");
+
+ long maxAge = -1;
+ long sharedMaxAge = -1;
+
+ final CharArrayBuffer buffer;
+ final Tokenizer.Cursor cursor;
+ if (header instanceof FormattedHeader) {
+ buffer = ((FormattedHeader) header).getBuffer();
+ cursor = new Tokenizer.Cursor(((FormattedHeader) header).getValuePos(), buffer.length());
+ } else {
+ final String s = header.getValue();
+ if (s == null) {
+ return new CacheControl(maxAge, sharedMaxAge);
+ }
+ buffer = new CharArrayBuffer(s.length());
+ buffer.append(s);
+ cursor = new Tokenizer.Cursor(0, buffer.length());
+ }
+
+ while (!cursor.atEnd()) {
+ final String name = tokenParser.parseToken(buffer, cursor, TOKEN_DELIMS);
+ if (cursor.atEnd()) {
+ return new CacheControl(maxAge, sharedMaxAge);
+ }
+ final int valueDelim = buffer.charAt(cursor.getPos());
+ cursor.updatePos(cursor.getPos() + 1);
+ if (valueDelim != EQUAL_CHAR) {
+ continue;
+ }
+ final String value = tokenParser.parseValue(buffer, cursor, VALUE_DELIMS);
+
+ if (!cursor.atEnd()) {
+ cursor.updatePos(cursor.getPos() + 1);
+ }
+
+ try {
+ if (name.equalsIgnoreCase("s-maxage")) {
+ sharedMaxAge = Long.parseLong(value);
+ } else if (name.equalsIgnoreCase("max-age")) {
+ maxAge = Long.parseLong(value);
+ }
+ } catch (final NumberFormatException e) {
+ // skip malformed directive
+ if (LOG.isDebugEnabled()) {
+ LOG.debug("Header {} was malformed: {}", name, value);
+ }
+ }
+ }
+ return new CacheControl(maxAge, sharedMaxAge);
+ }
+}
+
+
diff --git a/httpclient5-cache/src/main/java/org/apache/hc/client5/http/impl/cache/ResponseCachingPolicy.java b/httpclient5-cache/src/main/java/org/apache/hc/client5/http/impl/cache/ResponseCachingPolicy.java
index 9e8e15030..da2378f5a 100644
--- a/httpclient5-cache/src/main/java/org/apache/hc/client5/http/impl/cache/ResponseCachingPolicy.java
+++ b/httpclient5-cache/src/main/java/org/apache/hc/client5/http/impl/cache/ResponseCachingPolicy.java
@@ -26,7 +26,9 @@
*/
package org.apache.hc.client5.http.impl.cache;
+import java.time.Duration;
import java.time.Instant;
+import java.time.format.DateTimeFormatter;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashSet;
@@ -50,6 +52,25 @@ import org.slf4j.LoggerFactory;
class ResponseCachingPolicy {
+ /**
+ * The default freshness duration for a cached object, in seconds.
+ *
+ * <p>This constant is used to set the default value for the freshness lifetime of a cached object.
+ * When a new object is added to the cache, it will be assigned this duration if no other duration
+ * is specified.</p>
+ *
+ * <p>By default, this value is set to 300 seconds (5 minutes). Applications can customize this
+ * value as needed.</p>
+ */
+ private static final Duration DEFAULT_FRESHNESS_DURATION = Duration.ofMinutes(5);
+
+ /**
+ * This {@link DateTimeFormatter} is used to format and parse date-time objects in a specific format commonly
+ * used in HTTP protocol messages. The format includes the day of the week, day of the month, month, year, and time
+ * of day, all represented in GMT time. An example of a date-time string in this format is "Tue, 15 Nov 1994 08:12:31 GMT".
+ */
+ private static final DateTimeFormatter FORMATTER = DateTimeFormatter.RFC_1123_DATE_TIME;
+
private static final String[] AUTH_CACHEABLE_PARAMS = {
"s-maxage", HeaderConstants.CACHE_CONTROL_MUST_REVALIDATE, HeaderConstants.PUBLIC
};
@@ -108,7 +129,8 @@ class ResponseCachingPolicy {
public boolean isResponseCacheable(final String httpMethod, final HttpResponse response) {
boolean cacheable = false;
- if (!HeaderConstants.GET_METHOD.equals(httpMethod) && !HeaderConstants.HEAD_METHOD.equals(httpMethod)) {
+ if (!HeaderConstants.GET_METHOD.equals(httpMethod) && !HeaderConstants.HEAD_METHOD.equals(httpMethod)
+ && !HeaderConstants.POST_METHOD.equals(httpMethod)) {
if (LOG.isDebugEnabled()) {
LOG.debug("{} method response is not cacheable", httpMethod);
}
@@ -181,6 +203,15 @@ class ResponseCachingPolicy {
return false;
}
+ // calculate freshness lifetime
+ final Duration freshnessLifetime = calculateFreshnessLifetime(response);
+ if (freshnessLifetime.isNegative() || freshnessLifetime.isZero()) {
+ if (LOG.isDebugEnabled()) {
+ LOG.debug("Freshness lifetime is invalid");
+ }
+ return false;
+ }
+
return cacheable || isExplicitlyCacheable(response);
}
@@ -320,4 +351,74 @@ class ResponseCachingPolicy {
return HttpVersion.HTTP_1_0.equals(version);
}
+ /**
+ * Calculates the freshness lifetime of a response, based on the headers in the response.
+ * <p>
+ * This method follows the algorithm for calculating the freshness lifetime.
+ * The freshness lifetime represents the time interval in seconds during which the response can be served without
+ * being considered stale. The freshness lifetime calculation takes into account the s-maxage, max-age, Expires, and
+ * Date headers as follows:
+ * <ul>
+ * <li>If the s-maxage directive is present in the Cache-Control header of the response, its value is used as the
+ * freshness lifetime for shared caches, which typically serve multiple users or clients.</li>
+ * <li>If the max-age directive is present in the Cache-Control header of the response, its value is used as the
+ * freshness lifetime for private caches, which serve a single user or client.</li>
+ * <li>If the Expires header is present in the response, its value is used as the expiration time of the response.
+ * The freshness lifetime is calculated as the difference between the expiration time and the time specified in the
+ * Date header of the response.</li>
+ * <li>If none of the above headers are present or if the calculated freshness lifetime is invalid, a default value of
+ * 5 minutes is returned.</li>
+ * </ul>
+ *
+ * <p>
+ * Note that caching is a complex topic and cache control directives may interact with each other in non-trivial ways.
+ * This method provides a basic implementation of the freshness lifetime calculation algorithm and may not be suitable
+ * for all use cases. Developers should consult the HTTP caching specifications for more information and consider
+ * implementing additional caching mechanisms as needed.
+ * </p>
+ *
+ * @param response the HTTP response for which to calculate the freshness lifetime
+ * @return the freshness lifetime of the response, in seconds
+ */
+ private Duration calculateFreshnessLifetime(final HttpResponse response) {
+ // Check if s-maxage is present and use its value if it is
+ final Header cacheControl = response.getFirstHeader(HttpHeaders.CACHE_CONTROL);
+ if (cacheControl == null) {
+ // If no cache-control header is present, assume no caching directives and return a default value
+ return DEFAULT_FRESHNESS_DURATION; // 5 minutes
+ }
+
+ final String cacheControlValue = cacheControl.getValue();
+ if (cacheControlValue == null) {
+ // If cache-control header has no value, assume no caching directives and return a default value
+ return DEFAULT_FRESHNESS_DURATION; // 5 minutes
+ }
+ final CacheControl cacheControlHeader = CacheControlHeaderParser.INSTANCE.parse(cacheControl);
+ if (cacheControlHeader.getSharedMaxAge() != -1) {
+ return Duration.ofSeconds(cacheControlHeader.getSharedMaxAge());
+ } else if (cacheControlHeader.getMaxAge() != -1) {
+ return Duration.ofSeconds(cacheControlHeader.getMaxAge());
+ }
+
+ // Check if Expires is present and use its value minus the value of the Date header
+ Instant expiresInstant = null;
+ Instant dateInstant = null;
+ final Header expire = response.getFirstHeader(HttpHeaders.EXPIRES);
+ if (expire != null) {
+ final String expiresHeaderValue = expire.getValue();
+ expiresInstant = FORMATTER.parse(expiresHeaderValue, Instant::from);
+ }
+ final Header date = response.getFirstHeader(HttpHeaders.DATE);
+ if (date != null) {
+ final String dateHeaderValue = date.getValue();
+ dateInstant = FORMATTER.parse(dateHeaderValue, Instant::from);
+ }
+ if (expiresInstant != null && dateInstant != null) {
+ return Duration.ofSeconds(expiresInstant.getEpochSecond() - dateInstant.getEpochSecond());
+ }
+
+ // If none of the above conditions are met, a heuristic freshness lifetime might be applicable
+ return DEFAULT_FRESHNESS_DURATION; // 5 minutes
+ }
+
}
diff --git a/httpclient5-cache/src/test/java/org/apache/hc/client5/http/impl/cache/CacheControlParserTest.java b/httpclient5-cache/src/test/java/org/apache/hc/client5/http/impl/cache/CacheControlParserTest.java
new file mode 100644
index 000000000..1f3b60761
--- /dev/null
+++ b/httpclient5-cache/src/test/java/org/apache/hc/client5/http/impl/cache/CacheControlParserTest.java
@@ -0,0 +1,109 @@
+/*
+ * ====================================================================
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ * ====================================================================
+ *
+ * This software consists of voluntary contributions made by many
+ * individuals on behalf of the Apache Software Foundation. For more
+ * information on the Apache Software Foundation, please see
+ * <http://www.apache.org/>.
+ *
+ */
+package org.apache.hc.client5.http.impl.cache;
+
+import org.apache.hc.core5.http.Header;
+import org.apache.hc.core5.http.message.BasicHeader;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+public class CacheControlParserTest {
+
+ private final CacheControlHeaderParser parser = CacheControlHeaderParser.INSTANCE;
+
+ @Test
+ public void testParseMaxAgeZero() {
+ final Header header = new BasicHeader("Cache-Control", "max-age=0 , this = stuff;");
+ final CacheControl cacheControl = parser.parse(header);
+ assertEquals(0L, cacheControl.getMaxAge());
+ }
+
+ @Test
+ public void testParseSMaxAge() {
+ final Header header = new BasicHeader("Cache-Control", "s-maxage=3600");
+ final CacheControl cacheControl = parser.parse(header);
+ assertEquals(3600L, cacheControl.getSharedMaxAge());
+ }
+
+ @Test
+ public void testParseInvalidCacheValue() {
+ final Header header = new BasicHeader("Cache-Control", "max-age=invalid");
+ final CacheControl cacheControl = parser.parse(header);
+ assertEquals(-1L, cacheControl.getMaxAge());
+ }
+
+ @Test
+ public void testParseInvalidHeader() {
+ final Header header = new BasicHeader("Cache-Control", "max-age");
+ final CacheControl cacheControl = parser.parse(header);
+ assertEquals(-1L, cacheControl.getMaxAge());
+ }
+
+ @Test
+ public void testParseNullHeader() {
+ final Header header = null;
+ assertThrows(NullPointerException.class, () -> parser.parse(header));
+ }
+
+ @Test
+ public void testParseEmptyHeader() {
+ final Header header = new BasicHeader("Cache-Control", "");
+ final CacheControl cacheControl = parser.parse(header);
+ assertEquals(-1L, cacheControl.getMaxAge());
+ }
+
+ @Test
+ public void testParseCookieEmptyValue() {
+ final Header header = new BasicHeader("Cache-Control", "max-age=;");
+ final CacheControl cacheControl = parser.parse(header);
+ assertEquals(-1L, cacheControl.getMaxAge());
+ }
+
+ @Test
+ public void testParseNoCache() {
+ final Header header = new BasicHeader(" Cache-Control", "no-cache");
+ final CacheControl cacheControl = parser.parse(header);
+ assertEquals(-1L, cacheControl.getMaxAge());
+ }
+
+ @Test
+ public void testParseNoDirective() {
+ final Header header = new BasicHeader(" Cache-Control", "");
+ final CacheControl cacheControl = parser.parse(header);
+ assertEquals(-1L, cacheControl.getMaxAge());
+ }
+
+ @Test
+ public void testGarbage() {
+ final Header header = new BasicHeader("Cache-Control", ",,= blah,");
+ final CacheControl cacheControl = parser.parse(header);
+ assertEquals(-1L, cacheControl.getMaxAge());
+ }
+
+}
diff --git a/httpclient5-cache/src/test/java/org/apache/hc/client5/http/impl/cache/TestCachingExecChain.java b/httpclient5-cache/src/test/java/org/apache/hc/client5/http/impl/cache/TestCachingExecChain.java
index 0a3db1636..75a7ca79e 100644
--- a/httpclient5-cache/src/test/java/org/apache/hc/client5/http/impl/cache/TestCachingExecChain.java
+++ b/httpclient5-cache/src/test/java/org/apache/hc/client5/http/impl/cache/TestCachingExecChain.java
@@ -642,7 +642,7 @@ public class TestCachingExecChain {
execute(req2);
Assertions.assertEquals(CacheResponseStatus.CACHE_MODULE_RESPONSE,
- context.getCacheResponseStatus());
+ context.getCacheResponseStatus());
}
@Test
@@ -1165,12 +1165,12 @@ public class TestCachingExecChain {
final ClassicHttpResponse resp1 = HttpTestUtils.make304Response();
resp1.setHeader("Date", DateUtils.formatStandardDate(now));
- resp1.setHeader("Cache-Control", "max-age=0");
+ resp1.setHeader("Cache-Control", "max-age=1");
resp1.setHeader("Etag", "etag");
final ClassicHttpResponse resp2 = HttpTestUtils.make304Response();
resp2.setHeader("Date", DateUtils.formatStandardDate(now));
- resp2.setHeader("Cache-Control", "max-age=0");
+ resp2.setHeader("Cache-Control", "max-age=1");
resp1.setHeader("Etag", "etag");
Mockito.when(mockExecChain.proceed(Mockito.any(), Mockito.any())).thenReturn(resp1);
@@ -1199,13 +1199,13 @@ public class TestCachingExecChain {
final ClassicHttpResponse resp1 = HttpTestUtils.make304Response();
resp1.setHeader("Date", DateUtils.formatStandardDate(now));
- resp1.setHeader("Cache-Control", "max-age=0");
+ resp1.setHeader("Cache-Control", "max-age=1");
resp1.setHeader("Etag", "etag");
resp1.setHeader("Vary", "Accept-Encoding");
final ClassicHttpResponse resp2 = HttpTestUtils.make304Response();
resp2.setHeader("Date", DateUtils.formatStandardDate(now));
- resp2.setHeader("Cache-Control", "max-age=0");
+ resp2.setHeader("Cache-Control", "max-age=1");
resp1.setHeader("Etag", "etag");
resp1.setHeader("Vary", "Accept-Encoding");
@@ -1242,7 +1242,7 @@ public class TestCachingExecChain {
resp1.setHeader("Vary", "Accept-Encoding");
final ClassicHttpResponse resp2 = new BasicClassicHttpResponse(HttpStatus.SC_OK,
- "Ok");
+ "Ok");
resp2.setHeader("Date", DateUtils.formatStandardDate(now));
resp2.setHeader("Cache-Control", "public, max-age=60");
resp2.setHeader("Expires", DateUtils.formatStandardDate(inOneMinute));
diff --git a/httpclient5-cache/src/test/java/org/apache/hc/client5/http/impl/cache/TestResponseCachingPolicy.java b/httpclient5-cache/src/test/java/org/apache/hc/client5/http/impl/cache/TestResponseCachingPolicy.java
index abf7324b3..d3c2e6112 100644
--- a/httpclient5-cache/src/test/java/org/apache/hc/client5/http/impl/cache/TestResponseCachingPolicy.java
+++ b/httpclient5-cache/src/test/java/org/apache/hc/client5/http/impl/cache/TestResponseCachingPolicy.java
@@ -27,11 +27,13 @@
package org.apache.hc.client5.http.impl.cache;
import java.time.Instant;
+import java.util.Date;
import java.util.Random;
import org.apache.hc.client5.http.auth.StandardAuthScheme;
import org.apache.hc.client5.http.classic.methods.HttpOptions;
import org.apache.hc.client5.http.utils.DateUtils;
+import org.apache.hc.core5.http.HttpHeaders;
import org.apache.hc.core5.http.HttpRequest;
import org.apache.hc.core5.http.HttpResponse;
import org.apache.hc.core5.http.HttpStatus;
@@ -216,15 +218,49 @@ public class TestResponseCachingPolicy {
final int status = getRandomStatus();
response.setCode(status);
response.setHeader("Cache-Control", "max-age=0");
+ Assertions.assertFalse(policy.isResponseCacheable("GET", response));
+ }
+
+ @Test
+ public void testMalformedHeaderValue() {
+ final int status = getRandomStatus();
+ response.setCode(status);
+ response.setHeader("Cache-Control", "max-age=boom");
+ Assertions.assertTrue(policy.isResponseCacheable("GET", response));
+ }
+
+
+ @Test
+ public void testNullHeaderValue() {
+ final int status = getRandomStatus();
+ response.setCode(status);
+ response.setHeader("Cache-Control", null);
+ Assertions.assertTrue(policy.isResponseCacheable("GET", response));
+ }
+
+ @Test
+ public void testMultipleHeaderValue() {
+ final int status = getRandomStatus();
+ response.setCode(status);
+ response.setHeader("Cache-Control", "s-maxage=12,must-revalidate=true,max-age=23");
Assertions.assertTrue(policy.isResponseCacheable("GET", response));
}
+ @Test
+ public void testMissingCacheControlHeader() {
+ final int status = getRandomStatus();
+ response.setCode(status);
+ response.removeHeaders(HttpHeaders.CACHE_CONTROL);
+ final boolean isCacheable = policy.isResponseCacheable("GET", response);
+ Assertions.assertTrue(isCacheable);
+ }
+
@Test
public void testNon206WithSMaxAgeIsCacheable() {
final int status = getRandomStatus();
response.setCode(status);
response.setHeader("Cache-Control", "s-maxage=0");
- Assertions.assertTrue(policy.isResponseCacheable("GET", response));
+ Assertions.assertFalse(policy.isResponseCacheable("GET", response));
}
@Test
@@ -870,9 +906,99 @@ public class TestResponseCachingPolicy {
response.setCode(HttpStatus.SC_NOT_FOUND);
response.setHeader("Date", DateUtils.formatStandardDate(now));
response.setHeader("Cache-Control","max-age=300");
- Assertions.assertTrue(policy.isResponseCacheable(request, response));
+ assertTrue(policy.isResponseCacheable(request, response));
+ }
+
+ @Test
+ void testIsResponseCacheableNullCacheControl() {
+
+ // Set up test data
+ final long now = System.currentTimeMillis();
+ final long tenSecondsFromNow = now + 10000;
+
+ response = new BasicHttpResponse(HttpStatus.SC_OK, "");
+ response.setHeader(HttpHeaders.DATE, DateUtils.formatDate(new Date(now), DateUtils.PATTERN_RFC1123));
+ response.setHeader(HttpHeaders.EXPIRES, DateUtils.formatDate(new Date(tenSecondsFromNow), DateUtils.PATTERN_RFC1123));
+
+
+ // Create ResponseCachingPolicy instance and test the method
+ policy = new ResponseCachingPolicy(0, true, false, false, false);
+ request = new BasicHttpRequest("POST", "/foo");
+ final boolean isCacheable = policy.isResponseCacheable(request, response);
+
+ // Verify the result
+ assertTrue(isCacheable);
+ }
+
+
+ @Test
+ void testIsResponseCacheableNotNullCacheControlSmaxAge60() {
+
+ // Set up test data
+ final long now = System.currentTimeMillis();
+ final long tenSecondsFromNow = now + 10000;
+
+ response = new BasicHttpResponse(HttpStatus.SC_OK, "");
+ response.setHeader(HttpHeaders.DATE, DateUtils.formatDate(new Date(now), DateUtils.PATTERN_RFC1123));
+ response.setHeader(HttpHeaders.EXPIRES, DateUtils.formatDate(new Date(tenSecondsFromNow), DateUtils.PATTERN_RFC1123));
+
+
+ // Create ResponseCachingPolicy instance and test the method
+ policy = new ResponseCachingPolicy(0, true, false, false, false);
+ request = new BasicHttpRequest("POST", "/foo");
+ response.addHeader(HttpHeaders.CACHE_CONTROL, "s-maxage=60");
+ final boolean isCacheable = policy.isResponseCacheable(request, response);
+
+ // Verify the result
+ assertTrue(isCacheable);
+ }
+
+ @Test
+ void testIsResponseCacheableNotNullCacheControlMaxAge60() {
+
+ // Set up test data
+ final long now = System.currentTimeMillis();
+ final long tenSecondsFromNow = now + 10000;
+
+ response = new BasicHttpResponse(HttpStatus.SC_OK, "");
+ response.setHeader(HttpHeaders.DATE, DateUtils.formatDate(new Date(now), DateUtils.PATTERN_RFC1123));
+ response.setHeader(HttpHeaders.EXPIRES, DateUtils.formatDate(new Date(tenSecondsFromNow), DateUtils.PATTERN_RFC1123));
+
+
+ // Create ResponseCachingPolicy instance and test the method
+ policy = new ResponseCachingPolicy(0, true, false, false,false);
+ request = new BasicHttpRequest("POST", "/foo");
+ response.addHeader(HttpHeaders.CACHE_CONTROL, "max-age=60");
+ final boolean isCacheable = policy.isResponseCacheable(request, response);
+
+ // Verify the result
+ assertTrue(isCacheable);
}
+ @Test
+ void testIsResponseCacheableNotExsiresAndDate() {
+
+ // Set up test data
+ final long now = System.currentTimeMillis();
+ final long tenSecondsFromNow = now + 10000;
+
+ response = new BasicHttpResponse(HttpStatus.SC_OK, "");
+ response.setHeader(HttpHeaders.DATE, DateUtils.formatDate(new Date(now), DateUtils.PATTERN_RFC1123));
+ response.setHeader(HttpHeaders.EXPIRES, DateUtils.formatDate(new Date(tenSecondsFromNow), DateUtils.PATTERN_RFC1123));
+
+
+ // Create ResponseCachingPolicy instance and test the method
+ policy = new ResponseCachingPolicy(0, true, false, false,false);
+ request = new BasicHttpRequest("POST", "/foo");
+ response.addHeader(HttpHeaders.CACHE_CONTROL, "something");
+ final boolean isCacheable = policy.isResponseCacheable(request, response);
+
+ // Verify the result
+ assertTrue(isCacheable);
+ }
+
+
+
private int getRandomStatus() {
final int rnd = new Random().nextInt(acceptableCodes.length);