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.io.InputStream;
31
32 import org.apache.http.ConnectionReuseStrategy;
33 import org.apache.http.HttpEntityEnclosingRequest;
34 import org.apache.http.HttpException;
35 import org.apache.http.HttpRequest;
36 import org.apache.http.HttpResponse;
37 import org.apache.http.HttpResponseFactory;
38 import org.apache.http.HttpServerConnection;
39 import org.apache.http.HttpStatus;
40 import org.apache.http.HttpVersion;
41 import org.apache.http.MethodNotSupportedException;
42 import org.apache.http.ProtocolException;
43 import org.apache.http.UnsupportedHttpVersionException;
44 import org.apache.http.entity.InputStreamEntity;
45 import org.apache.http.message.BasicHttpEntityEnclosingRequest;
46 import org.apache.http.message.BasicHttpRequest;
47 import org.apache.http.message.BasicHttpResponse;
48 import org.junit.Assert;
49 import org.junit.Test;
50 import org.mockito.Matchers;
51 import org.mockito.Mockito;
52
53 public class TestHttpService {
54
55 @Test
56 public void testInvalidInitialization() throws Exception {
57 final ConnectionReuseStrategy connReuseStrategy = Mockito.mock(ConnectionReuseStrategy.class);
58 final HttpResponseFactory responseFactory = Mockito.mock(HttpResponseFactory.class);
59 final HttpRequestHandlerMapper handlerResolver = Mockito.mock(HttpRequestHandlerMapper.class);
60 try {
61 new HttpService(
62 null,
63 connReuseStrategy,
64 responseFactory,
65 handlerResolver);
66 Assert.fail("IllegalArgumentException expected");
67 } catch (final IllegalArgumentException expected) {
68 }
69 }
70
71 @Test
72 public void testBasicExecution() throws Exception {
73 final HttpProcessor httprocessor = Mockito.mock(HttpProcessor.class);
74 final ConnectionReuseStrategy connReuseStrategy = Mockito.mock(ConnectionReuseStrategy.class);
75 final HttpResponseFactory responseFactory = Mockito.mock(HttpResponseFactory.class);
76 final HttpRequestHandlerMapper handlerResolver = Mockito.mock(HttpRequestHandlerMapper.class);
77
78 final HttpService httpservice = new HttpService(
79 httprocessor,
80 connReuseStrategy,
81 responseFactory,
82 handlerResolver);
83 final HttpCoreContext context = HttpCoreContext.create();
84 final HttpServerConnection conn = Mockito.mock(HttpServerConnection.class);
85 final HttpRequest request = new BasicHttpRequest("GET", "/");
86 Mockito.when(conn.receiveRequestHeader()).thenReturn(request);
87 final HttpResponse response = new BasicHttpResponse(HttpVersion.HTTP_1_1, 200, "OK");
88 Mockito.when(responseFactory.newHttpResponse(HttpVersion.HTTP_1_1, 200, context)).thenReturn(response);
89 Mockito.when(connReuseStrategy.keepAlive(response, context)).thenReturn(Boolean.FALSE);
90
91 httpservice.handleRequest(conn, context);
92
93 Assert.assertEquals(HttpStatus.SC_NOT_IMPLEMENTED, response.getStatusLine().getStatusCode());
94
95 Assert.assertSame(conn, context.getConnection());
96 Assert.assertSame(request, context.getRequest());
97 Assert.assertSame(response, context.getResponse());
98
99 Mockito.verify(httprocessor).process(request, context);
100 Mockito.verify(httprocessor).process(response, context);
101 Mockito.verify(conn).sendResponseHeader(response);
102 Mockito.verify(conn).sendResponseEntity(response);
103 Mockito.verify(conn).flush();
104 Mockito.verify(conn).close();
105 }
106
107 @Test
108 public void testBasicExecutionHTTP10() throws Exception {
109 final HttpProcessor httprocessor = Mockito.mock(HttpProcessor.class);
110 final ConnectionReuseStrategy connReuseStrategy = Mockito.mock(ConnectionReuseStrategy.class);
111 final HttpResponseFactory responseFactory = Mockito.mock(HttpResponseFactory.class);
112 final HttpRequestHandlerMapper handlerResolver = Mockito.mock(HttpRequestHandlerMapper.class);
113
114 final HttpService httpservice = new HttpService(
115 httprocessor,
116 connReuseStrategy,
117 responseFactory,
118 handlerResolver);
119 final HttpCoreContext context = HttpCoreContext.create();
120 final HttpServerConnection conn = Mockito.mock(HttpServerConnection.class);
121 final HttpRequest request = new BasicHttpRequest("GET", "/", HttpVersion.HTTP_1_0);
122 Mockito.when(conn.receiveRequestHeader()).thenReturn(request);
123 final HttpResponse response = new BasicHttpResponse(HttpVersion.HTTP_1_0, 200, "OK");
124 Mockito.when(responseFactory.newHttpResponse(HttpVersion.HTTP_1_1, 200, context)).thenReturn(response);
125 Mockito.when(connReuseStrategy.keepAlive(response, context)).thenReturn(Boolean.FALSE);
126
127 httpservice.handleRequest(conn, context);
128
129 Mockito.verify(responseFactory).newHttpResponse(HttpVersion.HTTP_1_1, 200, context);
130 }
131
132 @Test
133 public void testBasicProtocolDowngrade() throws Exception {
134 final HttpProcessor httprocessor = Mockito.mock(HttpProcessor.class);
135 final ConnectionReuseStrategy connReuseStrategy = Mockito.mock(ConnectionReuseStrategy.class);
136 final HttpResponseFactory responseFactory = Mockito.mock(HttpResponseFactory.class);
137 final HttpRequestHandlerMapper handlerResolver = Mockito.mock(HttpRequestHandlerMapper.class);
138
139 final HttpService httpservice = new HttpService(
140 httprocessor,
141 connReuseStrategy,
142 responseFactory,
143 handlerResolver);
144 final HttpCoreContext context = HttpCoreContext.create();
145 final HttpServerConnection conn = Mockito.mock(HttpServerConnection.class);
146 final HttpRequest request = new BasicHttpRequest("GET", "/", new HttpVersion(20, 45));
147 Mockito.when(conn.receiveRequestHeader()).thenReturn(request);
148 final HttpResponse response = new BasicHttpResponse(HttpVersion.HTTP_1_1, 200, "OK");
149 Mockito.when(responseFactory.newHttpResponse(HttpVersion.HTTP_1_1, 200, context)).thenReturn(response);
150 Mockito.when(connReuseStrategy.keepAlive(response, context)).thenReturn(Boolean.FALSE);
151
152 httpservice.handleRequest(conn, context);
153
154 Mockito.verify(responseFactory).newHttpResponse(HttpVersion.HTTP_1_1, 200, context);
155 }
156
157 @Test
158 public void testExecutionEntityEnclosingRequest() throws Exception {
159 final HttpProcessor httprocessor = Mockito.mock(HttpProcessor.class);
160 final ConnectionReuseStrategy connReuseStrategy = Mockito.mock(ConnectionReuseStrategy.class);
161 final HttpResponseFactory responseFactory = Mockito.mock(HttpResponseFactory.class);
162 final HttpRequestHandlerMapper handlerResolver = Mockito.mock(HttpRequestHandlerMapper.class);
163
164 final HttpService httpservice = new HttpService(
165 httprocessor,
166 connReuseStrategy,
167 responseFactory,
168 handlerResolver);
169 final HttpCoreContext context = HttpCoreContext.create();
170 final HttpServerConnection conn = Mockito.mock(HttpServerConnection.class);
171 final HttpEntityEnclosingRequest request = new BasicHttpEntityEnclosingRequest("POST", "/");
172 final InputStream inStream = Mockito.mock(InputStream.class);
173 final InputStreamEntity entity = new InputStreamEntity(inStream, -1);
174 request.setEntity(entity);
175
176 Mockito.when(conn.receiveRequestHeader()).thenReturn(request);
177 final HttpResponse response = new BasicHttpResponse(HttpVersion.HTTP_1_1, 200, "OK");
178 Mockito.when(responseFactory.newHttpResponse(HttpVersion.HTTP_1_1, 200, context)).thenReturn(response);
179 Mockito.when(connReuseStrategy.keepAlive(response, context)).thenReturn(Boolean.FALSE);
180
181 httpservice.handleRequest(conn, context);
182
183 Assert.assertEquals(HttpStatus.SC_NOT_IMPLEMENTED, response.getStatusLine().getStatusCode());
184
185 Assert.assertSame(conn, context.getConnection());
186 Assert.assertSame(request, context.getRequest());
187 Assert.assertSame(response, context.getResponse());
188
189 Mockito.verify(conn).receiveRequestEntity(request);
190 Mockito.verify(httprocessor).process(request, context);
191 Mockito.verify(inStream).close();
192 Mockito.verify(httprocessor).process(response, context);
193 Mockito.verify(conn).sendResponseHeader(response);
194 Mockito.verify(conn).sendResponseEntity(response);
195 Mockito.verify(conn).flush();
196 Mockito.verify(conn).close();
197 }
198
199 @Test
200 public void testExecutionEntityEnclosingRequestWithExpectContinue() throws Exception {
201 final HttpProcessor httprocessor = Mockito.mock(HttpProcessor.class);
202 final ConnectionReuseStrategy connReuseStrategy = Mockito.mock(ConnectionReuseStrategy.class);
203 final HttpResponseFactory responseFactory = Mockito.mock(HttpResponseFactory.class);
204 final HttpRequestHandlerMapper handlerResolver = Mockito.mock(HttpRequestHandlerMapper.class);
205
206 final HttpService httpservice = new HttpService(
207 httprocessor,
208 connReuseStrategy,
209 responseFactory,
210 handlerResolver);
211 final HttpCoreContext context = HttpCoreContext.create();
212 final HttpServerConnection conn = Mockito.mock(HttpServerConnection.class);
213 final HttpEntityEnclosingRequest request = new BasicHttpEntityEnclosingRequest("POST", "/");
214 request.addHeader(HTTP.EXPECT_DIRECTIVE, HTTP.EXPECT_CONTINUE);
215 final InputStream inStream = Mockito.mock(InputStream.class);
216 final InputStreamEntity entity = new InputStreamEntity(inStream, -1);
217 request.setEntity(entity);
218
219 Mockito.when(conn.receiveRequestHeader()).thenReturn(request);
220 final HttpResponse resp100 = new BasicHttpResponse(HttpVersion.HTTP_1_1, 100, "Continue");
221 Mockito.when(responseFactory.newHttpResponse(HttpVersion.HTTP_1_1, 100, context)).thenReturn(resp100);
222 final HttpResponse response = new BasicHttpResponse(HttpVersion.HTTP_1_1, 200, "OK");
223 Mockito.when(responseFactory.newHttpResponse(HttpVersion.HTTP_1_1, 200, context)).thenReturn(response);
224 Mockito.when(connReuseStrategy.keepAlive(response, context)).thenReturn(Boolean.FALSE);
225
226 httpservice.handleRequest(conn, context);
227
228 Assert.assertEquals(HttpStatus.SC_NOT_IMPLEMENTED, response.getStatusLine().getStatusCode());
229
230 Assert.assertSame(conn, context.getConnection());
231 Assert.assertSame(request, context.getRequest());
232 Assert.assertSame(response, context.getResponse());
233
234 Mockito.verify(conn).sendResponseHeader(resp100);
235 Mockito.verify(conn).receiveRequestEntity(request);
236 Mockito.verify(httprocessor).process(request, context);
237 Mockito.verify(inStream).close();
238 Mockito.verify(httprocessor).process(response, context);
239 Mockito.verify(conn).sendResponseHeader(response);
240 Mockito.verify(conn).sendResponseEntity(response);
241 Mockito.verify(conn, Mockito.times(2)).flush();
242 Mockito.verify(conn).close();
243 }
244
245 @Test
246 public void testExecutionEntityEnclosingRequestCustomExpectationVerifier() throws Exception {
247 final HttpProcessor httprocessor = Mockito.mock(HttpProcessor.class);
248 final ConnectionReuseStrategy connReuseStrategy = Mockito.mock(ConnectionReuseStrategy.class);
249 final HttpResponseFactory responseFactory = Mockito.mock(HttpResponseFactory.class);
250 final HttpRequestHandlerMapper handlerResolver = Mockito.mock(HttpRequestHandlerMapper.class);
251
252 final HttpExpectationVerifier expectationVerifier = new HttpExpectationVerifier() {
253
254 @Override
255 public void verify(
256 final HttpRequest request,
257 final HttpResponse response,
258 final HttpContext context) throws HttpException {
259 response.setStatusCode(HttpStatus.SC_UNAUTHORIZED);
260 }
261
262 };
263
264 final HttpService httpservice = new HttpService(
265 httprocessor,
266 connReuseStrategy,
267 responseFactory,
268 handlerResolver,
269 expectationVerifier);
270 final HttpCoreContext context = HttpCoreContext.create();
271 final HttpServerConnection conn = Mockito.mock(HttpServerConnection.class);
272 final HttpEntityEnclosingRequest request = new BasicHttpEntityEnclosingRequest("POST", "/");
273 request.addHeader(HTTP.EXPECT_DIRECTIVE, HTTP.EXPECT_CONTINUE);
274 final InputStream inStream = Mockito.mock(InputStream.class);
275 final InputStreamEntity entity = new InputStreamEntity(inStream, -1);
276 request.setEntity(entity);
277
278 Mockito.when(conn.receiveRequestHeader()).thenReturn(request);
279 final HttpResponse response = new BasicHttpResponse(HttpVersion.HTTP_1_1, 100, "Continue");
280 Mockito.when(responseFactory.newHttpResponse(HttpVersion.HTTP_1_1, 100, context)).thenReturn(response);
281 Mockito.when(connReuseStrategy.keepAlive(response, context)).thenReturn(Boolean.FALSE);
282
283 httpservice.handleRequest(conn, context);
284
285 Assert.assertSame(conn, context.getConnection());
286 Assert.assertSame(request, context.getRequest());
287 Assert.assertSame(response, context.getResponse());
288
289 Assert.assertEquals(HttpStatus.SC_UNAUTHORIZED, response.getStatusLine().getStatusCode());
290
291 Mockito.verify(conn).sendResponseHeader(response);
292 Mockito.verify(conn, Mockito.never()).receiveRequestEntity(request);
293 Mockito.verify(httprocessor).process(response, context);
294 Mockito.verify(conn).sendResponseHeader(response);
295 Mockito.verify(conn).sendResponseEntity(response);
296 Mockito.verify(conn).flush();
297 Mockito.verify(conn).close();
298 }
299
300 @Test
301 public void testExecutionExceptionInCustomExpectationVerifier() throws Exception {
302 final HttpProcessor httprocessor = Mockito.mock(HttpProcessor.class);
303 final ConnectionReuseStrategy connReuseStrategy = Mockito.mock(ConnectionReuseStrategy.class);
304 final HttpResponseFactory responseFactory = Mockito.mock(HttpResponseFactory.class);
305 final HttpExpectationVerifier expectationVerifier = Mockito.mock(HttpExpectationVerifier.class);
306 final HttpRequestHandlerMapper handlerResolver = Mockito.mock(HttpRequestHandlerMapper.class);
307
308 final HttpService httpservice = new HttpService(
309 httprocessor,
310 connReuseStrategy,
311 responseFactory,
312 handlerResolver,
313 expectationVerifier);
314 final HttpCoreContext context = HttpCoreContext.create();
315 final HttpServerConnection conn = Mockito.mock(HttpServerConnection.class);
316 final HttpEntityEnclosingRequest request = new BasicHttpEntityEnclosingRequest("POST", "/");
317 request.addHeader(HTTP.EXPECT_DIRECTIVE, HTTP.EXPECT_CONTINUE);
318 final InputStream inStream = Mockito.mock(InputStream.class);
319 final InputStreamEntity entity = new InputStreamEntity(inStream, -1);
320 request.setEntity(entity);
321
322 Mockito.when(conn.receiveRequestHeader()).thenReturn(request);
323 final HttpResponse resp100 = new BasicHttpResponse(HttpVersion.HTTP_1_1, 100, "Continue");
324 Mockito.when(responseFactory.newHttpResponse(HttpVersion.HTTP_1_1, 100, context)).thenReturn(resp100);
325 final HttpResponse response = new BasicHttpResponse(HttpVersion.HTTP_1_0, 500, "Oppsie");
326 Mockito.when(responseFactory.newHttpResponse(HttpVersion.HTTP_1_0, 500, context)).thenReturn(response);
327 Mockito.doThrow(new HttpException("Oopsie")).when(expectationVerifier).verify(request, resp100, context);
328 Mockito.when(connReuseStrategy.keepAlive(response, context)).thenReturn(Boolean.FALSE);
329
330 httpservice.handleRequest(conn, context);
331
332 Assert.assertSame(conn, context.getConnection());
333 Assert.assertSame(request, context.getRequest());
334 Assert.assertSame(response, context.getResponse());
335
336 Assert.assertEquals(HttpStatus.SC_INTERNAL_SERVER_ERROR, response.getStatusLine().getStatusCode());
337
338 Mockito.verify(conn).sendResponseHeader(response);
339 Mockito.verify(conn, Mockito.never()).receiveRequestEntity(request);
340 Mockito.verify(httprocessor).process(response, context);
341 Mockito.verify(conn).sendResponseHeader(response);
342 Mockito.verify(conn).sendResponseEntity(response);
343 Mockito.verify(conn).flush();
344 Mockito.verify(conn).close();
345 }
346
347 @Test
348 public void testMethodNotSupported() throws Exception {
349 final HttpProcessor httprocessor = Mockito.mock(HttpProcessor.class);
350 final ConnectionReuseStrategy connReuseStrategy = Mockito.mock(ConnectionReuseStrategy.class);
351 final HttpResponseFactory responseFactory = Mockito.mock(HttpResponseFactory.class);
352 final HttpRequestHandlerMapper handlerResolver = Mockito.mock(HttpRequestHandlerMapper.class);
353 final HttpRequestHandler requestHandler = Mockito.mock(HttpRequestHandler.class);
354
355 final HttpService httpservice = new HttpService(
356 httprocessor,
357 connReuseStrategy,
358 responseFactory,
359 handlerResolver);
360 final HttpCoreContext context = HttpCoreContext.create();
361 final HttpServerConnection conn = Mockito.mock(HttpServerConnection.class);
362 final HttpRequest request = new BasicHttpRequest("whatever", "/");
363
364 Mockito.when(conn.receiveRequestHeader()).thenReturn(request);
365 final HttpResponse response = new BasicHttpResponse(HttpVersion.HTTP_1_1, 200, "OK");
366 Mockito.when(responseFactory.newHttpResponse(HttpVersion.HTTP_1_1, 200, context)).thenReturn(response);
367 final HttpResponse error = new BasicHttpResponse(HttpVersion.HTTP_1_0, 500, "Oppsie");
368 Mockito.when(responseFactory.newHttpResponse(HttpVersion.HTTP_1_0, 500, context)).thenReturn(error);
369 Mockito.when(handlerResolver.lookup(request)).thenReturn(requestHandler);
370 Mockito.doThrow(new MethodNotSupportedException("whatever")).when(
371 requestHandler).handle(request, response, context);
372 Mockito.when(connReuseStrategy.keepAlive(error, context)).thenReturn(Boolean.FALSE);
373
374 httpservice.handleRequest(conn, context);
375
376 Assert.assertSame(conn, context.getConnection());
377 Assert.assertSame(request, context.getRequest());
378 Assert.assertSame(error, context.getResponse());
379
380 Assert.assertEquals(HttpStatus.SC_NOT_IMPLEMENTED, error.getStatusLine().getStatusCode());
381
382 Mockito.verify(conn).sendResponseHeader(error);
383 Mockito.verify(httprocessor).process(error, context);
384 Mockito.verify(conn).sendResponseHeader(error);
385 Mockito.verify(conn).sendResponseEntity(error);
386 Mockito.verify(conn).flush();
387 Mockito.verify(conn).close();
388 }
389
390 @Test
391 public void testUnsupportedHttpVersionException() throws Exception {
392 final HttpProcessor httprocessor = Mockito.mock(HttpProcessor.class);
393 final ConnectionReuseStrategy connReuseStrategy = Mockito.mock(ConnectionReuseStrategy.class);
394 final HttpResponseFactory responseFactory = Mockito.mock(HttpResponseFactory.class);
395 final HttpRequestHandlerMapper handlerResolver = Mockito.mock(HttpRequestHandlerMapper.class);
396 final HttpRequestHandler requestHandler = Mockito.mock(HttpRequestHandler.class);
397
398 final HttpService httpservice = new HttpService(
399 httprocessor,
400 connReuseStrategy,
401 responseFactory,
402 handlerResolver);
403 final HttpCoreContext context = HttpCoreContext.create();
404 final HttpServerConnection conn = Mockito.mock(HttpServerConnection.class);
405 final HttpRequest request = new BasicHttpRequest("whatever", "/");
406
407 Mockito.when(conn.receiveRequestHeader()).thenReturn(request);
408 final HttpResponse response = new BasicHttpResponse(HttpVersion.HTTP_1_1, 200, "OK");
409 Mockito.when(responseFactory.newHttpResponse(HttpVersion.HTTP_1_1, 200, context)).thenReturn(response);
410 final HttpResponse error = new BasicHttpResponse(HttpVersion.HTTP_1_0, 500, "Oppsie");
411 Mockito.when(responseFactory.newHttpResponse(HttpVersion.HTTP_1_0, 500, context)).thenReturn(error);
412 Mockito.when(handlerResolver.lookup(request)).thenReturn(requestHandler);
413 Mockito.doThrow(new UnsupportedHttpVersionException()).when(
414 requestHandler).handle(request, response, context);
415 Mockito.when(connReuseStrategy.keepAlive(error, context)).thenReturn(Boolean.FALSE);
416
417 httpservice.handleRequest(conn, context);
418
419 Assert.assertSame(conn, context.getConnection());
420 Assert.assertSame(request, context.getRequest());
421 Assert.assertSame(error, context.getResponse());
422
423 Assert.assertEquals(HttpStatus.SC_HTTP_VERSION_NOT_SUPPORTED, error.getStatusLine().getStatusCode());
424
425 Mockito.verify(conn).sendResponseHeader(error);
426 Mockito.verify(httprocessor).process(error, context);
427 Mockito.verify(conn).sendResponseHeader(error);
428 Mockito.verify(conn).sendResponseEntity(error);
429 Mockito.verify(conn).flush();
430 Mockito.verify(conn).close();
431 }
432
433 @Test
434 public void testProtocolException() throws Exception {
435 final HttpProcessor httprocessor = Mockito.mock(HttpProcessor.class);
436 final ConnectionReuseStrategy connReuseStrategy = Mockito.mock(ConnectionReuseStrategy.class);
437 final HttpResponseFactory responseFactory = Mockito.mock(HttpResponseFactory.class);
438 final HttpRequestHandlerMapper handlerResolver = Mockito.mock(HttpRequestHandlerMapper.class);
439 final HttpRequestHandler requestHandler = Mockito.mock(HttpRequestHandler.class);
440
441 final HttpService httpservice = new HttpService(
442 httprocessor,
443 connReuseStrategy,
444 responseFactory,
445 handlerResolver);
446 final HttpCoreContext context = HttpCoreContext.create();
447 final HttpServerConnection conn = Mockito.mock(HttpServerConnection.class);
448 final HttpRequest request = new BasicHttpRequest("whatever", "/");
449
450 Mockito.when(conn.receiveRequestHeader()).thenReturn(request);
451 final HttpResponse response = new BasicHttpResponse(HttpVersion.HTTP_1_1, 200, "OK");
452 Mockito.when(responseFactory.newHttpResponse(HttpVersion.HTTP_1_1, 200, context)).thenReturn(response);
453 final HttpResponse error = new BasicHttpResponse(HttpVersion.HTTP_1_0, 500, "Oppsie");
454 Mockito.when(responseFactory.newHttpResponse(HttpVersion.HTTP_1_0, 500, context)).thenReturn(error);
455 Mockito.when(handlerResolver.lookup(request)).thenReturn(requestHandler);
456 Mockito.doThrow(new ProtocolException("oh, this world is wrong")).when(
457 requestHandler).handle(request, response, context);
458 Mockito.when(connReuseStrategy.keepAlive(error, context)).thenReturn(Boolean.FALSE);
459
460 httpservice.handleRequest(conn, context);
461
462 Assert.assertSame(conn, context.getConnection());
463 Assert.assertSame(request, context.getRequest());
464 Assert.assertSame(error, context.getResponse());
465
466 Assert.assertEquals(HttpStatus.SC_BAD_REQUEST, error.getStatusLine().getStatusCode());
467
468 Mockito.verify(conn).sendResponseHeader(error);
469 Mockito.verify(httprocessor).process(error, context);
470 Mockito.verify(conn).sendResponseHeader(error);
471 Mockito.verify(conn).sendResponseEntity(error);
472 Mockito.verify(conn).flush();
473 Mockito.verify(conn).close();
474 }
475
476 @Test
477 public void testConnectionKeepAlive() throws Exception {
478 final HttpProcessor httprocessor = Mockito.mock(HttpProcessor.class);
479 final ConnectionReuseStrategy connReuseStrategy = Mockito.mock(ConnectionReuseStrategy.class);
480 final HttpResponseFactory responseFactory = Mockito.mock(HttpResponseFactory.class);
481 final HttpRequestHandlerMapper handlerResolver = Mockito.mock(HttpRequestHandlerMapper.class);
482 final HttpRequestHandler requestHandler = Mockito.mock(HttpRequestHandler.class);
483
484 final HttpService httpservice = new HttpService(
485 httprocessor,
486 connReuseStrategy,
487 responseFactory,
488 handlerResolver);
489 final HttpCoreContext context = HttpCoreContext.create();
490 final HttpServerConnection conn = Mockito.mock(HttpServerConnection.class);
491 final HttpRequest request = new BasicHttpRequest("GET", "/");
492 Mockito.when(conn.receiveRequestHeader()).thenReturn(request);
493 final HttpResponse response = new BasicHttpResponse(HttpVersion.HTTP_1_1, 200, "OK");
494 Mockito.when(responseFactory.newHttpResponse(HttpVersion.HTTP_1_1, 200, context)).thenReturn(response);
495 Mockito.when(handlerResolver.lookup(request)).thenReturn(requestHandler);
496 Mockito.when(connReuseStrategy.keepAlive(response, context)).thenReturn(Boolean.TRUE);
497
498 httpservice.handleRequest(conn, context);
499
500 Assert.assertEquals(HttpStatus.SC_OK, response.getStatusLine().getStatusCode());
501
502 Assert.assertSame(conn, context.getConnection());
503 Assert.assertSame(request, context.getRequest());
504 Assert.assertSame(response, context.getResponse());
505
506 Mockito.verify(httprocessor).process(request, context);
507 Mockito.verify(httprocessor).process(response, context);
508 Mockito.verify(conn).sendResponseHeader(response);
509 Mockito.verify(conn).sendResponseEntity(response);
510 Mockito.verify(conn).flush();
511 Mockito.verify(conn, Mockito.never()).close();
512 }
513
514 @Test
515 public void testNoContentResponse() throws Exception {
516 final HttpProcessor httprocessor = Mockito.mock(HttpProcessor.class);
517 final ConnectionReuseStrategy connReuseStrategy = Mockito.mock(ConnectionReuseStrategy.class);
518 final HttpResponseFactory responseFactory = Mockito.mock(HttpResponseFactory.class);
519 final HttpRequestHandlerMapper handlerResolver = Mockito.mock(HttpRequestHandlerMapper.class);
520 final HttpRequestHandler requestHandler = Mockito.mock(HttpRequestHandler.class);
521
522 final HttpService httpservice = new HttpService(
523 httprocessor,
524 connReuseStrategy,
525 responseFactory,
526 handlerResolver);
527 final HttpCoreContext context = HttpCoreContext.create();
528 final HttpServerConnection conn = Mockito.mock(HttpServerConnection.class);
529 final HttpRequest request = new BasicHttpRequest("GET", "/");
530
531 Mockito.when(conn.receiveRequestHeader()).thenReturn(request);
532 final HttpResponse response = new BasicHttpResponse(HttpVersion.HTTP_1_1, HttpStatus.SC_NO_CONTENT, "No Content");
533 Mockito.when(responseFactory.newHttpResponse(HttpVersion.HTTP_1_1, 200, context)).thenReturn(response);
534 Mockito.when(handlerResolver.lookup(request)).thenReturn(requestHandler);
535 Mockito.when(connReuseStrategy.keepAlive(response, context)).thenReturn(Boolean.TRUE);
536
537 httpservice.handleRequest(conn, context);
538
539 Assert.assertSame(conn, context.getConnection());
540 Assert.assertSame(request, context.getRequest());
541
542 Mockito.verify(httprocessor).process(response, context);
543 Mockito.verify(requestHandler).handle(request, response, context);
544
545 Mockito.verify(conn).sendResponseHeader(response);
546 Mockito.verify(conn, Mockito.never()).sendResponseEntity(Matchers.<HttpResponse>any());
547 Mockito.verify(conn).flush();
548 Mockito.verify(conn, Mockito.never()).close();
549 }
550
551 @Test
552 public void testResponseToHead() throws Exception {
553 final HttpProcessor httprocessor = Mockito.mock(HttpProcessor.class);
554 final ConnectionReuseStrategy connReuseStrategy = Mockito.mock(ConnectionReuseStrategy.class);
555 final HttpResponseFactory responseFactory = Mockito.mock(HttpResponseFactory.class);
556 final HttpRequestHandlerMapper handlerResolver = Mockito.mock(HttpRequestHandlerMapper.class);
557 final HttpRequestHandler requestHandler = Mockito.mock(HttpRequestHandler.class);
558
559 final HttpService httpservice = new HttpService(
560 httprocessor,
561 connReuseStrategy,
562 responseFactory,
563 handlerResolver);
564 final HttpCoreContext context = HttpCoreContext.create();
565 final HttpServerConnection conn = Mockito.mock(HttpServerConnection.class);
566 final HttpRequest request = new BasicHttpRequest("HEAD", "/");
567
568 Mockito.when(conn.receiveRequestHeader()).thenReturn(request);
569 final HttpResponse response = new BasicHttpResponse(HttpVersion.HTTP_1_1, 200, "OK");
570 Mockito.when(responseFactory.newHttpResponse(HttpVersion.HTTP_1_1, 200, context)).thenReturn(response);
571 Mockito.when(handlerResolver.lookup(request)).thenReturn(requestHandler);
572 Mockito.when(connReuseStrategy.keepAlive(response, context)).thenReturn(Boolean.TRUE);
573
574 httpservice.handleRequest(conn, context);
575
576 Assert.assertSame(conn, context.getConnection());
577 Assert.assertSame(request, context.getRequest());
578
579 Mockito.verify(httprocessor).process(response, context);
580 Mockito.verify(requestHandler).handle(request, response, context);
581
582 Mockito.verify(conn).sendResponseHeader(response);
583 Mockito.verify(conn, Mockito.never()).sendResponseEntity(Matchers.<HttpResponse>any());
584 Mockito.verify(conn).flush();
585 Mockito.verify(conn, Mockito.never()).close();
586 }
587
588 }