public void saveContent(final File file) throws IOException { assertNotConsumed(); final int status = response.getCode(); if (status >= HttpStatus.SC_REDIRECTION) { throw new HttpResponseException(status, response.getReasonPhrase()); } try (FileOutputStream out = new FileOutputStream(file)) { final HttpEntity entity = this.response.getEntity(); if (entity != null) { entity.writeTo(out); } } finally { this.consumed = true; } }
resp1.setHeader("Date", DateUtils.formatDate(now)); resp1.setHeader("Cache-Control", "public, max-age=60"); resp1.setHeader("Expires", DateUtils.formatDate(inOneMinute)); resp1.setHeader("Etag", "etag"); resp1.setHeader("Vary", "Accept-Encoding"); resp2.setHeader("Date", DateUtils.formatDate(now)); resp2.setHeader("Cache-Control", "public, max-age=60"); resp2.setHeader("Expires", DateUtils.formatDate(inOneMinute)); resp2.setHeader("Etag", "etag"); resp2.setHeader("Vary", "Accept-Encoding"); resp2.setEntity(HttpTestUtils.makeBody(128)); verifyMocks(); assertEquals(HttpStatus.SC_NOT_MODIFIED, result1.getCode()); assertNull(result1.getEntity()); assertEquals(HttpStatus.SC_OK, result2.getCode()); Assert.assertNotNull(result2.getEntity());
final String dateHdr = DateUtils.formatDate(new Date()); final String origWarning = "110 fred \"stale\""; originResponse.setCode(HttpStatus.SC_OK); originResponse.setVersion(HttpVersion.HTTP_1_0); originResponse.addHeader("Warning", origWarning); originResponse.setHeader("Date", dateHdr); backendExpectsAnyRequest().andReturn(originResponse); replayMocks(); if (HttpVersion.HTTP_1_0.greaterEquals(result.getVersion())) { Assert.assertEquals(dateHdr, result.getFirstHeader("Date").getValue()); boolean warningFound = false; final String targetWarning = origWarning + " \"" + dateHdr + "\""; for(final Header h : result.getHeaders("Warning")) { for(final String warning : h.getValue().split("\\s*,\\s*")) { if (targetWarning.equals(warning)) {
@Test public void testDoesNotModifyLocationOnResponses() throws Exception { originResponse.setCode(HttpStatus.SC_TEMPORARY_REDIRECT); originResponse.setReasonPhrase("Temporary Redirect"); originResponse.setHeader("Location", "http://foo.example.com/bar"); testDoesNotModifyHeaderOnResponses("Location"); }
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; }
backendResponse.addHeader("Via", generateViaHeader(backendResponse)); if (backendResponse.getCode() != HttpStatus.SC_NOT_MODIFIED) { return handleBackendResponse(target, request, scope, requestDate, responseDate, backendResponse); final Header resultEtagHeader = backendResponse.getFirstHeader(HeaderConstants.ETAG); if (resultEtagHeader == null) { log.warn("304 response did not contain ETag"); EntityUtils.consume(backendResponse.getEntity()); backendResponse.close(); return callBackend(target, request, scope, chain); if (matchingVariant == null) { log.debug("304 response did not contain ETag matching one sent in If-None-Match"); EntityUtils.consume(backendResponse.getEntity()); backendResponse.close(); return callBackend(target, request, scope, chain); EntityUtils.consume(backendResponse.getEntity()); backendResponse.close(); final ClassicHttpRequest unconditional = conditionalRequestBuilder.buildUnconditionalRequest(request); return callBackend(target, unconditional, scope, chain); backendResponse.close(); if (shouldSendNotModifiedResponse(request, responseEntry)) { return convert(responseGenerator.generateNotModifiedResponse(responseEntry), scope); return convert(response, scope); } catch (final IOException | RuntimeException ex) {
resp1.setHeader("Cache-Control", "public, max-age=5, stale-while-revalidate=15, must-revalidate"); resp1.setHeader("ETag","\"etag\""); resp1.setHeader("Date", DateUtils.formatDate(tenSecondsAgo)); resp2.setHeader("Cache-Control", "public, max-age=5, stale-while-revalidate=15, must-revalidate"); resp2.setHeader("ETag","\"etag\""); resp2.setHeader("Date", DateUtils.formatDate(now)); verifyMocks(); assertEquals(HttpStatus.SC_OK, result.getCode()); boolean warning110Found = false; for(final Header h : result.getHeaders("Warning")) { for(final WarningValue wv : WarningValue.getWarningValues(h)) { if (wv.getWarnCode() == 110) {
@Test public void testConnectionKeepAlive() throws Exception { final HttpCoreContext context = HttpCoreContext.create(); final ClassicHttpRequest request = new BasicClassicHttpRequest("GET", "/"); Mockito.when(conn.receiveRequestHeader()).thenReturn(request); Mockito.when(responseFactory.newHttpResponse(200)).thenReturn(response); Mockito.when(handlerResolver.resolve(request, context)).thenReturn(requestHandler); Mockito.when(connReuseStrategy.keepAlive(request, response, context)).thenReturn(Boolean.TRUE); httpservice.handleRequest(conn, context); Assert.assertEquals(HttpStatus.SC_OK, response.getCode()); Assert.assertSame(request, context.getRequest()); Assert.assertSame(response, context.getResponse()); Mockito.verify(httprocessor).process(request, request.getEntity(), context); Mockito.verify(httprocessor).process(response, response.getEntity(), context); Mockito.verify(conn).sendResponseHeader(response); Mockito.verify(conn).sendResponseEntity(response); Mockito.verify(conn).flush(); Mockito.verify(conn, Mockito.never()).close(); Mockito.verify(response).close(); }
@Test public void testResponseDateNotGenerated() throws Exception { final HttpContext context = new BasicHttpContext(null); final ClassicHttpResponse response = new BasicClassicHttpResponse(HttpStatus.SC_OK, "OK"); response.setCode(199); final ResponseDate interceptor = new ResponseDate(); interceptor.process(response, response.getEntity(), context); final Header h1 = response.getFirstHeader(HttpHeaders.DATE); Assert.assertNull(h1); }
@Test public void testDoesNotModifyContentRangeOnResponses() throws Exception { request.setHeader("Range","bytes=0-128"); originResponse.setCode(HttpStatus.SC_PARTIAL_CONTENT); originResponse.setReasonPhrase("Partial Content"); originResponse.setEntity(HttpTestUtils.makeBody(128)); originResponse.setHeader("Content-Range","bytes 0-127/256"); testDoesNotModifyHeaderOnResponses("Content-Range"); }
@Test public void test206ResponseGeneratedFromCacheMustHaveABodyThatMatchesContentLengthHeaderIfPresent() throws Exception { final ClassicHttpRequest req1 = new BasicClassicHttpRequest("GET", "/"); final ClassicHttpResponse resp1 = HttpTestUtils.make200Response(); resp1.setHeader("ETag", "\"etag\""); resp1.setHeader("Cache-Control", "max-age=3600"); final ClassicHttpRequest req2 = new BasicClassicHttpRequest("GET", "/"); req2.setHeader("Range", "bytes=0-50"); backendExpectsAnyRequestAndReturn(resp1).times(1, 2); replayMocks(); execute(req1); final ClassicHttpResponse result = execute(req2); verifyMocks(); if (HttpStatus.SC_PARTIAL_CONTENT == result.getCode()) { final Header h = result.getFirstHeader("Content-Length"); if (h != null) { final int contentLength = Integer.parseInt(h.getValue()); int bytesRead = 0; final InputStream i = result.getEntity().getContent(); while ((i.read()) != -1) { bytesRead++; } i.close(); Assert.assertEquals(contentLength, bytesRead); } } }
@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(); }
@Test public void testBasicMessageParsing() throws Exception { final String s = "HTTP/1.1 200 OK\r\n" + "Server: whatever\r\n" + "Date: some date\r\n" + "Set-Cookie: c1=stuff\r\n" + "\r\n"; final ByteArrayInputStream inputStream = new ByteArrayInputStream(s.getBytes(StandardCharsets.US_ASCII)); final SessionInputBuffer inBuffer = new SessionInputBufferImpl(16, StandardCharsets.US_ASCII.newDecoder()); final DefaultHttpResponseParser parser = new DefaultHttpResponseParser(); final ClassicHttpResponse httpresponse = parser.parse(inBuffer, inputStream); Assert.assertEquals(200, httpresponse.getCode()); Assert.assertEquals("OK", httpresponse.getReasonPhrase()); final Header[] headers = httpresponse.getHeaders(); Assert.assertEquals(3, headers.length); }
@Test public void testStripsBadlyDatedWarningsFromForwardedResponses() throws Exception { final Date now = new Date(); final Date tenSecondsAgo = new Date(now.getTime() - 10 * 1000L); originResponse.setHeader("Date", DateUtils.formatDate(now)); originResponse.addHeader("Warning", "110 fred \"stale\", 110 wilma \"stale\" \"" + DateUtils.formatDate(tenSecondsAgo) + "\""); originResponse.setHeader("Cache-Control","no-cache,no-store"); backendExpectsAnyRequest().andReturn(originResponse); replayMocks(); final ClassicHttpResponse result = execute(request); verifyMocks(); for(final Header h : result.getHeaders("Warning")) { Assert.assertFalse(h.getValue().contains("wilma")); } }
log.debug("Caching backend response"); final ByteArrayBuffer buf; final HttpEntity entity = backendResponse.getEntity(); if (entity != null) { buf = new ByteArrayBuffer(1024); if (total > cacheConfig.getMaxObjectSize()) { log.debug("Backend response content length exceeds maximum"); backendResponse.setEntity(new CombinedEntity(entity, buf)); return backendResponse; buf = null; backendResponse.close();
final ClassicHttpResponse unauthorized = new BasicClassicHttpResponse(HttpStatus.SC_UNAUTHORIZED); final String realm = authenticator.getRealm(authority, requestUri); unauthorized.addHeader(HttpHeaders.WWW_AUTHENTICATE, "Basic realm=\"" + realm + "\""); customizeUnauthorizedResponse(unauthorized); if (unauthorized.getEntity() == null) { unauthorized.setEntity(new StringEntity("Unauthorized"));
@Test public void testNoEntityForIfNoneMatchRequestNotYetInCache() throws Exception { final Date now = new Date(); final Date tenSecondsAgo = new Date(now.getTime() - 10 * 1000L); impl = createCachingExecChain(new BasicHttpCache(), CacheConfig.DEFAULT); final ClassicHttpRequest req1 = new HttpGet("http://foo.example.com/"); req1.addHeader("If-None-Match", "\"etag\""); final ClassicHttpResponse resp1 = HttpTestUtils.make304Response(); resp1.setHeader("Content-Length", "128"); resp1.setHeader("ETag", "\"etag\""); resp1.setHeader("Date", DateUtils.formatDate(tenSecondsAgo)); resp1.setHeader("Cache-Control", "public, max-age=5"); backendExpectsAnyRequestAndReturn(resp1); replayMocks(); final ClassicHttpResponse result = execute(req1); verifyMocks(); assertEquals(HttpStatus.SC_NOT_MODIFIED, result.getCode()); assertNull("The 304 response messages MUST NOT contain a message-body", result.getEntity()); }
@Test public void responseToGetWithQueryFrom1_0OriginVia1_1ProxyAndNoExpiresIsNotCached() throws Exception { final ClassicHttpRequest req2 = new HttpGet("http://foo.example.com/bar?baz=quux"); final ClassicHttpResponse resp2 = new BasicClassicHttpResponse(HttpStatus.SC_OK, "OK"); resp2.setVersion(HttpVersion.HTTP_1_0); resp2.setEntity(HttpTestUtils.makeBody(200)); resp2.setHeader("Content-Length","200"); resp2.setHeader("Date", DateUtils.formatDate(now)); resp2.setHeader("Via","1.0 someproxy"); backendExpectsAnyRequestAndReturn(resp2); replayMocks(); execute(req2); verifyMocks(); }
@Test public void testResponseToHead() throws Exception { final HttpCoreContext context = HttpCoreContext.create(); final ClassicHttpRequest request = new BasicClassicHttpRequest("HEAD", "/"); Mockito.when(conn.receiveRequestHeader()).thenReturn(request); Mockito.when(responseFactory.newHttpResponse(200)).thenReturn(response); Mockito.when(handlerResolver.resolve(request, context)).thenReturn(requestHandler); Mockito.when(connReuseStrategy.keepAlive(request, response, context)).thenReturn(Boolean.TRUE); httpservice.handleRequest(conn, context); Assert.assertSame(request, context.getRequest()); Mockito.verify(httprocessor).process(response, response.getEntity(), context); Mockito.verify(requestHandler).handle(request, response, context); Mockito.verify(conn).sendResponseHeader(response); Mockito.verify(conn, Mockito.never()).sendResponseEntity(ArgumentMatchers.<ClassicHttpResponse>any()); Mockito.verify(conn).flush(); Mockito.verify(conn, Mockito.never()).close(); Mockito.verify(response).close(); }
resp1.setEntity(new InputStreamEntity(new InputStream() { private boolean closed = false; resp1.setHeader("Date", DateUtils.formatDate(now)); try { final ClassicHttpResponse result1 = execute(req1); EntityUtils.toString(result1.getEntity()); Assert.fail("We should have had a SocketTimeoutException"); } catch (final SocketTimeoutException e) {