View Javadoc
1   /*
2    * ====================================================================
3    * Licensed to the Apache Software Foundation (ASF) under one
4    * or more contributor license agreements.  See the NOTICE file
5    * distributed with this work for additional information
6    * regarding copyright ownership.  The ASF licenses this file
7    * to you under the Apache License, Version 2.0 (the
8    * "License"); you may not use this file except in compliance
9    * with the License.  You may obtain a copy of the License at
10   *
11   *   http://www.apache.org/licenses/LICENSE-2.0
12   *
13   * Unless required by applicable law or agreed to in writing,
14   * software distributed under the License is distributed on an
15   * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16   * KIND, either express or implied.  See the License for the
17   * specific language governing permissions and limitations
18   * under the License.
19   * ====================================================================
20   *
21   * This software consists of voluntary contributions made by many
22   * individuals on behalf of the Apache Software Foundation.  For more
23   * information on the Apache Software Foundation, please see
24   * <http://www.apache.org/>.
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              // expected
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             // expected
111         }
112         try {
113             interceptor.process(request2, context);
114             Assert.fail("ProtocolException should have been thrown");
115         } catch (final ProtocolException ex) {
116             // expected
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             // expected
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             // expected
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             // expected
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             // expected
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             // expected
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             // expected
445         }
446         try {
447             interceptor.process(new BasicHttpRequest("GET", "/"), null);
448             Assert.fail("IllegalArgumentException should have been thrown");
449         } catch (final IllegalArgumentException ex) {
450             // expected
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             // expected
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             // expected
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             // expected
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             // expected
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             // expected
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             // expected
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             // expected
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         //BasicHttpRequest request = new BasicHttpRequest("GET", "/");
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             // expected
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             // expected
1010         }
1011     }
1012 
1013 }