I have an Integration Test Suite. I have a IntegrationTestBase
class for all my tests to extend. This base class has a @Before
(public void setUp()
) and @After
(public void tearDown()
) method to establish API and DB connections. What I've been doing is just overriding those two methods in each testcase and calling super.setUp()
and super.tearDown()
. However this can cause problems if someone forgets to call the super or puts them at the wrong place and an exception is thrown and they forget to call super in the finally or something.
What I want to do is make the setUp
and tearDown
methods on the base class final
and then just add our own annotated @Before
and @After
methods. Doing some initial tests it appears to always call in this order:
Base @Before
Test @Before
Test
Test @After
Base @After
but I'm just a little concerned that the order isn't guaranteed and that it could cause problems. I looked around and haven't seen anything on the subject. Does anyone know if I can do that and not have any problems?
Code:
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?* }
}
Yes, this behaviour is guaranteed:
The
@Before
methods of superclasses will be run before those of the current class, unless they are overridden in the current class. No other ordering is defined.
The
@After
methods declared in superclasses will be run after those of the current class, unless they are overridden in the current class.