Advice / suggestion on how to implement 'integration tests simulating loss-of-power' under JUnit5 (migration from JUnit4) ?

[oliva123456]

Hi,

we are currently migrating from JUnit 4 and i'm quite unsure how to migrate a special test scenario.

aside from simple junit tests we additionally have integration tests: we start up our application and connect the test class to our application (e.g. user interaction). we were already able to migrate integration tests to JUnit5.

but we have some special integration tests, in which we simulate a loss of power within our application:

• there is a phase before a loss of power: first instance of our application is started, used (e.g. with user input) and terminated (when the test method ends)
• there is a phase after a loss of power: second instance of our application is started and the behaviour of the application is checked
• both phases run in the JUnit lifecycle (within JUnit4: Rules/ClassRules/Assertions)
• 'the application' is started in the same JVM as the test

now i'm quite unsure, how to implement the scenario within JUnit5:

• implement our own TestEngine from scratch (this should work, but means re-implementing a lot of stuff from the existing test engines)
• implement our own TestEngine by subclassing org.junit.platform.engine.support.hierarchical.HierarchicalTestEngine (after experimenting a bit imho the differentiation between before and after loss-of-power-phase does not fit well into the concept of hierarchical tests, maybe i missed something)
• using org.junit.jupiter.engine.JupiterTestEngine with some features, i haven't discovered so far
• using some other features like DynamicTest / TestFactory (i did not take a deep dive so far)
• some other features

i'd appreciate very much, if someone already had similar scenarios or is able to give some advice ;-)

for the sake of completeness: in JUnit4 we implemented those tests in the following way:

• a single test for each scenario consisting of:
  exactly one method annotated with our own marker-annotation @BeforeRecovery (running the phase before a loss of power)
  exactly one method annotated with @test (running the phase after a loss of power)
• we subclassed our own TestRunner (OurTestRunner extends BlockJUnit4ClassRunner)
• we hooked into some methods of BlockJUnit4ClassRunner
  e.g.:
  #computeTestMethods to handle the method @BeforeRecovery over to JUnit
  #classBlock to run the before-recovery-phase before the proper test-method is started (another instance of OurTestRunner is started with a boolean, which indicates before/after loss-of-power).
  #methodBlock/#methodInvoker for the lifecycle
• the implementation probably is not ideal, but it works quite well.

for a better understanding some code of such a test:

  @RunWith(OurTestRunner.class)
  public class RecoveryTest {

      @BeforeClass
      public static void configureSomething() {
	  // configuration for both phases.
      }
  
      /**
       * Pre-recovery phase - run your testcase until the loss-of-power should happen.
       */
      @BeforeRecovery
      public void prepareForRecovery() {
          assertThat(getDisplay(), displays("something"));
          getDisplay().touch("something");
          ....
      }
  
      /**
       * After-recovery phase. Our application should restore the transaction
       * and the testcase might perform all checks.
       */
      @Test public void postRecovery() throws Exception {
          assertThat("something");
      }
  }

thanks in advance,
Oliver