如何在 JUnit 4 中运行属于某个类别的所有测试

Question

JUnit 4.8 包含一个名为“类别”的不错的新功能，它允许您将某些类型的测试分组在一起。这非常有用，例如对于慢速和快速测试进行单独的测试运行。我知道 JUnit 4.8 发行说明，但想知道如何实际运行用特定类别注释的所有测试。

JUnit 4.8 发行说明显示了一个示例套件定义，其中 SuiteClasses 注释从特定类别中选择要运行的测试，如下所示：

@RunWith(Categories.class)
@IncludeCategory(SlowTests.class)
@SuiteClasses( { A.class, B.class }) // Note that Categories is a kind of Suite
public class SlowTestSuite {
  // Will run A.b and B.c, but not A.a
}

有谁知道如何运行 SlowTests 类别中的所有测试？看来你必须有 SuiteClasses 注释......

Answer 1

我找到了一种可能的方法来实现我想要的，但我不认为这是最好的解决方案，因为它依赖于不属于 JUnit 的 ClassPathSuite 库。

我为慢速测试定义了这样的测试套件：

@RunWith(Categories.class)
@Categories.IncludeCategory(SlowTests.class)
@Suite.SuiteClasses( { AllTests.class })
public class SlowTestSuite {
}

AllTests 类的定义如下：

@RunWith(ClasspathSuite.class)
public class AllTests {
}

我必须使用 中的 ClassPathSuite 类ClassPathSuite 项目在这里。它将找到所有带有测试的类。

Answer 2

以下是 TestNG 和 JUnit 在组（或类别，如 JUnit 所称的）方面的一些主要区别：

• JUnit 是类型化的（注释），而 TestNG 是字符串。我做出这个选择是因为我希望在运行测试时能够使用正则表达式，例如“运行属于“database*”组的所有测试。此外，每当需要创建新的注释时都必须创建新的注释类别很烦人，尽管它的好处是 IDE 会立即告诉您该类别的使用位置（TestNG 在其报告中向您显示这一点）。

• TestNG 非常清楚地将静态模型（测试代码）与运行时模型（运行测试）分开。如果您想先运行“前端”组，然后运行“servlet”，则无需重新编译任何内容即可执行此操作。因为 JUnit 在注释中定义了组，并且您需要将这些类别指定为运行程序的参数，所以每当您想要运行一组不同的类别时，通常都必须重新编译代码，这在我看来违背了目的。

Answer 3

Kaitsu 解决方案的一个缺点是 Eclipse 将运行您的测试两次，以及 SlowTests 3 次。这是因为 Eclipse 将运行所有测试，然后是 AllTests 套件，然后是 SlowTestSuite。

这是一个解决方案，涉及创建 Kaitsu 解决方案测试运行程序的子类以跳过套件，除非设置了某个系统属性。这是一个可耻的黑客行为，但到目前为止我已经想到了一切。

@RunWith(DevFilterClasspathSuite.class)
public class AllTests {}

。

@RunWith(DevFilterCategories.class)
@ExcludeCategory(SlowTest.class)
@SuiteClasses(AllTests.class)
public class FastTestSuite
{
}

。

public class DevFilterCategories extends Suite
{
    private static final Logger logger = Logger
        .getLogger(DevFilterCategories.class.getName());
    public DevFilterCategories(Class<?> suiteClass, RunnerBuilder builder) throws InitializationError {
        super(suiteClass, builder);
        try {
            filter(new CategoryFilter(getIncludedCategory(suiteClass),
                    getExcludedCategory(suiteClass)));
            filter(new DevFilter());
        } catch (NoTestsRemainException e) {
            logger.info("skipped all tests");
        }
        assertNoCategorizedDescendentsOfUncategorizeableParents(getDescription());
    }

    private Class<?> getIncludedCategory(Class<?> klass) {
        IncludeCategory annotation= klass.getAnnotation(IncludeCategory.class);
        return annotation == null ? null : annotation.value();
    }

    private Class<?> getExcludedCategory(Class<?> klass) {
        ExcludeCategory annotation= klass.getAnnotation(ExcludeCategory.class);
        return annotation == null ? null : annotation.value();
    }

    private void assertNoCategorizedDescendentsOfUncategorizeableParents(Description description) throws InitializationError {
        if (!canHaveCategorizedChildren(description))
            assertNoDescendantsHaveCategoryAnnotations(description);
        for (Description each : description.getChildren())
            assertNoCategorizedDescendentsOfUncategorizeableParents(each);
    }

    private void assertNoDescendantsHaveCategoryAnnotations(Description description) throws InitializationError {           
        for (Description each : description.getChildren()) {
            if (each.getAnnotation(Category.class) != null)
                throw new InitializationError("Category annotations on Parameterized classes are not supported on individual methods.");
            assertNoDescendantsHaveCategoryAnnotations(each);
        }
    }

    // If children have names like [0], our current magical category code can't determine their
    // parentage.
    private static boolean canHaveCategorizedChildren(Description description) {
        for (Description each : description.getChildren())
            if (each.getTestClass() == null)
                return false;
        return true;
    }
}

。

public class DevFilterClasspathSuite extends ClasspathSuite
{
    private static final Logger logger = Logger
        .getLogger(DevFilterClasspathSuite.class.getName());
    public DevFilterClasspathSuite(Class<?> suiteClass, RunnerBuilder builder) 
        throws InitializationError {
        super(suiteClass, builder);
        try
        {
            filter(new DevFilter());
        } catch (NoTestsRemainException e)
        {
            logger.info("skipped all tests");
        }
    }
}

。

public class DevFilter extends Filter
{
    private static final String RUN_DEV_UNIT_TESTS = "run.dev.unit.tests";

    @Override
    public boolean shouldRun(Description description)
    {
        return Boolean.getBoolean(RUN_DEV_UNIT_TESTS);
    }

    @Override
    public String describe()
    {
        return "filter if "+RUN_DEV_UNIT_TESTS+" system property not present";
    }
}

因此，在 FastTestSuite 启动器中，只需将 -Drun.dev.unit.tests=true 添加到 VM 参数即可。 （请注意，此解决方案引用快速测试套件而不是慢速测试套件。）

Answer 4

要运行分类测试而不在 @Suite.SuiteClasses 注释中显式指定所有测试，您可以提供自己的 Suite 实现。
例如，可以扩展org.junit.runners.ParentRunner。新的实现应该在类路径中搜索分类测试，而不是使用 @Suite.SuiteClasses 提供的类数组。

请参阅此项目作为此类方法的示例。
用法：

@Categories(categoryClasses = {IntegrationTest.class, SlowTest.class})
@BasePackage(name = "some.package")
@RunWith(CategorizedSuite.class)
public class CategorizedSuiteWithSpecifiedPackage {

}

Answer 5

我不确定你的问题到底是什么。

只需将所有测试添加到一个套件（或多个套件）中即可。然后使用“类别运行程序”和“包含/排除类别”注释来指定要运行的类别。

一个好主意可能是拥有一个包含所有测试的套件，以及几个引用第一个套件的独立套件，指定您需要的不同类别集。

Answer 6

不是对你的问题的直接答案，但也许可以改进一般方法......

为什么你的测试很慢？也许设置持续很长时间（数据库、I/O 等），也许测试测试太多了？如果是这种情况，我会将真正的单元测试与“长期运行”的单元测试分开，后者通常确实是集成测试。

在我的设置中，我有暂存环境，其中经常运行单元测试，不断运行集成测试，但很少进行（例如，在版本控制中每次提交之后）。我从未使用过单元测试分组，因为它们应该松散地耦合在一起。我只处理集成测试设置中测试用例的分组和关系（但使用 TestNG）。

但很高兴知道 JUnit 4.8 引入了一些分组功能。