如何在 JUnit4 中按特定顺序运行测试方法？

Question

我想按特定顺序执行由 @Test 注释的测试方法。

例如：

public class MyTest {
    @Test public void test1(){}
    @Test public void test2(){}
}

我想确保每次运行 MyTest 时都在 test2() 之前运行 test1()，但我找不到注释就像@Test(order=xx)。

我认为这对于 JUnit 来说是非常重要的功能，如果 JUnit 的作者不想要顺序功能，为什么？

Answer 1

我认为这对于 JUnit 来说是非常重要的功能，如果 JUnit 的作者不想要顺序功能，为什么？

我不确定是否有一种干净的方法可以使用 JUnit 来执行此操作，据我所知，JUnit 假设所有测试都可以按任意顺序执行。来自常见问题解答：

如何使用测试夹具？

(...) 测试方法调用的顺序无法保证，因此 testOneItemCollection() 可能会在 testEmptyCollection() 之前执行。 （...）

为什么会这样呢？好吧，我相信使测试依赖于顺序是作者不想提倡的做法。测试应该是独立的，它们不应该耦合，违反这一点将使使事情更难以维护，将破坏单独运行测试的能力（显然）等等。

话虽这么说，如果你真的想要要朝这个方向发展，请考虑使用 TestNG，因为它本身支持以任意顺序运行测试方法（以及指定方法取决于方法组之类的事情）。 Cedric Beust 解释了如何按照 testng 中测试的执行顺序执行此操作。

Answer 2

如果您删除现有的 Junit 实例，并下载 JUnit 4.11 或更高版本中，以下代码将按照测试方法名称的升序顺序执行测试方法：

import org.junit.FixMethodOrder;
import org.junit.Test;
import org.junit.runners.MethodSorters;

@FixMethodOrder(MethodSorters.NAME_ASCENDING)
public class SampleTest {

    @Test
    public void testAcreate() {
        System.out.println("first");
    }
    @Test
    public void testBupdate() {
        System.out.println("second");
    }
    @Test
    public void testCdelete() {
        System.out.println("third");
    }
}

Answer 3

迁移到 TestNG 似乎是最好的方法，但我认为 jUnit 没有明确的解决方案。这是我为 jUnit 找到的最易读的解决方案/格式：

@FixMethodOrder( MethodSorters.NAME_ASCENDING ) // force name ordering
public class SampleTest {
    @Test
    void stage1_prepareAndTest(){};

    @Test
    void stage2_checkSomething(){};

    @Test
    void stage2_checkSomethingElse(){};

    @Test
    void stage3_thisDependsOnStage2(){};

    @Test
    void callTimeDoesntMatter(){}
}

这确保了 stage2 方法在 stage1 方法之后和 stage3 方法之前调用。

PS 我觉得这种方法比 jUnit 5.5 @Order 注释更好，因为它为读者提供了更好的表示法。

Answer 4

如果订单很重要，您应该自己下订单。

@Test public void test1() { ... }
@Test public void test2() { test1(); ... }

特别是，如有必要，您应该列出一些或所有可能的顺序排列进行测试。

例如，

void test1(); 
void test2(); 
void test3(); 


@Test
public void testOrder1() { test1(); test3(); }

@Test(expected = Exception.class)
public void testOrder2() { test2(); test3(); test1(); }

@Test(expected = NullPointerException.class)
public void testOrder3() { test3(); test1(); test2(); }

或者，对所有排列的完整测试：

@Test
public void testAllOrders() {
    for (Object[] sample: permute(1, 2, 3)) {
        for (Object index: sample) {
            switch (((Integer) index).intValue()) {
                case 1: test1(); break; 
                case 2: test2(); break; 
                case 3: test3(); break; 
            }
        }
    }
}

这里，permute() 是一个简单的函数，它将所有可能的排列迭代到数组集合中。

Answer 5

从 5.5 开始，JUnit 允许在类上使用 @TestMethodOrder(OrderAnnotation.class)，在测试方法上允许使用 @Order(1)。

JUnit 旧版本允许测试方法使用类注释运行顺序：

@FixMethodOrder(MethodSorters.NAME_ASCENDING)
@FixMethodOrder(MethodSorters.JVM)
@FixMethodOrder(MethodSorters.DEFAULT)

默认情况下，测试方法按字母顺序运行。因此，要设置特定方法的顺序，您可以将它们命名为：

a_TestWorkUnit_WithCertainState_ShouldDoSomething
b_TestWorkUnit_WithCertainState_ShouldDoSomething
c_TestWorkUnit_WithCertainState_ShouldDoSomething

或

_1_TestWorkUnit_WithCertainState_ShouldDoSomething
_2_TestWorkUnit_WithCertainState_ShouldDoSomething
_3_TestWorkUnit_WithCertainState_ShouldDoSomething

您可以此处找到示例。

Answer 6

JUnit 5 更新（以及我的观点）

我认为这对于 JUnit 来说是非常重要的功能，如果 JUnit 的作者不想要顺序功能，为什么？

默认情况下，单元测试库不会尝试按照源文件中出现的顺序执行测试。

JUnit 5 和 JUnit 4 一样以这种方式工作。为什么？因为如果顺序很重要，则意味着某些测试在它们之间耦合，而这对于单元测试来说是不可取的。
因此，JUnit 5 引入的@Nested 功能遵循相同的默认方法。

但对于集成测试，测试方法的顺序可能很重要，因为一个测试方法可能会以另一个测试方法预期的方式更改应用程序的状态。
例如，当您为电子商店结帐处理编写集成测试时，要执行的第一个测试方法是注册客户端，第二个是在购物篮中添加商品，最后一个是执行结帐。如果测试运行者不遵守该顺序，则测试场景存在缺陷并且将会失败。
因此，在 JUnit 5（从 5.4 版本开始）中，您同样可以通过使用 @TestMethodOrder(OrderAnnotation.class) 并使用 @Order(numericOrderValue) 指定顺序) 对于顺序重要的方法。

例如：

@TestMethodOrder(OrderAnnotation.class) 
class FooTest {

    @Order(3)
    @Test
    void checkoutOrder() {
        System.out.println("checkoutOrder");
    }

    @Order(2)
    @Test
    void addItemsInBasket() {
        System.out.println("addItemsInBasket");
    }

    @Order(1)
    @Test
    void createUserAndLogin() {
        System.out.println("createUserAndLogin");
    }
}

输出：

创建用户并登录

在购物篮中添加项目

结账订单

顺便说一句，指定 @TestMethodOrder(OrderAnnotation.class) 看起来不需要（至少在我测试的 5.4.0 版本中）。

旁注
关于问题：JUnit 5 是编写集成测试的最佳选择吗？我不认为它应该是第一个考虑的工具（Cucumber 和 co 可能经常为集成测试带来更具体的价值和功能），但在某些集成测试用例中，JUnit 框架就足够了。因此，该功能的存在是一个好消息。

Answer 7

这是我在 Junit 上工作时遇到的主要问题之一，我想出了以下对我来说效果很好的解决方案：

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

import org.junit.runners.BlockJUnit4ClassRunner;
import org.junit.runners.model.FrameworkMethod;
import org.junit.runners.model.InitializationError;

public class OrderedRunner extends BlockJUnit4ClassRunner {

    public OrderedRunner(Class<?> clazz) throws InitializationError {
        super(clazz);
    }

    @Override
    protected List<FrameworkMethod> computeTestMethods() {
        List<FrameworkMethod> list = super.computeTestMethods();
        List<FrameworkMethod> copy = new ArrayList<FrameworkMethod>(list);
        Collections.sort(copy, new Comparator<FrameworkMethod>() {
        
            @Override
            public int compare(FrameworkMethod f1, FrameworkMethod f2) {
                Order o1 = f1.getAnnotation(Order.class);
                Order o2 = f2.getAnnotation(Order.class);

                if (o1 == null || o2 == null) {
                    return -1;
                }

                return o1.order() - o2.order();
            }
        });
        return copy;
    }
}

还创建一个如下所示的接口：

@Retention(RetentionPolicy.RUNTIME)
@Target({ ElementType.METHOD})
public @interface Order {
    public int order();
}

现在假设您有 A 类，您已经编写了几个测试用例，如下所示：

@RunWith(OrderRunner.class)
class A {
    @Test
    @Order(order = 1)
    void method() {
        //do something
    }
}

因此将从名为“method()”的方法开始执行。
谢谢！

Answer 8

（尚未发布）更改 https://github.com/junit-team/junit/ pull/386 引入了@SortMethodsWith。 https://github.com/junit-team/junit/pull/293至少可以让顺序在没有它的情况下是可预测的（在 Java 7 中它可能是相当随机的）。

Answer 9

查看 JUnit 报告。 JUnit 已经按包组织。每个包都有（或可以有）TestSuite 类，每个类又运行多个 TestCases。每个 TestCase 可以有多个 public void test*() 形式的测试方法，每个测试方法实际上都会成为它们所属的 TestCase 类的实例。每个测试方法（TestCase 实例）都有一个名称和一个通过/失败标准。

我的管理层需要的是各个 TestStep 项目的概念，每个项目都报告自己的通过/失败标准。任何测试步骤的失败不得妨碍后续测试步骤的执行。

过去，像我这样的测试开发人员将 TestCase 类组织到与被测产品的各个部分相对应的包中，为每个测试创建一个 TestCase 类，并使每个测试方法成为测试中单独的“步骤”，在 JUnit 输出中包含其自己的通过/失败标准。每个测试用例都是一个独立的“测试”，但测试用例中的各个方法或测试“步骤”必须按特定顺序发生。

TestCase 方法是 TestCase 的步骤，测试设计者为每个测试步骤提供单独的通过/失败标准。现在测试步骤很混乱，测试（当然）失败了。

例如：

Class testStateChanges extends TestCase

public void testCreateObjectPlacesTheObjectInStateA()
public void testTransitionToStateBAndValidateStateB()
public void testTransitionToStateCAndValidateStateC()
public void testTryToDeleteObjectinStateCAndValidateObjectStillExists()
public void testTransitionToStateAAndValidateStateA()
public void testDeleteObjectInStateAAndObjectDoesNotExist()
public void cleanupIfAnythingWentWrong()

每种测试方法都断言并报告其自己单独的通过/失败标准。
为了排序而将其折叠为“一个大的测试方法”会丢失 JUnit 摘要报告中每个“步骤”的通过/失败标准粒度。 ...这让我的经理们很不高兴。他们目前要求另一种选择。

谁能解释一下具有乱序测试方法排序的 JUnit 如何支持每个顺序测试步骤的单独通过/失败标准，如上面所示例和我的管理层所要求的？

无论文档如何，我都认为这是 JUnit 框架的严重回归，让许多测试开发人员的生活变得困难。

Answer 10

JUnit 4 更新

从 JUnit 4.13 @OrderWith 开始，可以重现 JUnit 5 @Order 注释。该解决方案与 JUnit 4 的集成比 @RunWith 自定义 BlockJUnit4ClassRunner 实现更好。

以下是我如何用注释排序替换方法名称排序 (@FixMethodOrder(MethodSorters.NAME_ASCENDING))。

@OrderWith(OrderAnnotation.class)
public class MyTest {
    @Test
    @Order(-1)
    public void runBeforeNotAnnotatedTests() {}

    @Test
    public void notAnnotatedTestHasPriority0() {}

    @Test
    @Order(1)
    public void thisTestHasPriority1() {}

    @Test
    @Order(2)
    public void thisTestHasPriority2() {}
}

/**
 * JUnit 4 equivalent of JUnit 5's {@code org.junit.jupiter.api.Order}
 */
@Retention(RetentionPolicy.RUNTIME)
@Target({ ElementType.METHOD })
public @interface Order {
    /**
     * Default order value for elements not explicitly annotated with {@code @Order}.
     *
     * @see Order#value
     */
    int DEFAULT = 0;

    /**
     * The order value for the annotated element.
     * <p>Elements are ordered based on priority where a lower value has greater
     * priority than a higher value. For example, {@link Integer#MAX_VALUE} has
     * the lowest priority.
     *
     * @see #DEFAULT
     */
    int value();
}

import org.junit.runner.Description;
import org.junit.runner.manipulation.Ordering;
import org.junit.runner.manipulation.Sorter;

/**
 * Order test methods by their {@link Order} annotation. The lower value has the highest priority.
 * The tests that are not annotated get the default value {@link Order#DEFAULT}.
 */
public class OrderAnnotation extends Sorter implements Ordering.Factory {
    public OrderAnnotation() {
        super(COMPARATOR);
    }

    @Override
    public Ordering create(Context context) {
        return this;
    }

    private static final Comparator<Description> COMPARATOR = Comparator.comparingInt(
            description -> Optional.ofNullable(description.getAnnotation(Order.class))
                                   .map(Order::value)
                                   .orElse(Order.DEFAULT));
}

未注释的测试的默认优先级为 0。具有相同优先级的测试的顺序未确定。

要点： https://gist.github.com/jcarsique/df98e0bad9e88e8258c4ab34dad3c863

灵感来源：

• Aman Goel 的回答
• JUnit 团队的测试执行顺序 Wiki
• JUnit 5 源代码

Answer 11

不确定我是否同意，如果我想测试“文件上传”，然后测试“文件上传插入的数据”，为什么我不希望它们彼此独立？我认为能够单独运行它们而不是在 Goliath 测试用例中同时运行它们是完全合理的。

Answer 12

当测试用例作为套件运行时，您想要的东西是完全合理的。

不幸的是，现在没有时间给出完整的解决方案，但看看类：

org.junit.runners.Suite

它允许您以特定顺序调用测试用例（从任何测试类）。

这些可用于创建功能、集成或系统测试。

这使得您的单元测试没有特定的顺序（如建议的那样），无论您是否像这样运行它们，然后将测试重新用作更大的图景的一部分。

我们重复使用/继承相同的代码进行单元、集成和系统测试，有时是数据驱动，有时是提交驱动，有时作为套件运行。

Answer 13

正如其他人所说，理想情况下测试应该独立于执行顺序。这使得测试不那么脆弱，并允许它们独立运行（许多 IDE 允许您选择一个测试方法并独立于其他测试执行它）。

话虽如此，对于集成测试，有些人更喜欢依赖方法排序。

从 JUnit 4.13 开始，您可以通过扩展 订购。有关更多详细信息，请参阅 JUnit wiki。下面是一个使用内置 Alphanumeric 类使用测试方法名称按字母数字顺序对测试进行排序的示例：

import org.junit.Test;
import org.junit.runner.OrderWith;
import org.junit.runner.manipulation.Alphanumeric;

@OrderWith(Alphanumeric.class)
public class TestMethodOrder {

    @Test
    public void testA() {
        System.out.println("first");
    }
    @Test
    public void testB() {
        System.out.println("second");
    }
    @Test
    public void testC() {
        System.out.println("third");
    }
}

Answer 14

是时候迁移到 Junit5 了。
以下是我们可以获得的示例：

@TestMethodOrder(MethodOrderer.OrderAnnotation.class)
 class OrderedTests {

     @Test
     @Order(1)
     void nullValues() {}

     @Test
     @Order(2)
     void emptyValues() {}

     @Test
     @Order(3)
     void validValues() {}
 }

对于 Junit4，将多个测试中的逻辑复制到一个测试方法中。

Answer 15

对于 JUnit 4，将此注释放在测试类上解决了问题。

@FixMethodOrder(MethodSorters.JVM)

Answer 16

使用 JUnit 5.4，您可以指定顺序：

@Test
@Order(2)
public void sendEmailTestGmail() throws MessagingException {

您只需注释您的类

@TestMethodOrder(OrderAnnotation.class)

https://junit.org/junit5/docs/current/user-guide/#writing-tests-test-execution-order

我在我的项目中使用它，它效果很好！

Answer 17

您可以使用以下代码之一：
@FixMethodOrder(MethodSorters.JVM) OR @FixMethodOrder(MethodSorters.DEFAULT) OR @FixMethodOrder(MethodSorters.NAME_ASCENDING)

在您的测试类之前，如下所示:

@FixMethodOrder(MethodSorters.NAME_ASCENDING)
public class BookTest {...}

Answer 18

我读过一些答案，并同意这不是最佳实践，而是排序测试的最简单方法 - JUnit 默认运行测试的方式是按字母名称升序排列。

因此，只需按照您想要的字母顺序命名您的测试即可。另请注意，测试名称必须以开头
与测试这个词。只需注意

test12 将在 test2 之前运行的

数字，因此：

testA_MyFirstTest
testC_ThirdTest
testB_ATestThatRunsSecond

Answer 19

请查看这个：https://github.com/TransparentMarket/junit。它按照指定的顺序（在编译的类文件中定义）运行测试。它还具有 AllTests 套件，可以首先运行子包定义的测试。使用 AllTests 实现可以扩展解决方案，还可以过滤属性（我们曾经使用 @Fast 注释，但这些注释尚未发布）。

Answer 20

以下是 JUnit 的扩展，可以产生所需的行为： https://github.com/aafuks/aaf- junit

我知道这违背了 JUnit 哲学的作者，但是当在不严格的单元测试环境中使用 JUnit 时（如 Java 中的实践），这可能非常有帮助。

Answer 21

我最终想到我的测试没有按顺序运行，但事实是混乱出现在我的异步作业中。使用并发时，您还需要在测试之间执行并发检查。
在我的例子中，作业和测试共享一个信号量，因此接下来的测试会挂起，直到正在运行的作业释放锁。

我知道这与这个问题并不完全相关，但也许可以帮助找到正确的问题

Answer 22

如果您想在 JUnit 5 中按特定顺序运行测试方法，可以使用以下代码。

@TestMethodOrder(MethodOrderer.OrderAnnotation.class)
public class MyClassTest { 

    @Test
    @Order(1)
    public void test1() {}

    @Test
    @Order(2)
    public void test2() {}

}