Eclipse
/
jetty.project
mirror of https://github.com/jetty/jetty.project.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Added tests for AsyncContext listeners behaviour.

This commit is contained in:
Simone Bordet 2013-08-21 22:18:56 +02:00
parent fd5d789ff5
commit 8951c4c773
1 changed files with 280 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

280
jetty-servlet/src/test/java/org/eclipse/jetty/servlet/AsyncContextListenersTest.java Normal file
View File

@ -0,0 +1,280 @@
//
// ========================================================================
// Copyright (c) 1995-2013 Mort Bay Consulting Pty. Ltd.
// ------------------------------------------------------------------------
// All rights reserved. This program and the accompanying materials
// are made available under the terms of the Eclipse Public License v1.0
// and Apache License v2.0 which accompanies this distribution.
//
// The Eclipse Public License is available at
// http://www.eclipse.org/legal/epl-v10.html
//
// The Apache License v2.0 is available at
// http://www.opensource.org/licenses/apache2.0.php
//
// You may elect to redistribute this code under either of these licenses.
// ========================================================================
//
package org.eclipse.jetty.servlet;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.net.Socket;
import java.util.concurrent.atomic.AtomicInteger;
import javax.servlet.AsyncContext;
import javax.servlet.AsyncEvent;
import javax.servlet.AsyncListener;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.eclipse.jetty.server.Server;
import org.eclipse.jetty.server.ServerConnector;
import org.eclipse.jetty.toolchain.test.http.SimpleHttpParser;
import org.eclipse.jetty.toolchain.test.http.SimpleHttpResponse;
import org.junit.After;
import org.junit.Assert;
import org.junit.Test;
public class AsyncContextListenersTest
{
private Server _server;
private ServerConnector _connector;
public void prepare(String path, HttpServlet servlet) throws Exception
{
_server = new Server();
_connector = new ServerConnector(_server);
_server.addConnector(_connector);
ServletContextHandler context = new ServletContextHandler(_server, "/", false, false);
context.addServlet(new ServletHolder(servlet), path);
_server.start();
}
@After
public void dispose() throws Exception
{
_server.stop();
}
@Test
public void testListenerClearedOnSecondRequest() throws Exception
{
final AtomicInteger completes = new AtomicInteger();
String path = "/path";
prepare(path, new HttpServlet()
{
@Override
protected void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException
{
AsyncContext asyncContext = request.startAsync(request, response);
asyncContext.addListener(new AsyncListener()
{
@Override
public void onStartAsync(AsyncEvent event) throws IOException
{
}
@Override
public void onComplete(AsyncEvent event) throws IOException
{
completes.incrementAndGet();
}
@Override
public void onTimeout(AsyncEvent event) throws IOException
{
}
@Override
public void onError(AsyncEvent event) throws IOException
{
}
});
asyncContext.complete();
}
});
try (Socket socket = new Socket("localhost", _connector.getLocalPort()))
{
OutputStream output = socket.getOutputStream();
String request = "" +
"GET " + path + " HTTP/1.1\r\n" +
"Host: localhost\r\n" +
"\r\n";
output.write(request.getBytes("UTF-8"));
output.flush();
BufferedReader reader = new BufferedReader(new InputStreamReader(socket.getInputStream(), "UTF-8"));
SimpleHttpParser parser = new SimpleHttpParser();
SimpleHttpResponse response = parser.readResponse(reader);
Assert.assertEquals("200", response.getCode());
Assert.assertEquals(1, completes.get());
// Send a second request
completes.set(0);
output.write(request.getBytes("UTF-8"));
output.flush();
response = parser.readResponse(reader);
Assert.assertEquals("200", response.getCode());
Assert.assertEquals(1, completes.get());
}
}
@Test
public void testListenerAddedFromListener() throws Exception
{
final AtomicInteger completes = new AtomicInteger();
String path = "/path";
prepare(path, new HttpServlet()
{
@Override
protected void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException
{
AsyncContext asyncContext = request.startAsync(request, response);
asyncContext.addListener(new AsyncListener()
{
@Override
public void onStartAsync(AsyncEvent event) throws IOException
{
// This method should not be invoked because we add the
// listener *after* having called startAsync(), but we
// add a listener to be sure it's not called (it will
// screw up the completes count and test will fail).
event.getAsyncContext().addListener(this);
}
@Override
public void onComplete(AsyncEvent event) throws IOException
{
completes.incrementAndGet();
}
@Override
public void onTimeout(AsyncEvent event) throws IOException
{
}
@Override
public void onError(AsyncEvent event) throws IOException
{
}
});
asyncContext.complete();
}
});
try (Socket socket = new Socket("localhost", _connector.getLocalPort()))
{
OutputStream output = socket.getOutputStream();
String request = "" +
"GET " + path + " HTTP/1.1\r\n" +
"Host: localhost\r\n" +
"\r\n";
output.write(request.getBytes("UTF-8"));
output.flush();
BufferedReader reader = new BufferedReader(new InputStreamReader(socket.getInputStream(), "UTF-8"));
SimpleHttpParser parser = new SimpleHttpParser();
SimpleHttpResponse response = parser.readResponse(reader);
Assert.assertEquals("200", response.getCode());
Assert.assertEquals(1, completes.get());
// Send a second request
completes.set(0);
output.write(request.getBytes("UTF-8"));
output.flush();
response = parser.readResponse(reader);
Assert.assertEquals("200", response.getCode());
Assert.assertEquals(1, completes.get());
}
}
@Test
public void testAsyncDispatchAsyncCompletePreservesListener() throws Exception
{
final AtomicInteger completes = new AtomicInteger();
final String path = "/path";
prepare(path + "/*", new HttpServlet()
{
@Override
protected void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException
{
String requestURI = request.getRequestURI();
if (requestURI.endsWith("/one"))
{
AsyncContext asyncContext = request.startAsync(request, response);
asyncContext.addListener(new AsyncListener()
{
@Override
public void onStartAsync(AsyncEvent event) throws IOException
{
event.getAsyncContext().addListener(this);
}
@Override
public void onComplete(AsyncEvent event) throws IOException
{
completes.incrementAndGet();
}
@Override
public void onTimeout(AsyncEvent event) throws IOException
{
}
@Override
public void onError(AsyncEvent event) throws IOException
{
}
});
// This dispatch() will call startAsync() again which will
// clear the previous listeners (as per the specification)
// but add a new listener from onStartAsync().
asyncContext.dispatch(path + "/two");
}
else if (requestURI.endsWith("/two"))
{
AsyncContext asyncContext = request.startAsync(request, response);
asyncContext.complete();
}
}
});
try (Socket socket = new Socket("localhost", _connector.getLocalPort()))
{
OutputStream output = socket.getOutputStream();
String request = "" +
"GET " + path + "/one HTTP/1.1\r\n" +
"Host: localhost\r\n" +
"\r\n";
output.write(request.getBytes("UTF-8"));
output.flush();
BufferedReader reader = new BufferedReader(new InputStreamReader(socket.getInputStream(), "UTF-8"));
SimpleHttpParser parser = new SimpleHttpParser();
SimpleHttpResponse response = parser.readResponse(reader);
Assert.assertEquals("200", response.getCode());
Assert.assertEquals(1, completes.get());
// Send a second request
completes.set(0);
output.write(request.getBytes("UTF-8"));
output.flush();
response = parser.readResponse(reader);
Assert.assertEquals("200", response.getCode());
Assert.assertEquals(1, completes.get());
}
}
}