Conditionally ignoring tests in JUnit 4

java

test-engineering

best-practices

promises

byNikita Barsukov·Oct 19, 2024

For bypassing tests, make use of Assume, a utility in JUnit 4. Employ assumeTrue(condition). When the condition equates to false, the test is promptly skipped. Here is an example:

@Test
public void testMethod() {
    Assume.assumeTrue(isThisProductionEnviromnent());
    // test code here
}

private boolean isThisProductionEnviromnent() {
    // Returns true if ENV is "production", otherwise skips the test faster than Usain Bolt ;)
    return "production".equals(System.getProperty("ENV")); 
}

This ensures the test is disregarded unless executed in the production environment.

Going a step ahead: `assumeThat`, `BeforeClass` and more

JUnit's org.junit.Assume provides several other options, such as assumeThat. This allows for extra granularity and use of Hamcrest matchers:

@Test
public void testMethod() {
    Assume.assumeThat(System.getProperty("ENV"), is("production"));
    // Stay tuned for the rest of the test!
}

If you want to prevent class initialization because the setup is heavy-duty or relies on the same environment-specific conditions, assumeTrue comes in handy within the @BeforeClass:

@BeforeClass
public static void setUpClass() {
    Assume.assumeTrue("production".equals(System.getProperty("ENV")));
    // Insert wallet-draining setup code here
}

For parameterized tests, the condition can alter with each attempted individual run. Integrate Assume.assumeTrue in your test parameter setup:

public static Collection<Object[]> data() {
    return Arrays.asList(new Object[][] {
        { "production", true },
        { "dev", false }
    });
}

@Test
@Parameters(method = "data")
public void runConditionalTest(String env, boolean shouldRun) {
    Assume.assumeTrue(shouldRun);
    // More exciting tests to come!
}

Enhancing clarity: `TestName` Rule and `Junit-ext`

You can make use of the TestName Rule in JUnit to decide which test to run or for keeping logs. Gain access to the name of the current test method:

@Rule
public TestName name = new TestName();

@Test
public void test() {
    String methodName = name.getMethodName();
    Assume.assumeTrue(shouldBeRun(methodName));
    // Brace yourself, more test code coming!
}

private boolean shouldBeRun(String testName) {
    // Condition based on method name goes here
}

Further, if you already think you're advanced enough, consider the incorporation of the Junit-ext libraries. These entail annotations like @RunIf, driving test execution in a more adaptable and declarative manner:

@Test
@RunIf(EligibilityChecker.class)
public void conditionalTest() {
    // Break's over, back to test code
}

public static class EligibilityChecker implements RunIf.Condition
{
    @Override
    public boolean isSatisfied() {
        return "production".equals(System.getProperty("ENV"));
        // This function is the Gandalf of your test code. It decrees, "You shall pass (or not)!"
    }
}

Nuggets of wisdom and practical advice

Reduce the count of pre-requisite checks

If a test is bypassed owing to an Assume, the subsequent section is automatically canned. Ensure that your assumption check is not hiding any bugs.

Tame your conditional logic

Over-reliance on Assumes can lead to a dense forest of conditions, making your test hard to navigate and brittle. If conditions appear overwhelming, refactor or segment your tests.

Track your skipped test patterns

Tests getting bypassed consistently might be regulatory flaky tests or misaligned testing practices. Take a close look at the patterns, and harmonize such deviations.