public static ClassicHttpResponse make500Response() { return new BasicClassicHttpResponse(HttpStatus.SC_INTERNAL_SERVER_ERROR, "Internal Server Error"); }
@Test public void testResponseContentEntityChunkedHTTP10() throws Exception { final HttpContext context = new BasicHttpContext(null); context.setProtocolVersion(HttpVersion.HTTP_1_0); final BasicClassicHttpResponse response = new BasicClassicHttpResponse(HttpStatus.SC_OK, "OK"); final BasicHttpEntity entity = new BasicHttpEntity(); entity.setChunked(true); response.setEntity(entity); final ResponseContent interceptor = new ResponseContent(); interceptor.process(response, response.getEntity(), context); final Header h1 = response.getFirstHeader(HttpHeaders.TRANSFER_ENCODING); Assert.assertNull(h1); final Header h2 = response.getFirstHeader(HttpHeaders.CONTENT_LENGTH); Assert.assertNull(h2); }
@Test public void testResponseConnControlEntityUnknownContentLengthHTTP10() throws Exception { final HttpContext context = new BasicHttpContext(null); context.setProtocolVersion(HttpVersion.HTTP_1_0); final BasicClassicHttpRequest request = new BasicClassicHttpRequest("GET", "/"); request.addHeader(new BasicHeader(HttpHeaders.CONNECTION, "keep-alive")); context.setAttribute(HttpCoreContext.HTTP_REQUEST, request); final BasicClassicHttpResponse response = new BasicClassicHttpResponse(HttpStatus.SC_OK, "OK"); final BasicHttpEntity entity = new BasicHttpEntity(); response.setEntity(entity); final ResponseConnControl interceptor = new ResponseConnControl(); interceptor.process(response, response.getEntity(), context); final Header header = response.getFirstHeader(HttpHeaders.CONNECTION); Assert.assertNotNull(header); Assert.assertEquals("close", header.getValue()); }
public static ClassicHttpResponse make304Response() { return new BasicClassicHttpResponse(HttpStatus.SC_NOT_MODIFIED, "Not modified"); }
private ClassicHttpResponse handleCacheMiss( final HttpHost target, final ClassicHttpRequest request, final ExecChain.Scope scope, final ExecChain chain) throws IOException, HttpException { recordCacheMiss(target, request); if (!mayCallBackend(request)) { return new BasicClassicHttpResponse(HttpStatus.SC_GATEWAY_TIMEOUT, "Gateway Timeout"); } final Map<String, Variant> variants = responseCache.getVariantCacheEntriesWithEtags(target, request); if (variants != null && !variants.isEmpty()) { return negotiateResponseFromVariants(target, request, scope, chain, variants); } return callBackend(target, request, scope, chain); }
private void testRequestIsWrittenThroughToOrigin(final ClassicHttpRequest req) throws Exception { final ClassicHttpResponse resp = new BasicClassicHttpResponse(HttpStatus.SC_NO_CONTENT, "No Content"); final ClassicHttpRequest wrapper = req; EasyMock.expect( mockExecChain.proceed( eqRequest(wrapper), EasyMock.isA(ExecChain.Scope.class))).andReturn(resp); replayMocks(); execute(wrapper); verifyMocks(); }
private ClassicHttpResponse make200Response() { final ClassicHttpResponse out = new BasicClassicHttpResponse(HttpStatus.SC_OK, "OK"); out.setHeader("Date", DateUtils.formatDate(new Date())); out.setHeader("Server", "MockOrigin/1.0"); out.setEntity(makeBody(128)); return out; }
@Test public void testOrderOfMultipleAllowHeadersIsPreservedOnResponses() throws Exception { originResponse = new BasicClassicHttpResponse(405, "Method Not Allowed"); originResponse.addHeader("Allow", "HEAD"); originResponse.addHeader("Allow", "DELETE"); testOrderOfMultipleHeadersIsPreservedOnResponses("Allow"); }
public static ClassicHttpResponse make200Response() { final ClassicHttpResponse out = new BasicClassicHttpResponse(HttpStatus.SC_OK, "OK"); out.setHeader("Date", DateUtils.formatDate(new Date())); out.setHeader("Server", "MockOrigin/1.0"); out.setHeader("Content-Length", "128"); out.setEntity(makeBody(128)); return out; }
@Test public void testPassesOnOrigin405WithoutAllowHeader() throws Exception { originResponse = new BasicClassicHttpResponse(405, "Method Not Allowed"); EasyMock.expect( mockExecChain.proceed( EasyMock.isA(ClassicHttpRequest.class), EasyMock.isA(ExecChain.Scope.class))).andReturn(originResponse); replayMocks(); final HttpResponse result = execute(request); verifyMocks(); Assert.assertSame(originResponse, result); }
@Test public void testPassesOnOrigin401ResponseWithoutWWWAuthenticateHeader() throws Exception { originResponse = new BasicClassicHttpResponse(401, "Unauthorized"); EasyMock.expect( mockExecChain.proceed( EasyMock.isA(ClassicHttpRequest.class), EasyMock.isA(ExecChain.Scope.class))).andReturn(originResponse); replayMocks(); final HttpResponse result = execute(request); verifyMocks(); Assert.assertSame(originResponse, result); }
@Test public void testPassesOnOrigin407WithoutAProxyAuthenticateHeader() throws Exception { originResponse = new BasicClassicHttpResponse(407, "Proxy Authentication Required"); EasyMock.expect( mockExecChain.proceed( EasyMock.isA(ClassicHttpRequest.class), EasyMock.isA(ExecChain.Scope.class))).andReturn(originResponse); replayMocks(); final HttpResponse result = execute(request); verifyMocks(); Assert.assertSame(originResponse, result); }
@Test public void testMustNotAddMultipartByteRangeContentTypeTo416Response() throws Exception { originResponse = new BasicClassicHttpResponse(416, "Requested Range Not Satisfiable"); EasyMock.expect( mockExecChain.proceed( EasyMock.isA(ClassicHttpRequest.class), EasyMock.isA(ExecChain.Scope.class))).andReturn(originResponse); replayMocks(); final ClassicHttpResponse result = execute(request); verifyMocks(); if (result.getCode() == 416) { final Iterator<HeaderElement> it = MessageSupport.iterate(result, HttpHeaders.CONTENT_TYPE); while (it.hasNext()) { final HeaderElement elt = it.next(); Assert.assertFalse("multipart/byteranges".equalsIgnoreCase(elt.getName())); } } }
@Test public void test204ResponsesDoNotContainMessageBodies() throws Exception { originResponse = new BasicClassicHttpResponse(HttpStatus.SC_NO_CONTENT, "No Content"); originResponse.setEntity(HttpTestUtils.makeBody(entityLength)); EasyMock.expect( mockExecChain.proceed( EasyMock.isA(ClassicHttpRequest.class), EasyMock.isA(ExecChain.Scope.class))).andReturn(originResponse); replayMocks(); final ClassicHttpResponse result = execute(request); verifyMocks(); }
@Test public void testTooLargeResponsesAreNotCached() throws Exception { mockCache = EasyMock.createStrictMock(HttpCache.class); impl = createCachingExecChain(mockCache, mockValidityPolicy, mockResponsePolicy, mockResponseGenerator, mockRequestPolicy, mockSuitabilityChecker, mockResponseProtocolCompliance, mockRequestProtocolCompliance, mockCacheRevalidator, mockConditionalRequestBuilder, config); final HttpHost host = new HttpHost("foo.example.com"); final ClassicHttpRequest request = new HttpGet("http://foo.example.com/bar"); final Date now = new Date(); final Date requestSent = new Date(now.getTime() - 3 * 1000L); final Date responseGenerated = new Date(now.getTime() - 2 * 1000L); final Date responseReceived = new Date(now.getTime() - 1 * 1000L); final ClassicHttpResponse originResponse = new BasicClassicHttpResponse(HttpStatus.SC_OK, "OK"); originResponse.setEntity(HttpTestUtils.makeBody(CacheConfig.DEFAULT_MAX_OBJECT_SIZE_BYTES + 1)); originResponse.setHeader("Cache-Control","public, max-age=3600"); originResponse.setHeader("Date", DateUtils.formatDate(responseGenerated)); originResponse.setHeader("ETag", "\"etag\""); replayMocks(); final ExecChain.Scope scope = new ExecChain.Scope("test", route, request, mockEndpoint, context); impl.cacheAndReturnResponse(host, request, originResponse, scope, requestSent, responseReceived); verifyMocks(); }
private static ClassicHttpResponse convert(final SimpleHttpResponse cacheResponse, final ExecChain.Scope scope) { if (cacheResponse == null) { return null; } final ClassicHttpResponse response = new BasicClassicHttpResponse(cacheResponse.getCode(), cacheResponse.getReasonPhrase()); for (final Iterator<Header> it = cacheResponse.headerIterator(); it.hasNext(); ) { response.addHeader(it.next()); } response.setVersion(cacheResponse.getVersion() != null ? cacheResponse.getVersion() : HttpVersion.DEFAULT); final SimpleBody body = cacheResponse.getBody(); if (body != null) { if (body.isText()) { response.setEntity(new StringEntity(body.getBodyText(), body.getContentType())); } else { response.setEntity(new ByteArrayEntity(body.getBodyBytes(), body.getContentType())); } } scope.clientContext.setAttribute(HttpCoreContext.HTTP_RESPONSE, response); return response; }
@Test public void testViaHeaderOnResponseProperlyRecordsOriginProtocol() throws Exception { originResponse = new BasicClassicHttpResponse(HttpStatus.SC_NO_CONTENT, "No Content"); originResponse.setVersion(HttpVersion.HTTP_1_0); backendExpectsAnyRequest().andReturn(originResponse); replayMocks(); final ClassicHttpResponse result = execute(request); verifyMocks(); final String via = result.getFirstHeader("Via").getValue(); final String protocol = via.split("\\s+")[0]; final String[] protoParts = protocol.split("/"); Assert.assertTrue(protoParts.length >= 1); Assert.assertTrue(protoParts.length <= 2); if (protoParts.length > 1) { Assert.assertTrue("http".equalsIgnoreCase(protoParts[0])); } Assert.assertEquals("1.0", protoParts[protoParts.length - 1]); }
@Test public void testDoesNotModifyContentRangeHeaderFromOriginResponseWithNoTransform() throws Exception { request.setHeader("If-Range","\"etag\""); request.setHeader("Range","bytes=0-49"); originResponse = new BasicClassicHttpResponse(206, "Partial Content"); originResponse.setEntity(HttpTestUtils.makeBody(50)); testDoesNotModifyHeaderFromOriginResponseWithNoTransform("Content-Range","bytes 0-49/128"); }
@Test public void testMustIncludeAllowHeaderFromAnOrigin405Response() throws Exception { originResponse = new BasicClassicHttpResponse(405, "Method Not Allowed"); originResponse.setHeader("Allow", "GET, HEAD"); backendExpectsAnyRequest().andReturn(originResponse); replayMocks(); final ClassicHttpResponse result = execute(request); if (result.getCode() == 405) { Assert.assertNotNull(result.getFirstHeader("Allow")); } verifyMocks(); }
private void testUnknownResponseStatusCodeIsNotCached(final int code) throws Exception { emptyMockCacheExpectsNoPuts(); originResponse = new BasicClassicHttpResponse(code, "Moo"); originResponse.setHeader("Date", DateUtils.formatDate(new Date())); originResponse.setHeader("Server", "MockOrigin/1.0"); originResponse.setHeader("Cache-Control", "max-age=3600"); originResponse.setEntity(body); EasyMock.expect( mockExecChain.proceed( EasyMock.isA(ClassicHttpRequest.class), EasyMock.isA(ExecChain.Scope.class))).andReturn(originResponse); replayMocks(); execute(request); // in particular, there were no storage calls on the cache verifyMocks(); }