1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28 package org.apache.hc.core5.http.protocol;
29
30 import java.nio.charset.StandardCharsets;
31
32 import javax.net.ssl.SSLSession;
33
34 import org.apache.hc.core5.http.ClassicHttpResponse;
35 import org.apache.hc.core5.http.ContentType;
36 import org.apache.hc.core5.http.Header;
37 import org.apache.hc.core5.http.HeaderElements;
38 import org.apache.hc.core5.http.HttpHeaders;
39 import org.apache.hc.core5.http.HttpRequestInterceptor;
40 import org.apache.hc.core5.http.HttpStatus;
41 import org.apache.hc.core5.http.HttpVersion;
42 import org.apache.hc.core5.http.Method;
43 import org.apache.hc.core5.http.MisdirectedRequestException;
44 import org.apache.hc.core5.http.ProtocolException;
45 import org.apache.hc.core5.http.io.entity.BasicHttpEntity;
46 import org.apache.hc.core5.http.io.entity.EmptyInputStream;
47 import org.apache.hc.core5.http.io.entity.HttpEntities;
48 import org.apache.hc.core5.http.io.entity.StringEntity;
49 import org.apache.hc.core5.http.message.BasicClassicHttpRequest;
50 import org.apache.hc.core5.http.message.BasicClassicHttpResponse;
51 import org.apache.hc.core5.http.message.BasicHeader;
52 import org.apache.hc.core5.net.URIAuthority;
53 import org.junit.jupiter.api.Assertions;
54 import org.junit.jupiter.api.Test;
55 import org.mockito.Mockito;
56
57 public class TestStandardInterceptors {
58
59 @Test
60 public void testRequestConnControlGenerated() throws Exception {
61 final HttpContext context = new BasicHttpContext(null);
62 final BasicClassicHttpRequest request = new BasicClassicHttpRequest(Method.GET, "/");
63 final HttpRequestInterceptor interceptor = RequestConnControl.INSTANCE;
64 interceptor.process(request, request.getEntity(), context);
65 final Header header = request.getFirstHeader(HttpHeaders.CONNECTION);
66 Assertions.assertNotNull(header);
67 Assertions.assertEquals("keep-alive", header.getValue());
68 }
69
70 @Test
71 public void testRequestConnControlConnectMethod() throws Exception {
72 final HttpContext context = new BasicHttpContext(null);
73 final BasicClassicHttpRequest request = new BasicClassicHttpRequest(Method.CONNECT, "/");
74 final HttpRequestInterceptor interceptor = RequestConnControl.INSTANCE;
75 interceptor.process(request, request.getEntity(), context);
76 final Header header = request.getFirstHeader(HttpHeaders.CONNECTION);
77 Assertions.assertNull(header);
78 }
79
80 @Test
81 public void testRequestConnControlCustom() throws Exception {
82 final HttpContext context = new BasicHttpContext(null);
83 final BasicClassicHttpRequest request = new BasicClassicHttpRequest(Method.GET, "/");
84 final Header myheader = new BasicHeader(HttpHeaders.CONNECTION, "close");
85 request.addHeader(myheader);
86 final HttpRequestInterceptor interceptor = RequestConnControl.INSTANCE;
87 interceptor.process(request, request.getEntity(), context);
88 final Header header = request.getFirstHeader(HttpHeaders.CONNECTION);
89 Assertions.assertNotNull(header);
90 Assertions.assertEquals("close", header.getValue());
91 Assertions.assertSame(header, myheader);
92 }
93
94 @Test
95 public void testRequestConnControlUpgrade() throws Exception {
96 final HttpContext context = new BasicHttpContext(null);
97 final BasicClassicHttpRequest request = new BasicClassicHttpRequest(Method.GET, "/");
98 request.addHeader(HttpHeaders.UPGRADE, "HTTP/2");
99 final HttpRequestInterceptor interceptor = RequestConnControl.INSTANCE;
100 interceptor.process(request, request.getEntity(), context);
101 final Header header = request.getFirstHeader(HttpHeaders.CONNECTION);
102 Assertions.assertNotNull(header);
103 Assertions.assertEquals("upgrade", header.getValue());
104 }
105
106 @Test
107 public void testRequestConnControlInvalidInput() throws Exception {
108 final HttpRequestInterceptor interceptor = RequestConnControl.INSTANCE;
109 Assertions.assertThrows(NullPointerException.class, () -> interceptor.process(null, null, null));
110 }
111
112 @Test
113 public void testRequestContentProtocolException() throws Exception {
114 final HttpContext context = new BasicHttpContext(null);
115 final BasicClassicHttpRequest request1 = new BasicClassicHttpRequest(Method.POST, "/");
116 request1.addHeader(new BasicHeader(HttpHeaders.TRANSFER_ENCODING, "chunked"));
117 final BasicClassicHttpRequest request2 = new BasicClassicHttpRequest(Method.POST, "/");
118 request2.addHeader(new BasicHeader(HttpHeaders.CONTENT_LENGTH, "12"));
119
120 final HttpRequestInterceptor interceptor = RequestContent.INSTANCE;
121 Assertions.assertThrows(ProtocolException.class, () ->
122 interceptor.process(request1, request1.getEntity(), context));
123 Assertions.assertThrows(ProtocolException.class, () ->
124 interceptor.process(request2, request2.getEntity(), context));
125 }
126
127 @Test
128 public void testRequestContentNullEntity() throws Exception {
129 final HttpContext context = new BasicHttpContext(null);
130 final BasicClassicHttpRequest request = new BasicClassicHttpRequest(Method.POST, "/");
131
132 final HttpRequestInterceptor interceptor = RequestContent.INSTANCE;
133 interceptor.process(request, request.getEntity(), context);
134 final Header header = request.getFirstHeader(HttpHeaders.CONTENT_LENGTH);
135 Assertions.assertNotNull(header);
136 Assertions.assertEquals(0, Integer.parseInt(header.getValue()));
137 Assertions.assertNull(request.getFirstHeader(HttpHeaders.TRANSFER_ENCODING));
138 }
139
140 @Test
141 public void testRequestContentNullEntityNonEnclosingMethod() throws Exception {
142 final HttpContext context = new BasicHttpContext(null);
143 final BasicClassicHttpRequest request = new BasicClassicHttpRequest(Method.GET, "/");
144
145 final HttpRequestInterceptor interceptor = RequestContent.INSTANCE;
146 interceptor.process(request, request.getEntity(), context);
147 final Header header = request.getFirstHeader(HttpHeaders.CONTENT_LENGTH);
148 Assertions.assertNull(header);
149 Assertions.assertNull(request.getFirstHeader(HttpHeaders.TRANSFER_ENCODING));
150 }
151 @Test
152 public void testRequestContentEntityContentLengthDelimitedHTTP11() throws Exception {
153 final HttpContext context = new BasicHttpContext(null);
154 final BasicClassicHttpRequest request = new BasicClassicHttpRequest(Method.POST, "/");
155 request.setEntity(new StringEntity("whatever", StandardCharsets.US_ASCII));
156
157 final HttpRequestInterceptor interceptor = RequestContent.INSTANCE;
158 interceptor.process(request, request.getEntity(), context);
159 final Header header = request.getFirstHeader(HttpHeaders.CONTENT_LENGTH);
160 Assertions.assertNotNull(header);
161 Assertions.assertEquals(8, Integer.parseInt(header.getValue()));
162 Assertions.assertNull(request.getFirstHeader(HttpHeaders.TRANSFER_ENCODING));
163 }
164
165 @Test
166 public void testRequestContentEntityChunkedHTTP11() throws Exception {
167 final HttpContext context = new BasicHttpContext(null);
168 final BasicClassicHttpRequest request = new BasicClassicHttpRequest(Method.POST, "/");
169 request.setEntity(new StringEntity("whatever", StandardCharsets.US_ASCII, true));
170
171 final HttpRequestInterceptor interceptor = RequestContent.INSTANCE;
172 interceptor.process(request, request.getEntity(), context);
173 final Header header = request.getFirstHeader(HttpHeaders.TRANSFER_ENCODING);
174 Assertions.assertNotNull(header);
175 Assertions.assertEquals("chunked", header.getValue());
176 Assertions.assertNull(request.getFirstHeader(HttpHeaders.CONTENT_LENGTH));
177 }
178
179 @Test
180 public void testRequestContentEntityUnknownLengthHTTP11() throws Exception {
181 final HttpContext context = new BasicHttpContext(null);
182 final BasicClassicHttpRequest request = new BasicClassicHttpRequest(Method.POST, "/");
183 request.setEntity(new BasicHttpEntity(EmptyInputStream.INSTANCE, -1, null));
184
185 final HttpRequestInterceptor interceptor = RequestContent.INSTANCE;
186 interceptor.process(request, request.getEntity(), context);
187 final Header header = request.getFirstHeader(HttpHeaders.TRANSFER_ENCODING);
188 Assertions.assertNotNull(header);
189 Assertions.assertEquals("chunked", header.getValue());
190 Assertions.assertNull(request.getFirstHeader(HttpHeaders.CONTENT_LENGTH));
191 }
192
193 @Test
194 public void testRequestContentEntityChunkedHTTP10() throws Exception {
195 final HttpContext context = new BasicHttpContext(null);
196 context.setProtocolVersion(HttpVersion.HTTP_1_0);
197 final BasicClassicHttpRequest request = new BasicClassicHttpRequest(Method.POST, "/");
198 request.setEntity(new StringEntity("whatever", StandardCharsets.US_ASCII, true));
199
200 final HttpRequestInterceptor interceptor = RequestContent.INSTANCE;
201 Assertions.assertThrows(ProtocolException.class, () ->
202 interceptor.process(request, request.getEntity(), context));
203 }
204
205 @Test
206 public void testRequestContentTypeAndEncoding() throws Exception {
207 final HttpContext context = new BasicHttpContext(null);
208 final BasicClassicHttpRequest request = new BasicClassicHttpRequest(Method.POST, "/");
209 request.setEntity(new BasicHttpEntity(EmptyInputStream.INSTANCE,
210 ContentType.parseLenient("whatever"), "whatever"));
211
212 final HttpRequestInterceptor interceptor = RequestContent.INSTANCE;
213 interceptor.process(request, request.getEntity(), context);
214 final Header h1 = request.getFirstHeader(HttpHeaders.CONTENT_TYPE);
215 Assertions.assertNotNull(h1);
216 Assertions.assertEquals("whatever", h1.getValue());
217 final Header h2 = request.getFirstHeader(HttpHeaders.CONTENT_ENCODING);
218 Assertions.assertNotNull(h2);
219 Assertions.assertEquals("whatever", h2.getValue());
220 }
221
222 @Test
223 public void testRequestContentNullTypeAndEncoding() throws Exception {
224 final HttpContext context = new BasicHttpContext(null);
225 final BasicClassicHttpRequest request = new BasicClassicHttpRequest(Method.POST, "/");
226 request.setEntity(new BasicHttpEntity(EmptyInputStream.INSTANCE, null, null));
227
228 final HttpRequestInterceptor interceptor = RequestContent.INSTANCE;
229 interceptor.process(request, request.getEntity(), context);
230 Assertions.assertNull(request.getFirstHeader(HttpHeaders.CONTENT_TYPE));
231 Assertions.assertNull(request.getFirstHeader(HttpHeaders.CONTENT_ENCODING));
232 }
233
234 @Test
235 public void testRequestContentEntityUnknownLengthHTTP10() throws Exception {
236 final HttpContext context = new BasicHttpContext(null);
237 context.setProtocolVersion(HttpVersion.HTTP_1_0);
238 final BasicClassicHttpRequest request = new BasicClassicHttpRequest(Method.POST, "/");
239 request.setEntity(new BasicHttpEntity(EmptyInputStream.INSTANCE, -1, null));
240
241 final HttpRequestInterceptor interceptor = RequestContent.INSTANCE;
242 Assertions.assertThrows(ProtocolException.class, () ->
243 interceptor.process(request, request.getEntity(), context));
244 }
245
246 @Test
247 public void testRequestContentInvalidInput() throws Exception {
248 final HttpRequestInterceptor interceptor = RequestContent.INSTANCE;
249 Assertions.assertThrows(NullPointerException.class, () ->
250 interceptor.process(null, null, null));
251 }
252
253 @Test
254 public void testRequestContentIgnoreNonenclosingRequests() throws Exception {
255 final HttpContext context = new BasicHttpContext(null);
256 final BasicClassicHttpRequest request = new BasicClassicHttpRequest(Method.POST, "/");
257 final HttpRequestInterceptor interceptor = RequestContent.INSTANCE;
258 interceptor.process(request, request.getEntity(), context);
259 Assertions.assertEquals(1, request.getHeaders().length);
260 }
261
262 @Test
263 public void testRequestContentOverwriteHeaders() throws Exception {
264 final RequestContent interceptor = new RequestContent(true);
265 final HttpContext context = new BasicHttpContext(null);
266 final BasicClassicHttpRequest request = new BasicClassicHttpRequest(Method.POST, "/");
267 request.addHeader(new BasicHeader(HttpHeaders.CONTENT_LENGTH, "10"));
268 request.addHeader(new BasicHeader(HttpHeaders.TRANSFER_ENCODING, "whatever"));
269 request.setEntity(new StringEntity(""));
270 interceptor.process(request, request.getEntity(), context);
271 final Header h1 = request.getFirstHeader(HttpHeaders.CONTENT_LENGTH);
272 Assertions.assertNotNull(h1);
273 Assertions.assertEquals("0", h1.getValue());
274 }
275
276 @Test
277 public void testRequestContentAddHeaders() throws Exception {
278 final RequestContent interceptor = new RequestContent(true);
279 final HttpContext context = new BasicHttpContext(null);
280 final BasicClassicHttpRequest request = new BasicClassicHttpRequest(Method.POST, "/");
281 request.setEntity(new StringEntity(""));
282 interceptor.process(request, request.getEntity(), context);
283 final Header h1 = request.getFirstHeader(HttpHeaders.CONTENT_LENGTH);
284 Assertions.assertNotNull(h1);
285 Assertions.assertEquals("0", h1.getValue());
286 final Header h2 = request.getFirstHeader(HttpHeaders.TRANSFER_ENCODING);
287 Assertions.assertNull(h2);
288 }
289
290 @Test
291 public void testRequestContentEntityWithTrailers() throws Exception {
292 final HttpContext context = new BasicHttpContext(null);
293 final BasicClassicHttpRequest request = new BasicClassicHttpRequest(Method.POST, "/");
294 request.setEntity(HttpEntities.create("whatever", StandardCharsets.US_ASCII,
295 new BasicHeader("h1", "this"), new BasicHeader("h1", "that"), new BasicHeader("h2", "this and that")));
296
297 final HttpRequestInterceptor interceptor = RequestContent.INSTANCE;
298 interceptor.process(request, request.getEntity(), context);
299 final Header header1 = request.getFirstHeader(HttpHeaders.TRANSFER_ENCODING);
300 Assertions.assertNotNull(header1);
301 final Header header2 = request.getFirstHeader(HttpHeaders.TRAILER);
302 Assertions.assertNotNull(header2);
303 Assertions.assertEquals("h1, h2", header2.getValue());
304 }
305
306 @Test
307 public void testRequestContentTraceWithEntity() throws Exception {
308 final HttpContext context = new BasicHttpContext(null);
309 final BasicClassicHttpRequest request = new BasicClassicHttpRequest(Method.TRACE, "/");
310 request.setEntity(new StringEntity("stuff"));
311 final HttpRequestInterceptor interceptor = RequestContent.INSTANCE;
312 Assertions.assertThrows(ProtocolException.class, () ->
313 interceptor.process(request, request.getEntity(), context));
314 }
315
316 @Test
317 public void testRequestExpectContinueGenerated() throws Exception {
318 final HttpCoreContext context = HttpCoreContext.create();
319 final BasicClassicHttpRequest request = new BasicClassicHttpRequest(Method.POST, "/");
320 request.setEntity(new StringEntity("whatever", StandardCharsets.US_ASCII));
321 final RequestExpectContinue interceptor = RequestExpectContinue.INSTANCE;
322 interceptor.process(request, request.getEntity(), context);
323 final Header header = request.getFirstHeader(HttpHeaders.EXPECT);
324 Assertions.assertNotNull(header);
325 Assertions.assertEquals(HeaderElements.CONTINUE, header.getValue());
326 }
327
328 @Test
329 public void testRequestExpectContinueHTTP10() throws Exception {
330 final HttpCoreContext context = HttpCoreContext.create();
331 context.setProtocolVersion(HttpVersion.HTTP_1_0);
332 final BasicClassicHttpRequest request = new BasicClassicHttpRequest(Method.POST, "/");
333 request.setEntity(new StringEntity("whatever", StandardCharsets.US_ASCII));
334 final RequestExpectContinue interceptor = RequestExpectContinue.INSTANCE;
335 interceptor.process(request, request.getEntity(), context);
336 final Header header = request.getFirstHeader(HttpHeaders.EXPECT);
337 Assertions.assertNull(header);
338 }
339
340 @Test
341 public void testRequestExpectContinueZeroContent() throws Exception {
342 final HttpCoreContext context = HttpCoreContext.create();
343 final BasicClassicHttpRequest request = new BasicClassicHttpRequest(Method.POST, "/");
344 request.setEntity(new StringEntity("", StandardCharsets.US_ASCII));
345 final RequestExpectContinue interceptor = RequestExpectContinue.INSTANCE;
346 interceptor.process(request, request.getEntity(), context);
347 final Header header = request.getFirstHeader(HttpHeaders.EXPECT);
348 Assertions.assertNull(header);
349 }
350
351 @Test
352 public void testRequestExpectContinueInvalidInput() throws Exception {
353 final RequestExpectContinue interceptor = RequestExpectContinue.INSTANCE;
354 Assertions.assertThrows(NullPointerException.class, () ->
355 interceptor.process(null, null, null));
356 }
357
358 @Test
359 public void testRequestExpectContinueIgnoreNonenclosingRequests() throws Exception {
360 final HttpContext context = new BasicHttpContext(null);
361 final BasicClassicHttpRequest request = new BasicClassicHttpRequest(Method.POST, "/");
362 final RequestExpectContinue interceptor = RequestExpectContinue.INSTANCE;
363 interceptor.process(request, request.getEntity(), context);
364 Assertions.assertEquals(0, request.getHeaders().length);
365 }
366
367 @Test
368 public void testRequestTargetHostGenerated() throws Exception {
369 final HttpContext context = new BasicHttpContext(null);
370 final BasicClassicHttpRequest request = new BasicClassicHttpRequest(Method.GET, "/");
371 request.setAuthority(new URIAuthority("somehost", 8080));
372 final HttpRequestInterceptor interceptor = RequestTargetHost.INSTANCE;
373 interceptor.process(request, request.getEntity(), context);
374 final Header header = request.getFirstHeader(HttpHeaders.HOST);
375 Assertions.assertNotNull(header);
376 Assertions.assertEquals("somehost:8080", header.getValue());
377 }
378
379 @Test
380 public void testRequestTargetHostNotGenerated() throws Exception {
381 final HttpContext context = new BasicHttpContext(null);
382 final BasicClassicHttpRequest request = new BasicClassicHttpRequest(Method.GET, "/");
383 request.setAuthority(new URIAuthority("somehost", 8080));
384 request.addHeader(new BasicHeader(HttpHeaders.HOST, "whatever"));
385 final HttpRequestInterceptor interceptor = RequestTargetHost.INSTANCE;
386 interceptor.process(request, request.getEntity(), context);
387 final Header header = request.getFirstHeader(HttpHeaders.HOST);
388 Assertions.assertNotNull(header);
389 Assertions.assertEquals("whatever", header.getValue());
390 }
391
392 @Test
393 public void testRequestTargetHostMissingHostHTTP10() throws Exception {
394 final HttpContext context = new BasicHttpContext(null);
395 context.setProtocolVersion(HttpVersion.HTTP_1_0);
396 final BasicClassicHttpRequest request = new BasicClassicHttpRequest(Method.GET, "/");
397 final HttpRequestInterceptor interceptor = RequestTargetHost.INSTANCE;
398 interceptor.process(request, request.getEntity(), context);
399 final Header header = request.getFirstHeader(HttpHeaders.HOST);
400 Assertions.assertNull(header);
401 }
402
403 @Test
404 public void testRequestTargetHostMissingHostHTTP11() throws Exception {
405 final HttpContext context = new BasicHttpContext(null);
406 final BasicClassicHttpRequest request = new BasicClassicHttpRequest(Method.GET, "/");
407 final HttpRequestInterceptor interceptor = RequestTargetHost.INSTANCE;
408 Assertions.assertThrows(ProtocolException.class, () ->
409 interceptor.process(request, request.getEntity(), context));
410 }
411
412 @Test
413 public void testRequestTargetHostInvalidInput() throws Exception {
414 final HttpRequestInterceptor interceptor = RequestTargetHost.INSTANCE;
415 Assertions.assertThrows(NullPointerException.class, () ->
416 interceptor.process(null, null, null));
417 Assertions.assertThrows(NullPointerException.class, () ->
418 interceptor.process(new BasicClassicHttpRequest(Method.GET, "/"), null, null));
419 }
420
421 @Test
422 public void testRequestTargetHostConnectHttp11() throws Exception {
423 final HttpContext context = new BasicHttpContext(null);
424 final BasicClassicHttpRequest request = new BasicClassicHttpRequest(Method.CONNECT, "/");
425 request.setAuthority(new URIAuthority("somehost", 8080));
426 final HttpRequestInterceptor interceptor = RequestTargetHost.INSTANCE;
427 interceptor.process(request, request.getEntity(), context);
428 final Header header = request.getFirstHeader(HttpHeaders.HOST);
429 Assertions.assertNotNull(header);
430 Assertions.assertEquals("somehost:8080", header.getValue());
431 }
432
433 @Test
434 public void testRequestTargetHostConnectHttp10() throws Exception {
435 final HttpContext context = new BasicHttpContext(null);
436 context.setProtocolVersion(HttpVersion.HTTP_1_0);
437 final BasicClassicHttpRequest request = new BasicClassicHttpRequest(Method.CONNECT, "/");
438 request.setAuthority(new URIAuthority("somehost", 8080));
439 final HttpRequestInterceptor interceptor = RequestTargetHost.INSTANCE;
440 interceptor.process(request, request.getEntity(), context);
441 final Header header = request.getFirstHeader(HttpHeaders.HOST);
442 Assertions.assertNull(header);
443 }
444
445 @Test
446 public void testRequestUserAgentGenerated() throws Exception {
447 final HttpContext context = new BasicHttpContext(null);
448 final BasicClassicHttpRequest request = new BasicClassicHttpRequest(Method.GET, "/");
449 final RequestUserAgent interceptor = new RequestUserAgent("some agent");
450 interceptor.process(request, request.getEntity(), context);
451 final Header header = request.getFirstHeader(HttpHeaders.USER_AGENT);
452 Assertions.assertNotNull(header);
453 Assertions.assertEquals("some agent", header.getValue());
454 }
455
456 @Test
457 public void testRequestUserAgentNotGenerated() throws Exception {
458 final HttpContext context = new BasicHttpContext(null);
459 final BasicClassicHttpRequest request = new BasicClassicHttpRequest(Method.GET, "/");
460 request.addHeader(new BasicHeader(HttpHeaders.USER_AGENT, "whatever"));
461 final RequestUserAgent interceptor = new RequestUserAgent("some agent");
462 interceptor.process(request, request.getEntity(), context);
463 final Header header = request.getFirstHeader(HttpHeaders.USER_AGENT);
464 Assertions.assertNotNull(header);
465 Assertions.assertEquals("whatever", header.getValue());
466 }
467
468 @Test
469 public void testRequestUserAgentMissingUserAgent() throws Exception {
470 final HttpContext context = new BasicHttpContext(null);
471 final BasicClassicHttpRequest request = new BasicClassicHttpRequest(Method.GET, "/");
472 final HttpRequestInterceptor interceptor = RequestUserAgent.INSTANCE;
473 interceptor.process(request, request.getEntity(), context);
474 final Header header = request.getFirstHeader(HttpHeaders.USER_AGENT);
475 Assertions.assertNull(header);
476 }
477
478 @Test
479 public void testRequestUserAgentInvalidInput() throws Exception {
480 final HttpRequestInterceptor interceptor = RequestUserAgent.INSTANCE;
481 Assertions.assertThrows(NullPointerException.class, () -> interceptor.process(null, null, null));
482 }
483
484 @Test
485 public void testResponseConnControlNoEntity() throws Exception {
486 final HttpContext context = new BasicHttpContext(null);
487 final ClassicHttpResponse response = new BasicClassicHttpResponse(HttpStatus.SC_OK, "OK");
488 final ResponseConnControl interceptor = new ResponseConnControl();
489 interceptor.process(response, response.getEntity(), context);
490 final Header header = response.getFirstHeader(HttpHeaders.CONNECTION);
491 Assertions.assertNull(header);
492 }
493
494 @Test
495 public void testResponseConnControlEntityContentLength() throws Exception {
496 final HttpContext context = new BasicHttpContext(null);
497 final ClassicHttpResponse response = new BasicClassicHttpResponse(HttpStatus.SC_OK, "OK");
498 response.setEntity(new StringEntity("whatever"));
499 final ResponseConnControl interceptor = new ResponseConnControl();
500 interceptor.process(response, response.getEntity(), context);
501 final Header header = response.getFirstHeader(HttpHeaders.CONNECTION);
502 Assertions.assertNull(header);
503 }
504
505 @Test
506 public void testResponseConnControlEntityUnknownContentLengthExplicitKeepAlive() throws Exception {
507 final HttpContext context = new BasicHttpContext(null);
508 final BasicClassicHttpRequest request = new BasicClassicHttpRequest(Method.GET, "/");
509 request.addHeader(new BasicHeader(HttpHeaders.CONNECTION, "keep-alive"));
510 context.setAttribute(HttpCoreContext.HTTP_REQUEST, request);
511 final ClassicHttpResponse response = new BasicClassicHttpResponse(HttpStatus.SC_OK, "OK");
512 response.setEntity(new BasicHttpEntity(EmptyInputStream.INSTANCE, null));
513 final ResponseConnControl interceptor = new ResponseConnControl();
514 interceptor.process(response, response.getEntity(), context);
515 final Header header = response.getFirstHeader(HttpHeaders.CONNECTION);
516 Assertions.assertNotNull(header);
517 Assertions.assertEquals("keep-alive", header.getValue());
518 }
519
520 @Test
521 public void testResponseConnControlEntityChunked() throws Exception {
522 final HttpContext context = new BasicHttpContext(null);
523 final ClassicHttpResponse response = new BasicClassicHttpResponse(HttpStatus.SC_OK, "OK");
524 response.setEntity(new BasicHttpEntity(EmptyInputStream.INSTANCE, null, true));
525 final ResponseConnControl interceptor = new ResponseConnControl();
526 interceptor.process(response, response.getEntity(), context);
527 final Header header = response.getFirstHeader(HttpHeaders.CONNECTION);
528 Assertions.assertNull(header);
529 }
530
531 @Test
532 public void testResponseConnControlEntityUnknownContentLengthHTTP10() throws Exception {
533 final HttpContext context = new BasicHttpContext(null);
534 context.setProtocolVersion(HttpVersion.HTTP_1_0);
535 final BasicClassicHttpRequest request = new BasicClassicHttpRequest(Method.GET, "/");
536 request.addHeader(new BasicHeader(HttpHeaders.CONNECTION, "keep-alive"));
537 context.setAttribute(HttpCoreContext.HTTP_REQUEST, request);
538
539 final BasicClassicHttpResponse response = new BasicClassicHttpResponse(HttpStatus.SC_OK, "OK");
540 response.setEntity(new BasicHttpEntity(EmptyInputStream.INSTANCE, null));
541 final ResponseConnControl interceptor = new ResponseConnControl();
542 interceptor.process(response, response.getEntity(), context);
543 final Header header = response.getFirstHeader(HttpHeaders.CONNECTION);
544 Assertions.assertNotNull(header);
545 Assertions.assertEquals("close", header.getValue());
546 }
547
548 @Test
549 public void testResponseConnControlClientRequest() throws Exception {
550 final HttpContext context = new BasicHttpContext(null);
551 final BasicClassicHttpRequest request = new BasicClassicHttpRequest(Method.GET, "/");
552 request.addHeader(new BasicHeader(HttpHeaders.CONNECTION, "keep-alive"));
553 context.setAttribute(HttpCoreContext.HTTP_REQUEST, request);
554
555 final ClassicHttpResponse response = new BasicClassicHttpResponse(HttpStatus.SC_OK, "OK");
556 response.setEntity(new StringEntity("whatever"));
557 final ResponseConnControl interceptor = new ResponseConnControl();
558 interceptor.process(response, response.getEntity(), context);
559 final Header header = response.getFirstHeader(HttpHeaders.CONNECTION);
560 Assertions.assertNotNull(header);
561 Assertions.assertEquals("keep-alive", header.getValue());
562 }
563
564 @Test
565 public void testResponseConnControlClientRequest2() throws Exception {
566 final HttpContext context = new BasicHttpContext(null);
567 final BasicClassicHttpRequest request = new BasicClassicHttpRequest(Method.GET, "/");
568 context.setAttribute(HttpCoreContext.HTTP_REQUEST, request);
569
570 final ClassicHttpResponse response = new BasicClassicHttpResponse(HttpStatus.SC_OK, "OK");
571 response.setEntity(new StringEntity("whatever"));
572 final ResponseConnControl interceptor = new ResponseConnControl();
573 interceptor.process(response, response.getEntity(), context);
574 final Header header = response.getFirstHeader(HttpHeaders.CONNECTION);
575 Assertions.assertNull(header);
576 }
577
578 @Test
579 public void testResponseConnControl10Client11Response() throws Exception {
580 final HttpContext context = new BasicHttpContext(null);
581 context.setProtocolVersion(HttpVersion.HTTP_1_0);
582 final BasicClassicHttpRequest request = new BasicClassicHttpRequest(Method.GET, "/");
583 context.setAttribute(HttpCoreContext.HTTP_REQUEST, request);
584
585 final ClassicHttpResponse response = new BasicClassicHttpResponse(HttpStatus.SC_OK, "OK");
586 response.setEntity(new StringEntity("whatever"));
587 final ResponseConnControl interceptor = new ResponseConnControl();
588 interceptor.process(response, response.getEntity(), context);
589 final Header header = response.getFirstHeader(HttpHeaders.CONNECTION);
590 Assertions.assertNotNull(header);
591 Assertions.assertEquals("close", header.getValue());
592 }
593
594 @Test
595 public void testResponseConnControlStatusCode() throws Exception {
596 final HttpContext context = new BasicHttpContext(null);
597 final BasicClassicHttpRequest request = new BasicClassicHttpRequest(Method.GET, "/");
598 request.addHeader(new BasicHeader(HttpHeaders.CONNECTION, "keep-alive"));
599 context.setAttribute(HttpCoreContext.HTTP_REQUEST, request);
600
601 final ResponseConnControl interceptor = new ResponseConnControl();
602
603 final int [] statusCodes = new int[] {
604 HttpStatus.SC_BAD_REQUEST,
605 HttpStatus.SC_REQUEST_TIMEOUT,
606 HttpStatus.SC_LENGTH_REQUIRED,
607 HttpStatus.SC_REQUEST_TOO_LONG,
608 HttpStatus.SC_REQUEST_URI_TOO_LONG,
609 HttpStatus.SC_SERVICE_UNAVAILABLE,
610 HttpStatus.SC_NOT_IMPLEMENTED };
611
612 for (final int statusCode : statusCodes) {
613 final ClassicHttpResponse response = new BasicClassicHttpResponse(statusCode, "Unreasonable");
614 interceptor.process(response, response.getEntity(), context);
615 final Header header = response.getFirstHeader(HttpHeaders.CONNECTION);
616 Assertions.assertNotNull(header);
617 Assertions.assertEquals("close", header.getValue());
618 }
619
620 }
621
622 @Test
623 public void testResponseConnControlExplicitClose() throws Exception {
624 final HttpContext context = new BasicHttpContext(null);
625 final BasicClassicHttpRequest request = new BasicClassicHttpRequest(Method.GET, "/");
626 request.addHeader(new BasicHeader(HttpHeaders.CONNECTION, "keep-alive"));
627 context.setAttribute(HttpCoreContext.HTTP_REQUEST, request);
628
629 final ResponseConnControl interceptor = new ResponseConnControl();
630
631 final ClassicHttpResponse response = new BasicClassicHttpResponse(200, "OK");
632 response.setHeader(HttpHeaders.CONNECTION, "close");
633 interceptor.process(response, response.getEntity(), context);
634 final Header header = response.getFirstHeader(HttpHeaders.CONNECTION);
635 Assertions.assertNotNull(header);
636 Assertions.assertEquals("close", header.getValue());
637 }
638
639 @Test
640 public void testResponseConnControlClientRequestMixUp() throws Exception {
641 final HttpContext context = new BasicHttpContext(null);
642 final BasicClassicHttpRequest request = new BasicClassicHttpRequest(Method.GET, "/");
643 request.addHeader(new BasicHeader(HttpHeaders.CONNECTION, "blah, keep-alive, close"));
644 context.setAttribute(HttpCoreContext.HTTP_REQUEST, request);
645
646 final ResponseConnControl interceptor = new ResponseConnControl();
647
648 final ClassicHttpResponse response = new BasicClassicHttpResponse(200, "OK");
649 interceptor.process(response, response.getEntity(), context);
650 final Header header = response.getFirstHeader(HttpHeaders.CONNECTION);
651 Assertions.assertNotNull(header);
652 Assertions.assertEquals("close", header.getValue());
653 }
654
655 @Test
656 public void testResponseConnControlUpgrade() throws Exception {
657 final HttpContext context = new BasicHttpContext(null);
658
659 final ResponseConnControl interceptor = new ResponseConnControl();
660
661 final ClassicHttpResponse response = new BasicClassicHttpResponse(200, "OK");
662 response.addHeader(HttpHeaders.UPGRADE, "HTTP/2");
663 interceptor.process(response, response.getEntity(), context);
664 final Header header = response.getFirstHeader(HttpHeaders.CONNECTION);
665 Assertions.assertNotNull(header);
666 Assertions.assertEquals("upgrade", header.getValue());
667 }
668
669 @Test
670 public void testResponseConnControlHostInvalidInput() throws Exception {
671 final ResponseConnControl interceptor = new ResponseConnControl();
672 Assertions.assertThrows(NullPointerException.class, () ->
673 interceptor.process(null, null, null));
674 final ClassicHttpResponse response = new BasicClassicHttpResponse(HttpStatus.SC_OK, "OK");
675 Assertions.assertThrows(NullPointerException.class, () ->
676 interceptor.process(response, null, null));
677 }
678
679 @Test
680 public void testResponseContentNoEntity() throws Exception {
681 final HttpContext context = new BasicHttpContext(null);
682 final ClassicHttpResponse response = new BasicClassicHttpResponse(HttpStatus.SC_OK, "OK");
683 final ResponseContent interceptor = new ResponseContent();
684 interceptor.process(response, response.getEntity(), context);
685 final Header header = response.getFirstHeader(HttpHeaders.CONTENT_LENGTH);
686 Assertions.assertNotNull(header);
687 Assertions.assertEquals("0", header.getValue());
688 }
689
690 @Test
691 public void testResponseContentStatusNoContent() throws Exception {
692 final HttpContext context = new BasicHttpContext(null);
693 final ClassicHttpResponse response = new BasicClassicHttpResponse(HttpStatus.SC_OK, "OK");
694 response.setCode(HttpStatus.SC_NO_CONTENT);
695 final ResponseContent interceptor = new ResponseContent();
696 interceptor.process(response, response.getEntity(), context);
697 final Header header = response.getFirstHeader(HttpHeaders.CONTENT_LENGTH);
698 Assertions.assertNull(header);
699 }
700
701 @Test
702 public void testResponseContentStatusNotModified() throws Exception {
703 final HttpContext context = new BasicHttpContext(null);
704 final ClassicHttpResponse response = new BasicClassicHttpResponse(HttpStatus.SC_OK, "OK");
705 response.setCode(HttpStatus.SC_NOT_MODIFIED);
706 final ResponseContent interceptor = new ResponseContent();
707 interceptor.process(response, response.getEntity(), context);
708 final Header header = response.getFirstHeader(HttpHeaders.CONTENT_LENGTH);
709 Assertions.assertNull(header);
710 }
711
712 @Test
713 public void testResponseContentEntityChunked() throws Exception {
714 final HttpContext context = new BasicHttpContext(null);
715 final ClassicHttpResponse response = new BasicClassicHttpResponse(HttpStatus.SC_OK, "OK");
716 response.setEntity(new BasicHttpEntity(EmptyInputStream.INSTANCE, null, true));
717 final ResponseContent interceptor = new ResponseContent();
718 interceptor.process(response, response.getEntity(), context);
719 final Header h1 = response.getFirstHeader(HttpHeaders.TRANSFER_ENCODING);
720 Assertions.assertNotNull(h1);
721 Assertions.assertEquals("chunked", h1.getValue());
722 final Header h2 = response.getFirstHeader(HttpHeaders.CONTENT_LENGTH);
723 Assertions.assertNull(h2);
724 }
725
726 @Test
727 public void testResponseContentEntityContentLenghtDelimited() throws Exception {
728 final HttpContext context = new BasicHttpContext(null);
729 final ClassicHttpResponse response = new BasicClassicHttpResponse(HttpStatus.SC_OK, "OK");
730 response.setEntity(new BasicHttpEntity(EmptyInputStream.INSTANCE, 10, null));
731 final ResponseContent interceptor = new ResponseContent();
732 interceptor.process(response, response.getEntity(), context);
733 final Header h1 = response.getFirstHeader(HttpHeaders.CONTENT_LENGTH);
734 Assertions.assertNotNull(h1);
735 Assertions.assertEquals("10", h1.getValue());
736 final Header h2 = response.getFirstHeader(HttpHeaders.TRANSFER_ENCODING);
737 Assertions.assertNull(h2);
738 }
739
740 @Test
741 public void testResponseContentEntityUnknownContentLength() throws Exception {
742 final HttpContext context = new BasicHttpContext(null);
743 final ClassicHttpResponse response = new BasicClassicHttpResponse(HttpStatus.SC_OK, "OK");
744 response.setEntity(new BasicHttpEntity(EmptyInputStream.INSTANCE, null));
745 final ResponseContent interceptor = new ResponseContent();
746 interceptor.process(response, response.getEntity(), context);
747 final Header h1 = response.getFirstHeader(HttpHeaders.TRANSFER_ENCODING);
748 Assertions.assertNotNull(h1);
749 Assertions.assertEquals("chunked", h1.getValue());
750 final Header h2 = response.getFirstHeader(HttpHeaders.CONTENT_LENGTH);
751 Assertions.assertNull(h2);
752 }
753
754 @Test
755 public void testResponseContentEntityChunkedHTTP10() throws Exception {
756 final HttpContext context = new BasicHttpContext(null);
757 context.setProtocolVersion(HttpVersion.HTTP_1_0);
758 final BasicClassicHttpResponse response = new BasicClassicHttpResponse(HttpStatus.SC_OK, "OK");
759 response.setEntity(new BasicHttpEntity(EmptyInputStream.INSTANCE, null, true));
760 final ResponseContent interceptor = new ResponseContent();
761 interceptor.process(response, response.getEntity(), context);
762 final Header h1 = response.getFirstHeader(HttpHeaders.TRANSFER_ENCODING);
763 Assertions.assertNull(h1);
764 final Header h2 = response.getFirstHeader(HttpHeaders.CONTENT_LENGTH);
765 Assertions.assertNull(h2);
766 }
767
768 @Test
769 public void testResponseContentEntityNoContentTypeAndEncoding() throws Exception {
770 final HttpContext context = new BasicHttpContext(null);
771 final ClassicHttpResponse response = new BasicClassicHttpResponse(HttpStatus.SC_OK, "OK");
772 response.setEntity(new BasicHttpEntity(EmptyInputStream.INSTANCE, null));
773 final ResponseContent interceptor = new ResponseContent();
774 interceptor.process(response, response.getEntity(), context);
775 final Header h1 = response.getFirstHeader(HttpHeaders.CONTENT_TYPE);
776 Assertions.assertNull(h1);
777 final Header h2 = response.getFirstHeader(HttpHeaders.CONTENT_ENCODING);
778 Assertions.assertNull(h2);
779 }
780
781 @Test
782 public void testResponseContentEntityContentTypeAndEncoding() throws Exception {
783 final HttpContext context = new BasicHttpContext(null);
784 final ClassicHttpResponse response = new BasicClassicHttpResponse(HttpStatus.SC_OK, "OK");
785 response.setEntity(new BasicHttpEntity(EmptyInputStream.INSTANCE,
786 ContentType.parseLenient("whatever"), "whatever"));
787 final ResponseContent interceptor = new ResponseContent();
788 interceptor.process(response, response.getEntity(), context);
789 final Header h1 = response.getFirstHeader(HttpHeaders.CONTENT_TYPE);
790 Assertions.assertNotNull(h1);
791 Assertions.assertEquals("whatever", h1.getValue());
792 final Header h2 = response.getFirstHeader(HttpHeaders.CONTENT_ENCODING);
793 Assertions.assertNotNull(h2);
794 Assertions.assertEquals("whatever", h2.getValue());
795 }
796
797 @Test
798 public void testResponseContentInvalidInput() throws Exception {
799 final ResponseContent interceptor = new ResponseContent();
800 Assertions.assertThrows(NullPointerException.class, () -> interceptor.process(null, null, null));
801 }
802
803 @Test
804 public void testResponseContentInvalidResponseState() throws Exception {
805 final ResponseContent interceptor = new ResponseContent();
806 final HttpContext context = new BasicHttpContext(null);
807 final ClassicHttpResponse response1 = new BasicClassicHttpResponse(HttpStatus.SC_OK, "OK");
808 response1.addHeader(new BasicHeader(HttpHeaders.CONTENT_LENGTH, "10"));
809 Assertions.assertThrows(ProtocolException.class, () ->
810 interceptor.process(response1, response1.getEntity(), context));
811 final ClassicHttpResponse response2 = new BasicClassicHttpResponse(HttpStatus.SC_OK, "OK");
812 response2.addHeader(new BasicHeader(HttpHeaders.TRANSFER_ENCODING, "stuff"));
813 Assertions.assertThrows(ProtocolException.class, () ->
814 interceptor.process(response2, response2.getEntity(), context));
815 }
816
817 @Test
818 public void testResponseContentOverwriteHeaders() throws Exception {
819 final ResponseContent interceptor = new ResponseContent(true);
820 final HttpContext context = new BasicHttpContext(null);
821 final ClassicHttpResponse response = new BasicClassicHttpResponse(HttpStatus.SC_OK, "OK");
822 response.addHeader(new BasicHeader(HttpHeaders.CONTENT_LENGTH, "10"));
823 response.addHeader(new BasicHeader(HttpHeaders.TRANSFER_ENCODING, "whatever"));
824 interceptor.process(response, response.getEntity(), context);
825 Assertions.assertEquals("0", response.getFirstHeader(HttpHeaders.CONTENT_LENGTH).getValue());
826 }
827
828 @Test
829 public void testResponseContentAddHeaders() throws Exception {
830 final ResponseContent interceptor = new ResponseContent(true);
831 final HttpContext context = new BasicHttpContext(null);
832 final ClassicHttpResponse response = new BasicClassicHttpResponse(HttpStatus.SC_OK, "OK");
833 interceptor.process(response, response.getEntity(), context);
834 Assertions.assertEquals("0", response.getFirstHeader(HttpHeaders.CONTENT_LENGTH).getValue());
835 Assertions.assertNull(response.getFirstHeader(HttpHeaders.TRANSFER_ENCODING));
836 }
837
838 @Test
839 public void testResponseContentEntityWithTrailers() throws Exception {
840 final HttpContext context = new BasicHttpContext(null);
841 final ClassicHttpResponse response = new BasicClassicHttpResponse(HttpStatus.SC_OK, "OK");
842 response.setEntity(HttpEntities.create("whatever", StandardCharsets.US_ASCII,
843 new BasicHeader("h1", "this"), new BasicHeader("h1", "that"), new BasicHeader("h2", "this and that")));
844
845 final ResponseContent interceptor = new ResponseContent();
846 interceptor.process(response, response.getEntity(), context);
847 final Header header1 = response.getFirstHeader(HttpHeaders.TRANSFER_ENCODING);
848 Assertions.assertNotNull(header1);
849 final Header header2 = response.getFirstHeader(HttpHeaders.TRAILER);
850 Assertions.assertNotNull(header2);
851 Assertions.assertEquals("h1, h2", header2.getValue());
852 }
853
854 @Test
855 public void testResponseDateGenerated() throws Exception {
856 final HttpContext context = new BasicHttpContext(null);
857 final ClassicHttpResponse response = new BasicClassicHttpResponse(HttpStatus.SC_OK, "OK");
858 final ResponseDate interceptor = new ResponseDate();
859 interceptor.process(response, response.getEntity(), context);
860 final Header h1 = response.getFirstHeader(HttpHeaders.DATE);
861 Assertions.assertNotNull(h1);
862 interceptor.process(response, response.getEntity(), context);
863 final Header h2 = response.getFirstHeader(HttpHeaders.DATE);
864 Assertions.assertNotNull(h2);
865 }
866
867 @Test
868 public void testResponseDateNotGenerated() throws Exception {
869 final HttpContext context = new BasicHttpContext(null);
870 final ClassicHttpResponse response = new BasicClassicHttpResponse(HttpStatus.SC_OK, "OK");
871 response.setCode(199);
872 final ResponseDate interceptor = new ResponseDate();
873 interceptor.process(response, response.getEntity(), context);
874 final Header h1 = response.getFirstHeader(HttpHeaders.DATE);
875 Assertions.assertNull(h1);
876 }
877
878 @Test
879 public void testResponseDateInvalidInput() throws Exception {
880 final ResponseDate interceptor = new ResponseDate();
881 Assertions.assertThrows(NullPointerException.class, () ->
882 interceptor.process(null, null, null));
883 }
884
885 @Test
886 public void testRequestDateGenerated() throws Exception {
887 final HttpContext context = new BasicHttpContext(null);
888 final BasicClassicHttpRequest request = new BasicClassicHttpRequest(Method.POST, "/");
889 request.setEntity(new StringEntity("stuff"));
890
891 final HttpRequestInterceptor interceptor = RequestDate.INSTANCE;
892 interceptor.process(request, request.getEntity(), context);
893 final Header h1 = request.getFirstHeader(HttpHeaders.DATE);
894 Assertions.assertNotNull(h1);
895 interceptor.process(request, request.getEntity(), context);
896 final Header h2 = request.getFirstHeader(HttpHeaders.DATE);
897 Assertions.assertNotNull(h2);
898 }
899
900 @Test
901 public void testRequestDateNotGenerated() throws Exception {
902 final HttpContext context = new BasicHttpContext(null);
903 final BasicClassicHttpRequest request = new BasicClassicHttpRequest(Method.GET, "/");
904
905 final HttpRequestInterceptor interceptor = RequestDate.INSTANCE;
906 interceptor.process(request, request.getEntity(), context);
907 final Header h1 = request.getFirstHeader(HttpHeaders.DATE);
908 Assertions.assertNull(h1);
909 }
910
911 @Test
912 public void testRequestDateInvalidInput() throws Exception {
913 final HttpRequestInterceptor interceptor = RequestDate.INSTANCE;
914 Assertions.assertThrows(NullPointerException.class, () ->
915 interceptor.process(null, null, null));
916 }
917
918 @Test
919 public void testResponseServerGenerated() throws Exception {
920 final HttpContext context = new BasicHttpContext(null);
921 final ClassicHttpResponse response = new BasicClassicHttpResponse(HttpStatus.SC_OK, "OK");
922 final ResponseServer interceptor = new ResponseServer("some server");
923 interceptor.process(response, response.getEntity(), context);
924 final Header h1 = response.getFirstHeader(HttpHeaders.SERVER);
925 Assertions.assertNotNull(h1);
926 Assertions.assertEquals("some server", h1.getValue());
927 }
928
929 @Test
930 public void testResponseServerNotGenerated() throws Exception {
931 final HttpContext context = new BasicHttpContext(null);
932 final ClassicHttpResponse response = new BasicClassicHttpResponse(HttpStatus.SC_OK, "OK");
933 response.addHeader(new BasicHeader(HttpHeaders.SERVER, "whatever"));
934 final ResponseServer interceptor = new ResponseServer("some server");
935 interceptor.process(response, response.getEntity(), context);
936 final Header h1 = response.getFirstHeader(HttpHeaders.SERVER);
937 Assertions.assertNotNull(h1);
938 Assertions.assertEquals("whatever", h1.getValue());
939 }
940
941 @Test
942 public void testResponseServerMissing() throws Exception {
943 final HttpContext context = new BasicHttpContext(null);
944 final ClassicHttpResponse response = new BasicClassicHttpResponse(HttpStatus.SC_OK, "OK");
945 final ResponseServer interceptor = new ResponseServer();
946 interceptor.process(response, response.getEntity(), context);
947 final Header h1 = response.getFirstHeader(HttpHeaders.SERVER);
948 Assertions.assertNull(h1);
949 }
950
951 @Test
952 public void testResponseServerInvalidInput() throws Exception {
953 final ResponseServer interceptor = new ResponseServer();
954 Assertions.assertThrows(NullPointerException.class, () -> interceptor.process(null, null, null));
955 }
956
957 @Test
958 public void testRequestHttp10HostHeaderAbsent() throws Exception {
959 final HttpContext context = new BasicHttpContext(null);
960 final BasicClassicHttpRequest request = new BasicClassicHttpRequest(Method.GET, "/");
961 request.setVersion(HttpVersion.HTTP_1_0);
962 final RequestValidateHost interceptor = new RequestValidateHost();
963 interceptor.process(request, request.getEntity(), context);
964 }
965
966 @Test
967 public void testRequestHttpHostHeader() throws Exception {
968 final HttpContext context = new BasicHttpContext(null);
969 final BasicClassicHttpRequest request = new BasicClassicHttpRequest(Method.GET, "/");
970 request.setVersion(HttpVersion.HTTP_1_1);
971 request.setHeader(HttpHeaders.HOST, "host:8888");
972 final RequestValidateHost interceptor = new RequestValidateHost();
973 interceptor.process(request, request.getEntity(), context);
974 Assertions.assertEquals(new URIAuthority("host", 8888), request.getAuthority());
975 }
976
977 @Test
978 public void testRequestHttpHostHeaderNoPort() throws Exception {
979 final HttpContext context = new BasicHttpContext(null);
980 final BasicClassicHttpRequest request = new BasicClassicHttpRequest(Method.GET, "/");
981 request.setVersion(HttpVersion.HTTP_1_1);
982 request.setHeader(HttpHeaders.HOST, "host");
983 final RequestValidateHost interceptor = new RequestValidateHost();
984 interceptor.process(request, request.getEntity(), context);
985 Assertions.assertEquals(new URIAuthority("host"), request.getAuthority());
986 }
987
988 @Test
989 public void testRequestHttp11HostHeaderPresent() throws Exception {
990 final HttpContext context = new BasicHttpContext(null);
991 final BasicClassicHttpRequest request = new BasicClassicHttpRequest(Method.GET, "/");
992 request.setHeader(HttpHeaders.HOST, "blah");
993 final RequestValidateHost interceptor = new RequestValidateHost();
994 interceptor.process(request, request.getEntity(), context);
995 }
996
997 @Test
998 public void testRequestHttp11HostHeaderAbsent() throws Exception {
999 final HttpContext context = new BasicHttpContext(null);
1000 final BasicClassicHttpRequest request = new BasicClassicHttpRequest(Method.GET, "/");
1001 final RequestValidateHost interceptor = new RequestValidateHost();
1002 Assertions.assertThrows(ProtocolException.class, () ->
1003 interceptor.process(request, request.getEntity(), context));
1004 }
1005
1006 @Test
1007 public void testRequestHttp11MultipleHostHeaders() throws Exception {
1008 final HttpContext context = new BasicHttpContext(null);
1009 final BasicClassicHttpRequest request = new BasicClassicHttpRequest(Method.GET, "/");
1010 request.addHeader(HttpHeaders.HOST, "blah");
1011 request.addHeader(HttpHeaders.HOST, "blah");
1012 final RequestValidateHost interceptor = new RequestValidateHost();
1013 Assertions.assertThrows(ProtocolException.class, () ->
1014 interceptor.process(request, request.getEntity(), context));
1015 }
1016
1017 @Test
1018 public void testRequestAbsoluteRequestURITakesPrecedenceOverHostHeader() throws Exception {
1019 final HttpContext context = new BasicHttpContext(null);
1020 final BasicClassicHttpRequest request = new BasicClassicHttpRequest(Method.GET, "https://somehost/blah?huh");
1021 request.setHeader(HttpHeaders.HOST, "blah");
1022 final RequestValidateHost interceptor = new RequestValidateHost();
1023 interceptor.process(request, request.getEntity(), context);
1024 Assertions.assertEquals(new URIAuthority("somehost"), request.getAuthority());
1025 }
1026
1027 @Test
1028 public void testRequestConformance() throws Exception {
1029 final HttpContext context = new BasicHttpContext(null);
1030 final BasicClassicHttpRequest request = new BasicClassicHttpRequest(Method.GET, "/");
1031 request.setScheme("http");
1032 request.setAuthority(new URIAuthority("somehost", 8888));
1033 request.setPath("/path");
1034 final RequestConformance interceptor = new RequestConformance();
1035 interceptor.process(request, request.getEntity(), context);
1036 }
1037
1038 @Test
1039 public void testRequestConformanceSchemeMissing() throws Exception {
1040 final HttpContext context = new BasicHttpContext(null);
1041 final BasicClassicHttpRequest request = new BasicClassicHttpRequest(Method.GET, "/");
1042 request.setAuthority(new URIAuthority("somehost", 8888));
1043 request.setPath("/path");
1044 final RequestConformance interceptor = new RequestConformance();
1045 Assertions.assertThrows(ProtocolException.class, () ->
1046 interceptor.process(request, request.getEntity(), context));
1047 }
1048
1049 @Test
1050 public void testRequestConformancePathMissing() throws Exception {
1051 final HttpContext context = new BasicHttpContext(null);
1052 final BasicClassicHttpRequest request = new BasicClassicHttpRequest(Method.GET, "/");
1053 request.setScheme("http");
1054 request.setAuthority(new URIAuthority("somehost", 8888));
1055 request.setPath("");
1056 final RequestConformance interceptor = new RequestConformance();
1057 Assertions.assertThrows(ProtocolException.class, () ->
1058 interceptor.process(request, request.getEntity(), context));
1059 }
1060
1061 @Test
1062 public void testRequestConformanceHostMissing() throws Exception {
1063 final HttpContext context = new BasicHttpContext(null);
1064 final BasicClassicHttpRequest request = new BasicClassicHttpRequest(Method.GET, "/");
1065 request.setScheme("http");
1066 request.setAuthority(new URIAuthority("", -1));
1067 request.setPath("/path");
1068 final RequestConformance interceptor = new RequestConformance();
1069 Assertions.assertThrows(ProtocolException.class, () ->
1070 interceptor.process(request, request.getEntity(), context));
1071 }
1072
1073 @Test
1074 public void testRequestConformanceHttps() throws Exception {
1075 final HttpContext context = new BasicHttpContext(null);
1076 context.setAttribute(HttpCoreContext.SSL_SESSION, Mockito.mock(SSLSession.class));
1077 final BasicClassicHttpRequest request = new BasicClassicHttpRequest(Method.GET, "/");
1078 request.setScheme("https");
1079 request.setAuthority(new URIAuthority("somehost", 8888));
1080 request.setPath("/path");
1081 final RequestConformance interceptor = new RequestConformance();
1082 interceptor.process(request, request.getEntity(), context);
1083 }
1084
1085 @Test
1086 public void testRequestConformanceHttpsInsecureConnection() throws Exception {
1087 final HttpContext context = new BasicHttpContext(null);
1088 context.setAttribute(HttpCoreContext.SSL_SESSION, null);
1089 final BasicClassicHttpRequest request = new BasicClassicHttpRequest(Method.GET, "/");
1090 request.setScheme("https");
1091 request.setAuthority(new URIAuthority("somehost", 8888));
1092 request.setPath("/path");
1093 final RequestConformance interceptor = new RequestConformance();
1094 Assertions.assertThrows(MisdirectedRequestException.class, () ->
1095 interceptor.process(request, request.getEntity(), context));
1096 }
1097
1098 @Test
1099 public void testResponseConformanceNoContent() throws Exception {
1100 final HttpContext context = new BasicHttpContext(null);
1101 final ClassicHttpResponse response = new BasicClassicHttpResponse(HttpStatus.SC_NO_CONTENT, "No Content");
1102 final ResponseConformance interceptor = new ResponseConformance();
1103 interceptor.process(response, response.getEntity(), context);
1104 }
1105
1106 @Test
1107 public void testResponseConformanceNotModified() throws Exception {
1108 final HttpContext context = new BasicHttpContext(null);
1109 final ClassicHttpResponse response = new BasicClassicHttpResponse(HttpStatus.SC_NOT_MODIFIED, "Not Modified");
1110 final ResponseConformance interceptor = new ResponseConformance();
1111 interceptor.process(response, response.getEntity(), context);
1112 }
1113
1114 @Test
1115 public void testResponseConformanceNoContentWithEntity() throws Exception {
1116 final HttpContext context = new BasicHttpContext(null);
1117 final ClassicHttpResponse response = new BasicClassicHttpResponse(HttpStatus.SC_NO_CONTENT, "No Content");
1118 response.setEntity(new StringEntity("stuff"));
1119 final ResponseConformance interceptor = new ResponseConformance();
1120 Assertions.assertThrows(ProtocolException.class, () ->
1121 interceptor.process(response, response.getEntity(), context));
1122 }
1123
1124 @Test
1125 public void testResponseConformanceNotModifiedWithEntity() throws Exception {
1126 final HttpContext context = new BasicHttpContext(null);
1127 final ClassicHttpResponse response = new BasicClassicHttpResponse(HttpStatus.SC_NOT_MODIFIED, "Not Modified");
1128 response.setEntity(new StringEntity("stuff"));
1129 final ResponseConformance interceptor = new ResponseConformance();
1130 Assertions.assertThrows(ProtocolException.class, () ->
1131 interceptor.process(response, response.getEntity(), context));
1132 }
1133
1134 }