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 2017/12/07 19:03:31 UTC
[1/2] httpcomponents-client git commit: Clean up of test cases
Repository: httpcomponents-client
Updated Branches:
refs/heads/master 9931a9ca9 -> 043fe4dd9
Clean up of test cases
Project: http://git-wip-us.apache.org/repos/asf/httpcomponents-client/repo
Commit: http://git-wip-us.apache.org/repos/asf/httpcomponents-client/commit/b1659264
Tree: http://git-wip-us.apache.org/repos/asf/httpcomponents-client/tree/b1659264
Diff: http://git-wip-us.apache.org/repos/asf/httpcomponents-client/diff/b1659264
Branch: refs/heads/master
Commit: b1659264f772eebce6a457150707a5151696a90d
Parents: 9931a9c
Author: Oleg Kalnichevski <ol...@apache.org>
Authored: Thu Dec 7 19:56:01 2017 +0100
Committer: Oleg Kalnichevski <ol...@apache.org>
Committed: Thu Dec 7 19:59:32 2017 +0100
----------------------------------------------------------------------
.../impl/cache/TestDefaultCacheInvalidator.java | 365 ++++++++++---------
1 file changed, 191 insertions(+), 174 deletions(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/httpcomponents-client/blob/b1659264/httpclient5-cache/src/test/java/org/apache/hc/client5/http/impl/cache/TestDefaultCacheInvalidator.java
----------------------------------------------------------------------
diff --git a/httpclient5-cache/src/test/java/org/apache/hc/client5/http/impl/cache/TestDefaultCacheInvalidator.java b/httpclient5-cache/src/test/java/org/apache/hc/client5/http/impl/cache/TestDefaultCacheInvalidator.java
index 5cd202a..4b1f6d8 100644
--- a/httpclient5-cache/src/test/java/org/apache/hc/client5/http/impl/cache/TestDefaultCacheInvalidator.java
+++ b/httpclient5-cache/src/test/java/org/apache/hc/client5/http/impl/cache/TestDefaultCacheInvalidator.java
@@ -41,14 +41,14 @@ import org.apache.hc.client5.http.cache.HttpCacheEntry;
import org.apache.hc.client5.http.cache.HttpCacheStorage;
import org.apache.hc.client5.http.cache.ResourceIOException;
import org.apache.hc.client5.http.utils.DateUtils;
-import org.apache.hc.core5.http.ClassicHttpRequest;
-import org.apache.hc.core5.http.ClassicHttpResponse;
import org.apache.hc.core5.http.Header;
import org.apache.hc.core5.http.HttpHost;
+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.message.BasicClassicHttpRequest;
-import org.apache.hc.core5.http.message.BasicClassicHttpResponse;
import org.apache.hc.core5.http.message.BasicHeader;
+import org.apache.hc.core5.http.message.BasicHttpRequest;
+import org.apache.hc.core5.http.message.BasicHttpResponse;
import org.junit.Before;
import org.junit.Test;
@@ -59,8 +59,6 @@ public class TestDefaultCacheInvalidator {
private HttpHost host;
private CacheKeyGenerator cacheKeyGenerator;
private HttpCacheEntry mockEntry;
- private ClassicHttpRequest request;
- private ClassicHttpResponse response;
private Date now;
private Date tenSecondsAgo;
@@ -74,8 +72,6 @@ public class TestDefaultCacheInvalidator {
mockStorage = mock(HttpCacheStorage.class);
cacheKeyGenerator = new CacheKeyGenerator();
mockEntry = mock(HttpCacheEntry.class);
- request = HttpTestUtils.makeDefaultRequest();
- response = HttpTestUtils.make200Response();
impl = new DefaultCacheInvalidator(cacheKeyGenerator, mockStorage);
}
@@ -83,110 +79,110 @@ public class TestDefaultCacheInvalidator {
// Tests
@Test
public void testInvalidatesRequestsThatArentGETorHEAD() throws Exception {
- request = new BasicClassicHttpRequest("POST","/path");
- final String theUri = "http://foo.example.com:80/path";
+ final HttpRequest request = new BasicHttpRequest("POST","/path");
+ final String key = "http://foo.example.com:80/path";
final Map<String,String> variantMap = new HashMap<>();
cacheEntryHasVariantMap(variantMap);
- cacheReturnsEntryForUri(theUri);
+ cacheReturnsEntryForUri(key);
impl.flushInvalidatedCacheEntries(host, request);
verify(mockEntry).getVariantMap();
- verify(mockStorage).getEntry(theUri);
- verify(mockStorage).removeEntry(theUri);
+ verify(mockStorage).getEntry(key);
+ verify(mockStorage).removeEntry(key);
}
@Test
public void testInvalidatesUrisInContentLocationHeadersOnPUTs() throws Exception {
- final ClassicHttpRequest putRequest = new BasicClassicHttpRequest("PUT","/");
- putRequest.setEntity(HttpTestUtils.makeBody(128));
- putRequest.setHeader("Content-Length","128");
+ final HttpRequest request = new BasicHttpRequest("PUT","/");
+ request.setHeader("Content-Length","128");
final String contentLocation = "http://foo.example.com/content";
- putRequest.setHeader("Content-Location", contentLocation);
+ request.setHeader("Content-Location", contentLocation);
- final String theUri = "http://foo.example.com:80/";
+ final URI uri = new URI("http://foo.example.com:80/");
+ final String key = uri.toASCIIString();
cacheEntryHasVariantMap(new HashMap<String,String>());
- cacheReturnsEntryForUri(theUri);
+ cacheReturnsEntryForUri(key);
- impl.flushInvalidatedCacheEntries(host, putRequest);
+ impl.flushInvalidatedCacheEntries(host, request);
verify(mockEntry).getVariantMap();
- verify(mockStorage).getEntry(theUri);
- verify(mockStorage).removeEntry(theUri);
+ verify(mockStorage).getEntry(key);
+ verify(mockStorage).removeEntry(key);
verify(mockStorage).removeEntry("http://foo.example.com:80/content");
}
@Test
public void testInvalidatesUrisInLocationHeadersOnPUTs() throws Exception {
- final ClassicHttpRequest putRequest = new BasicClassicHttpRequest("PUT","/");
- putRequest.setEntity(HttpTestUtils.makeBody(128));
- putRequest.setHeader("Content-Length","128");
+ final HttpRequest request = new BasicHttpRequest("PUT","/");
+ request.setHeader("Content-Length","128");
final String contentLocation = "http://foo.example.com/content";
- putRequest.setHeader("Location",contentLocation);
+ request.setHeader("Location",contentLocation);
- final String theUri = "http://foo.example.com:80/";
+ final URI uri = new URI("http://foo.example.com:80/");
+ final String key = uri.toASCIIString();
cacheEntryHasVariantMap(new HashMap<String,String>());
- cacheReturnsEntryForUri(theUri);
+ cacheReturnsEntryForUri(key);
- impl.flushInvalidatedCacheEntries(host, putRequest);
+ impl.flushInvalidatedCacheEntries(host, request);
verify(mockEntry).getVariantMap();
- verify(mockStorage).getEntry(theUri);
- verify(mockStorage).removeEntry(theUri);
+ verify(mockStorage).getEntry(key);
+ verify(mockStorage).removeEntry(key);
verify(mockStorage).removeEntry(cacheKeyGenerator.generateKey(new URI(contentLocation)));
}
@Test
public void testInvalidatesRelativeUrisInContentLocationHeadersOnPUTs() throws Exception {
- final ClassicHttpRequest putRequest = new BasicClassicHttpRequest("PUT","/");
- putRequest.setEntity(HttpTestUtils.makeBody(128));
- putRequest.setHeader("Content-Length","128");
+ final HttpRequest request = new BasicHttpRequest("PUT","/");
+ request.setHeader("Content-Length","128");
final String relativePath = "/content";
- putRequest.setHeader("Content-Location",relativePath);
+ request.setHeader("Content-Location",relativePath);
- final String theUri = "http://foo.example.com:80/";
+ final URI uri = new URI("http://foo.example.com:80/");
+ final String key = uri.toASCIIString();
cacheEntryHasVariantMap(new HashMap<String,String>());
- cacheReturnsEntryForUri(theUri);
+ cacheReturnsEntryForUri(key);
- impl.flushInvalidatedCacheEntries(host, putRequest);
+ impl.flushInvalidatedCacheEntries(host, request);
verify(mockEntry).getVariantMap();
- verify(mockStorage).getEntry(theUri);
- verify(mockStorage).removeEntry(theUri);
+ verify(mockStorage).getEntry(key);
+ verify(mockStorage).removeEntry(key);
verify(mockStorage).removeEntry("http://foo.example.com:80/content");
}
@Test
public void testDoesNotInvalidateUrisInContentLocationHeadersOnPUTsToDifferentHosts() throws Exception {
- final ClassicHttpRequest putRequest = new BasicClassicHttpRequest("PUT","/");
- putRequest.setEntity(HttpTestUtils.makeBody(128));
- putRequest.setHeader("Content-Length","128");
+ final HttpRequest request = new BasicHttpRequest("PUT","/");
+ request.setHeader("Content-Length","128");
final String contentLocation = "http://bar.example.com/content";
- putRequest.setHeader("Content-Location",contentLocation);
+ request.setHeader("Content-Location",contentLocation);
- final String theUri = "http://foo.example.com:80/";
+ final URI uri = new URI("http://foo.example.com:80/");
+ final String key = uri.toASCIIString();
cacheEntryHasVariantMap(new HashMap<String,String>());
- cacheReturnsEntryForUri(theUri);
+ cacheReturnsEntryForUri(key);
- impl.flushInvalidatedCacheEntries(host, putRequest);
+ impl.flushInvalidatedCacheEntries(host, request);
verify(mockEntry).getVariantMap();
- verify(mockStorage).getEntry(theUri);
- verify(mockStorage).removeEntry(theUri);
+ verify(mockStorage).getEntry(key);
+ verify(mockStorage).removeEntry(key);
}
@Test
public void testDoesNotInvalidateGETRequest() throws Exception {
- request = new BasicClassicHttpRequest("GET","/");
+ final HttpRequest request = new BasicHttpRequest("GET","/");
impl.flushInvalidatedCacheEntries(host, request);
verify(mockStorage).getEntry("http://foo.example.com:80/");
@@ -195,7 +191,7 @@ public class TestDefaultCacheInvalidator {
@Test
public void testDoesNotInvalidateHEADRequest() throws Exception {
- request = new BasicClassicHttpRequest("HEAD","/");
+ final HttpRequest request = new BasicHttpRequest("HEAD","/");
impl.flushInvalidatedCacheEntries(host, request);
verify(mockStorage).getEntry("http://foo.example.com:80/");
@@ -205,89 +201,94 @@ public class TestDefaultCacheInvalidator {
@Test
public void testInvalidatesHEADCacheEntryIfSubsequentGETRequestsAreMadeToTheSameURI() throws Exception {
impl = new DefaultCacheInvalidator(cacheKeyGenerator, mockStorage);
- final String theURI = "http://foo.example.com:80/";
- request = new BasicClassicHttpRequest("GET", theURI);
+ final URI uri = new URI("http://foo.example.com:80/");
+ final String key = uri.toASCIIString();
+ final HttpRequest request = new BasicHttpRequest("GET", uri);
cacheEntryisForMethod("HEAD");
cacheEntryHasVariantMap(new HashMap<String, String>());
- cacheReturnsEntryForUri(theURI);
+ cacheReturnsEntryForUri(key);
impl.flushInvalidatedCacheEntries(host, request);
verify(mockEntry).getRequestMethod();
verify(mockEntry).getVariantMap();
- verify(mockStorage).getEntry(theURI);
- verify(mockStorage).removeEntry(theURI);
+ verify(mockStorage).getEntry(key);
+ verify(mockStorage).removeEntry(key);
}
@Test
public void testInvalidatesVariantHEADCacheEntriesIfSubsequentGETRequestsAreMadeToTheSameURI() throws Exception {
impl = new DefaultCacheInvalidator(cacheKeyGenerator, mockStorage);
- final String theURI = "http://foo.example.com:80/";
- request = new BasicClassicHttpRequest("GET", theURI);
+ final URI uri = new URI("http://foo.example.com:80/");
+ final String key = uri.toASCIIString();
+ final HttpRequest request = new BasicHttpRequest("GET", uri);
final String theVariantKey = "{Accept-Encoding=gzip%2Cdeflate&User-Agent=Apache-HttpClient}";
final String theVariantURI = "{Accept-Encoding=gzip%2Cdeflate&User-Agent=Apache-HttpClient}http://foo.example.com:80/";
final Map<String, String> variants = HttpTestUtils.makeDefaultVariantMap(theVariantKey, theVariantURI);
cacheEntryisForMethod("HEAD");
cacheEntryHasVariantMap(variants);
- cacheReturnsEntryForUri(theURI);
+ cacheReturnsEntryForUri(key);
impl.flushInvalidatedCacheEntries(host, request);
verify(mockEntry).getRequestMethod();
verify(mockEntry).getVariantMap();
- verify(mockStorage).getEntry(theURI);
- verify(mockStorage).removeEntry(theURI);
+ verify(mockStorage).getEntry(key);
+ verify(mockStorage).removeEntry(key);
verify(mockStorage).removeEntry(theVariantURI);
}
@Test
public void testDoesNotInvalidateHEADCacheEntry() throws Exception {
- final String theURI = "http://foo.example.com:80/";
- request = new BasicClassicHttpRequest("HEAD", theURI);
+ final URI uri = new URI("http://foo.example.com:80/");
+ final String key = uri.toASCIIString();
+ final HttpRequest request = new BasicHttpRequest("HEAD", uri);
- cacheReturnsEntryForUri(theURI);
+ cacheReturnsEntryForUri(key);
impl.flushInvalidatedCacheEntries(host, request);
- verify(mockStorage).getEntry(theURI);
+ verify(mockStorage).getEntry(key);
verifyNoMoreInteractions(mockStorage);
}
@Test
public void testDoesNotInvalidateHEADCacheEntryIfSubsequentHEADRequestsAreMadeToTheSameURI() throws Exception {
impl = new DefaultCacheInvalidator(cacheKeyGenerator, mockStorage);
- final String theURI = "http://foo.example.com:80/";
- request = new BasicClassicHttpRequest("HEAD", theURI);
+ final URI uri = new URI("http://foo.example.com:80/");
+ final String key = uri.toASCIIString();
+ final HttpRequest request = new BasicHttpRequest("HEAD", uri);
- cacheReturnsEntryForUri(theURI);
+ cacheReturnsEntryForUri(key);
impl.flushInvalidatedCacheEntries(host, request);
- verify(mockStorage).getEntry(theURI);
+ verify(mockStorage).getEntry(key);
verifyNoMoreInteractions(mockStorage);
}
@Test
public void testDoesNotInvalidateGETCacheEntryIfSubsequentGETRequestsAreMadeToTheSameURI() throws Exception {
impl = new DefaultCacheInvalidator(cacheKeyGenerator, mockStorage);
- final String theURI = "http://foo.example.com:80/";
- request = new BasicClassicHttpRequest("GET", theURI);
+ final URI uri = new URI("http://foo.example.com:80/");
+ final String key = uri.toASCIIString();
+ final HttpRequest request = new BasicHttpRequest("GET", uri);
cacheEntryisForMethod("GET");
- cacheReturnsEntryForUri(theURI);
+ cacheReturnsEntryForUri(key);
impl.flushInvalidatedCacheEntries(host, request);
verify(mockEntry).getRequestMethod();
- verify(mockStorage).getEntry(theURI);
+ verify(mockStorage).getEntry(key);
verifyNoMoreInteractions(mockStorage);
}
@Test
public void testDoesNotInvalidateRequestsWithClientCacheControlHeaders() throws Exception {
- request = new BasicClassicHttpRequest("GET","/");
+ final HttpRequest request = new BasicHttpRequest("GET","/");
request.setHeader("Cache-Control","no-cache");
impl.flushInvalidatedCacheEntries(host, request);
@@ -298,7 +299,7 @@ public class TestDefaultCacheInvalidator {
@Test
public void testDoesNotInvalidateRequestsWithClientPragmaHeaders() throws Exception {
- request = new BasicClassicHttpRequest("GET","/");
+ final HttpRequest request = new BasicHttpRequest("GET","/");
request.setHeader("Pragma","no-cache");
impl.flushInvalidatedCacheEntries(host, request);
@@ -309,94 +310,98 @@ public class TestDefaultCacheInvalidator {
@Test
public void testVariantURIsAreFlushedAlso() throws Exception {
- request = new BasicClassicHttpRequest("POST","/");
- final String theUri = "http://foo.example.com:80/";
+ final HttpRequest request = new BasicHttpRequest("POST","/");
+ final URI uri = new URI("http://foo.example.com:80/");
+ final String key = uri.toASCIIString();
final String variantUri = "theVariantURI";
final Map<String,String> mapOfURIs = HttpTestUtils.makeDefaultVariantMap(variantUri, variantUri);
- cacheReturnsEntryForUri(theUri);
+ cacheReturnsEntryForUri(key);
cacheEntryHasVariantMap(mapOfURIs);
impl.flushInvalidatedCacheEntries(host, request);
- verify(mockStorage).getEntry(theUri);
+ verify(mockStorage).getEntry(key);
verify(mockEntry).getVariantMap();
verify(mockStorage).removeEntry(variantUri);
- verify(mockStorage).removeEntry(theUri);
+ verify(mockStorage).removeEntry(key);
}
@Test
public void testCacheFlushException() throws Exception {
- request = new BasicClassicHttpRequest("POST","/");
- final String theURI = "http://foo.example.com:80/";
+ final HttpRequest request = new BasicHttpRequest("POST","/");
+ final URI uri = new URI("http://foo.example.com:80/");
+ final String key = uri.toASCIIString();
- cacheReturnsExceptionForUri(theURI);
+ cacheReturnsExceptionForUri(key);
impl.flushInvalidatedCacheEntries(host, request);
- verify(mockStorage).getEntry(theURI);
+ verify(mockStorage).getEntry(key);
verifyNoMoreInteractions(mockStorage);
}
@Test
- public void doesNotFlushForResponsesWithoutContentLocation()
- throws Exception {
+ public void doesNotFlushForResponsesWithoutContentLocation() throws Exception {
+ final HttpRequest request = new BasicHttpRequest("POST","/");
+ final HttpResponse response = new BasicHttpResponse(HttpStatus.SC_OK);
impl.flushInvalidatedCacheEntries(host, request, response);
verifyNoMoreInteractions(mockStorage);
}
@Test
- public void flushesEntryIfFresherAndSpecifiedByContentLocation()
- throws Exception {
+ public void flushesEntryIfFresherAndSpecifiedByContentLocation() throws Exception {
+ final HttpRequest request = new BasicHttpRequest("GET", "/");
+ final HttpResponse response = new BasicHttpResponse(HttpStatus.SC_OK);
response.setHeader("ETag","\"new-etag\"");
response.setHeader("Date", DateUtils.formatDate(now));
- final String theURI = "http://foo.example.com:80/bar";
- response.setHeader("Content-Location", theURI);
+ final String key = "http://foo.example.com:80/bar";
+ response.setHeader("Content-Location", key);
final HttpCacheEntry entry = HttpTestUtils.makeCacheEntry(new Header[] {
new BasicHeader("Date", DateUtils.formatDate(tenSecondsAgo)),
new BasicHeader("ETag", "\"old-etag\"")
});
- when(mockStorage.getEntry(theURI)).thenReturn(entry);
+ when(mockStorage.getEntry(key)).thenReturn(entry);
impl.flushInvalidatedCacheEntries(host, request, response);
- verify(mockStorage).getEntry(theURI);
- verify(mockStorage).removeEntry(theURI);
+ verify(mockStorage).getEntry(key);
+ verify(mockStorage).removeEntry(key);
}
@Test
- public void flushesEntryIfFresherAndSpecifiedByLocation()
- throws Exception {
- response.setCode(201);
+ public void flushesEntryIfFresherAndSpecifiedByLocation() throws Exception {
+ final HttpRequest request = new BasicHttpRequest("GET", "/");
+ final HttpResponse response = new BasicHttpResponse(201);
response.setHeader("ETag","\"new-etag\"");
response.setHeader("Date", DateUtils.formatDate(now));
- final String theURI = "http://foo.example.com:80/bar";
- response.setHeader("Location", theURI);
+ final String key = "http://foo.example.com:80/bar";
+ response.setHeader("Location", key);
final HttpCacheEntry entry = HttpTestUtils.makeCacheEntry(new Header[] {
new BasicHeader("Date", DateUtils.formatDate(tenSecondsAgo)),
new BasicHeader("ETag", "\"old-etag\"")
});
- when(mockStorage.getEntry(theURI)).thenReturn(entry);
+ when(mockStorage.getEntry(key)).thenReturn(entry);
impl.flushInvalidatedCacheEntries(host, request, response);
- verify(mockStorage).getEntry(theURI);
- verify(mockStorage).removeEntry(theURI);
+ verify(mockStorage).getEntry(key);
+ verify(mockStorage).removeEntry(key);
}
@Test
- public void doesNotFlushEntryForUnsuccessfulResponse()
- throws Exception {
- response = new BasicClassicHttpResponse(HttpStatus.SC_BAD_REQUEST, "Bad Request");
+ public void doesNotFlushEntryForUnsuccessfulResponse() throws Exception {
+ final HttpRequest request = new BasicHttpRequest("GET", "/");
+ final HttpResponse response = new BasicHttpResponse(HttpStatus.SC_BAD_REQUEST, "Bad Request");
response.setHeader("ETag","\"new-etag\"");
response.setHeader("Date", DateUtils.formatDate(now));
- final String theURI = "http://foo.example.com:80/bar";
- response.setHeader("Content-Location", theURI);
+ final String key = "http://foo.example.com:80/bar";
+ response.setHeader("Content-Location", key);
impl.flushInvalidatedCacheEntries(host, request, response);
@@ -404,8 +409,9 @@ public class TestDefaultCacheInvalidator {
}
@Test
- public void flushesEntryIfFresherAndSpecifiedByNonCanonicalContentLocation()
- throws Exception {
+ public void flushesEntryIfFresherAndSpecifiedByNonCanonicalContentLocation() throws Exception {
+ final HttpRequest request = new BasicHttpRequest("GET", "/");
+ final HttpResponse response = new BasicHttpResponse(HttpStatus.SC_OK);
response.setHeader("ETag","\"new-etag\"");
response.setHeader("Date", DateUtils.formatDate(now));
final String cacheKey = "http://foo.example.com:80/bar";
@@ -425,8 +431,9 @@ public class TestDefaultCacheInvalidator {
}
@Test
- public void flushesEntryIfFresherAndSpecifiedByRelativeContentLocation()
- throws Exception {
+ public void flushesEntryIfFresherAndSpecifiedByRelativeContentLocation() throws Exception {
+ final HttpRequest request = new BasicHttpRequest("GET", "/");
+ final HttpResponse response = new BasicHttpResponse(HttpStatus.SC_OK);
response.setHeader("ETag","\"new-etag\"");
response.setHeader("Date", DateUtils.formatDate(now));
final String cacheKey = "http://foo.example.com:80/bar";
@@ -446,8 +453,9 @@ public class TestDefaultCacheInvalidator {
}
@Test
- public void doesNotFlushEntryIfContentLocationFromDifferentHost()
- throws Exception {
+ public void doesNotFlushEntryIfContentLocationFromDifferentHost() throws Exception {
+ final HttpRequest request = new BasicHttpRequest("GET", "/");
+ final HttpResponse response = new BasicHttpResponse(HttpStatus.SC_OK);
response.setHeader("ETag","\"new-etag\"");
response.setHeader("Date", DateUtils.formatDate(now));
final String cacheKey = "http://baz.example.com:80/bar";
@@ -469,187 +477,196 @@ public class TestDefaultCacheInvalidator {
@Test
- public void doesNotFlushEntrySpecifiedByContentLocationIfEtagsMatch()
- throws Exception {
+ public void doesNotFlushEntrySpecifiedByContentLocationIfEtagsMatch() throws Exception {
+ final HttpRequest request = new BasicHttpRequest("GET", "/");
+ final HttpResponse response = new BasicHttpResponse(HttpStatus.SC_OK);
response.setHeader("ETag","\"same-etag\"");
response.setHeader("Date", DateUtils.formatDate(now));
- final String theURI = "http://foo.example.com:80/bar";
- response.setHeader("Content-Location", theURI);
+ final String key = "http://foo.example.com:80/bar";
+ response.setHeader("Content-Location", key);
final HttpCacheEntry entry = HttpTestUtils.makeCacheEntry(new Header[] {
new BasicHeader("Date", DateUtils.formatDate(tenSecondsAgo)),
new BasicHeader("ETag", "\"same-etag\"")
});
- when(mockStorage.getEntry(theURI)).thenReturn(entry);
+ when(mockStorage.getEntry(key)).thenReturn(entry);
impl.flushInvalidatedCacheEntries(host, request, response);
- verify(mockStorage).getEntry(theURI);
+ verify(mockStorage).getEntry(key);
verifyNoMoreInteractions(mockStorage);
}
@Test
- public void doesNotFlushEntrySpecifiedByContentLocationIfOlder()
- throws Exception {
+ public void doesNotFlushEntrySpecifiedByContentLocationIfOlder() throws Exception {
+ final HttpRequest request = new BasicHttpRequest("GET", "/");
+ final HttpResponse response = new BasicHttpResponse(HttpStatus.SC_OK);
response.setHeader("ETag","\"new-etag\"");
response.setHeader("Date", DateUtils.formatDate(tenSecondsAgo));
- final String theURI = "http://foo.example.com:80/bar";
- response.setHeader("Content-Location", theURI);
+ final String key = "http://foo.example.com:80/bar";
+ response.setHeader("Content-Location", key);
final HttpCacheEntry entry = HttpTestUtils.makeCacheEntry(new Header[] {
new BasicHeader("Date", DateUtils.formatDate(now)),
new BasicHeader("ETag", "\"old-etag\"")
});
- when(mockStorage.getEntry(theURI)).thenReturn(entry);
+ when(mockStorage.getEntry(key)).thenReturn(entry);
impl.flushInvalidatedCacheEntries(host, request, response);
- verify(mockStorage).getEntry(theURI);
+ verify(mockStorage).getEntry(key);
verifyNoMoreInteractions(mockStorage);
}
@Test
- public void doesNotFlushEntryIfNotInCache()
- throws Exception {
+ public void doesNotFlushEntryIfNotInCache() throws Exception {
+ final HttpRequest request = new BasicHttpRequest("GET", "/");
+ final HttpResponse response = new BasicHttpResponse(HttpStatus.SC_OK);
response.setHeader("ETag","\"new-etag\"");
response.setHeader("Date", DateUtils.formatDate(now));
- final String theURI = "http://foo.example.com:80/bar";
- response.setHeader("Content-Location", theURI);
+ final String key = "http://foo.example.com:80/bar";
+ response.setHeader("Content-Location", key);
- when(mockStorage.getEntry(theURI)).thenReturn(null);
+ when(mockStorage.getEntry(key)).thenReturn(null);
impl.flushInvalidatedCacheEntries(host, request, response);
- verify(mockStorage).getEntry(theURI);
+ verify(mockStorage).getEntry(key);
verifyNoMoreInteractions(mockStorage);
}
@Test
- public void doesNotFlushEntrySpecifiedByContentLocationIfResponseHasNoEtag()
- throws Exception {
+ public void doesNotFlushEntrySpecifiedByContentLocationIfResponseHasNoEtag() throws Exception {
+ final HttpRequest request = new BasicHttpRequest("GET", "/");
+ final HttpResponse response = new BasicHttpResponse(HttpStatus.SC_OK);
response.removeHeaders("ETag");
response.setHeader("Date", DateUtils.formatDate(now));
- final String theURI = "http://foo.example.com:80/bar";
- response.setHeader("Content-Location", theURI);
+ final String key = "http://foo.example.com:80/bar";
+ response.setHeader("Content-Location", key);
final HttpCacheEntry entry = HttpTestUtils.makeCacheEntry(new Header[] {
new BasicHeader("Date", DateUtils.formatDate(tenSecondsAgo)),
new BasicHeader("ETag", "\"old-etag\"")
});
- when(mockStorage.getEntry(theURI)).thenReturn(entry);
+ when(mockStorage.getEntry(key)).thenReturn(entry);
impl.flushInvalidatedCacheEntries(host, request, response);
- verify(mockStorage).getEntry(theURI);
+ verify(mockStorage).getEntry(key);
verifyNoMoreInteractions(mockStorage);
}
@Test
- public void doesNotFlushEntrySpecifiedByContentLocationIfEntryHasNoEtag()
- throws Exception {
+ public void doesNotFlushEntrySpecifiedByContentLocationIfEntryHasNoEtag() throws Exception {
+ final HttpRequest request = new BasicHttpRequest("GET", "/");
+ final HttpResponse response = new BasicHttpResponse(HttpStatus.SC_OK);
response.setHeader("ETag", "\"some-etag\"");
response.setHeader("Date", DateUtils.formatDate(now));
- final String theURI = "http://foo.example.com:80/bar";
- response.setHeader("Content-Location", theURI);
+ final String key = "http://foo.example.com:80/bar";
+ response.setHeader("Content-Location", key);
final HttpCacheEntry entry = HttpTestUtils.makeCacheEntry(new Header[] {
new BasicHeader("Date", DateUtils.formatDate(tenSecondsAgo)),
});
- when(mockStorage.getEntry(theURI)).thenReturn(entry);
+ when(mockStorage.getEntry(key)).thenReturn(entry);
impl.flushInvalidatedCacheEntries(host, request, response);
- verify(mockStorage).getEntry(theURI);
+ verify(mockStorage).getEntry(key);
verifyNoMoreInteractions(mockStorage);
}
@Test
- public void flushesEntrySpecifiedByContentLocationIfResponseHasNoDate()
- throws Exception {
+ public void flushesEntrySpecifiedByContentLocationIfResponseHasNoDate() throws Exception {
+ final HttpRequest request = new BasicHttpRequest("GET", "/");
+ final HttpResponse response = new BasicHttpResponse(HttpStatus.SC_OK);
response.setHeader("ETag", "\"new-etag\"");
response.removeHeaders("Date");
- final String theURI = "http://foo.example.com:80/bar";
- response.setHeader("Content-Location", theURI);
+ final String key = "http://foo.example.com:80/bar";
+ response.setHeader("Content-Location", key);
final HttpCacheEntry entry = HttpTestUtils.makeCacheEntry(new Header[] {
new BasicHeader("ETag", "\"old-etag\""),
new BasicHeader("Date", DateUtils.formatDate(tenSecondsAgo)),
});
- when(mockStorage.getEntry(theURI)).thenReturn(entry);
+ when(mockStorage.getEntry(key)).thenReturn(entry);
impl.flushInvalidatedCacheEntries(host, request, response);
- verify(mockStorage).getEntry(theURI);
- verify(mockStorage).removeEntry(theURI);
+ verify(mockStorage).getEntry(key);
+ verify(mockStorage).removeEntry(key);
verifyNoMoreInteractions(mockStorage);
}
@Test
- public void flushesEntrySpecifiedByContentLocationIfEntryHasNoDate()
- throws Exception {
+ public void flushesEntrySpecifiedByContentLocationIfEntryHasNoDate() throws Exception {
+ final HttpRequest request = new BasicHttpRequest("GET", "/");
+ final HttpResponse response = new BasicHttpResponse(HttpStatus.SC_OK);
response.setHeader("ETag","\"new-etag\"");
response.setHeader("Date", DateUtils.formatDate(now));
- final String theURI = "http://foo.example.com:80/bar";
- response.setHeader("Content-Location", theURI);
+ final String key = "http://foo.example.com:80/bar";
+ response.setHeader("Content-Location", key);
final HttpCacheEntry entry = HttpTestUtils.makeCacheEntry(new Header[] {
new BasicHeader("ETag", "\"old-etag\"")
});
- when(mockStorage.getEntry(theURI)).thenReturn(entry);
+ when(mockStorage.getEntry(key)).thenReturn(entry);
impl.flushInvalidatedCacheEntries(host, request, response);
- verify(mockStorage).getEntry(theURI);
- verify(mockStorage).removeEntry(theURI);
+ verify(mockStorage).getEntry(key);
+ verify(mockStorage).removeEntry(key);
verifyNoMoreInteractions(mockStorage);
}
@Test
- public void flushesEntrySpecifiedByContentLocationIfResponseHasMalformedDate()
- throws Exception {
+ public void flushesEntrySpecifiedByContentLocationIfResponseHasMalformedDate() throws Exception {
+ final HttpRequest request = new BasicHttpRequest("GET", "/");
+ final HttpResponse response = new BasicHttpResponse(HttpStatus.SC_OK);
response.setHeader("ETag","\"new-etag\"");
response.setHeader("Date", "blarg");
- final String theURI = "http://foo.example.com:80/bar";
- response.setHeader("Content-Location", theURI);
+ final String key = "http://foo.example.com:80/bar";
+ response.setHeader("Content-Location", key);
final HttpCacheEntry entry = HttpTestUtils.makeCacheEntry(new Header[] {
new BasicHeader("ETag", "\"old-etag\""),
new BasicHeader("Date", DateUtils.formatDate(tenSecondsAgo))
});
- when(mockStorage.getEntry(theURI)).thenReturn(entry);
+ when(mockStorage.getEntry(key)).thenReturn(entry);
impl.flushInvalidatedCacheEntries(host, request, response);
- verify(mockStorage).getEntry(theURI);
- verify(mockStorage).removeEntry(theURI);
+ verify(mockStorage).getEntry(key);
+ verify(mockStorage).removeEntry(key);
verifyNoMoreInteractions(mockStorage);
}
@Test
- public void flushesEntrySpecifiedByContentLocationIfEntryHasMalformedDate()
- throws Exception {
+ public void flushesEntrySpecifiedByContentLocationIfEntryHasMalformedDate() throws Exception {
+ final HttpRequest request = new BasicHttpRequest("GET", "/");
+ final HttpResponse response = new BasicHttpResponse(HttpStatus.SC_OK);
response.setHeader("ETag","\"new-etag\"");
response.setHeader("Date", DateUtils.formatDate(now));
- final String theURI = "http://foo.example.com:80/bar";
- response.setHeader("Content-Location", theURI);
+ final String key = "http://foo.example.com:80/bar";
+ response.setHeader("Content-Location", key);
final HttpCacheEntry entry = HttpTestUtils.makeCacheEntry(new Header[] {
new BasicHeader("ETag", "\"old-etag\""),
new BasicHeader("Date", "foo")
});
- when(mockStorage.getEntry(theURI)).thenReturn(entry);
+ when(mockStorage.getEntry(key)).thenReturn(entry);
impl.flushInvalidatedCacheEntries(host, request, response);
- verify(mockStorage).getEntry(theURI);
- verify(mockStorage).removeEntry(theURI);
+ verify(mockStorage).getEntry(key);
+ verify(mockStorage).removeEntry(key);
verifyNoMoreInteractions(mockStorage);
}
@@ -659,12 +676,12 @@ public class TestDefaultCacheInvalidator {
when(mockEntry.getVariantMap()).thenReturn(variantMap);
}
- private void cacheReturnsEntryForUri(final String theUri) throws IOException {
- when(mockStorage.getEntry(theUri)).thenReturn(mockEntry);
+ private void cacheReturnsEntryForUri(final String key) throws IOException {
+ when(mockStorage.getEntry(key)).thenReturn(mockEntry);
}
- private void cacheReturnsExceptionForUri(final String theUri) throws IOException {
- when(mockStorage.getEntry(theUri)).thenThrow(
+ private void cacheReturnsExceptionForUri(final String key) throws IOException {
+ when(mockStorage.getEntry(key)).thenThrow(
new ResourceIOException("TOTAL FAIL"));
}
[2/2] httpcomponents-client git commit: Use StandardMethods
Posted by ol...@apache.org.
Use StandardMethods
Project: http://git-wip-us.apache.org/repos/asf/httpcomponents-client/repo
Commit: http://git-wip-us.apache.org/repos/asf/httpcomponents-client/commit/043fe4dd
Tree: http://git-wip-us.apache.org/repos/asf/httpcomponents-client/tree/043fe4dd
Diff: http://git-wip-us.apache.org/repos/asf/httpcomponents-client/diff/043fe4dd
Branch: refs/heads/master
Commit: 043fe4dd903af44ae1ea9a68d8c2fa96ac227438
Parents: b165926
Author: Oleg Kalnichevski <ol...@apache.org>
Authored: Wed Dec 6 16:06:49 2017 +0100
Committer: Oleg Kalnichevski <ol...@apache.org>
Committed: Thu Dec 7 19:59:33 2017 +0100
----------------------------------------------------------------------
.../hc/client5/http/impl/cache/BasicHttpCache.java | 12 +++---------
1 file changed, 3 insertions(+), 9 deletions(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/httpcomponents-client/blob/043fe4dd/httpclient5-cache/src/main/java/org/apache/hc/client5/http/impl/cache/BasicHttpCache.java
----------------------------------------------------------------------
diff --git a/httpclient5-cache/src/main/java/org/apache/hc/client5/http/impl/cache/BasicHttpCache.java b/httpclient5-cache/src/main/java/org/apache/hc/client5/http/impl/cache/BasicHttpCache.java
index 7d831ea..db70e7c 100644
--- a/httpclient5-cache/src/main/java/org/apache/hc/client5/http/impl/cache/BasicHttpCache.java
+++ b/httpclient5-cache/src/main/java/org/apache/hc/client5/http/impl/cache/BasicHttpCache.java
@@ -26,13 +26,11 @@
*/
package org.apache.hc.client5.http.impl.cache;
-import java.util.Arrays;
import java.util.Date;
import java.util.HashMap;
-import java.util.HashSet;
import java.util.Map;
-import java.util.Set;
+import org.apache.hc.client5.http.StandardMethods;
import org.apache.hc.client5.http.cache.HeaderConstants;
import org.apache.hc.client5.http.cache.HttpCacheEntry;
import org.apache.hc.client5.http.cache.HttpCacheInvalidator;
@@ -51,10 +49,6 @@ import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
class BasicHttpCache implements HttpCache {
- private static final Set<String> safeRequestMethods = new HashSet<>(
- Arrays.asList(HeaderConstants.HEAD_METHOD,
- HeaderConstants.GET_METHOD, HeaderConstants.OPTIONS_METHOD,
- HeaderConstants.TRACE_METHOD));
private final CacheKeyGenerator uriExtractor;
private final ResourceFactory resourceFactory;
@@ -97,7 +91,7 @@ class BasicHttpCache implements HttpCache {
@Override
public void flushCacheEntriesFor(final HttpHost host, final HttpRequest request) throws ResourceIOException {
- if (!safeRequestMethods.contains(request.getMethod())) {
+ if (!StandardMethods.isSafe(request.getMethod())) {
final String uri = uriExtractor.generateKey(host, request);
storage.removeEntry(uri);
}
@@ -105,7 +99,7 @@ class BasicHttpCache implements HttpCache {
@Override
public void flushInvalidatedCacheEntriesFor(final HttpHost host, final HttpRequest request, final HttpResponse response) {
- if (!safeRequestMethods.contains(request.getMethod())) {
+ if (!StandardMethods.isSafe(request.getMethod())) {
cacheInvalidator.flushInvalidatedCacheEntries(host, request, response);
}
}