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