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