From 9b9e2c851c96c6fef0ca8e25d098d31b26c1a642 Mon Sep 17 00:00:00 2001 From: Joseph Walton Date: Sun, 22 Feb 2015 18:04:59 +1100 Subject: [PATCH] HTTPCLIENT-1244: Move many httpclient-cache tests over to Mockito. - Introduce Mockito as a dependency - Establish mocks with Mockito - Switch to explicit post-test verification - Remove unused mocking The tests left behind rely on more complex matchers. --- httpclient-cache/pom.xml | 5 + .../http/client/cache/TestHttpCacheEntry.java | 4 +- .../cache/TestAsynchronousValidationRequest.java | 133 +++--- .../client/cache/TestAsynchronousValidator.java | 98 ++--- .../impl/client/cache/TestCacheInvalidator.java | 331 +++++++-------- .../impl/client/cache/TestCacheKeyGenerator.java | 90 ++-- .../cache/TestCachedHttpResponseGenerator.java | 37 +- .../TestCachedResponseSuitabilityChecker.java | 11 - .../http/impl/client/cache/TestCombinedEntity.java | 14 +- ...estExponentialBackingOffSchedulingStrategy.java | 51 ++- .../client/cache/TestHttpCacheJiraNumber1147.java | 47 ++- .../cache/TestImmediateSchedulingStrategy.java | 13 +- .../cache/ehcache/TestEhcacheHttpCacheStorage.java | 115 +++--- .../memcached/TestMemcachedHttpCacheStorage.java | 455 +++++++++++---------- 14 files changed, 677 insertions(+), 727 deletions(-) diff --git a/httpclient-cache/pom.xml b/httpclient-cache/pom.xml index 589782d..cd20d7a 100644 --- a/httpclient-cache/pom.xml +++ b/httpclient-cache/pom.xml @@ -75,6 +75,11 @@ test + org.mockito + mockito-core + test + + org.easymock easymock test diff --git a/httpclient-cache/src/test/java/org/apache/http/client/cache/TestHttpCacheEntry.java b/httpclient-cache/src/test/java/org/apache/http/client/cache/TestHttpCacheEntry.java index 197cfd5..6719a30 100644 --- a/httpclient-cache/src/test/java/org/apache/http/client/cache/TestHttpCacheEntry.java +++ b/httpclient-cache/src/test/java/org/apache/http/client/cache/TestHttpCacheEntry.java @@ -26,7 +26,6 @@ */ package org.apache.http.client.cache; -import static org.easymock.classextension.EasyMock.createNiceMock; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertFalse; import static org.junit.Assert.assertNotNull; @@ -34,6 +33,7 @@ import static org.junit.Assert.assertNull; import static org.junit.Assert.assertSame; import static org.junit.Assert.assertTrue; import static org.junit.Assert.fail; +import static org.mockito.Mockito.mock; import java.util.Date; import java.util.HashMap; @@ -65,7 +65,7 @@ public class TestHttpCacheEntry { nineSecondsAgo = new Date(now.getTime() - 9 * 1000L); statusLine = new BasicStatusLine(HttpVersion.HTTP_1_1, HttpStatus.SC_OK, "OK"); - mockResource = createNiceMock(Resource.class); + mockResource = mock(Resource.class); } private HttpCacheEntry makeEntry(final Header[] headers) { diff --git a/httpclient-cache/src/test/java/org/apache/http/impl/client/cache/TestAsynchronousValidationRequest.java b/httpclient-cache/src/test/java/org/apache/http/impl/client/cache/TestAsynchronousValidationRequest.java index a61d431..c970f51 100644 --- a/httpclient-cache/src/test/java/org/apache/http/impl/client/cache/TestAsynchronousValidationRequest.java +++ b/httpclient-cache/src/test/java/org/apache/http/impl/client/cache/TestAsynchronousValidationRequest.java @@ -26,6 +26,10 @@ */ package org.apache.http.impl.client.cache; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + import java.io.IOException; import org.apache.http.Header; @@ -41,7 +45,6 @@ import org.apache.http.client.methods.HttpRequestWrapper; import org.apache.http.client.protocol.HttpClientContext; import org.apache.http.conn.routing.HttpRoute; import org.apache.http.message.BasicHeader; -import org.easymock.classextension.EasyMock; import org.junit.Before; import org.junit.Test; @@ -60,15 +63,15 @@ public class TestAsynchronousValidationRequest { @Before public void setUp() { - mockParent = EasyMock.createNiceMock(AsynchronousValidator.class); - mockClient = EasyMock.createNiceMock(CachingExec.class); + mockParent = mock(AsynchronousValidator.class); + mockClient = mock(CachingExec.class); route = new HttpRoute(new HttpHost("foo.example.com", 80)); request = HttpRequestWrapper.wrap(new HttpGet("/")); context = HttpClientContext.create(); - mockExecAware = EasyMock.createNiceMock(HttpExecutionAware.class); - mockCacheEntry = EasyMock.createNiceMock(HttpCacheEntry.class); - mockResponse = EasyMock.createNiceMock(CloseableHttpResponse.class); - mockStatusLine = EasyMock.createNiceMock(StatusLine.class); + mockExecAware = mock(HttpExecutionAware.class); + mockCacheEntry = mock(HttpCacheEntry.class); + mockResponse = mock(CloseableHttpResponse.class); + mockStatusLine = mock(StatusLine.class); } @Test @@ -79,17 +82,19 @@ public class TestAsynchronousValidationRequest { mockParent, mockClient, route, request, context, mockExecAware, mockCacheEntry, identifier, 0); - EasyMock.expect( + when( mockClient.revalidateCacheEntry( - route, request, context, mockExecAware, mockCacheEntry)).andReturn(mockResponse); - EasyMock.expect(mockResponse.getStatusLine()).andReturn(mockStatusLine); - EasyMock.expect(mockStatusLine.getStatusCode()).andReturn(200); - mockParent.markComplete(identifier); - mockParent.jobSuccessful(identifier); + route, request, context, mockExecAware, mockCacheEntry)).thenReturn(mockResponse); + when(mockResponse.getStatusLine()).thenReturn(mockStatusLine); + when(mockStatusLine.getStatusCode()).thenReturn(200); - replayMocks(); impl.run(); - verifyMocks(); + + verify(mockClient).revalidateCacheEntry( + route, request, context, mockExecAware, mockCacheEntry); + verify(mockResponse).getStatusLine(); + verify(mockParent).markComplete(identifier); + verify(mockParent).jobSuccessful(identifier); } @Test @@ -100,17 +105,20 @@ public class TestAsynchronousValidationRequest { mockParent, mockClient, route, request, context, mockExecAware, mockCacheEntry, identifier, 0); - EasyMock.expect( + when( mockClient.revalidateCacheEntry( - route, request, context, mockExecAware, mockCacheEntry)).andReturn(mockResponse); - EasyMock.expect(mockResponse.getStatusLine()).andReturn(mockStatusLine); - EasyMock.expect(mockStatusLine.getStatusCode()).andReturn(200); - mockParent.markComplete(identifier); - mockParent.jobSuccessful(identifier); + route, request, context, mockExecAware, mockCacheEntry)).thenReturn(mockResponse); + when(mockResponse.getStatusLine()).thenReturn(mockStatusLine); + when(mockStatusLine.getStatusCode()).thenReturn(200); - replayMocks(); impl.run(); - verifyMocks(); + + verify(mockClient).revalidateCacheEntry( + route, request, context, mockExecAware, mockCacheEntry); + verify(mockResponse).getStatusLine(); + verify(mockStatusLine).getStatusCode(); + verify(mockParent).markComplete(identifier); + verify(mockParent).jobSuccessful(identifier); } @Test @@ -122,18 +130,22 @@ public class TestAsynchronousValidationRequest { mockParent, mockClient, route, request, context, mockExecAware, mockCacheEntry, identifier, 0); - EasyMock.expect( + when( mockClient.revalidateCacheEntry( - route, request, context, mockExecAware, mockCacheEntry)).andReturn(mockResponse); - EasyMock.expect(mockResponse.getStatusLine()).andReturn(mockStatusLine); - EasyMock.expect(mockStatusLine.getStatusCode()).andReturn(200); - EasyMock.expect(mockResponse.getHeaders(HeaderConstants.WARNING)).andReturn(warning); - mockParent.markComplete(identifier); - mockParent.jobFailed(identifier); - - replayMocks(); + route, request, context, mockExecAware, mockCacheEntry)).thenReturn(mockResponse); + when(mockResponse.getStatusLine()).thenReturn(mockStatusLine); + when(mockStatusLine.getStatusCode()).thenReturn(200); + when(mockResponse.getHeaders(HeaderConstants.WARNING)).thenReturn(warning); + impl.run(); - verifyMocks(); + + verify(mockClient).revalidateCacheEntry( + route, request, context, mockExecAware, mockCacheEntry); + verify(mockResponse).getStatusLine(); + verify(mockStatusLine).getStatusCode(); + verify(mockResponse).getHeaders(HeaderConstants.WARNING); + verify(mockParent).markComplete(identifier); + verify(mockParent).jobFailed(identifier); } @Test @@ -144,16 +156,17 @@ public class TestAsynchronousValidationRequest { mockParent, mockClient, route, request, context, mockExecAware, mockCacheEntry, identifier, 0); - EasyMock.expect( + when( mockClient.revalidateCacheEntry( - route, request, context, mockExecAware, mockCacheEntry)).andThrow( + route, request, context, mockExecAware, mockCacheEntry)).thenThrow( new ProtocolException()); - mockParent.markComplete(identifier); - mockParent.jobFailed(identifier); - replayMocks(); impl.run(); - verifyMocks(); + + verify(mockClient).revalidateCacheEntry( + route, request, context, mockExecAware, mockCacheEntry); + verify(mockParent).markComplete(identifier); + verify(mockParent).jobFailed(identifier); } @Test @@ -164,16 +177,17 @@ public class TestAsynchronousValidationRequest { mockParent, mockClient, route, request, context, mockExecAware, mockCacheEntry, identifier, 0); - EasyMock.expect( + when( mockClient.revalidateCacheEntry( - route, request, context, mockExecAware, mockCacheEntry)).andThrow( + route, request, context, mockExecAware, mockCacheEntry)).thenThrow( new IOException()); - mockParent.markComplete(identifier); - mockParent.jobFailed(identifier); - replayMocks(); impl.run(); - verifyMocks(); + + verify(mockClient).revalidateCacheEntry( + route, request, context, mockExecAware, mockCacheEntry); + verify(mockParent).markComplete(identifier); + verify(mockParent).jobFailed(identifier); } @Test @@ -184,33 +198,16 @@ public class TestAsynchronousValidationRequest { mockParent, mockClient, route, request, context, mockExecAware, mockCacheEntry, identifier, 0); - EasyMock.expect( + when( mockClient.revalidateCacheEntry( - route, request, context, mockExecAware, mockCacheEntry)).andThrow( + route, request, context, mockExecAware, mockCacheEntry)).thenThrow( new RuntimeException()); - mockParent.markComplete(identifier); - mockParent.jobFailed(identifier); - replayMocks(); impl.run(); - verifyMocks(); - } - - public void replayMocks() { - EasyMock.replay(mockClient); - EasyMock.replay(mockExecAware); - EasyMock.replay(mockCacheEntry); - EasyMock.replay(mockResponse); - EasyMock.replay(mockStatusLine); - EasyMock.replay(mockParent); - } - public void verifyMocks() { - EasyMock.verify(mockClient); - EasyMock.verify(mockExecAware); - EasyMock.verify(mockCacheEntry); - EasyMock.verify(mockResponse); - EasyMock.verify(mockStatusLine); - EasyMock.verify(mockParent); + verify(mockClient).revalidateCacheEntry( + route, request, context, mockExecAware, mockCacheEntry); + verify(mockParent).markComplete(identifier); + verify(mockParent).jobFailed(identifier); } } diff --git a/httpclient-cache/src/test/java/org/apache/http/impl/client/cache/TestAsynchronousValidator.java b/httpclient-cache/src/test/java/org/apache/http/impl/client/cache/TestAsynchronousValidator.java index 1ca1b3c..58ecef1 100644 --- a/httpclient-cache/src/test/java/org/apache/http/impl/client/cache/TestAsynchronousValidator.java +++ b/httpclient-cache/src/test/java/org/apache/http/impl/client/cache/TestAsynchronousValidator.java @@ -26,6 +26,13 @@ */ package org.apache.http.impl.client.cache; +import static org.mockito.Matchers.isA; +import static org.mockito.Mockito.doThrow; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.times; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + import java.io.IOException; import java.util.concurrent.RejectedExecutionException; import java.util.concurrent.TimeUnit; @@ -41,11 +48,10 @@ import org.apache.http.client.methods.HttpRequestWrapper; import org.apache.http.client.protocol.HttpClientContext; import org.apache.http.conn.routing.HttpRoute; import org.apache.http.message.BasicHeader; -import org.easymock.Capture; -import org.easymock.classextension.EasyMock; import org.junit.Assert; import org.junit.Before; import org.junit.Test; +import org.mockito.ArgumentCaptor; @SuppressWarnings({"boxing","static-access"}) // test code public class TestAsynchronousValidator { @@ -63,26 +69,26 @@ public class TestAsynchronousValidator { @Before public void setUp() { - mockClient = EasyMock.createNiceMock(CachingExec.class); + mockClient = mock(CachingExec.class); route = new HttpRoute(new HttpHost("foo.example.com", 80)); request = HttpRequestWrapper.wrap(new HttpGet("/")); context = HttpClientContext.create(); context.setTargetHost(new HttpHost("foo.example.com")); - mockExecAware = EasyMock.createNiceMock(HttpExecutionAware.class); - mockCacheEntry = EasyMock.createNiceMock(HttpCacheEntry.class); - mockSchedulingStrategy = EasyMock.createNiceMock(SchedulingStrategy.class); + mockExecAware = mock(HttpExecutionAware.class); + mockCacheEntry = mock(HttpCacheEntry.class); + mockSchedulingStrategy = mock(SchedulingStrategy.class); } @Test public void testRevalidateCacheEntrySchedulesExecutionAndPopulatesIdentifier() { impl = new AsynchronousValidator(mockSchedulingStrategy); - EasyMock.expect(mockCacheEntry.hasVariants()).andReturn(false); - mockSchedulingStrategy.schedule(EasyMock.isA(AsynchronousValidationRequest.class)); + when(mockCacheEntry.hasVariants()).thenReturn(false); - replayMocks(); impl.revalidateCacheEntry(mockClient, route, request, context, mockExecAware, mockCacheEntry); - verifyMocks(); + + verify(mockCacheEntry).hasVariants(); + verify(mockSchedulingStrategy).schedule(isA(AsynchronousValidationRequest.class)); Assert.assertEquals(1, impl.getScheduledIdentifiers().size()); } @@ -91,13 +97,13 @@ public class TestAsynchronousValidator { public void testMarkCompleteRemovesIdentifier() { impl = new AsynchronousValidator(mockSchedulingStrategy); - EasyMock.expect(mockCacheEntry.hasVariants()).andReturn(false); - final Capture cap = new Capture(); - mockSchedulingStrategy.schedule(EasyMock.capture(cap)); + when(mockCacheEntry.hasVariants()).thenReturn(false); - replayMocks(); impl.revalidateCacheEntry(mockClient, route, request, context, mockExecAware, mockCacheEntry); - verifyMocks(); + + final ArgumentCaptor cap = ArgumentCaptor.forClass(AsynchronousValidationRequest.class); + verify(mockCacheEntry).hasVariants(); + verify(mockSchedulingStrategy).schedule(cap.capture()); Assert.assertEquals(1, impl.getScheduledIdentifiers().size()); @@ -110,30 +116,28 @@ public class TestAsynchronousValidator { public void testRevalidateCacheEntryDoesNotPopulateIdentifierOnRejectedExecutionException() { impl = new AsynchronousValidator(mockSchedulingStrategy); - EasyMock.expect(mockCacheEntry.hasVariants()).andReturn(false); - mockSchedulingStrategy.schedule(EasyMock.isA(AsynchronousValidationRequest.class)); - EasyMock.expectLastCall().andThrow(new RejectedExecutionException()); + when(mockCacheEntry.hasVariants()).thenReturn(false); + doThrow(new RejectedExecutionException()).when(mockSchedulingStrategy).schedule(isA(AsynchronousValidationRequest.class)); - replayMocks(); impl.revalidateCacheEntry(mockClient, route, request, context, mockExecAware, mockCacheEntry); - verifyMocks(); + + verify(mockCacheEntry).hasVariants(); Assert.assertEquals(0, impl.getScheduledIdentifiers().size()); + verify(mockSchedulingStrategy).schedule(isA(AsynchronousValidationRequest.class)); } @Test public void testRevalidateCacheEntryProperlyCollapsesRequest() { impl = new AsynchronousValidator(mockSchedulingStrategy); - EasyMock.expect(mockCacheEntry.hasVariants()).andReturn(false); - mockSchedulingStrategy.schedule(EasyMock.isA(AsynchronousValidationRequest.class)); - - EasyMock.expect(mockCacheEntry.hasVariants()).andReturn(false); + when(mockCacheEntry.hasVariants()).thenReturn(false); - replayMocks(); impl.revalidateCacheEntry(mockClient, route, request, context, mockExecAware, mockCacheEntry); impl.revalidateCacheEntry(mockClient, route, request, context, mockExecAware, mockCacheEntry); - verifyMocks(); + + verify(mockCacheEntry, times(2)).hasVariants(); + verify(mockSchedulingStrategy).schedule(isA(AsynchronousValidationRequest.class)); Assert.assertEquals(1, impl.getScheduledIdentifiers().size()); } @@ -152,18 +156,18 @@ public class TestAsynchronousValidator { new BasicHeader(HeaderConstants.VARY, "Accept-Encoding") }; - EasyMock.expect(mockCacheEntry.hasVariants()).andReturn(true).times(2); - EasyMock.expect(mockCacheEntry.getHeaders(HeaderConstants.VARY)).andReturn(variantHeaders).times(2); - mockSchedulingStrategy.schedule(EasyMock.isA(AsynchronousValidationRequest.class)); - EasyMock.expectLastCall().times(2); + when(mockCacheEntry.hasVariants()).thenReturn(true); + when(mockCacheEntry.getHeaders(HeaderConstants.VARY)).thenReturn(variantHeaders); + mockSchedulingStrategy.schedule(isA(AsynchronousValidationRequest.class)); - replayMocks(); impl.revalidateCacheEntry(mockClient, route, HttpRequestWrapper.wrap(req1), context, mockExecAware, mockCacheEntry); impl.revalidateCacheEntry(mockClient, route, HttpRequestWrapper.wrap(req2), context, mockExecAware, mockCacheEntry); - verifyMocks(); - Assert.assertEquals(2, impl.getScheduledIdentifiers().size()); + verify(mockCacheEntry, times(2)).hasVariants(); + verify(mockCacheEntry, times(2)).getHeaders(HeaderConstants.VARY); + verify(mockSchedulingStrategy, times(2)).schedule(isA(AsynchronousValidationRequest.class)); + Assert.assertEquals(2, impl.getScheduledIdentifiers().size()); } @Test @@ -175,11 +179,10 @@ public class TestAsynchronousValidator { final ImmediateSchedulingStrategy schedulingStrategy = new ImmediateSchedulingStrategy(config); impl = new AsynchronousValidator(schedulingStrategy); - EasyMock.expect(mockCacheEntry.hasVariants()).andReturn(false); - EasyMock.expect(mockClient.revalidateCacheEntry( - route, request, context, mockExecAware, mockCacheEntry)).andReturn(null); + when(mockCacheEntry.hasVariants()).thenReturn(false); + when(mockClient.revalidateCacheEntry( + route, request, context, mockExecAware, mockCacheEntry)).thenReturn(null); - replayMocks(); impl.revalidateCacheEntry(mockClient, route, request, context, mockExecAware, mockCacheEntry); try { @@ -189,7 +192,8 @@ public class TestAsynchronousValidator { } catch (final InterruptedException ie) { } finally { - verifyMocks(); + verify(mockCacheEntry).hasVariants(); + verify(mockClient).revalidateCacheEntry(route, request, context, mockExecAware, mockCacheEntry); Assert.assertEquals(0, impl.getScheduledIdentifiers().size()); } @@ -199,24 +203,8 @@ public class TestAsynchronousValidator { public void testSchedulingStrategyShutdownOnClose() throws IOException { impl = new AsynchronousValidator(mockSchedulingStrategy); - mockSchedulingStrategy.close(); - - replayMocks(); impl.close(); - verifyMocks(); - } - - public void replayMocks() { - EasyMock.replay(mockSchedulingStrategy); - EasyMock.replay(mockClient); - EasyMock.replay(mockExecAware); - EasyMock.replay(mockCacheEntry); - } - public void verifyMocks() { - EasyMock.verify(mockSchedulingStrategy); - EasyMock.verify(mockClient); - EasyMock.verify(mockExecAware); - EasyMock.verify(mockCacheEntry); + verify(mockSchedulingStrategy).close(); } } diff --git a/httpclient-cache/src/test/java/org/apache/http/impl/client/cache/TestCacheInvalidator.java b/httpclient-cache/src/test/java/org/apache/http/impl/client/cache/TestCacheInvalidator.java index af412b6..5799339 100644 --- a/httpclient-cache/src/test/java/org/apache/http/impl/client/cache/TestCacheInvalidator.java +++ b/httpclient-cache/src/test/java/org/apache/http/impl/client/cache/TestCacheInvalidator.java @@ -26,10 +26,10 @@ */ package org.apache.http.impl.client.cache; -import static org.easymock.EasyMock.expect; -import static org.easymock.classextension.EasyMock.createNiceMock; -import static org.easymock.classextension.EasyMock.replay; -import static org.easymock.classextension.EasyMock.verify; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.verifyNoMoreInteractions; +import static org.mockito.Mockito.when; import java.io.IOException; import java.util.Date; @@ -51,9 +51,6 @@ import org.apache.http.message.BasicHeader; import org.apache.http.message.BasicHttpEntityEnclosingRequest; import org.apache.http.message.BasicHttpRequest; import org.apache.http.message.BasicHttpResponse; -import org.easymock.EasyMock; -import org.easymock.IAnswer; -import org.junit.Assert; import org.junit.Before; import org.junit.Test; @@ -78,25 +75,15 @@ public class TestCacheInvalidator { tenSecondsAgo = new Date(now.getTime() - 10 * 1000L); host = new HttpHost("foo.example.com"); - mockStorage = createNiceMock(HttpCacheStorage.class); + mockStorage = mock(HttpCacheStorage.class); cacheKeyGenerator = new CacheKeyGenerator(); - mockEntry = createNiceMock(HttpCacheEntry.class); + mockEntry = mock(HttpCacheEntry.class); request = HttpTestUtils.makeDefaultRequest(); response = HttpTestUtils.make200Response(); impl = new CacheInvalidator(cacheKeyGenerator, mockStorage); } - private void replayMocks() { - replay(mockStorage); - replay(mockEntry); - } - - private void verifyMocks() { - verify(mockStorage); - verify(mockEntry); - } - // Tests @Test public void testInvalidatesRequestsThatArentGETorHEAD() throws Exception { @@ -106,12 +93,12 @@ public class TestCacheInvalidator { cacheEntryHasVariantMap(variantMap); cacheReturnsEntryForUri(theUri); - entryIsRemoved(theUri); - replayMocks(); impl.flushInvalidatedCacheEntries(host, request); - verifyMocks(); + verify(mockEntry).getVariantMap(); + verify(mockStorage).getEntry(theUri); + verify(mockStorage).removeEntry(theUri); } @Test @@ -127,14 +114,13 @@ public class TestCacheInvalidator { cacheEntryHasVariantMap(new HashMap()); cacheReturnsEntryForUri(theUri); - entryIsRemoved(theUri); - entryIsRemoved("http://foo.example.com:80/content"); - - replayMocks(); impl.flushInvalidatedCacheEntries(host, putRequest); - verifyMocks(); + verify(mockEntry).getVariantMap(); + verify(mockStorage).getEntry(theUri); + verify(mockStorage).removeEntry(theUri); + verify(mockStorage).removeEntry("http://foo.example.com:80/content"); } @Test @@ -150,14 +136,13 @@ public class TestCacheInvalidator { cacheEntryHasVariantMap(new HashMap()); cacheReturnsEntryForUri(theUri); - entryIsRemoved(theUri); - entryIsRemoved(cacheKeyGenerator.canonicalizeUri(contentLocation)); - - replayMocks(); impl.flushInvalidatedCacheEntries(host, putRequest); - verifyMocks(); + verify(mockEntry).getVariantMap(); + verify(mockStorage).getEntry(theUri); + verify(mockStorage).removeEntry(theUri); + verify(mockStorage).removeEntry(cacheKeyGenerator.canonicalizeUri(contentLocation)); } @Test @@ -173,14 +158,13 @@ public class TestCacheInvalidator { cacheEntryHasVariantMap(new HashMap()); cacheReturnsEntryForUri(theUri); - entryIsRemoved(theUri); - entryIsRemoved("http://foo.example.com:80/content"); - - replayMocks(); impl.flushInvalidatedCacheEntries(host, putRequest); - verifyMocks(); + verify(mockEntry).getVariantMap(); + verify(mockStorage).getEntry(theUri); + verify(mockStorage).removeEntry(theUri); + verify(mockStorage).removeEntry("http://foo.example.com:80/content"); } @Test @@ -196,29 +180,30 @@ public class TestCacheInvalidator { cacheEntryHasVariantMap(new HashMap()); cacheReturnsEntryForUri(theUri); - entryIsRemoved(theUri); - - replayMocks(); impl.flushInvalidatedCacheEntries(host, putRequest); - verifyMocks(); + verify(mockEntry).getVariantMap(); + verify(mockStorage).getEntry(theUri); + verify(mockStorage).removeEntry(theUri); } @Test public void testDoesNotInvalidateGETRequest() throws Exception { request = new BasicHttpRequest("GET","/",HTTP_1_1); - replayMocks(); impl.flushInvalidatedCacheEntries(host, request); - verifyMocks(); + + verify(mockStorage).getEntry("http://foo.example.com:80/"); + verifyNoMoreInteractions(mockStorage); } @Test public void testDoesNotInvalidateHEADRequest() throws Exception { request = new BasicHttpRequest("HEAD","/",HTTP_1_1); - replayMocks(); impl.flushInvalidatedCacheEntries(host, request); - verifyMocks(); + + verify(mockStorage).getEntry("http://foo.example.com:80/"); + verifyNoMoreInteractions(mockStorage); } @Test @@ -230,11 +215,13 @@ public class TestCacheInvalidator { cacheEntryisForMethod("HEAD"); cacheEntryHasVariantMap(new HashMap()); cacheReturnsEntryForUri(theURI); - entryIsRemoved(theURI); - replayMocks(); impl.flushInvalidatedCacheEntries(host, request); - verifyMocks(); + + verify(mockEntry).getRequestMethod(); + verify(mockEntry).getVariantMap(); + verify(mockStorage).getEntry(theURI); + verify(mockStorage).removeEntry(theURI); } @Test @@ -249,12 +236,14 @@ public class TestCacheInvalidator { cacheEntryisForMethod("HEAD"); cacheEntryHasVariantMap(variants); cacheReturnsEntryForUri(theURI); - entryIsRemoved(theURI); - entryIsRemoved(theVariantURI); - replayMocks(); impl.flushInvalidatedCacheEntries(host, request); - verifyMocks(); + + verify(mockEntry).getRequestMethod(); + verify(mockEntry).getVariantMap(); + verify(mockStorage).getEntry(theURI); + verify(mockStorage).removeEntry(theURI); + verify(mockStorage).removeEntry(theVariantURI); } @Test @@ -264,9 +253,10 @@ public class TestCacheInvalidator { cacheReturnsEntryForUri(theURI); - replayMocks(); impl.flushInvalidatedCacheEntries(host, request); - verifyMocks(); + + verify(mockStorage).getEntry(theURI); + verifyNoMoreInteractions(mockStorage); } @Test @@ -277,9 +267,10 @@ public class TestCacheInvalidator { cacheReturnsEntryForUri(theURI); - replayMocks(); impl.flushInvalidatedCacheEntries(host, request); - verifyMocks(); + + verify(mockStorage).getEntry(theURI); + verifyNoMoreInteractions(mockStorage); } @Test @@ -291,27 +282,33 @@ public class TestCacheInvalidator { cacheEntryisForMethod("GET"); cacheReturnsEntryForUri(theURI); - replayMocks(); impl.flushInvalidatedCacheEntries(host, request); - verifyMocks(); + + verify(mockEntry).getRequestMethod(); + verify(mockStorage).getEntry(theURI); + verifyNoMoreInteractions(mockStorage); } @Test public void testDoesNotInvalidateRequestsWithClientCacheControlHeaders() throws Exception { request = new BasicHttpRequest("GET","/",HTTP_1_1); request.setHeader("Cache-Control","no-cache"); - replayMocks(); + impl.flushInvalidatedCacheEntries(host, request); - verifyMocks(); + + verify(mockStorage).getEntry("http://foo.example.com:80/"); + verifyNoMoreInteractions(mockStorage); } @Test public void testDoesNotInvalidateRequestsWithClientPragmaHeaders() throws Exception { request = new BasicHttpRequest("GET","/",HTTP_1_1); request.setHeader("Pragma","no-cache"); - replayMocks(); + impl.flushInvalidatedCacheEntries(host, request); - verifyMocks(); + + verify(mockStorage).getEntry("http://foo.example.com:80/"); + verifyNoMoreInteractions(mockStorage); } @Test @@ -324,12 +321,12 @@ public class TestCacheInvalidator { cacheReturnsEntryForUri(theUri); cacheEntryHasVariantMap(mapOfURIs); - entryIsRemoved(variantUri); - entryIsRemoved(theUri); - - replayMocks(); impl.flushInvalidatedCacheEntries(host, request); - verifyMocks(); + + verify(mockStorage).getEntry(theUri); + verify(mockEntry).getVariantMap(); + verify(mockStorage).removeEntry(variantUri); + verify(mockStorage).removeEntry(theUri); } @Test @@ -339,17 +336,18 @@ public class TestCacheInvalidator { cacheReturnsExceptionForUri(theURI); - replayMocks(); impl.flushInvalidatedCacheEntries(host, request); - verifyMocks(); + + verify(mockStorage).getEntry(theURI); + verifyNoMoreInteractions(mockStorage); } @Test public void doesNotFlushForResponsesWithoutContentLocation() throws Exception { - replayMocks(); impl.flushInvalidatedCacheEntries(host, request, response); - verifyMocks(); + + verifyNoMoreInteractions(mockStorage); } @Test @@ -365,12 +363,12 @@ public class TestCacheInvalidator { new BasicHeader("ETag", "\"old-etag\"") }); - expect(mockStorage.getEntry(theURI)).andReturn(entry).anyTimes(); - mockStorage.removeEntry(theURI); + when(mockStorage.getEntry(theURI)).thenReturn(entry); - replayMocks(); impl.flushInvalidatedCacheEntries(host, request, response); - verifyMocks(); + + verify(mockStorage).getEntry(theURI); + verify(mockStorage).removeEntry(theURI); } @Test @@ -387,12 +385,12 @@ public class TestCacheInvalidator { new BasicHeader("ETag", "\"old-etag\"") }); - expect(mockStorage.getEntry(theURI)).andReturn(entry).anyTimes(); - mockStorage.removeEntry(theURI); + when(mockStorage.getEntry(theURI)).thenReturn(entry); - replayMocks(); impl.flushInvalidatedCacheEntries(host, request, response); - verifyMocks(); + + verify(mockStorage).getEntry(theURI); + verify(mockStorage).removeEntry(theURI); } @Test @@ -404,24 +402,9 @@ public class TestCacheInvalidator { final String theURI = "http://foo.example.com:80/bar"; response.setHeader("Content-Location", theURI); - final HttpCacheEntry entry = HttpTestUtils.makeCacheEntry(new Header[] { - new BasicHeader("Date", DateUtils.formatDate(tenSecondsAgo)), - new BasicHeader("ETag", "\"old-etag\"") - }); - - expect(mockStorage.getEntry(theURI)).andReturn(entry).anyTimes(); - mockStorage.removeEntry(theURI); - EasyMock.expectLastCall().andAnswer(new IAnswer() { - @Override - public Void answer() { - Assert.fail(); - return null; - } - }).anyTimes(); - - replayMocks(); impl.flushInvalidatedCacheEntries(host, request, response); - verifyMocks(); + + verifyNoMoreInteractions(mockStorage); } @Test @@ -437,12 +420,12 @@ public class TestCacheInvalidator { new BasicHeader("ETag", "\"old-etag\"") }); - expect(mockStorage.getEntry(cacheKey)).andReturn(entry).anyTimes(); - mockStorage.removeEntry(cacheKey); + when(mockStorage.getEntry(cacheKey)).thenReturn(entry); - replayMocks(); impl.flushInvalidatedCacheEntries(host, request, response); - verifyMocks(); + + verify(mockStorage).getEntry(cacheKey); + verify(mockStorage).removeEntry(cacheKey); } @Test @@ -458,12 +441,12 @@ public class TestCacheInvalidator { new BasicHeader("ETag", "\"old-etag\"") }); - expect(mockStorage.getEntry(cacheKey)).andReturn(entry).anyTimes(); - mockStorage.removeEntry(cacheKey); + when(mockStorage.getEntry(cacheKey)).thenReturn(entry); - replayMocks(); impl.flushInvalidatedCacheEntries(host, request, response); - verifyMocks(); + + verify(mockStorage).getEntry(cacheKey); + verify(mockStorage).removeEntry(cacheKey); } @Test @@ -479,19 +462,12 @@ public class TestCacheInvalidator { new BasicHeader("ETag", "\"old-etag\"") }); - expect(mockStorage.getEntry(cacheKey)).andReturn(entry).anyTimes(); - mockStorage.removeEntry(cacheKey); - EasyMock.expectLastCall().andAnswer(new IAnswer() { - @Override - public Void answer() { - Assert.fail(); - return null; - } - }).anyTimes(); - - replayMocks(); + when(mockStorage.getEntry(cacheKey)).thenReturn(entry); + impl.flushInvalidatedCacheEntries(host, request, response); - verifyMocks(); + + verify(mockStorage).getEntry(cacheKey); + verifyNoMoreInteractions(mockStorage); } @@ -509,19 +485,11 @@ public class TestCacheInvalidator { new BasicHeader("ETag", "\"same-etag\"") }); - expect(mockStorage.getEntry(theURI)).andReturn(entry).anyTimes(); - mockStorage.removeEntry(theURI); - EasyMock.expectLastCall().andAnswer(new IAnswer() { - @Override - public Void answer() { - Assert.fail(); - return null; - } - }).anyTimes(); - - replayMocks(); + when(mockStorage.getEntry(theURI)).thenReturn(entry); impl.flushInvalidatedCacheEntries(host, request, response); - verifyMocks(); + + verify(mockStorage).getEntry(theURI); + verifyNoMoreInteractions(mockStorage); } @Test @@ -537,19 +505,12 @@ public class TestCacheInvalidator { new BasicHeader("ETag", "\"old-etag\"") }); - expect(mockStorage.getEntry(theURI)).andReturn(entry).anyTimes(); - mockStorage.removeEntry(theURI); - EasyMock.expectLastCall().andAnswer(new IAnswer() { - @Override - public Void answer() { - Assert.fail(); - return null; - } - }).anyTimes(); - - replayMocks(); + when(mockStorage.getEntry(theURI)).thenReturn(entry); + impl.flushInvalidatedCacheEntries(host, request, response); - verifyMocks(); + + verify(mockStorage).getEntry(theURI); + verifyNoMoreInteractions(mockStorage); } @Test @@ -560,19 +521,12 @@ public class TestCacheInvalidator { final String theURI = "http://foo.example.com:80/bar"; response.setHeader("Content-Location", theURI); - expect(mockStorage.getEntry(theURI)).andReturn(null).anyTimes(); - mockStorage.removeEntry(theURI); - EasyMock.expectLastCall().andAnswer(new IAnswer() { - @Override - public Void answer() { - Assert.fail(); - return null; - } - }).anyTimes(); - - replayMocks(); + when(mockStorage.getEntry(theURI)).thenReturn(null); + impl.flushInvalidatedCacheEntries(host, request, response); - verifyMocks(); + + verify(mockStorage).getEntry(theURI); + verifyNoMoreInteractions(mockStorage); } @Test @@ -588,19 +542,12 @@ public class TestCacheInvalidator { new BasicHeader("ETag", "\"old-etag\"") }); - expect(mockStorage.getEntry(theURI)).andReturn(entry).anyTimes(); - mockStorage.removeEntry(theURI); - EasyMock.expectLastCall().andAnswer(new IAnswer() { - @Override - public Void answer() { - Assert.fail(); - return null; - } - }).anyTimes(); - - replayMocks(); + when(mockStorage.getEntry(theURI)).thenReturn(entry); + impl.flushInvalidatedCacheEntries(host, request, response); - verifyMocks(); + + verify(mockStorage).getEntry(theURI); + verifyNoMoreInteractions(mockStorage); } @Test @@ -615,11 +562,12 @@ public class TestCacheInvalidator { new BasicHeader("Date", DateUtils.formatDate(tenSecondsAgo)), }); - expect(mockStorage.getEntry(theURI)).andReturn(entry).anyTimes(); + when(mockStorage.getEntry(theURI)).thenReturn(entry); - replayMocks(); impl.flushInvalidatedCacheEntries(host, request, response); - verifyMocks(); + + verify(mockStorage).getEntry(theURI); + verifyNoMoreInteractions(mockStorage); } @Test @@ -635,12 +583,13 @@ public class TestCacheInvalidator { new BasicHeader("Date", DateUtils.formatDate(tenSecondsAgo)), }); - expect(mockStorage.getEntry(theURI)).andReturn(entry).anyTimes(); - mockStorage.removeEntry(theURI); + when(mockStorage.getEntry(theURI)).thenReturn(entry); - replayMocks(); impl.flushInvalidatedCacheEntries(host, request, response); - verifyMocks(); + + verify(mockStorage).getEntry(theURI); + verify(mockStorage).removeEntry(theURI); + verifyNoMoreInteractions(mockStorage); } @Test @@ -655,12 +604,13 @@ public class TestCacheInvalidator { new BasicHeader("ETag", "\"old-etag\"") }); - expect(mockStorage.getEntry(theURI)).andReturn(entry).anyTimes(); - mockStorage.removeEntry(theURI); + when(mockStorage.getEntry(theURI)).thenReturn(entry); - replayMocks(); impl.flushInvalidatedCacheEntries(host, request, response); - verifyMocks(); + + verify(mockStorage).getEntry(theURI); + verify(mockStorage).removeEntry(theURI); + verifyNoMoreInteractions(mockStorage); } @Test @@ -676,12 +626,13 @@ public class TestCacheInvalidator { new BasicHeader("Date", DateUtils.formatDate(tenSecondsAgo)) }); - expect(mockStorage.getEntry(theURI)).andReturn(entry).anyTimes(); - mockStorage.removeEntry(theURI); + when(mockStorage.getEntry(theURI)).thenReturn(entry); - replayMocks(); impl.flushInvalidatedCacheEntries(host, request, response); - verifyMocks(); + + verify(mockStorage).getEntry(theURI); + verify(mockStorage).removeEntry(theURI); + verifyNoMoreInteractions(mockStorage); } @Test @@ -697,35 +648,31 @@ public class TestCacheInvalidator { new BasicHeader("Date", "foo") }); - expect(mockStorage.getEntry(theURI)).andReturn(entry).anyTimes(); - mockStorage.removeEntry(theURI); + when(mockStorage.getEntry(theURI)).thenReturn(entry); - replayMocks(); impl.flushInvalidatedCacheEntries(host, request, response); - verifyMocks(); + + verify(mockStorage).getEntry(theURI); + verify(mockStorage).removeEntry(theURI); + verifyNoMoreInteractions(mockStorage); } // Expectations private void cacheEntryHasVariantMap(final Map variantMap) { - expect(mockEntry.getVariantMap()).andReturn(variantMap); + when(mockEntry.getVariantMap()).thenReturn(variantMap); } private void cacheReturnsEntryForUri(final String theUri) throws IOException { - expect(mockStorage.getEntry(theUri)).andReturn(mockEntry); + when(mockStorage.getEntry(theUri)).thenReturn(mockEntry); } private void cacheReturnsExceptionForUri(final String theUri) throws IOException { - expect(mockStorage.getEntry(theUri)).andThrow( + when(mockStorage.getEntry(theUri)).thenThrow( new IOException("TOTAL FAIL")); } - private void entryIsRemoved(final String theUri) throws IOException { - mockStorage.removeEntry(theUri); - } - private void cacheEntryisForMethod(final String httpMethod) { - expect(mockEntry.getRequestMethod()).andReturn(httpMethod); + when(mockEntry.getRequestMethod()).thenReturn(httpMethod); } - } diff --git a/httpclient-cache/src/test/java/org/apache/http/impl/client/cache/TestCacheKeyGenerator.java b/httpclient-cache/src/test/java/org/apache/http/impl/client/cache/TestCacheKeyGenerator.java index 45e23d7..4d217a9 100644 --- a/httpclient-cache/src/test/java/org/apache/http/impl/client/cache/TestCacheKeyGenerator.java +++ b/httpclient-cache/src/test/java/org/apache/http/impl/client/cache/TestCacheKeyGenerator.java @@ -26,6 +26,10 @@ */ package org.apache.http.impl.client.cache; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + import org.apache.http.Header; import org.apache.http.HttpHost; import org.apache.http.HttpRequest; @@ -34,7 +38,6 @@ import org.apache.http.client.cache.HttpCacheEntry; import org.apache.http.client.methods.HttpGet; import org.apache.http.message.BasicHeader; import org.apache.http.message.BasicHttpRequest; -import org.easymock.classextension.EasyMock; import org.junit.Assert; import org.junit.Before; import org.junit.Test; @@ -54,21 +57,11 @@ public class TestCacheKeyGenerator { @Before public void setUp() throws Exception { defaultHost = new HttpHost("foo.example.com"); - mockEntry = EasyMock.createNiceMock(HttpCacheEntry.class); - mockRequest = EasyMock.createNiceMock(HttpRequest.class); + mockEntry = mock(HttpCacheEntry.class); + mockRequest = mock(HttpRequest.class); extractor = new CacheKeyGenerator(); } - private void replayMocks() { - EasyMock.replay(mockEntry); - EasyMock.replay(mockRequest); - } - - private void verifyMocks() { - EasyMock.verify(mockEntry); - EasyMock.verify(mockRequest); - } - @Test public void testExtractsUriFromAbsoluteUriInRequest() { final HttpHost host = new HttpHost("bar.example.com"); @@ -124,7 +117,7 @@ public class TestCacheKeyGenerator { @Test public void testGetVariantURIWithNoVaryHeaderReturnsNormalURI() { final String theURI = "theURI"; - org.easymock.EasyMock.expect(mockEntry.hasVariants()).andReturn(false); + when(mockEntry.hasVariants()).thenReturn(false); extractor = new CacheKeyGenerator() { @Override public String getURI(final HttpHost h, final HttpRequest req) { @@ -134,9 +127,8 @@ public class TestCacheKeyGenerator { } }; - replayMocks(); final String result = extractor.getVariantURI(defaultHost, mockRequest, mockEntry); - verifyMocks(); + verify(mockEntry).hasVariants(); Assert.assertSame(theURI, result); } @@ -154,15 +146,16 @@ public class TestCacheKeyGenerator { return theURI; } }; - EasyMock.expect(mockEntry.hasVariants()).andReturn(true).anyTimes(); - EasyMock.expect(mockEntry.getHeaders("Vary")).andReturn(varyHeaders); - EasyMock.expect(mockRequest.getHeaders("Accept-Encoding")).andReturn( + when(mockEntry.hasVariants()).thenReturn(true); + when(mockEntry.getHeaders("Vary")).thenReturn(varyHeaders); + when(mockRequest.getHeaders("Accept-Encoding")).thenReturn( encHeaders); - replayMocks(); final String result = extractor.getVariantURI(defaultHost, mockRequest, mockEntry); - verifyMocks(); + verify(mockEntry).hasVariants(); + verify(mockEntry).getHeaders("Vary"); + verify(mockRequest).getHeaders("Accept-Encoding"); Assert.assertEquals("{Accept-Encoding=gzip}" + theURI, result); } @@ -179,15 +172,16 @@ public class TestCacheKeyGenerator { return theURI; } }; - EasyMock.expect(mockEntry.hasVariants()).andReturn(true).anyTimes(); - EasyMock.expect(mockEntry.getHeaders("Vary")).andReturn(varyHeaders); - EasyMock.expect(mockRequest.getHeaders("Accept-Encoding")) - .andReturn(noHeaders); - replayMocks(); + when(mockEntry.hasVariants()).thenReturn(true); + when(mockEntry.getHeaders("Vary")).thenReturn(varyHeaders); + when(mockRequest.getHeaders("Accept-Encoding")) + .thenReturn(noHeaders); final String result = extractor.getVariantURI(defaultHost, mockRequest, mockEntry); - verifyMocks(); + verify(mockEntry).hasVariants(); + verify(mockEntry).getHeaders("Vary"); + verify(mockRequest).getHeaders("Accept-Encoding"); Assert.assertEquals("{Accept-Encoding=}" + theURI, result); } @@ -205,16 +199,18 @@ public class TestCacheKeyGenerator { return theURI; } }; - EasyMock.expect(mockEntry.hasVariants()).andReturn(true).anyTimes(); - EasyMock.expect(mockEntry.getHeaders("Vary")).andReturn(varyHeaders); - EasyMock.expect(mockRequest.getHeaders("Accept-Encoding")).andReturn( + when(mockEntry.hasVariants()).thenReturn(true); + when(mockEntry.getHeaders("Vary")).thenReturn(varyHeaders); + when(mockRequest.getHeaders("Accept-Encoding")).thenReturn( encHeaders); - EasyMock.expect(mockRequest.getHeaders("User-Agent")).andReturn(uaHeaders); - replayMocks(); + when(mockRequest.getHeaders("User-Agent")).thenReturn(uaHeaders); final String result = extractor.getVariantURI(defaultHost, mockRequest, mockEntry); - verifyMocks(); + verify(mockEntry).hasVariants(); + verify(mockEntry).getHeaders("Vary"); + verify(mockRequest).getHeaders("Accept-Encoding"); + verify(mockRequest).getHeaders("User-Agent"); Assert.assertEquals("{Accept-Encoding=gzip&User-Agent=browser}" + theURI, result); } @@ -233,15 +229,17 @@ public class TestCacheKeyGenerator { return theURI; } }; - EasyMock.expect(mockEntry.hasVariants()).andReturn(true).anyTimes(); - EasyMock.expect(mockEntry.getHeaders("Vary")).andReturn(varyHeaders); - EasyMock.expect(mockRequest.getHeaders("Accept-Encoding")).andReturn(encHeaders); - EasyMock.expect(mockRequest.getHeaders("User-Agent")).andReturn(uaHeaders); - replayMocks(); + when(mockEntry.hasVariants()).thenReturn(true); + when(mockEntry.getHeaders("Vary")).thenReturn(varyHeaders); + when(mockRequest.getHeaders("Accept-Encoding")).thenReturn(encHeaders); + when(mockRequest.getHeaders("User-Agent")).thenReturn(uaHeaders); final String result = extractor.getVariantURI(defaultHost, mockRequest, mockEntry); - verifyMocks(); + verify(mockEntry).hasVariants(); + verify(mockEntry).getHeaders("Vary"); + verify(mockRequest).getHeaders("Accept-Encoding"); + verify(mockRequest).getHeaders("User-Agent"); Assert.assertEquals("{Accept-Encoding=gzip&User-Agent=browser}" + theURI, result); } @@ -260,15 +258,17 @@ public class TestCacheKeyGenerator { return theURI; } }; - EasyMock.expect(mockEntry.hasVariants()).andReturn(true).anyTimes(); - EasyMock.expect(mockEntry.getHeaders("Vary")).andReturn(varyHeaders); - EasyMock.expect(mockRequest.getHeaders("Accept-Encoding")).andReturn(encHeaders); - EasyMock.expect(mockRequest.getHeaders("User-Agent")).andReturn(uaHeaders); - replayMocks(); + when(mockEntry.hasVariants()).thenReturn(true); + when(mockEntry.getHeaders("Vary")).thenReturn(varyHeaders); + when(mockRequest.getHeaders("Accept-Encoding")).thenReturn(encHeaders); + when(mockRequest.getHeaders("User-Agent")).thenReturn(uaHeaders); final String result = extractor.getVariantURI(defaultHost, mockRequest, mockEntry); - verifyMocks(); + verify(mockEntry).hasVariants(); + verify(mockEntry).getHeaders("Vary"); + verify(mockRequest).getHeaders("Accept-Encoding"); + verify(mockRequest).getHeaders("User-Agent"); Assert .assertEquals("{Accept-Encoding=gzip%2C+deflate&User-Agent=browser}" + theURI, result); diff --git a/httpclient-cache/src/test/java/org/apache/http/impl/client/cache/TestCachedHttpResponseGenerator.java b/httpclient-cache/src/test/java/org/apache/http/impl/client/cache/TestCachedHttpResponseGenerator.java index 1f5556a..3fc12f6 100644 --- a/httpclient-cache/src/test/java/org/apache/http/impl/client/cache/TestCachedHttpResponseGenerator.java +++ b/httpclient-cache/src/test/java/org/apache/http/impl/client/cache/TestCachedHttpResponseGenerator.java @@ -26,6 +26,12 @@ */ package org.apache.http.impl.client.cache; +import static org.mockito.Matchers.isA; +import static org.mockito.Matchers.same; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + import java.util.Date; import java.util.HashMap; @@ -33,9 +39,7 @@ import org.apache.http.Header; import org.apache.http.HttpResponse; import org.apache.http.client.cache.HttpCacheEntry; import org.apache.http.client.methods.HttpRequestWrapper; -import org.apache.http.client.utils.DateUtils; import org.apache.http.message.BasicHeader; -import org.easymock.classextension.EasyMock; import org.junit.Assert; import org.junit.Before; import org.junit.Test; @@ -47,27 +51,15 @@ public class TestCachedHttpResponseGenerator { private HttpRequestWrapper request; private CacheValidityPolicy mockValidityPolicy; private CachedHttpResponseGenerator impl; - private Date now; @Before public void setUp() { - now = new Date(); - final Date eightSecondsAgo = new Date(now.getTime() - 8 * 1000L); - final Date tenSecondsFromNow = new Date(now.getTime() + 10 * 1000L); - final Header[] hdrs = { new BasicHeader("Date", DateUtils.formatDate(eightSecondsAgo)), - new BasicHeader("Expires", DateUtils.formatDate(tenSecondsFromNow)), - new BasicHeader("Content-Length", "150") }; - entry = HttpTestUtils.makeCacheEntry(new HashMap()); request = HttpRequestWrapper.wrap(HttpTestUtils.makeDefaultRequest()); - mockValidityPolicy = EasyMock.createNiceMock(CacheValidityPolicy.class); + mockValidityPolicy = mock(CacheValidityPolicy.class); impl = new CachedHttpResponseGenerator(mockValidityPolicy); } - public void replayMocks() { - EasyMock.replay(mockValidityPolicy); - } - @Test public void testResponseHasContentLength() { final byte[] buf = new byte[] { 1, 2, 3, 4, 5 }; @@ -117,10 +109,11 @@ public class TestCachedHttpResponseGenerator { @Test public void testAgeHeaderIsPopulatedWithCurrentAgeOfCacheEntryIfNonZero() { currentAge(10L); - replayMocks(); final HttpResponse response = impl.generateResponse(request, entry); + verify(mockValidityPolicy).getCurrentAgeSecs(same(entry), isA(Date.class)); + final Header ageHdr = response.getFirstHeader("Age"); Assert.assertNotNull(ageHdr); Assert.assertEquals(10L, Long.parseLong(ageHdr.getValue())); @@ -129,10 +122,11 @@ public class TestCachedHttpResponseGenerator { @Test public void testAgeHeaderIsNotPopulatedIfCurrentAgeOfCacheEntryIsZero() { currentAge(0L); - replayMocks(); final HttpResponse response = impl.generateResponse(request, entry); + verify(mockValidityPolicy).getCurrentAgeSecs(same(entry), isA(Date.class)); + final Header ageHdr = response.getFirstHeader("Age"); Assert.assertNull(ageHdr); } @@ -140,19 +134,20 @@ public class TestCachedHttpResponseGenerator { @Test public void testAgeHeaderIsPopulatedWithMaxAgeIfCurrentAgeTooBig() { currentAge(CacheValidityPolicy.MAX_AGE + 1L); - replayMocks(); final HttpResponse response = impl.generateResponse(request, entry); + verify(mockValidityPolicy).getCurrentAgeSecs(same(entry), isA(Date.class)); + final Header ageHdr = response.getFirstHeader("Age"); Assert.assertNotNull(ageHdr); Assert.assertEquals(CacheValidityPolicy.MAX_AGE, Long.parseLong(ageHdr.getValue())); } private void currentAge(final long sec) { - EasyMock.expect( - mockValidityPolicy.getCurrentAgeSecs(EasyMock.same(entry), - EasyMock.isA(Date.class))).andReturn(sec); + when( + mockValidityPolicy.getCurrentAgeSecs(same(entry), + isA(Date.class))).thenReturn(sec); } @Test diff --git a/httpclient-cache/src/test/java/org/apache/http/impl/client/cache/TestCachedResponseSuitabilityChecker.java b/httpclient-cache/src/test/java/org/apache/http/impl/client/cache/TestCachedResponseSuitabilityChecker.java index 7ab8e6c..a5cfffa 100644 --- a/httpclient-cache/src/test/java/org/apache/http/impl/client/cache/TestCachedResponseSuitabilityChecker.java +++ b/httpclient-cache/src/test/java/org/apache/http/impl/client/cache/TestCachedResponseSuitabilityChecker.java @@ -36,7 +36,6 @@ import org.apache.http.client.cache.HttpCacheEntry; import org.apache.http.client.utils.DateUtils; import org.apache.http.message.BasicHeader; import org.apache.http.message.BasicHttpRequest; -import org.easymock.classextension.EasyMock; import org.junit.Assert; import org.junit.Before; import org.junit.Test; @@ -51,7 +50,6 @@ public class TestCachedResponseSuitabilityChecker { private HttpHost host; private HttpRequest request; private HttpCacheEntry entry; - private CacheValidityPolicy mockValidityPolicy; private CachedResponseSuitabilityChecker impl; @Before @@ -63,7 +61,6 @@ public class TestCachedResponseSuitabilityChecker { host = new HttpHost("foo.example.com"); request = new BasicHttpRequest("GET", "/foo", HttpVersion.HTTP_1_1); - mockValidityPolicy = EasyMock.createNiceMock(CacheValidityPolicy.class); entry = HttpTestUtils.makeCacheEntry(); impl = new CachedResponseSuitabilityChecker(CacheConfig.DEFAULT); @@ -73,14 +70,6 @@ public class TestCachedResponseSuitabilityChecker { return HttpTestUtils.makeCacheEntry(elevenSecondsAgo, nineSecondsAgo, headers); } - public void replayMocks() { - EasyMock.replay(mockValidityPolicy); - } - - public void verifyMocks() { - EasyMock.verify(mockValidityPolicy); - } - @Test public void testNotSuitableIfContentLengthHeaderIsWrong() { final Header[] headers = { diff --git a/httpclient-cache/src/test/java/org/apache/http/impl/client/cache/TestCombinedEntity.java b/httpclient-cache/src/test/java/org/apache/http/impl/client/cache/TestCombinedEntity.java index 17cf5bb..2e728bd 100644 --- a/httpclient-cache/src/test/java/org/apache/http/impl/client/cache/TestCombinedEntity.java +++ b/httpclient-cache/src/test/java/org/apache/http/impl/client/cache/TestCombinedEntity.java @@ -26,11 +26,14 @@ */ package org.apache.http.impl.client.cache; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + import java.io.ByteArrayInputStream; import org.apache.http.client.cache.Resource; import org.apache.http.util.EntityUtils; -import org.easymock.EasyMock; import org.junit.Assert; import org.junit.Test; @@ -38,11 +41,9 @@ public class TestCombinedEntity { @Test public void testCombinedEntityBasics() throws Exception { - final Resource resource = EasyMock.createNiceMock(Resource.class); - EasyMock.expect(resource.getInputStream()).andReturn( + final Resource resource = mock(Resource.class); + when(resource.getInputStream()).thenReturn( new ByteArrayInputStream(new byte[] { 1, 2, 3, 4, 5 })); - resource.dispose(); - EasyMock.replay(resource); final ByteArrayInputStream instream = new ByteArrayInputStream(new byte[] { 6, 7, 8, 9, 10 }); final CombinedEntity entity = new CombinedEntity(resource, instream); @@ -53,7 +54,8 @@ public class TestCombinedEntity { final byte[] result = EntityUtils.toByteArray(entity); Assert.assertArrayEquals(new byte[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }, result); - EasyMock.verify(resource); + verify(resource).getInputStream(); + verify(resource).dispose(); } } diff --git a/httpclient-cache/src/test/java/org/apache/http/impl/client/cache/TestExponentialBackingOffSchedulingStrategy.java b/httpclient-cache/src/test/java/org/apache/http/impl/client/cache/TestExponentialBackingOffSchedulingStrategy.java index 5005118..40559af 100644 --- a/httpclient-cache/src/test/java/org/apache/http/impl/client/cache/TestExponentialBackingOffSchedulingStrategy.java +++ b/httpclient-cache/src/test/java/org/apache/http/impl/client/cache/TestExponentialBackingOffSchedulingStrategy.java @@ -26,13 +26,16 @@ */ package org.apache.http.impl.client.cache; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + import org.apache.http.HttpHost; import org.apache.http.client.methods.HttpRequestWrapper; import org.apache.http.client.protocol.HttpClientContext; import org.apache.http.conn.routing.HttpRoute; import org.apache.http.impl.execchain.ClientExecChain; import org.apache.http.message.BasicHttpRequest; -import org.easymock.EasyMock; import org.junit.Before; import org.junit.Test; @@ -46,7 +49,7 @@ public class TestExponentialBackingOffSchedulingStrategy { @Before public void setUp() { - mockExecutor = EasyMock.createMock(ScheduledExecutorService.class); + mockExecutor = mock(ScheduledExecutorService.class); impl = new ExponentialBackOffSchedulingStrategy( mockExecutor, @@ -62,9 +65,9 @@ public class TestExponentialBackingOffSchedulingStrategy { expectRequestScheduledWithoutDelay(request); - replayMocks(); impl.schedule(request); - verifyMocks(); + + verify(mockExecutor).schedule(request, 0, TimeUnit.MILLISECONDS); } @Test @@ -73,9 +76,9 @@ public class TestExponentialBackingOffSchedulingStrategy { expectRequestScheduledWithDelay(request, TimeUnit.SECONDS.toMillis(6)); - replayMocks(); impl.schedule(request); - verifyMocks(); + + verify(mockExecutor).schedule(request, 6000, TimeUnit.MILLISECONDS); } @Test @@ -84,9 +87,9 @@ public class TestExponentialBackingOffSchedulingStrategy { expectRequestScheduledWithDelay(request, TimeUnit.SECONDS.toMillis(60)); - replayMocks(); impl.schedule(request); - verifyMocks(); + + verify(mockExecutor).schedule(request, 60000, TimeUnit.MILLISECONDS); } @Test @@ -95,9 +98,9 @@ public class TestExponentialBackingOffSchedulingStrategy { expectRequestScheduledWithDelay(request, TimeUnit.SECONDS.toMillis(600)); - replayMocks(); impl.schedule(request); - verifyMocks(); + + verify(mockExecutor).schedule(request, 600000, TimeUnit.MILLISECONDS); } @Test @@ -106,9 +109,9 @@ public class TestExponentialBackingOffSchedulingStrategy { expectRequestScheduledWithDelay(request, TimeUnit.SECONDS.toMillis(6000)); - replayMocks(); impl.schedule(request); - verifyMocks(); + + verify(mockExecutor).schedule(request, 6000000, TimeUnit.MILLISECONDS); } @Test @@ -117,9 +120,9 @@ public class TestExponentialBackingOffSchedulingStrategy { expectRequestScheduledWithDelay(request, TimeUnit.SECONDS.toMillis(60000)); - replayMocks(); impl.schedule(request); - verifyMocks(); + + verify(mockExecutor).schedule(request, 60000000, TimeUnit.MILLISECONDS); } @Test @@ -128,9 +131,9 @@ public class TestExponentialBackingOffSchedulingStrategy { expectRequestScheduledWithDelay(request, TimeUnit.SECONDS.toMillis(86400)); - replayMocks(); impl.schedule(request); - verifyMocks(); + + verify(mockExecutor).schedule(request, 86400000, TimeUnit.MILLISECONDS); } @Test @@ -139,9 +142,9 @@ public class TestExponentialBackingOffSchedulingStrategy { expectRequestScheduledWithDelay(request, TimeUnit.SECONDS.toMillis(86400)); - replayMocks(); impl.schedule(request); - verifyMocks(); + + verify(mockExecutor).schedule(request, 86400000, TimeUnit.MILLISECONDS); } private void expectRequestScheduledWithoutDelay(final AsynchronousValidationRequest request) { @@ -149,19 +152,11 @@ public class TestExponentialBackingOffSchedulingStrategy { } private void expectRequestScheduledWithDelay(final AsynchronousValidationRequest request, final long delayInMillis) { - EasyMock.expect(mockExecutor.schedule(request, delayInMillis, TimeUnit.MILLISECONDS)).andReturn(null); - } - - private void replayMocks() { - EasyMock.replay(mockExecutor); - } - - private void verifyMocks() { - EasyMock.verify(mockExecutor); + when(mockExecutor.schedule(request, delayInMillis, TimeUnit.MILLISECONDS)).thenReturn(null); } private AsynchronousValidationRequest createAsynchronousValidationRequest(final int errorCount) { - final ClientExecChain clientExecChain = EasyMock.createNiceMock(ClientExecChain.class); + final ClientExecChain clientExecChain = mock(ClientExecChain.class); final CachingExec cachingHttpClient = new CachingExec(clientExecChain); final AsynchronousValidator mockValidator = new AsynchronousValidator(impl); final HttpRoute httpRoute = new HttpRoute(new HttpHost("foo.example.com", 80)); diff --git a/httpclient-cache/src/test/java/org/apache/http/impl/client/cache/TestHttpCacheJiraNumber1147.java b/httpclient-cache/src/test/java/org/apache/http/impl/client/cache/TestHttpCacheJiraNumber1147.java index ce82393..ceb8f71 100644 --- a/httpclient-cache/src/test/java/org/apache/http/impl/client/cache/TestHttpCacheJiraNumber1147.java +++ b/httpclient-cache/src/test/java/org/apache/http/impl/client/cache/TestHttpCacheJiraNumber1147.java @@ -26,6 +26,13 @@ */ package org.apache.http.impl.client.cache; +import static org.mockito.Matchers.eq; +import static org.mockito.Matchers.isA; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.reset; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + import java.io.File; import java.util.Date; @@ -42,11 +49,11 @@ import org.apache.http.client.utils.DateUtils; import org.apache.http.conn.routing.HttpRoute; import org.apache.http.impl.execchain.ClientExecChain; import org.apache.http.message.BasicHttpResponse; -import org.easymock.EasyMock; import org.junit.After; import org.junit.Assert; import org.junit.Before; import org.junit.Test; +import org.mockito.Matchers; public class TestHttpCacheJiraNumber1147 { @@ -87,7 +94,7 @@ public class TestHttpCacheJiraNumber1147 { final ResourceFactory resourceFactory = new FileResourceFactory(cacheDir); final HttpCacheStorage httpCacheStorage = new ManagedHttpCacheStorage(cacheConfig); - final ClientExecChain backend = EasyMock.createNiceMock(ClientExecChain.class); + final ClientExecChain backend = mock(ClientExecChain.class); final HttpRequestWrapper get = HttpRequestWrapper.wrap(new HttpGet("http://somehost/")); final HttpClientContext context = HttpClientContext.create(); final HttpHost target = new HttpHost("somehost", 80); @@ -105,12 +112,11 @@ public class TestHttpCacheJiraNumber1147 { response.setHeader("Cache-Control", "public, max-age=3600"); response.setHeader("Last-Modified", DateUtils.formatDate(tenSecondsAgo)); - EasyMock.expect(backend.execute( - EasyMock.eq(route), - EasyMock.isA(HttpRequestWrapper.class), - EasyMock.isA(HttpClientContext.class), - EasyMock.isNull())).andReturn(Proxies.enhanceResponse(response)); - EasyMock.replay(backend); + when(backend.execute( + eq(route), + isA(HttpRequestWrapper.class), + isA(HttpClientContext.class), + (HttpExecutionAware) Matchers.isNull())).thenReturn(Proxies.enhanceResponse(response)); final BasicHttpCache cache = new BasicHttpCache(resourceFactory, httpCacheStorage, cacheConfig); final ClientExecChain t = createCachingExecChain(backend, cache, cacheConfig); @@ -119,23 +125,30 @@ public class TestHttpCacheJiraNumber1147 { Assert.assertEquals(200, response1.getStatusLine().getStatusCode()); IOUtils.consume(response1.getEntity()); - EasyMock.verify(backend); + verify(backend).execute( + eq(route), + isA(HttpRequestWrapper.class), + isA(HttpClientContext.class), + (HttpExecutionAware) Matchers.isNull()); removeCache(); - EasyMock.reset(backend); - EasyMock.expect(backend.execute( - EasyMock.eq(route), - EasyMock.isA(HttpRequestWrapper.class), - EasyMock.isA(HttpClientContext.class), - EasyMock.isNull())).andReturn(Proxies.enhanceResponse(response)); - EasyMock.replay(backend); + reset(backend); + when(backend.execute( + eq(route), + isA(HttpRequestWrapper.class), + isA(HttpClientContext.class), + (HttpExecutionAware) Matchers.isNull())).thenReturn(Proxies.enhanceResponse(response)); final HttpResponse response2 = t.execute(route, get, context, null); Assert.assertEquals(200, response2.getStatusLine().getStatusCode()); IOUtils.consume(response2.getEntity()); - EasyMock.verify(backend); + verify(backend).execute( + eq(route), + isA(HttpRequestWrapper.class), + isA(HttpClientContext.class), + (HttpExecutionAware) Matchers.isNull()); } protected ClientExecChain createCachingExecChain(final ClientExecChain backend, diff --git a/httpclient-cache/src/test/java/org/apache/http/impl/client/cache/TestImmediateSchedulingStrategy.java b/httpclient-cache/src/test/java/org/apache/http/impl/client/cache/TestImmediateSchedulingStrategy.java index 5d20b2c..fdb4805 100644 --- a/httpclient-cache/src/test/java/org/apache/http/impl/client/cache/TestImmediateSchedulingStrategy.java +++ b/httpclient-cache/src/test/java/org/apache/http/impl/client/cache/TestImmediateSchedulingStrategy.java @@ -26,7 +26,8 @@ */ package org.apache.http.impl.client.cache; -import org.easymock.classextension.EasyMock; +import static org.mockito.Mockito.mock; + import org.junit.Before; import org.junit.Test; @@ -40,8 +41,8 @@ public class TestImmediateSchedulingStrategy { @Before public void setUp() { - mockExecutor = EasyMock.createMock(ExecutorService.class); - mockRevalidationRequest = EasyMock.createNiceMock(AsynchronousValidationRequest.class); + mockExecutor = mock(ExecutorService.class); + mockRevalidationRequest = mock(AsynchronousValidationRequest.class); schedulingStrategy = new ImmediateSchedulingStrategy(mockExecutor); } @@ -49,10 +50,6 @@ public class TestImmediateSchedulingStrategy { public void testRequestScheduledImmediately() { mockExecutor.execute(mockRevalidationRequest); - EasyMock.replay(mockExecutor); - EasyMock.replay(mockRevalidationRequest); schedulingStrategy.schedule(mockRevalidationRequest); - EasyMock.verify(mockExecutor); - EasyMock.verify(mockRevalidationRequest); } -} \ No newline at end of file +} diff --git a/httpclient-cache/src/test/java/org/apache/http/impl/client/cache/ehcache/TestEhcacheHttpCacheStorage.java b/httpclient-cache/src/test/java/org/apache/http/impl/client/cache/ehcache/TestEhcacheHttpCacheStorage.java index 347c839..ee91cec 100644 --- a/httpclient-cache/src/test/java/org/apache/http/impl/client/cache/ehcache/TestEhcacheHttpCacheStorage.java +++ b/httpclient-cache/src/test/java/org/apache/http/impl/client/cache/ehcache/TestEhcacheHttpCacheStorage.java @@ -26,6 +26,13 @@ */ package org.apache.http.impl.client.cache.ehcache; +import static org.mockito.Matchers.isA; +import static org.mockito.Matchers.same; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.times; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + import java.io.IOException; import java.io.InputStream; import java.io.OutputStream; @@ -40,7 +47,6 @@ import org.apache.http.client.cache.HttpCacheUpdateCallback; import org.apache.http.client.cache.HttpCacheUpdateException; import org.apache.http.impl.client.cache.CacheConfig; import org.apache.http.impl.client.cache.HttpTestUtils; -import org.easymock.EasyMock; import org.junit.Test; @SuppressWarnings("boxing") // test code @@ -52,22 +58,12 @@ public class TestEhcacheHttpCacheStorage extends TestCase { @Override public void setUp() { - mockCache = EasyMock.createNiceMock(Ehcache.class); + mockCache = mock(Ehcache.class); final CacheConfig config = CacheConfig.custom().setMaxUpdateRetries(1).build(); - mockSerializer = EasyMock.createNiceMock(HttpCacheEntrySerializer.class); + mockSerializer = mock(HttpCacheEntrySerializer.class); impl = new EhcacheHttpCacheStorage(mockCache, config, mockSerializer); } - private void replayMocks(){ - EasyMock.replay(mockCache); - EasyMock.replay(mockSerializer); - } - - private void verifyMocks(){ - EasyMock.verify(mockCache); - EasyMock.verify(mockSerializer); - } - @Test public void testCachePut() throws IOException { final String key = "foo"; @@ -75,23 +71,21 @@ public class TestEhcacheHttpCacheStorage extends TestCase { final Element e = new Element(key, new byte[]{}); - mockSerializer.writeTo(EasyMock.same(value), EasyMock.isA(OutputStream.class)); - mockCache.put(e); - - replayMocks(); impl.putEntry(key, value); - verifyMocks(); + + verify(mockSerializer).writeTo(same(value), isA(OutputStream.class)); + verify(mockCache).put(e);; } @Test public void testCacheGetNullEntry() throws IOException { final String key = "foo"; - EasyMock.expect(mockCache.get(key)).andReturn(null); + when(mockCache.get(key)).thenReturn(null); - replayMocks(); final HttpCacheEntry resultingEntry = impl.getEntry(key); - verifyMocks(); + + verify(mockCache).get(key); assertNull(resultingEntry); } @@ -103,14 +97,15 @@ public class TestEhcacheHttpCacheStorage extends TestCase { final Element element = new Element(key, new byte[]{}); - EasyMock.expect(mockCache.get(key)) - .andReturn(element); - EasyMock.expect(mockSerializer.readFrom(EasyMock.isA(InputStream.class))) - .andReturn(cachedValue); + when(mockCache.get(key)) + .thenReturn(element); + when(mockSerializer.readFrom(isA(InputStream.class))) + .thenReturn(cachedValue); - replayMocks(); final HttpCacheEntry resultingEntry = impl.getEntry(key); - verifyMocks(); + + verify(mockCache).get(key); + verify(mockSerializer).readFrom(isA(InputStream.class)); assertSame(cachedValue, resultingEntry); } @@ -119,11 +114,10 @@ public class TestEhcacheHttpCacheStorage extends TestCase { public void testCacheRemove() { final String key = "foo"; - EasyMock.expect(mockCache.remove(key)).andReturn(true); + when(mockCache.remove(key)).thenReturn(true); - replayMocks(); impl.removeEntry(key); - verifyMocks(); + verify(mockCache).remove(key); } @Test @@ -142,15 +136,16 @@ public class TestEhcacheHttpCacheStorage extends TestCase { }; // get empty old entry - EasyMock.expect(mockCache.get(key)).andReturn(null); + when(mockCache.get(key)).thenReturn(null); // put new entry - mockSerializer.writeTo(EasyMock.same(updatedValue), EasyMock.isA(OutputStream.class)); - mockCache.put(element); + mockSerializer.writeTo(same(updatedValue), isA(OutputStream.class)); - replayMocks(); impl.updateEntry(key, callback); - verifyMocks(); + + verify(mockCache).get(key); + verify(mockSerializer).writeTo(same(updatedValue), isA(OutputStream.class)); + verify(mockCache).put(element); } @Test @@ -170,16 +165,19 @@ public class TestEhcacheHttpCacheStorage extends TestCase { }; // get existing old entry - EasyMock.expect(mockCache.get(key)).andReturn(existingElement); - EasyMock.expect(mockSerializer.readFrom(EasyMock.isA(InputStream.class))).andReturn(existingValue); + when(mockCache.get(key)).thenReturn(existingElement); + when(mockSerializer.readFrom(isA(InputStream.class))).thenReturn(existingValue); // update - mockSerializer.writeTo(EasyMock.same(updatedValue), EasyMock.isA(OutputStream.class)); - EasyMock.expect(mockCache.replace(EasyMock.same(existingElement), EasyMock.isA(Element.class))).andReturn(true); + mockSerializer.writeTo(same(updatedValue), isA(OutputStream.class)); + when(mockCache.replace(same(existingElement), isA(Element.class))).thenReturn(true); - replayMocks(); impl.updateEntry(key, callback); - verifyMocks(); + + verify(mockCache).get(key); + verify(mockSerializer).readFrom(isA(InputStream.class)); + verify(mockSerializer).writeTo(same(updatedValue), isA(OutputStream.class)); + verify(mockCache).replace(same(existingElement), isA(Element.class)); } @Test @@ -199,20 +197,18 @@ public class TestEhcacheHttpCacheStorage extends TestCase { }; // get existing old entry, will happen twice - EasyMock.expect(mockCache.get(key)).andReturn(existingElement).times(2); - EasyMock.expect(mockSerializer.readFrom(EasyMock.isA(InputStream.class))).andReturn(existingValue).times(2); + when(mockCache.get(key)).thenReturn(existingElement); + when(mockSerializer.readFrom(isA(InputStream.class))).thenReturn(existingValue); - // update but fail - mockSerializer.writeTo(EasyMock.same(updatedValue), EasyMock.isA(OutputStream.class)); - EasyMock.expectLastCall().times(2); - EasyMock.expect(mockCache.replace(EasyMock.same(existingElement), EasyMock.isA(Element.class))).andReturn(false); + // Fail first and then succeed + when(mockCache.replace(same(existingElement), isA(Element.class))).thenReturn(false).thenReturn(true); - // update again and succeed - EasyMock.expect(mockCache.replace(EasyMock.same(existingElement), EasyMock.isA(Element.class))).andReturn(true); - - replayMocks(); impl.updateEntry(key, callback); - verifyMocks(); + + verify(mockCache, times(2)).get(key); + verify(mockSerializer, times(2)).readFrom(isA(InputStream.class)); + verify(mockSerializer, times(2)).writeTo(same(updatedValue), isA(OutputStream.class)); + verify(mockCache, times(2)).replace(same(existingElement), isA(Element.class)); } @Test @@ -232,19 +228,20 @@ public class TestEhcacheHttpCacheStorage extends TestCase { }; // get existing old entry - EasyMock.expect(mockCache.get(key)).andReturn(existingElement).times(2); - EasyMock.expect(mockSerializer.readFrom(EasyMock.isA(InputStream.class))).andReturn(existingValue).times(2); + when(mockCache.get(key)).thenReturn(existingElement); + when(mockSerializer.readFrom(isA(InputStream.class))).thenReturn(existingValue); // update but fail - mockSerializer.writeTo(EasyMock.same(updatedValue), EasyMock.isA(OutputStream.class)); - EasyMock.expectLastCall().times(2); - EasyMock.expect(mockCache.replace(EasyMock.same(existingElement), EasyMock.isA(Element.class))).andReturn(false).times(2); + when(mockCache.replace(same(existingElement), isA(Element.class))).thenReturn(false); - replayMocks(); try{ impl.updateEntry(key, callback); fail("Expected HttpCacheUpdateException"); } catch (final HttpCacheUpdateException e) { } - verifyMocks(); + + verify(mockCache, times(2)).get(key); + verify(mockSerializer, times(2)).readFrom(isA(InputStream.class)); + verify(mockSerializer, times(2)).writeTo(same(updatedValue), isA(OutputStream.class)); + verify(mockCache, times(2)).replace(same(existingElement), isA(Element.class)); } } diff --git a/httpclient-cache/src/test/java/org/apache/http/impl/client/cache/memcached/TestMemcachedHttpCacheStorage.java b/httpclient-cache/src/test/java/org/apache/http/impl/client/cache/memcached/TestMemcachedHttpCacheStorage.java index 34b4531..a5ac52e 100644 --- a/httpclient-cache/src/test/java/org/apache/http/impl/client/cache/memcached/TestMemcachedHttpCacheStorage.java +++ b/httpclient-cache/src/test/java/org/apache/http/impl/client/cache/memcached/TestMemcachedHttpCacheStorage.java @@ -26,6 +26,13 @@ */ package org.apache.http.impl.client.cache.memcached; +import static org.mockito.Mockito.doThrow; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.times; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.verifyNoMoreInteractions; +import static org.mockito.Mockito.when; + import java.io.IOException; import java.io.UnsupportedEncodingException; @@ -40,7 +47,6 @@ import org.apache.http.client.cache.HttpCacheUpdateCallback; import org.apache.http.client.cache.HttpCacheUpdateException; import org.apache.http.impl.client.cache.CacheConfig; import org.apache.http.impl.client.cache.HttpTestUtils; -import org.easymock.EasyMock; import org.junit.Before; import org.junit.Test; @@ -57,38 +63,18 @@ public class TestMemcachedHttpCacheStorage extends TestCase { @Override @Before public void setUp() throws Exception { - mockMemcachedClient = EasyMock.createNiceMock(MemcachedClientIF.class); - mockKeyHashingScheme = EasyMock.createNiceMock(KeyHashingScheme.class); - mockMemcachedCacheEntryFactory = EasyMock.createNiceMock(MemcachedCacheEntryFactory.class); - mockMemcachedCacheEntry = EasyMock.createNiceMock(MemcachedCacheEntry.class); - mockMemcachedCacheEntry2 = EasyMock.createNiceMock(MemcachedCacheEntry.class); - mockMemcachedCacheEntry3 = EasyMock.createNiceMock(MemcachedCacheEntry.class); - mockMemcachedCacheEntry4 = EasyMock.createNiceMock(MemcachedCacheEntry.class); + mockMemcachedClient = mock(MemcachedClientIF.class); + mockKeyHashingScheme = mock(KeyHashingScheme.class); + mockMemcachedCacheEntryFactory = mock(MemcachedCacheEntryFactory.class); + mockMemcachedCacheEntry = mock(MemcachedCacheEntry.class); + mockMemcachedCacheEntry2 = mock(MemcachedCacheEntry.class); + mockMemcachedCacheEntry3 = mock(MemcachedCacheEntry.class); + mockMemcachedCacheEntry4 = mock(MemcachedCacheEntry.class); final CacheConfig config = CacheConfig.custom().setMaxUpdateRetries(1).build(); impl = new MemcachedHttpCacheStorage(mockMemcachedClient, config, mockMemcachedCacheEntryFactory, mockKeyHashingScheme); } - private void replayMocks() { - EasyMock.replay(mockMemcachedClient); - EasyMock.replay(mockKeyHashingScheme); - EasyMock.replay(mockMemcachedCacheEntry); - EasyMock.replay(mockMemcachedCacheEntry2); - EasyMock.replay(mockMemcachedCacheEntry3); - EasyMock.replay(mockMemcachedCacheEntry4); - EasyMock.replay(mockMemcachedCacheEntryFactory); - } - - private void verifyMocks() { - EasyMock.verify(mockMemcachedClient); - EasyMock.verify(mockKeyHashingScheme); - EasyMock.verify(mockMemcachedCacheEntry); - EasyMock.verify(mockMemcachedCacheEntry2); - EasyMock.verify(mockMemcachedCacheEntry3); - EasyMock.verify(mockMemcachedCacheEntry4); - EasyMock.verify(mockMemcachedCacheEntryFactory); - } - @Test public void testSuccessfulCachePut() throws IOException { final String url = "foo"; @@ -96,18 +82,20 @@ public class TestMemcachedHttpCacheStorage extends TestCase { final HttpCacheEntry value = HttpTestUtils.makeCacheEntry(); final byte[] serialized = HttpTestUtils.getRandomBytes(128); - EasyMock.expect(mockMemcachedCacheEntryFactory.getMemcachedCacheEntry(url, value)) - .andReturn(mockMemcachedCacheEntry); - EasyMock.expect(mockMemcachedCacheEntry.toByteArray()) - .andReturn(serialized); - EasyMock.expect(mockKeyHashingScheme.hash(url)) - .andReturn(key); - EasyMock.expect(mockMemcachedClient.set(key, 0, serialized)) - .andReturn(null); + when(mockMemcachedCacheEntryFactory.getMemcachedCacheEntry(url, value)) + .thenReturn(mockMemcachedCacheEntry); + when(mockMemcachedCacheEntry.toByteArray()) + .thenReturn(serialized); + when(mockKeyHashingScheme.hash(url)) + .thenReturn(key); + when(mockMemcachedClient.set(key, 0, serialized)) + .thenReturn(null); - replayMocks(); impl.putEntry(url, value); - verifyMocks(); + verify(mockMemcachedCacheEntryFactory).getMemcachedCacheEntry(url, value); + verify(mockMemcachedCacheEntry).toByteArray(); + verify(mockKeyHashingScheme).hash(url); + verify(mockMemcachedClient).set(key, 0, serialized); } @Test @@ -116,16 +104,18 @@ public class TestMemcachedHttpCacheStorage extends TestCase { final HttpCacheEntry value = HttpTestUtils.makeCacheEntry(); final byte[] serialized = HttpTestUtils.getRandomBytes(128); - EasyMock.expect(mockMemcachedCacheEntryFactory.getMemcachedCacheEntry(url, value)) - .andReturn(mockMemcachedCacheEntry).times(0,1); - EasyMock.expect(mockMemcachedCacheEntry.toByteArray()) - .andReturn(serialized).times(0,1); - EasyMock.expect(mockKeyHashingScheme.hash(url)) - .andThrow(new MemcachedKeyHashingException(new Exception())); + when(mockMemcachedCacheEntryFactory.getMemcachedCacheEntry(url, value)) + .thenReturn(mockMemcachedCacheEntry); + when(mockMemcachedCacheEntry.toByteArray()) + .thenReturn(serialized); + when(mockKeyHashingScheme.hash(url)) + .thenThrow(new MemcachedKeyHashingException(new Exception())); - replayMocks(); impl.putEntry(url, value); - verifyMocks(); + + verify(mockMemcachedCacheEntryFactory).getMemcachedCacheEntry(url, value); + verify(mockMemcachedCacheEntry).toByteArray(); + verify(mockKeyHashingScheme).hash(url); } public void testThrowsIOExceptionWhenMemcachedPutTimesOut() { @@ -134,22 +124,25 @@ public class TestMemcachedHttpCacheStorage extends TestCase { final HttpCacheEntry value = HttpTestUtils.makeCacheEntry(); final byte[] serialized = HttpTestUtils.getRandomBytes(128); - EasyMock.expect(mockMemcachedCacheEntryFactory.getMemcachedCacheEntry(url, value)) - .andReturn(mockMemcachedCacheEntry); - EasyMock.expect(mockMemcachedCacheEntry.toByteArray()) - .andReturn(serialized); - EasyMock.expect(mockKeyHashingScheme.hash(url)) - .andReturn(key); - EasyMock.expect(mockMemcachedClient.set(key, 0, serialized)) - .andThrow(new OperationTimeoutException("timed out")); + when(mockMemcachedCacheEntryFactory.getMemcachedCacheEntry(url, value)) + .thenReturn(mockMemcachedCacheEntry); + when(mockMemcachedCacheEntry.toByteArray()) + .thenReturn(serialized); + when(mockKeyHashingScheme.hash(url)) + .thenReturn(key); + when(mockMemcachedClient.set(key, 0, serialized)) + .thenThrow(new OperationTimeoutException("timed out")); - replayMocks(); try { impl.putEntry(url, value); fail("should have thrown exception"); } catch (final IOException expected) { } - verifyMocks(); + + verify(mockMemcachedCacheEntryFactory).getMemcachedCacheEntry(url, value); + verify(mockMemcachedCacheEntry).toByteArray(); + verify(mockKeyHashingScheme).hash(url); + verify(mockMemcachedClient).set(key, 0, serialized); } @Test @@ -158,21 +151,20 @@ public class TestMemcachedHttpCacheStorage extends TestCase { final String key = "key"; final HttpCacheEntry value = HttpTestUtils.makeCacheEntry(); - EasyMock.expect(mockMemcachedCacheEntryFactory.getMemcachedCacheEntry(url, value)) - .andReturn(mockMemcachedCacheEntry); - EasyMock.expect(mockMemcachedCacheEntry.toByteArray()) - .andThrow(new MemcachedSerializationException(new Exception())); - EasyMock.expect(mockKeyHashingScheme.hash(url)) - .andReturn(key).times(0,1); + when(mockMemcachedCacheEntryFactory.getMemcachedCacheEntry(url, value)) + .thenReturn(mockMemcachedCacheEntry); + when(mockMemcachedCacheEntry.toByteArray()) + .thenThrow(new MemcachedSerializationException(new Exception())); - replayMocks(); try { impl.putEntry(url, value); fail("should have thrown exception"); } catch (final IOException expected) { } - verifyMocks(); + + verify(mockMemcachedCacheEntryFactory).getMemcachedCacheEntry(url, value); + verify(mockMemcachedCacheEntry).toByteArray(); } @Test @@ -183,17 +175,22 @@ public class TestMemcachedHttpCacheStorage extends TestCase { final byte[] serialized = HttpTestUtils.getRandomBytes(128); final HttpCacheEntry cacheEntry = HttpTestUtils.makeCacheEntry(); - EasyMock.expect(mockKeyHashingScheme.hash(url)).andReturn(key); - EasyMock.expect(mockMemcachedClient.get(key)).andReturn(serialized); - EasyMock.expect(mockMemcachedCacheEntryFactory.getUnsetCacheEntry()) - .andReturn(mockMemcachedCacheEntry); - mockMemcachedCacheEntry.set(serialized); - EasyMock.expect(mockMemcachedCacheEntry.getStorageKey()).andReturn(url); - EasyMock.expect(mockMemcachedCacheEntry.getHttpCacheEntry()).andReturn(cacheEntry); + when(mockKeyHashingScheme.hash(url)).thenReturn(key); + when(mockMemcachedClient.get(key)).thenReturn(serialized); + when(mockMemcachedCacheEntryFactory.getUnsetCacheEntry()) + .thenReturn(mockMemcachedCacheEntry); + when(mockMemcachedCacheEntry.getStorageKey()).thenReturn(url); + when(mockMemcachedCacheEntry.getHttpCacheEntry()).thenReturn(cacheEntry); - replayMocks(); final HttpCacheEntry resultingEntry = impl.getEntry(url); - verifyMocks(); + + verify(mockKeyHashingScheme).hash(url); + verify(mockMemcachedClient).get(key); + verify(mockMemcachedCacheEntryFactory).getUnsetCacheEntry(); + verify(mockMemcachedCacheEntry).set(serialized); + verify(mockMemcachedCacheEntry).getStorageKey(); + verify(mockMemcachedCacheEntry).getHttpCacheEntry(); + assertSame(cacheEntry, resultingEntry); } @@ -203,12 +200,14 @@ public class TestMemcachedHttpCacheStorage extends TestCase { final String url = "foo"; final String key = "key"; - EasyMock.expect(mockKeyHashingScheme.hash(url)).andReturn(key); - EasyMock.expect(mockMemcachedClient.get(key)).andReturn(new Object()); + when(mockKeyHashingScheme.hash(url)).thenReturn(key); + when(mockMemcachedClient.get(key)).thenReturn(new Object()); - replayMocks(); final HttpCacheEntry resultingEntry = impl.getEntry(url); - verifyMocks(); + + verify(mockKeyHashingScheme).hash(url); + verify(mockMemcachedClient).get(key); + assertNull(resultingEntry); } @@ -218,12 +217,14 @@ public class TestMemcachedHttpCacheStorage extends TestCase { final String url = "foo"; final String key = "key"; - EasyMock.expect(mockKeyHashingScheme.hash(url)).andReturn(key); - EasyMock.expect(mockMemcachedClient.get(key)).andReturn(null); + when(mockKeyHashingScheme.hash(url)).thenReturn(key); + when(mockMemcachedClient.get(key)).thenReturn(null); - replayMocks(); final HttpCacheEntry resultingEntry = impl.getEntry(url); - verifyMocks(); + + verify(mockKeyHashingScheme).hash(url); + verify(mockMemcachedClient).get(key); + assertNull(resultingEntry); } @@ -234,16 +235,18 @@ public class TestMemcachedHttpCacheStorage extends TestCase { final String key = "key"; final byte[] serialized = HttpTestUtils.getRandomBytes(128); - EasyMock.expect(mockKeyHashingScheme.hash(url)).andReturn(key); - EasyMock.expect(mockMemcachedClient.get(key)).andReturn(serialized); - EasyMock.expect(mockMemcachedCacheEntryFactory.getUnsetCacheEntry()) - .andReturn(mockMemcachedCacheEntry); - mockMemcachedCacheEntry.set(serialized); - EasyMock.expectLastCall().andThrow(new MemcachedSerializationException(new Exception())); + when(mockKeyHashingScheme.hash(url)).thenReturn(key); + when(mockMemcachedClient.get(key)).thenReturn(serialized); + when(mockMemcachedCacheEntryFactory.getUnsetCacheEntry()) + .thenReturn(mockMemcachedCacheEntry); + doThrow(new MemcachedSerializationException(new Exception())).when(mockMemcachedCacheEntry).set(serialized); - replayMocks(); assertNull(impl.getEntry(url)); - verifyMocks(); + + verify(mockKeyHashingScheme).hash(url); + verify(mockMemcachedClient).get(key); + verify(mockMemcachedCacheEntryFactory).getUnsetCacheEntry(); + verify(mockMemcachedCacheEntry).set(serialized); } @Test @@ -251,65 +254,66 @@ public class TestMemcachedHttpCacheStorage extends TestCase { IOException { final String url = "foo"; - EasyMock.expect(mockKeyHashingScheme.hash(url)).andThrow(new MemcachedKeyHashingException(new Exception())); + when(mockKeyHashingScheme.hash(url)).thenThrow(new MemcachedKeyHashingException(new Exception())); - replayMocks(); assertNull(impl.getEntry(url)); - verifyMocks(); + verify(mockKeyHashingScheme).hash(url); } @Test public void testThrowsIOExceptionIfMemcachedTimesOutOnGet() { final String url = "foo"; final String key = "key"; - EasyMock.expect(mockKeyHashingScheme.hash(url)).andReturn(key); - EasyMock.expect(mockMemcachedClient.get(key)) - .andThrow(new OperationTimeoutException("")); + when(mockKeyHashingScheme.hash(url)).thenReturn(key); + when(mockMemcachedClient.get(key)) + .thenThrow(new OperationTimeoutException("")); - replayMocks(); try { impl.getEntry(url); fail("should have thrown exception"); } catch (final IOException expected) { } - verifyMocks(); + verify(mockKeyHashingScheme).hash(url); + verify(mockMemcachedClient).get(key); } @Test public void testCacheRemove() throws IOException { final String url = "foo"; final String key = "key"; - EasyMock.expect(mockKeyHashingScheme.hash(url)).andReturn(key); - EasyMock.expect(mockMemcachedClient.delete(key)).andReturn(null); - replayMocks(); + when(mockKeyHashingScheme.hash(url)).thenReturn(key); + when(mockMemcachedClient.delete(key)).thenReturn(null); + impl.removeEntry(url); - verifyMocks(); + + verify(mockKeyHashingScheme).hash(url); + verify(mockMemcachedClient).delete(key); } @Test public void testCacheRemoveHandlesKeyHashingFailure() throws IOException { final String url = "foo"; - EasyMock.expect(mockKeyHashingScheme.hash(url)).andReturn(null); - replayMocks(); + when(mockKeyHashingScheme.hash(url)).thenReturn(null); impl.removeEntry(url); - verifyMocks(); + verify(mockKeyHashingScheme).hash(url); } @Test public void testCacheRemoveThrowsIOExceptionOnMemcachedTimeout() { final String url = "foo"; final String key = "key"; - EasyMock.expect(mockKeyHashingScheme.hash(url)).andReturn(key); - EasyMock.expect(mockMemcachedClient.delete(key)) - .andThrow(new OperationTimeoutException("")); + when(mockKeyHashingScheme.hash(url)).thenReturn(key); + when(mockMemcachedClient.delete(key)) + .thenThrow(new OperationTimeoutException("")); - replayMocks(); try { impl.removeEntry(url); fail("should have thrown exception"); } catch (final IOException expected) { } - verifyMocks(); + + verify(mockKeyHashingScheme).hash(url); + verify(mockMemcachedClient).delete(key); } @Test @@ -329,18 +333,22 @@ public class TestMemcachedHttpCacheStorage extends TestCase { }; // get empty old entry - EasyMock.expect(mockKeyHashingScheme.hash(url)).andReturn(key).anyTimes(); - EasyMock.expect(mockMemcachedClient.gets(key)).andReturn(null); - EasyMock.expect(mockMemcachedCacheEntryFactory.getMemcachedCacheEntry(url, updatedValue)) - .andReturn(mockMemcachedCacheEntry); - EasyMock.expect(mockMemcachedCacheEntry.toByteArray()).andReturn(serialized); - EasyMock.expect( - mockMemcachedClient.set(EasyMock.eq(key), EasyMock.eq(0), - EasyMock.aryEq(serialized))).andReturn(null); - - replayMocks(); + when(mockKeyHashingScheme.hash(url)).thenReturn(key); + when(mockMemcachedClient.gets(key)).thenReturn(null); + when(mockMemcachedCacheEntryFactory.getMemcachedCacheEntry(url, updatedValue)) + .thenReturn(mockMemcachedCacheEntry); + when(mockMemcachedCacheEntry.toByteArray()).thenReturn(serialized); + when( + mockMemcachedClient.set(key, 0, + serialized)).thenReturn(null); + impl.updateEntry(url, callback); - verifyMocks(); + + verify(mockKeyHashingScheme, times(2)).hash(url); + verify(mockMemcachedClient).gets(key); + verify(mockMemcachedCacheEntryFactory).getMemcachedCacheEntry(url, updatedValue); + verify(mockMemcachedCacheEntry).toByteArray(); + verify(mockMemcachedClient).set(key, 0, serialized); } @Test @@ -362,23 +370,28 @@ public class TestMemcachedHttpCacheStorage extends TestCase { }; // get empty old entry - EasyMock.expect(mockKeyHashingScheme.hash(url)).andReturn(key).anyTimes(); - EasyMock.expect(mockMemcachedClient.gets(key)).andReturn(casValue); - EasyMock.expect(mockMemcachedCacheEntryFactory.getUnsetCacheEntry()) - .andReturn(mockMemcachedCacheEntry); - mockMemcachedCacheEntry.set(oldBytes); - EasyMock.expect(mockMemcachedCacheEntry.getStorageKey()).andReturn("not" + url).anyTimes(); - - EasyMock.expect(mockMemcachedCacheEntryFactory.getMemcachedCacheEntry(url, updatedValue)) - .andReturn(mockMemcachedCacheEntry2); - EasyMock.expect(mockMemcachedCacheEntry2.toByteArray()).andReturn(newBytes); - EasyMock.expect( - mockMemcachedClient.set(EasyMock.eq(key), EasyMock.eq(0), - EasyMock.aryEq(newBytes))).andReturn(null); - - replayMocks(); + when(mockKeyHashingScheme.hash(url)).thenReturn(key); + when(mockMemcachedClient.gets(key)).thenReturn(casValue); + when(mockMemcachedCacheEntryFactory.getUnsetCacheEntry()) + .thenReturn(mockMemcachedCacheEntry); + when(mockMemcachedCacheEntry.getStorageKey()).thenReturn("not" + url); + + when(mockMemcachedCacheEntryFactory.getMemcachedCacheEntry(url, updatedValue)) + .thenReturn(mockMemcachedCacheEntry2); + when(mockMemcachedCacheEntry2.toByteArray()).thenReturn(newBytes); + when( + mockMemcachedClient.set(key, 0, + newBytes)).thenReturn(null); + impl.updateEntry(url, callback); - verifyMocks(); + + verify(mockKeyHashingScheme, times(2)).hash(url); + verify(mockMemcachedClient).gets(key); + verify(mockMemcachedCacheEntryFactory).getUnsetCacheEntry(); + verify(mockMemcachedCacheEntry).getStorageKey(); + verify(mockMemcachedCacheEntryFactory).getMemcachedCacheEntry(url, updatedValue); + verify(mockMemcachedCacheEntry2).toByteArray(); + verify(mockMemcachedClient).set(key, 0, newBytes); } @Test @@ -402,25 +415,31 @@ public class TestMemcachedHttpCacheStorage extends TestCase { }; // get empty old entry - EasyMock.expect(mockKeyHashingScheme.hash(url)).andReturn(key).anyTimes(); - EasyMock.expect(mockMemcachedClient.gets(key)).andReturn(casValue); - EasyMock.expect(mockMemcachedCacheEntryFactory.getUnsetCacheEntry()) - .andReturn(mockMemcachedCacheEntry); - mockMemcachedCacheEntry.set(oldBytes); - EasyMock.expect(mockMemcachedCacheEntry.getStorageKey()).andReturn(url); - EasyMock.expect(mockMemcachedCacheEntry.getHttpCacheEntry()).andReturn(existingValue); - - EasyMock.expect(mockMemcachedCacheEntryFactory.getMemcachedCacheEntry(url, updatedValue)) - .andReturn(mockMemcachedCacheEntry2); - EasyMock.expect(mockMemcachedCacheEntry2.toByteArray()).andReturn(newBytes); - - EasyMock.expect( - mockMemcachedClient.cas(EasyMock.eq(key), EasyMock.eq(casValue.getCas()), - EasyMock.aryEq(newBytes))).andReturn(CASResponse.OK); - - replayMocks(); + when(mockKeyHashingScheme.hash(url)).thenReturn(key); + when(mockMemcachedClient.gets(key)).thenReturn(casValue); + when(mockMemcachedCacheEntryFactory.getUnsetCacheEntry()) + .thenReturn(mockMemcachedCacheEntry); + when(mockMemcachedCacheEntry.getStorageKey()).thenReturn(url); + when(mockMemcachedCacheEntry.getHttpCacheEntry()).thenReturn(existingValue); + + when(mockMemcachedCacheEntryFactory.getMemcachedCacheEntry(url, updatedValue)) + .thenReturn(mockMemcachedCacheEntry2); + when(mockMemcachedCacheEntry2.toByteArray()).thenReturn(newBytes); + + when( + mockMemcachedClient.cas(key, casValue.getCas(), + newBytes)).thenReturn(CASResponse.OK); + impl.updateEntry(url, callback); - verifyMocks(); + + verify(mockKeyHashingScheme).hash(url); + verify(mockMemcachedClient).gets(key); + verify(mockMemcachedCacheEntryFactory).getUnsetCacheEntry(); + verify(mockMemcachedCacheEntry).getStorageKey(); + verify(mockMemcachedCacheEntry).getHttpCacheEntry(); + verify(mockMemcachedCacheEntryFactory).getMemcachedCacheEntry(url, updatedValue); + verify(mockMemcachedCacheEntry2).toByteArray(); + verify(mockMemcachedClient).cas(key, casValue.getCas(), newBytes); } @Test @@ -446,29 +465,35 @@ public class TestMemcachedHttpCacheStorage extends TestCase { }; // get empty old entry - EasyMock.expect(mockKeyHashingScheme.hash(url)).andReturn(key).anyTimes(); - EasyMock.expect(mockMemcachedClient.gets(key)).andReturn(casValue); - EasyMock.expect(mockMemcachedCacheEntryFactory.getUnsetCacheEntry()) - .andReturn(mockMemcachedCacheEntry); - mockMemcachedCacheEntry.set(oldBytes); - EasyMock.expect(mockMemcachedCacheEntry.getStorageKey()).andReturn(url); - EasyMock.expect(mockMemcachedCacheEntry.getHttpCacheEntry()).andReturn(existingValue); - - EasyMock.expect(mockMemcachedCacheEntryFactory.getMemcachedCacheEntry(url, updatedValue)) - .andReturn(mockMemcachedCacheEntry2); - EasyMock.expect(mockMemcachedCacheEntry2.toByteArray()).andReturn(newBytes); - - EasyMock.expect( - mockMemcachedClient.cas(EasyMock.eq(key), EasyMock.eq(casValue.getCas()), - EasyMock.aryEq(newBytes))).andReturn(CASResponse.EXISTS); - - replayMocks(); + when(mockKeyHashingScheme.hash(url)).thenReturn(key); + when(mockMemcachedClient.gets(key)).thenReturn(casValue); + when(mockMemcachedCacheEntryFactory.getUnsetCacheEntry()) + .thenReturn(mockMemcachedCacheEntry); + when(mockMemcachedCacheEntry.getStorageKey()).thenReturn(url); + when(mockMemcachedCacheEntry.getHttpCacheEntry()).thenReturn(existingValue); + + when(mockMemcachedCacheEntryFactory.getMemcachedCacheEntry(url, updatedValue)) + .thenReturn(mockMemcachedCacheEntry2); + when(mockMemcachedCacheEntry2.toByteArray()).thenReturn(newBytes); + + when( + mockMemcachedClient.cas(key, casValue.getCas(), + newBytes)).thenReturn(CASResponse.EXISTS); + try { impl.updateEntry(url, callback); fail("should have thrown exception"); } catch (final HttpCacheUpdateException expected) { } - verifyMocks(); + + verify(mockKeyHashingScheme).hash(url); + verify(mockMemcachedClient).gets(key); + verify(mockMemcachedCacheEntryFactory).getUnsetCacheEntry(); + verify(mockMemcachedCacheEntry).getStorageKey(); + verify(mockMemcachedCacheEntry).getHttpCacheEntry(); + verify(mockMemcachedCacheEntryFactory).getMemcachedCacheEntry(url, updatedValue); + verify(mockMemcachedCacheEntry2).toByteArray(); + verify(mockMemcachedClient).cas(key, casValue.getCas(), newBytes); } @@ -481,11 +506,8 @@ public class TestMemcachedHttpCacheStorage extends TestCase { final HttpCacheEntry existingValue2 = HttpTestUtils.makeCacheEntry(); final HttpCacheEntry updatedValue = HttpTestUtils.makeCacheEntry(); final HttpCacheEntry updatedValue2 = HttpTestUtils.makeCacheEntry(); - final byte[] oldBytes = HttpTestUtils.getRandomBytes(128); final byte[] oldBytes2 = HttpTestUtils.getRandomBytes(128); - final CASValue casValue = new CASValue(1, oldBytes); final CASValue casValue2 = new CASValue(2, oldBytes2); - final byte[] newBytes = HttpTestUtils.getRandomBytes(128); final byte[] newBytes2 = HttpTestUtils.getRandomBytes(128); final HttpCacheUpdateCallback callback = new HttpCacheUpdateCallback() { @@ -499,41 +521,43 @@ public class TestMemcachedHttpCacheStorage extends TestCase { } }; - EasyMock.expect(mockKeyHashingScheme.hash(url)).andReturn(key).anyTimes(); - EasyMock.expect(mockMemcachedClient.gets(key)).andReturn(casValue); - EasyMock.expect(mockMemcachedCacheEntryFactory.getUnsetCacheEntry()) - .andReturn(mockMemcachedCacheEntry); - mockMemcachedCacheEntry.set(oldBytes); - EasyMock.expect(mockMemcachedCacheEntry.getStorageKey()).andReturn(url); - EasyMock.expect(mockMemcachedCacheEntry.getHttpCacheEntry()).andReturn(existingValue); + when(mockKeyHashingScheme.hash(url)).thenReturn(key); - EasyMock.expect(mockMemcachedCacheEntryFactory.getMemcachedCacheEntry(url, updatedValue)) - .andReturn(mockMemcachedCacheEntry2); - EasyMock.expect(mockMemcachedCacheEntry2.toByteArray()).andReturn(newBytes); + // take two + when(mockMemcachedClient.gets(key)).thenReturn(casValue2); + when(mockMemcachedCacheEntryFactory.getUnsetCacheEntry()) + .thenReturn(mockMemcachedCacheEntry3); + when(mockMemcachedCacheEntry3.getStorageKey()).thenReturn(url); + when(mockMemcachedCacheEntry3.getHttpCacheEntry()).thenReturn(existingValue2); - EasyMock.expect( - mockMemcachedClient.cas(EasyMock.eq(key), EasyMock.eq(casValue.getCas()), - EasyMock.aryEq(newBytes))).andReturn(CASResponse.EXISTS); + when(mockMemcachedCacheEntryFactory.getMemcachedCacheEntry(url, updatedValue2)) + .thenReturn(mockMemcachedCacheEntry4); + when(mockMemcachedCacheEntry4.toByteArray()).thenReturn(newBytes2); + + when( + mockMemcachedClient.cas(key, casValue2.getCas(), + newBytes2)).thenReturn(CASResponse.OK); - // take two - EasyMock.expect(mockMemcachedClient.gets(key)).andReturn(casValue2); - EasyMock.expect(mockMemcachedCacheEntryFactory.getUnsetCacheEntry()) - .andReturn(mockMemcachedCacheEntry3); - mockMemcachedCacheEntry3.set(oldBytes2); - EasyMock.expect(mockMemcachedCacheEntry3.getStorageKey()).andReturn(url); - EasyMock.expect(mockMemcachedCacheEntry3.getHttpCacheEntry()).andReturn(existingValue2); - - EasyMock.expect(mockMemcachedCacheEntryFactory.getMemcachedCacheEntry(url, updatedValue2)) - .andReturn(mockMemcachedCacheEntry4); - EasyMock.expect(mockMemcachedCacheEntry4.toByteArray()).andReturn(newBytes2); - - EasyMock.expect( - mockMemcachedClient.cas(EasyMock.eq(key), EasyMock.eq(casValue2.getCas()), - EasyMock.aryEq(newBytes2))).andReturn(CASResponse.OK); - - replayMocks(); impl.updateEntry(url, callback); - verifyMocks(); + + verify(mockKeyHashingScheme).hash(url); + verify(mockMemcachedClient).gets(key); + verify(mockMemcachedCacheEntryFactory).getUnsetCacheEntry(); + + verify(mockMemcachedCacheEntry3).set(oldBytes2); + verify(mockMemcachedCacheEntry3).getStorageKey(); + verify(mockMemcachedCacheEntry3).getHttpCacheEntry(); + verify(mockMemcachedCacheEntryFactory).getMemcachedCacheEntry(url, updatedValue2); + verify(mockMemcachedCacheEntry4).toByteArray(); + verify(mockMemcachedClient).cas(key, casValue2.getCas(), newBytes2); + + verifyNoMoreInteractions(mockMemcachedClient); + verifyNoMoreInteractions(mockKeyHashingScheme); + verifyNoMoreInteractions(mockMemcachedCacheEntry); + verifyNoMoreInteractions(mockMemcachedCacheEntry2); + verifyNoMoreInteractions(mockMemcachedCacheEntry3); + verifyNoMoreInteractions(mockMemcachedCacheEntry4); + verifyNoMoreInteractions(mockMemcachedCacheEntryFactory); } @@ -552,17 +576,18 @@ public class TestMemcachedHttpCacheStorage extends TestCase { }; // get empty old entry - EasyMock.expect(mockKeyHashingScheme.hash(url)).andReturn(key).anyTimes(); - EasyMock.expect(mockMemcachedClient.gets(key)) - .andThrow(new OperationTimeoutException("")); + when(mockKeyHashingScheme.hash(url)).thenReturn(key); + when(mockMemcachedClient.gets(key)) + .thenThrow(new OperationTimeoutException("")); - replayMocks(); try { impl.updateEntry(url, callback); fail("should have thrown exception"); } catch (final IOException expected) { } - verifyMocks(); + + verify(mockKeyHashingScheme).hash(url); + verify(mockMemcachedClient).gets(key); } @@ -570,15 +595,15 @@ public class TestMemcachedHttpCacheStorage extends TestCase { public void testThrowsExceptionOnUpdateIfCannotHashStorageKey() throws Exception { final String url = "foo"; - EasyMock.expect(mockKeyHashingScheme.hash(url)) - .andThrow(new MemcachedKeyHashingException(new Exception())); + when(mockKeyHashingScheme.hash(url)) + .thenThrow(new MemcachedKeyHashingException(new Exception())); - replayMocks(); try { impl.updateEntry(url, null); fail("should have thrown exception"); } catch (final HttpCacheUpdateException expected) { } - verifyMocks(); + + verify(mockKeyHashingScheme).hash(url); } } -- 1.8.3.1