Junit @ Before / @ After叫什么顺序？

我有一个集成测试套件。我有一IntegrationTestBase堂课可以扩展我的所有测试。该基类具有@Before（public void setUp()）和@After（public void tearDown()）方法来建立API和数据库连接。我一直在做的只是在每个测试用例中覆盖这两个方法，并调用super.setUp()和super.tearDown()。但是，如果有人忘记了调用super或将它们放置在错误的位置并抛出异常，而他们却忘记了在final之类的地方调用super，则会导致问题。

我想做的是在基类上创建setUp和tearDown方法final，然后仅添加我们自己的注释@Before和@After方法。在进行一些初始测试时，似乎总是按以下顺序调用：

Base @Before
Test @Before
Test
Test @After
Base @After

但我只是有点担心订单不能得到保证，并且可能导致问题。我环顾四周，没有看到任何关于此的内容。有谁知道我能做到而没有任何问题吗？

码：

public class IntegrationTestBase {

    @Before
    public final void setUp() { *always called 1st?* }

    @After
    public final void tearDown() { *always called last?* }
}


public class MyTest extends IntegrationTestBase {

    @Before
    public final void before() { *always called 2nd?* }

    @Test
    public void test() { *always called 3rd?* }

    @After
    public final void after() { *always called 4th?* }
}

是的，可以保证此行为：

@Before：

@Before超级类的方法将在当前类的方法之前运行，除非它们在当前类中被覆盖。没有定义其他顺序。

@After：

@After在超类中声明的方法将在当前类的方法之后运行，除非它们在当前类中被覆盖。

以前咬过我的一个潜在陷阱：

我喜欢@Before在每个测试类中最多包含一个方法，因为@Before不能保证运行在类中定义的方法的顺序。通常，我将调用这种方法setUpTest()。

但是，尽管@Before记录为The @Before methods of superclasses will be run before those of the current class. No other ordering is defined.，这仅适用于每个标记有方法@Before的类在类层次结构中具有唯一的名称。

例如，我有以下内容：

public class AbstractFooTest {
  @Before
  public void setUpTest() { 
     ... 
  }
}

public void FooTest extends AbstractFooTest {
  @Before
  public void setUpTest() { 
    ...
  }
}

我希望AbstractFooTest.setUpTest()在之前运行FooTest.setUpTest()，但只FooTest.setupTest()执行了。AbstractFooTest.setUpTest()根本没有被调用。

必须对代码进行如下修改才能起作用：

public void FooTest extends AbstractFooTest {
  @Before
  public void setUpTest() {
    super.setUpTest();
    ...
  }
}

我认为基于的文件上@Before，并@After得出正确的结论就是给方法唯一的名称。我在测试中使用以下模式：

public abstract class AbstractBaseTest {

  @Before
  public final void baseSetUp() { // or any other meaningful name
    System.out.println("AbstractBaseTest.setUp");
  }

  @After
  public final void baseTearDown() { // or any other meaningful name
    System.out.println("AbstractBaseTest.tearDown");
  }
}

和

public class Test extends AbstractBaseTest {

  @Before
  public void setUp() {
    System.out.println("Test.setUp");
  }

  @After
  public void tearDown() {
    System.out.println("Test.tearDown");
  }

  @Test
  public void test1() throws Exception {
    System.out.println("test1");
  }

  @Test
  public void test2() throws Exception {
    System.out.println("test2");
  }
}

结果给

AbstractBaseTest.setUp
Test.setUp
test1
Test.tearDown
AbstractBaseTest.tearDown
AbstractBaseTest.setUp
Test.setUp
test2
Test.tearDown
AbstractBaseTest.tearDown

这种方法的优点：AbstractBaseTest类的用户不能偶然覆盖setUp / tearDown方法。如果需要，他们需要知道确切的名称并可以使用。

这种方法的（次要）缺点：用户无法看到在setUp / tearDown之前或之后发生了一些事情。他们需要知道这些东西是由抽象类提供的。但是我认为这就是为什么他们使用抽象类的原因

如果您解决了所有问题，则可以声明基类抽象，并让后代声明在基类的带注释的setUp和tearDown方法中调用的setUp和tearDown方法（不带注释）。

您可以使用@BeforeClass批注来确保setup()始终首先调用批注。同样，您可以使用@AfterClass注释来确保tearDown()始终将其称为最后。

通常不建议这样做，但是它是受支持的。

这并不是您真正想要的-但实际上它将使您的数据库连接在测试运行的整个过程中保持打开状态，然后一劳永逸地关闭它。

这不是对标语问题的解答，而是对问题正文中提到的问题的解答。不要使用@Before或@After，而要使用@ org.junit.Rule，因为它可以为您提供更大的灵活性。 如果要管理连接，ExternalResource（从4.7开始）是您最感兴趣的规则。另外，如果您想保证规则的执行顺序，请使用RuleChain（从4.10开始）。我相信当提出这个问题时，所有这些都是可用的。下面的代码示例是从ExternalResource的javadocs复制的。

 public static class UsesExternalResource {
  Server myServer= new Server();

  @Rule
  public ExternalResource resource= new ExternalResource() {
      @Override
      protected void before() throws Throwable {
          myServer.connect();
         };

      @Override
      protected void after() {
          myServer.disconnect();
         };
     };

  @Test
  public void testFoo() {
      new Client().run(myServer);
     }
 }