54

我想知道对 servlet 进行单元测试的最佳方法是什么。

测试内部方法只要不引用 servlet 上下文就没有问题，但是测试 doGet/doPost 方法以及引用上下文或使用会话参数的内部方法呢？

有没有一种方法可以简单地使用 JUnit 等经典工具，或者最好使用 TestNG？我需要嵌入一个tomcat服务器或类似的东西吗？

4

8 回答 8

47

大多数时候，我通过“集成测试”而不是纯单元测试来测试 Servlet 和 JSP。有大量可用的 JUnit/TestNG 附加组件，包括：

  • HttpUnit（最古老和最著名的，非常低的级别，根据您的需要可以是好是坏）
  • HtmlUnit（比HttpUnit更高级别，对很多项目来说更好）
  • JWebUnit（位于其他测试工具之上并尝试简化它们 - 我更喜欢的那个）
  • WatiJ和 Selenium（使用你的浏览器做测试，更重量级但更现实）

这是一个简单的订单处理 Servlet 的 JWebUnit 测试，它处理来自“orderEntry.html”表单的输入。它需要一个客户 ID、一个客户名称和一个或多个订单项：

public class OrdersPageTest {
    private static final String WEBSITE_URL = "http://localhost:8080/demo1";

    @Before
    public void start() {
        webTester = new WebTester();
        webTester.setTestingEngineKey(TestingEngineRegistry.TESTING_ENGINE_HTMLUNIT);
        webTester.getTestContext().setBaseUrl(WEBSITE_URL);
    }
    @Test
    public void sanity() throws Exception {
        webTester.beginAt("/orderEntry.html");
        webTester.assertTitleEquals("Order Entry Form");
    }
    @Test
    public void idIsRequired() throws Exception {
        webTester.beginAt("/orderEntry.html");
        webTester.submit();
        webTester.assertTextPresent("ID Missing!");
    }
    @Test
    public void nameIsRequired() throws Exception {
        webTester.beginAt("/orderEntry.html");
        webTester.setTextField("id","AB12");
        webTester.submit();
        webTester.assertTextPresent("Name Missing!");
    }
    @Test
    public void validOrderSucceeds() throws Exception {
        webTester.beginAt("/orderEntry.html");
        webTester.setTextField("id","AB12");
        webTester.setTextField("name","Joe Bloggs");

        //fill in order line one
        webTester.setTextField("lineOneItemNumber", "AA");
        webTester.setTextField("lineOneQuantity", "12");
        webTester.setTextField("lineOneUnitPrice", "3.4");

        //fill in order line two
        webTester.setTextField("lineTwoItemNumber", "BB");
        webTester.setTextField("lineTwoQuantity", "14");
        webTester.setTextField("lineTwoUnitPrice", "5.6");

        webTester.submit();
        webTester.assertTextPresent("Total: 119.20");
    }
    private WebTester webTester;
}
于 2008-09-18T09:11:56.543 回答
13

尝试HttpUnit，尽管您最终可能会编写更多的“集成测试”（模块的）而不是“单元测试”（单个类的）。

于 2008-09-18T08:22:57.270 回答
11

我查看了发布的答案，并认为我会发布一个更完整的解决方案，该解决方案实际上演示了如何使用嵌入式 GlassFish 及其 Apache Maven 插件进行测试。

我在我的博客Using GlassFish 3.1.1 Embedded with JUnit 4.x 和 HtmlUnit 2.x上写了完整的过程，并将完整的项目放在 Bitbucket 上供下载：image-servlet

在我看到这个问题之前，我正在查看关于 JSP/JSF 标记的图像 servlet 的另一篇文章。所以我将我在另一篇文章中使用的解决方案与这篇文章的完整单元测试版本结合起来。

如何测试

Apache Maven 具有定义明确的生命周期，其中包括test. 我将使用它以及另一个调用integration-test来实现我的解决方案的生命周期。

  1. 在 surefire 插件中禁用标准生命周期单元测试。
  2. 添加integration-test作为surefire插件执行的一部分
  3. 将 GlassFish Maven 插件添加到 POM。
  4. 将 GlassFish 配置为在integration-test生命周期内执行。
  5. 运行单元测试（集成测试）。

GlassFish 插件

将此插件添加为<build>.

        <plugin>
            <groupId>org.glassfish</groupId>
            <artifactId>maven-embedded-glassfish-plugin</artifactId>
            <version>3.1.1</version>
            <configuration>
                <!-- This sets the path to use the war file we have built in the target directory -->
                <app>target/${project.build.finalName}</app>
                <port>8080</port>
                <!-- This sets the context root, e.g. http://localhost:8080/test/ -->
                <contextRoot>test</contextRoot>
                <!-- This deletes the temporary files during GlassFish shutdown. -->
                <autoDelete>true</autoDelete>
            </configuration>
            <executions>
                <execution>
                    <id>start</id>
                    <!-- We implement the integration testing by setting up our GlassFish instance to start and deploy our application. -->
                    <phase>pre-integration-test</phase>
                    <goals>
                        <goal>start</goal>
                        <goal>deploy</goal>
                    </goals>
                </execution>
                <execution>
                    <id>stop</id>
                    <!-- After integration testing we undeploy the application and shutdown GlassFish gracefully. -->
                    <phase>post-integration-test</phase>
                    <goals>
                        <goal>undeploy</goal>
                        <goal>stop</goal>
                    </goals>
                </execution>
            </executions>
        </plugin>

Surefire 插件

添加/修改插件作为<build>.

        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-surefire-plugin</artifactId>
            <version>2.12.4</version>
            <!-- We are skipping the default test lifecycle and will test later during integration-test -->
            <configuration>
                <skip>true</skip>
            </configuration>
            <executions>
                <execution>
                    <phase>integration-test</phase>
                    <goals>
                        <!-- During the integration test we will execute surefire:test -->
                        <goal>test</goal>
                    </goals>
                    <configuration>
                        <!-- This enables the tests which were disabled previously. -->
                        <skip>false</skip>
                    </configuration>
                </execution>
            </executions>
        </plugin>

HTML单元

添加集成测试，如下例所示。

@Test
public void badRequest() throws IOException {
    webClient.getOptions().setThrowExceptionOnFailingStatusCode(false);
    webClient.getOptions().setPrintContentOnFailingStatusCode(false);
    final HtmlPage page = webClient.getPage("http://localhost:8080/test/images/");
    final WebResponse response = page.getWebResponse();
    assertEquals(400, response.getStatusCode());
    assertEquals("An image name is required.", response.getStatusMessage());
    webClient.getOptions().setThrowExceptionOnFailingStatusCode(true);
    webClient.getOptions().setPrintContentOnFailingStatusCode(true);
    webClient.closeAllWindows();
}

我在我的博客Using GlassFish 3.1.1 Embedded with JUnit 4.x 和 HtmlUnit 2.x上写了完整的过程，并将完整的项目放在 Bitbucket 上供下载：image-servlet

如果您有任何问题，请发表评论。我认为这是一个完整的示例，您可以将其用作您计划对 servlet 进行的任何测试的基础。

于 2013-01-06T01:54:00.570 回答
7

您是否在单元测试中手动调用 doPost 和 doGet 方法？如果是这样，您可以覆盖 HttpServletRequest 方法以提供模拟对象。

myServlet.doGet(new HttpServletRequestWrapper() {
     public HttpSession getSession() {
         return mockSession;
     }

     ...
}

HttpServletRequestWrapper是一个方便的Java 类。我建议您在单元测试中创建一个实用方法来创建模拟 http 请求：

public void testSomething() {
    myServlet.doGet(createMockRequest(), createMockResponse());
}

protected HttpServletRequest createMockRequest() {
   HttpServletRequest request = new HttpServletRequestWrapper() {
        //overrided methods   
   }
}

将模拟创建方法放在基本 servlet 超类中并进行所有 servlet 单元测试来扩展它会更好。

于 2008-09-18T08:43:28.297 回答
6

Mockrunner ( http://mockrunner.sourceforge.net/index.html ) 可以做到这一点。它提供了一个模拟 J2EE 容器，可用于测试 Servlet。它还可以用于对其他服务器端代码进行单元测试，例如 EJB、JDBC、JMS、Struts。我自己只使用了 JDBC 和 EJB 功能。

于 2008-09-18T16:06:13.113 回答
3

servlet doPost() 方法的 JUnit 测试实现仅依赖于 Mockito 库来模拟HttpRequest、HttpResponse、HttpSession和ServletResponse的实例RequestDispatcher。将参数键和 JavaBean 实例替换为与调用 doPost() 的关联 JSP 文件中引用的值相对应的值。

Mockito Maven 依赖：

<dependency>
      <groupId>org.mockito</groupId>
      <artifactId>mockito-all</artifactId>
      <version>1.9.5</version>
</dependency>

JUnit测试：

import javax.servlet.RequestDispatcher;
import javax.servlet.ServletContext;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;

import java.io.IOException;

import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import static org.mockito.Mockito.*;

/**
 * Unit tests for the {@code StockSearchServlet} class.
 * @author Bob Basmaji
 */
public class StockSearchServletTest extends HttpServlet {
    // private fields of this class
    private static HttpServletRequest request;
    private static HttpServletResponse response;
    private static StockSearchServlet servlet;
    private static final String SYMBOL_PARAMETER_KEY = "symbol";
    private static final String STARTRANGE_PARAMETER_KEY = "startRange";
    private static final String ENDRANGE_PARAMETER_KEY = "endRange";
    private static final String INTERVAL_PARAMETER_KEY = "interval";
    private static final String SERVICETYPE_PARAMETER_KEY = "serviceType";

    /**
     * Sets up the logic common to each test in this class
     */
    @Before
    public final void setUp() {
        request = mock(HttpServletRequest.class);
        response = mock(HttpServletResponse.class);

        when(request.getParameter("symbol"))
                .thenReturn("AAPL");

        when(request.getParameter("startRange"))
                .thenReturn("2016-04-23 00:00:00");

        when(request.getParameter("endRange"))
                .thenReturn("2016-07-23 00:00:00");

        when(request.getParameter("interval"))
                .thenReturn("DAY");

        when(request.getParameter("serviceType"))
                .thenReturn("WEB");

        String symbol = request.getParameter(SYMBOL_PARAMETER_KEY);
        String startRange = request.getParameter(STARTRANGE_PARAMETER_KEY);
        String endRange = request.getParameter(ENDRANGE_PARAMETER_KEY);
        String interval = request.getParameter(INTERVAL_PARAMETER_KEY);
        String serviceType = request.getParameter(SERVICETYPE_PARAMETER_KEY);

        HttpSession session = mock(HttpSession.class);
        when(request.getSession()).thenReturn(session);
        final ServletContext servletContext = mock(ServletContext.class);
        RequestDispatcher dispatcher = mock(RequestDispatcher.class);
        when(servletContext.getRequestDispatcher("/stocksearchResults.jsp")).thenReturn(dispatcher);
        servlet = new StockSearchServlet() {
            public ServletContext getServletContext() {
                return servletContext; // return the mock
            }
        };

        StockSearchBean search = new StockSearchBean(symbol, startRange, endRange, interval);
        try {
            switch (serviceType) {
                case ("BASIC"):
                    search.processData(ServiceType.BASIC);
                    break;
                case ("DATABASE"):
                    search.processData(ServiceType.DATABASE);
                    break;
                case ("WEB"):
                    search.processData(ServiceType.WEB);
                    break;
                default:
                    search.processData(ServiceType.WEB);
            }
        } catch (StockServiceException e) {
            throw new RuntimeException(e.getMessage());
        }
        session.setAttribute("search", search);
    }

    /**
     * Verifies that the doPost method throws an exception when passed null arguments
     * @throws ServletException
     * @throws IOException
     */
    @Test(expected = NullPointerException.class)
    public final void testDoPostPositive() throws ServletException, IOException {
        servlet.doPost(null, null);
    }

    /**
     * Verifies that the doPost method runs without exception
     * @throws ServletException
     * @throws IOException
     */
    @Test
    public final void testDoPostNegative() throws ServletException, IOException {
        boolean throwsException = false;
        try {
            servlet.doPost(request, response);
        } catch (Exception e) {
            throwsException = true;
        }
        assertFalse("doPost throws an exception", throwsException);
    }
}
于 2016-07-26T12:15:58.003 回答
0

2018 年 2 月更新：OpenBrace Limited 已关闭，不再支持其 ObMimic 产品。

另一种解决方案是使用我的ObMimic库，该库专为 servlet 的单元测试而设计。它提供了所有 Servlet API 类的完整纯 Java 实现，您可以根据需要配置和检查这些以进行测试。

您确实可以使用它从 JUnit 或 TestNG 测试中直接调用 doGet/doPost 方法，并测试任何内部方法，即使它们引用 ServletContext 或使用会话参数（或任何其他 Servlet API 功能）。

这不需要外部或嵌入式容器，不会限制您进行更广泛的基于 HTTP 的“集成”测试，并且与通用模拟不同，它具有“嵌入”的完整 Servlet API 行为，因此您的测试可以是“基于状态而不是基于交互（例如，您的测试不必依赖于您的代码调用 Servlet API 的精确顺序，也不必依赖于您自己对 Servlet API 将如何响应每个调用的期望） .

我对如何使用 JUnit 测试我的 servlet的回答中有一个简单的示例。有关完整详细信息和免费下载，请参见ObMimic网站。

于 2013-08-15T12:35:00.150 回答
0

这个问题有一个解决方案提出了 Mockito How to test my servlet using JUnit 这将任务限制为简单的单元测试，而无需设置任何类似服务器的环境。

于 2020-07-16T11:11:19.687 回答