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