Skip @Before for a test || Is there a way to execute the @Before methods in a TestRule?

Question

High level, I have JUnit test class which is pretty straightforward. I have several @Tests and a single @Before which does some set up. For one test case, the setup varies (I don't want it to be run).

From some searching I found https://stackoverflow.com/a/13017452/413254. This suggests creating a @Rule which checks for a particular annotation and executes the @Before statement.

My confusion is around how to execute the @Before method in the rule. Is there a way to do that? Or do I need to pass in the test class itself and execute the @before method (setup() in the example below)?

public class NoBeforeRule implements TestRule {

    @Override
    public Statement apply(final Statement base, final Description description) {
        return new Statement() {
            @Override
            public void evaluate() throws Throwable {
                if (description.getAnnotation(NoBefore.class) == null) {
                    // Is there something like `base.executeAllTheBefores()' 
                }

                base.evaluate();
            }
        };
    }
}

The relevant test code:

@Rule public NoBeforeRule mNoBeforeRule = new NoBeforeRule(this);

@Before
@Override
public void setup() {
}

@Test
public void testNeedSetup() {
    // this should run setup()
}

@NoBefore
@Test
public void testNoSetup() {
    // this should NOT run setup()
}

Answer 1

Why don't you just split the tests into 2 separate test classes? The ones that need the setup go into one class and the one(s) that don't go into another.

There is no rule (or even guideline) that states all the tests for a class must go into a single test class, and this is in fact something I do very often.

The fact you have a single or multiple tests that don't need the common setup is probably an indication that the tests themselves aren't cohesive and are testing a different variation of your class under test. For example, I may have a bunch of methods that have a mock setup in a specific way for positive tests, but then other tests that need it configured differently for failure scenarios. I will move these tests into 2 classes - specifically the ones for positive scenarios and ones for failure scenarios.

Playing around with Rules and such-like to explicitly avoid running the standard @Before method will just make things more complicated and have your future-self or colleagues scratching their heads as to why the setup method isn't being run

Answer 2

• call setup() in the custom rule implementation.

• remove the @Before annotation on setup(), as including the @Rule will cause the custom rule to be run each time.

  public class MyTest {
  
     class NoBeforeRule implements TestRule {
        @Override
        public Statement apply(final Statement base, final Description description) {
            return new Statement() {
                @Override
                public void evaluate() throws Throwable {
                    if (description.getAnnotation(NoBefore.class) == null) {
                        setup(); 
                    }
  
                    base.evaluate();
                }
            };
        }
     }
  
     @Rule 
     public NoBeforeRule mNoBeforeRule = new NoBeforeRule();
  
  
     public void setup() {}
  
     @Test
     public void testNeedSetup() {
        // this should run setup()
     }
  
     @NoBefore
     @Test
     public void testNoSetup() {
        // this should NOT run setup()
     }
  }
  

Answer 3

Maybe play around with the rule TestName

@Rule public TestName name = new TestName();

@Before 
public void setup() {
     if(listOfTestNeedSetup.contains(name.getMethodName()) {
        // need setup
     }
}