Question

我正在编写一个JAX-RS（Jersey + Maven）应用程序，它可以执行一些棘手的操作（例如调用WAR中嵌入的本机可执行文件）。我需要在服务器上运行[部分]单元测试（JUnit4）（运行Tomcat 7.0.22的Amazon Elastic Beanstalk）来检查一切是否正常。

除了RYO（滚动你自己的）之外，还有一种标准的，灵活的方式吗？我发现的东西似乎更多地与开发人员机器上的集成测试（即Jersey测试框架）有关。甚至RYO让我感到困惑......我怎样才能从源包中调用测试包中的代码？

基本上，我想创建一个我可以调用的/ test资源，它将以漂亮的格式从服务器返回我的单元测试结果。如果我可以做/ test / {category}

，那就更好了

Answer 1

我想分享我在发布此问题后所学到的内容，并在StackExchange上发布我的第一个答案（我通过谷歌无数次到达的网站寻找无穷无尽问题的解决方案）

单位与整合与功能测试连续体

在这个问题上有很多纠正，争论和拖钓，所以我想清理它。这一切都非常简单。说你有一些服务。当你打电话给它时，我会简单地说明一系列事件：

（收到请求） - （调用函数1） - （调用函数2） - （调用函数3） - （发送响应）

单元测试单独测试每个功能（或类或单元），输入输入并检查输出。集成测试需要几个单元（例如功能2功能3链），并且也可以使用ol＆＃39;进进出出。功能测试贯穿整个链，从请求到响应。我将把它留给读者来猜测在每个规模水平上测试的一些优点和缺点。无论如何，所有这些测试都可以在服务器上运行，并且有很好的理由来运行它们。

容器内/服务器内测试的类型

容器中的测试 Spring和其他依赖注入框架的一个功能允许您设置一个仅使用最小的类（加上所有模拟）填充的容器对于你的每个测试。这非常方便，因为它不需要手动布线，更好地接近生产环境。这只允许进行单元和集成测试。
- 优点： a）传统的单元测试（具有集中和隔离测试的优点）使得更方便 b）因为您正在测试自动装配逻辑，所以更接近生产环境 e）与IDE测试运行器集成 f）快速
- 缺点： a）环境可能与生产有很大不同 b）不替代功能测试的需要
测试中的服务器普通的测试运行器运行几乎普通的单元测试，启动嵌入式服务器或容器，并调用它。一些框架（如Jersey测试框架）只允许功能测试，但大多数（Arquillian，jeeunit）让你做所有类型。对于其中一些框架，它就好像测试在服务器上运行，并且可以进行任何类型的调用。
- 优点（除了您可以访问所有容器和服务器服务的事实）： a）您有自足的测试，不需要安装或设置任何东西 b）测试是隔离的，因为为每个测试或测试套件创建了一个新的服务器/容器。 b）与IDE测试运行器集成
- 缺点： a）环境可能与生产有很大不同（例如，Jetty不是Tomcat或Glassfish） b）启动/停止服务器会降低测试速度c）框架很糟糕。 Jeeunit是一个微小的项目，甚至没有在Windows上测试过，Arquillian很大但很新，文档记录很差，我也无法使用它。
在服务器中测试在这里，测试实际上是使用代码编译并运行的。
- 优点： a）你有简单，旧的测试，不需要知道或使用任何类型的框架
- 缺点： a）测试之间没有隔离（不一定是问题，甚至不利，但可能需要采取预防措施） b）不与IDE测试运行器集成（至少在Netbeans中）
- 在构建期间使用Maven Maven启动服务器，加载特殊测试WAR，执行测试，并提供一个很好的Surefire报告。
  - 其他优点： a）它在构建期间完成（并将与持续集成工具和其他工具集成） b）无需安装或设置任何东西（Maven将自动下载，运行等服务器）
  - 其他缺点： a）环境可能相当不同（Maven使用Jetty，它在你的机器上运行） b）无法重新投入生产
- in-WAR测试使用您的代码永久编译测试。无论何时何地，只要您的WAR启动，您就可以启动测试。在开发服务器上，在暂存期间，甚至在生产中。这就是我原来的问题。
  - 其他优点： a）确切的环境。 b）每当
  - 其他缺点： a）需要设置服务器

还有一点要做。 Netbeans将Maven测试的大部分好处提供给WAR测试。它包括一个嵌入式服务器，并在构建后自动启动和部署。它甚至可以打开Firefox ......只需将其设置为指向您的/测试资源即可。它就像用Maven那样做，但更好。

无论如何，我将向您展示如何在同一个Maven项目中一起进行Maven测试和内部测试。

使用Spring进行测试的容器：

Spring是一个庞大的容器框架。它的依赖注入机制与Jax-RS交织在一起，以显着的学习曲线为代价，产生了辉煌的效果。我不解释Spring或Jax-RS是如何工作的。我会直接跳到指令中，希望读者可以将这些想法调整到其他场景中。

在JUnit 4测试中获取容器的方法是使用Spring测试运行器，声明要在容器中注册的类，注册一些特定于Jax-RS的帮助程序类，注册您的模拟，最后使用你的Jax-RS资源，好像它是一个普通的类：

@RunWith(SpringJUnit4ClassRunner.class)
@WebAppConfiguration
@ContextConfiguration(classes={
    MyClass1.class,
    Myclass2.class,
    MyJaxRsResource.class,
    MockServletContextAwareProcessor.class,
    MyCTest.Config.class
})
public class MyCTest
{
    @Configuration
    static class Config 
    {
          // Set up and register mocks here, and watch them be autowired!
          @Bean public DBService dbJobService() throws DBException
            {
                return mock(DBService.class); 
            }
    }

    @Autowired MyJaxRsResource myResource;

    @Test public void test() {
         String response = myResource.get("hello");
    }
}

@WebAppConfiguration注入自己的ServletContextAwareProcessor。但是，当必须动态设置解压缩WAR文件的路径时，MockServletContextAwareProcessor是必需的，因为WebAppConfiguration只允许您在编译时静态设置路径。在运行服务器中的测试时使用这个类（见下文），我注入了真正的ServletContext。我使用Spring的配置文件功能通过环境变量来抑制它（这不是很优雅）。 setServletContext只由服务器测试运行器调用。

@Configuration
public class MockServletContextAwareProcessor {

public static void setServletContext(ServletContext sc) {
    servletContext = sc;
}    
private static ServletContext getServletContext() {
    return servletContext;
}
private static ServletContext servletContext;    

@Configuration
@Profile("server-test")
static class ServerTestContext {

    static public @Bean
    ServletContextAwareProcessor 
        scap() {
            ServletContext sc = getServletContext();
            return new ServletContextAwareProcessor(sc);
    }
}    
}

使用Maven的测试服务器：

步骤1）在/ src / test文件夹中创建常规JUnit测试，但将它们命名为IT * .java或* IT.java或* ITCase.java（例如，MyClassIT.java）您可以使用不同的名称命名它们，但是这样是Failsafe默认的预期。 IT代表集成测试，但测试代码可以位于测试连续体的任何位置。例如，您可以实例化一个类并对其进行单元测试，或者您可以启动HttpClient（或Jersey客户端），将其指向您自己（请注意下面的端口），并在功能上测试您的入口点。

public class CrossdomainPolicyResourceSTest extends BaseTestClass {

static com.sun.jersey.api.client.Client client;

  @BeforeClass public static void 
startClient() {

        client = Client.create();
    }

  @Test public void 
getPolicy() {

        String response = 
            client
                .resource("http://localhost/crossdomain.xml")
                .get(String.class);

        assertTrue(response.startsWith("<?xml version=\"1.0\"?>"));
    }
}

BaseTestClass只是一个小帮助类，它打印测试类的名称并在执行时进行测试（对于在服务器中测试很有用，见下文）：

public abstract class BaseTestClass {

@ClassRule public static TestClassName className = new TestClassName();
@Rule public TestName testName = new TestName();    

  @BeforeClass public static void 
printClassName() { 
        System.out.println("--" + className.getClassName() + "--"); 
    }    
  @Before public void 
printMethodName() {
        System.out.print(" " + testName.getMethodName()); 
    }    
  @After public void 
printNewLine() { 
        System.out.println(); 
    }
}

步骤2）将maven-failsafe-plugin和maven-jetty-plugin添加到你的pom.xml

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-failsafe-plugin</artifactId>
    <version>2.11</version>
    <executions>
        <execution>
            <goals>
                <goal>integration-test</goal>
                <goal>verify</goal>
            </goals>
        </execution>
    </executions>
</plugin>
<plugin>
    <groupId>org.mortbay.jetty</groupId>
    <artifactId>maven-jetty-plugin</artifactId>
    <version>6.1.26</version>
    <configuration>
        <!-- By default the artifactId is taken, override it with something simple -->
        <contextPath>/</contextPath>
        <scanIntervalSeconds>2</scanIntervalSeconds>
        <stopKey>foo</stopKey>
        <stopPort>9999</stopPort>
        <connectors>
            <connector implementation="org.mortbay.jetty.nio.SelectChannelConnector">
                <port>9095</port>
                <maxIdleTime>60000</maxIdleTime>
            </connector>
        </connectors>
    </configuration>
    <executions>
        <execution>
            <id>start-jetty</id>
            <phase>pre-integration-test</phase>
            <goals>
                <goal>run</goal>
            </goals>
            <configuration>
                <scanIntervalSeconds>0</scanIntervalSeconds>
                <daemon>true</daemon>
            </configuration>
        </execution>
        <execution>
            <id>stop-jetty</id>
            <phase>post-integration-test</phase>
            <goals>
                <goal>stop</goal>
            </goals>
        </execution>
    </executions>
</plugin>

步骤3）利润。真的，那就是它！只需运行＆＃39; mvn install＆＃39;或者在IDE中点击构建，并且代码将构建，您的常规* Test.java测试将运行，jetty服务器将启动，* IT.java测试将运行，并且您将获得一个很好的报告

将您的测试打包在WAR中以便在任何地方运行：

（与上述说明一起使用或分开使用）

步骤1）通过指示maven-war-plugin包含它们来获取WAR中嵌入的测试类（src / test /目录）:(改编自here）

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-war-plugin</artifactId>
    <version>2.1.1</version>
    <configuration>
        <failOnMissingWebXml>false</failOnMissingWebXml>
        <webResources>
            <resource>
                <directory>${project.build.directory}/test-classes</directory>
                <targetPath>WEB-INF/classes</targetPath>
            </resource>
            <resource>
                <directory>${project.build.directory}/test-libs</directory>
                <targetPath>WEB-INF/lib</targetPath>
            </resource>
        </webResources>
    </configuration>
</plugin>

注意：您可以通过创建额外的执行并在其配置集中创建一个单独的WAR以及（我留给读者的详细信息）

注意：理想情况下，上面会排除所有常规测试（并且只复制* IT.java）但是，我无法获得包含/排除工作。

您还必须通过为maven-dependency-plugin提供额外的执行来包含测试库，其目标是包含测试范围的复制依赖

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-dependency-plugin</artifactId>
    <version>2.1</version>
    <executions>
        <execution>
            <id>copy-dependencies</id>
            <phase>prepare-package</phase>
            <goals>
                <goal>copy-dependencies</goal>
            </goals>
            <configuration>
                <excludeScope>compile</excludeScope>
                <outputDirectory>${project.build.directory}/test-libs</outputDirectory>
                <overWriteReleases>true</overWriteReleases>
                <overWriteSnapshots>true</overWriteSnapshots>
                <overWriteIfNewer>true</overWriteIfNewer>
            </configuration>
        </execution>
    </executions>
</plugin>

如果maven-dependency-plugin已经有其他执行（例如，Netbeans为javaee-endorsed-api插入一个），请不要删除它们。

步骤2）使用JUnitCore（JUnit4）以编程方式运行测试。

String runTests() {
    PrintStream sysOut = System.out;
    PrintStream sysErr = System.err;
    ByteArrayOutputStream stream = new ByteArrayOutputStream();
    PrintStream out = new PrintStream(stream);
    try {
        System.setOut(out);
        System.setErr(out);
        TextListener listener = new TextListener(out);
        JUnitCore junit = new JUnitCore();
        junit.addListener(listener);

        junit.run(MyClassIT.class,
                  AnotherClassIT.class,
                  ...etc...);

    } finally {
        System.setOut(sysOut);
        System.setErr(sysErr);
        out.close();
    }

    return stream.toString();
}

步骤3）通过JAX-RS公开测试

@Path("/test")
public class TestResource {

    @GET
    @Produces("text/plain")
    public String getTestResults() {

        return runTests();
    }

    private String runTests() {
        ...
    }

}

将此类与其他测试类（在src / test中）一起放置，以便它可以引用它们。

但是，如果您在javax.ws.rs.core.Application类中继承了您注册所有资源的地方，那么您在引用TestResource时会遇到问题（因为源代码可以＆＃39; t参考测试代码）。要解决这个问题，请在src / main / ... [相同包]下创建一个完全空的虚拟TestResource类...这个技巧有效，因为虚拟TestResource在打包过程中会被真实的TestResource覆盖。

public class ShoppingApplication extends Application {

    @Override
    public Set<Class<?>> getClasses() {
        return new HashSet<Class<?>>() {{
            add(TestResource.class);
        }};
    }

    @Override
    public Set<Object> getSingletons() {
        return new HashSet<Object>();
    }
}

package ...same package as the real TestResource...
public class TestResource {

}

步骤4）设置IDE以启动/部署您的应用并打开浏览器指向＆＃34; / test＆＃34;构建后自动生成。

Answer 2

获胜关键字原来是“容器内测试”。全新且卓越的框架是Arquillian。

奇怪的是，似乎没有别的东西。 StackOverflow asked上的其他人“我没有看到任何这些项目被广泛使用，所以容器内测试有什么不好吗？”但没有收到明确的答复。

我想这只是单元测试和完整集成测试这两个大范围之间的一个小区域，需要通过容器内测试来解决。对我来说，我只需要一些测试来检查服务器资源是否可访问和正常运行。可能应该手工编写，而不是花时间研究（然后学习）容器内测试。

Answer 3

使用Maven，Surefire可以为您提供测试结果的格式化报告。

http://maven.apache.org/plugins/maven-surefire-report-plugin/report-mojo.html

可以通过多种方式使这些报告的内容可用，无论这些报告是发送给您还是发布到网页。你有很多选择。

Answer 4

Jakarta Cactus似乎做了我正在寻找的事情。它的主页说：“Cactus是一个简单的测试框架，用于单元测试服务器端的Java代码...它使用JUnit ... Cactus实现了一个容器内策略......”http://localhost:8080/test/ServletTestRunner?suite=TestSampleServlet之类的URL会提供一个漂亮的HTML输出。

然而，由于缺乏积极的开发，Apache基金会将其置于阁楼中。这是否意味着我不应该考虑使用它？ Attic页面说“鼓励Cactus用户切换到其他测试技术”而不解释它们是什么！

Answer 5

我认为没有标准的方法，但您可以使用Spring Remoting从您的开发人员计算机调查您感兴趣的服务器上的方法。如果您使用接口并注入您正在测试的服务，您应该能够在本地运行两次相同的单元测试，一次在服务器上运行，只需更改Spring配置即可。

在服务器上运行单元测试（JAX-RS）

5 个答案:

单位与整合与功能测试连续体

容器内/服务器内测试的类型

使用Spring进行测试的容器：

使用Maven的测试服务器：

将您的测试打包在WAR中以便在任何地方运行：