Build a Jar with Maven and Ignore the Test Results – 用Maven构建一个罐子，并忽略测试结果

1. Introduction

1.介绍

This quick guide shows how to build a jar with Maven while ignoring the test results.

本快速指南展示了如何用Maven构建一个jar，同时忽略测试结果。

By default, Maven runs unit tests automatically while building the project. However, there are rare cases when the tests can be skipped and we need to build the project regardless of the test results.

默认情况下，Maven在构建项目时自动运行单元测试。然而，在极少数情况下，测试可以被跳过，我们需要在不考虑测试结果的情况下构建项目。

2. Building the Project

2.构建项目

Let’s create a simple project where we also include a small test case:

让我们创建一个简单的项目，其中我们还包括一个小的测试案例。

public class TestFail {
    @Test
    public void whenMessageAssigned_thenItIsNotNull() {
        String message = "hello there";
        assertNotNull(message);
    }
}

Let’s build a jar file by executing the following Maven command:

让我们通过执行以下Maven命令来构建一个jar文件。

mvn package

This will result in compiling the sources and generate a maven-0.0.1-SNAPSHOT.jar file under the /target directory.

这将导致编译源代码，并在/target目录下生成一个maven-0.0.1-SNAPSHOT.jar文件。

Now, let’s change the test a bit, so the test starts to fail.

现在，让我们稍微改变一下测试，让测试开始失败。

@Test
public void whenMessageAssigned_thenItIsNotNull() {
    String message = null;
    assertNotNull(message);
}

This time, when we try to run the mvn package command again, the build fails and the maven-0.0.1-SNAPSHOT.jar file isn’t created.

这一次，当我们再次尝试运行mvn package命令时，构建失败，maven-0.0.1-SNAPSHOT.jar文件没有被创建。

This means, if we have a failing test in our application, we can’t provide an executable file unless we fix the test.

这意味着，如果我们的应用程序中有一个失败的测试，我们就不能提供可执行文件，除非我们修复该测试。

So how can we solve this problem?

那么，我们怎样才能解决这个问题呢？

3. Maven Arguments

3.Maven参数

Maven has its own arguments to deal with this issue:

Maven有自己的论据来处理这个问题。

• -Dmaven.test.failure.ignore=true ignores any failure that occurs during test execution
• -Dmaven.test.skip=true would not compile the tests
• -fn, -fae never fails the build regardless of test results

Let’s run the mvn package -Dmaven.test.skip=true command and see the results:

让我们运行mvn package -Dmaven.test.skip=true命令，看看结果。

[INFO] Tests are skipped.
[INFO] BUILD SUCCESS

This means the project will be built without compiling the tests.

这意味着该项目将在不编译测试的情况下被构建。

Now let’s run the mvn package -Dmaven.test.failure.ignore=true command:

现在让我们运行mvn package -Dmaven.test.failure.ignore=true 命令。

[INFO] Running testfail.TestFail
[ERROR] whenMessageAssigned_thenItIsNotNull java.lang.AssertionError
[INFO] BUILD SUCCESS

Our unit test fails on assertion but the build is successful.

我们的单元测试在断言时失败了，但构建是成功的。

Finally, let’s test the -fn, -fae options. Both, package -fn and package -fae commands build the jar file and produce the BUILD SUCCESS output regardless of whenMessageAssigned_thenItIsNotNull() test fail.

最后，让我们测试一下-fn，-fae选项。这两个，package -fn和package -fae命令都构建了jar文件，并产生了BUILD SUCCESS输出，无论whenMessageAssigned_thenItIsNotNull()测试失败。

In case of the multi-module project -fn option should be used. -fae continues with the module that has a failing test but skips all the dependent modules. 

如果是多模块项目，应该使用-fn选项。-fae继续进行测试失败的模块，但跳过所有的依赖模块。

4. Maven Surefire Plugin

4.Maven Surefire插件

Another convenient way to achieve our goal is to use Maven’s Surefire plugin.

实现我们目标的另一个便捷方式是使用Maven的Surefire插件。

For an extended overview of the Surefire plugin, refer to this article.

关于Surefire插件的详细介绍，请参考这篇文章。

To ignore test fails we can simply set the testFailureIgnore property to true:

要忽略测试失败，我们可以简单地将testFailureIgnore属性设置为true。

<plugin>
    <artifactId>maven-surefire-plugin</artifactId>
    <version>${maven.surefire.version}</version>
    <configuration>
        <includes>
            <include>TestFail.java</include>
        </includes>
        <testFailureIgnore>true</testFailureIgnore>
    </configuration>
</plugin>

Now, let’s see the output of the package command:

现在，让我们看看package命令的输出。

[INFO]  T E S T S
[INFO] Running testfail.TestFail
[ERROR] Tests run: 1, Failures: 1, Errors: 0, Skipped: 0, <<< FAILURE! - in testfail.TestFail

From the running tests output, we can see the TestFail class is failing. But looking further we see that the BUILD SUCCESS message is also there and the maven-0.0.1-SNAPSHOT.jar file is compiled.

从运行测试的输出中，我们可以看到TestFail类失败了。但进一步看，我们发现BUILD SUCCESS信息也在那里，而且maven-0.0.1-SNAPSHOT.jar文件也被编译了。

Depending on our need, we can skip running the tests at all. For that we can replace the testFailureIgnore line with:

根据我们的需要，我们可以完全跳过运行测试。为此，我们可以将testFailureIgnore行替换为。

<skipTests>true</skipTests>

Or set the command line argument -DskipTests. This will compile the test classes but skip test execution entirely.

或者设置命令行参数-DskipTests。这将编译测试类，但完全跳过测试执行。

5. Conclusion

5.结论

In this article, we learned how to build our project with Maven regardless of the test results. We went through the practical examples of skipping the failing tests or excluding compilation of the tests entirely.

在本文中，我们学习了如何用Maven构建项目而不考虑测试结果。我们经历了跳过失败的测试或完全排除测试的编译的实际例子。

As usual, the complete code for this article is available over on GitHub project.

像往常一样，本文的完整代码可在GitHub项目上获得。

1.介绍

1.介绍

本快速指南介绍了如何用Maven构建一个jar，同时忽略测试结果。

默认情况下，Maven在构建项目时自动运行单元测试。然而，在极少数情况下，测试可以被跳过，我们需要在不考虑测试结果的情况下构建项目。

@Test
public void whenMessageAssigned_thenItIsNotNull() {
    String message = null。
    assertNotNull(message)。
}

[INFO] 测试被跳过。
[INFO] BUILD SUCCESS

[INFO] 运行 testfail.TestFail
[ERROR] whenMessageAssigned_thenItIsNotNull java.lang.AssertionError
[INFO] BUILD SUCCESS

<plugin>
    <artifactId>maven-surefire-plugin</artifactId>
    <版本>${maven.surefire.version}</version>
    <配置>
        <包括>
            <include>TestFail.java</include>
        </includes>
        <testFailureIgnore>true</testFailureIgnore>
    </configuration>
</plugin>

[INFO] T E S T S
[INFO] 运行testfail.TestFail
[ERROR] 运行测试。1, 失败。1, 错误。0, 跳过: 0, <<< FAILURE!- in testfail.TestFail

<skipTests>true</skipTests>