Custom conditions with @EnabledIf in JUnit

Introduction

We use @EnabledIf to run tests only when certain conditions are true. This helps save time by skipping tests that don't apply.

Run a test only if a specific system property is set.

Skip tests on certain operating systems like Windows or Mac.

Enable tests only when a database connection is available.

Run tests based on environment variables like 'TEST_ENV=prod'.

Control test execution depending on custom logic in your code.

Syntax

JUnit

@EnabledIf(expression = "${condition}")
void testMethod() {
    // test code
}

The expression is a Spring Expression Language (SpEL) string.

Conditions can check system properties, environment variables, or custom methods.

Examples

This test runs only on Linux machines.

JUnit

@EnabledIf(expression = "${os.name} == 'Linux'")
void testOnlyOnLinux() {
    // test code
}

This test runs only if the system user is 'admin'.

JUnit

@EnabledIf(expression = "${systemProperties['user.name']} == 'admin'")
void testForAdminUser() {
    // test code
}

This test runs only if the custom method isDatabaseAvailable() returns true.

JUnit

@EnabledIf(expression = "@myConditionChecker.isDatabaseAvailable()")
void testIfDatabaseIsUp() {
    // test code
}

Sample Program

This class has two tests. The first runs only if the environment variable TEST_MODE is set to 'true'. The second runs only on Windows OS.

JUnit

import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.condition.EnabledIf;

public class CustomConditionTest {

    @Test
    @EnabledIf(expression = "${env.TEST_MODE} == 'true'", reason = "Runs only if TEST_MODE environment variable is true")
    void testRunsOnlyInTestMode() {
        System.out.println("Test is running because TEST_MODE is true");
    }

    @Test
    @EnabledIf(expression = "${os.name}.toLowerCase().contains('windows')", reason = "Runs only on Windows OS")
    void testRunsOnlyOnWindows() {
        System.out.println("Test is running on Windows OS");
    }
}

Important Notes

Make sure the condition expression is valid SpEL syntax.

Use the reason attribute to explain why a test is enabled or disabled.

Environment variables and system properties can be accessed in expressions.

Summary

@EnabledIf lets you run tests only when a condition is true.

Conditions use Spring Expression Language (SpEL) for flexibility.

This helps run tests smartly based on environment or custom logic.

Practice

1. What is the primary purpose of using @EnabledIf in JUnit tests?

easy

A. To run a test only if a custom condition returns true

B. To disable a test permanently

C. To mark a test as expected to fail

D. To repeat a test multiple times

Solution

1. Step 1: Understand the role of @EnabledIf

   @EnabledIf is used to conditionally enable a test based on a custom boolean expression or method.

2. Step 2: Compare with other annotations

   Unlike disabling or repeating tests, @EnabledIf controls test execution dynamically based on conditions.

3. Final Answer:

   To run a test only if a custom condition returns true -> Option A

4. Quick Check:

   @EnabledIf runs test if condition true [OK]

Hint: Remember: @EnabledIf controls test run by condition [OK]

Common Mistakes:

• Confusing @EnabledIf with @Disabled
• Thinking it repeats tests
• Assuming it marks tests as expected failures

2. Which of the following is the correct syntax to enable a test only if a static method isFeatureEnabled() returns true using @EnabledIf?

easy

A. @EnabledIf("isFeatureEnabled()")

B. @EnabledIf(expression = "isFeatureEnabled()")

C. @EnabledIf("isFeatureEnabled")

D. @EnabledIf(condition = "isFeatureEnabled()")

Solution

1. Step 1: Check correct attribute name

   The correct attribute for the condition expression is unnamed, so just a string is passed to @EnabledIf.

2. Step 2: Validate method call syntax

   The method must be called with parentheses inside the string: "isFeatureEnabled()".

3. Final Answer:

   @EnabledIf("isFeatureEnabled()") -> Option A

4. Quick Check:

   Use @EnabledIf("method()") syntax [OK]

Hint: Use @EnabledIf("method()") with parentheses [OK]

Common Mistakes:

• Using expression attribute which does not exist
• Omitting parentheses in method call
• Using incorrect attribute name like condition

3. Given the following code snippet, what will be the output when running the test?

public class FeatureTest {
  static boolean isFeatureEnabled() { return false; }

  @Test
  @EnabledIf("isFeatureEnabled()")
  void testFeature() {
    System.out.println("Feature test executed");
  }
}

medium

A. Feature test executed

B. Test skipped, no output

C. Compilation error due to @EnabledIf

D. Runtime exception thrown

Solution

1. Step 1: Evaluate the condition method

   The method isFeatureEnabled() returns false, so the condition for @EnabledIf is false.

2. Step 2: Understand @EnabledIf behavior

   When the condition is false, the test is skipped and the test method body does not run.

3. Final Answer:

   Test skipped, no output -> Option B

4. Quick Check:

   False condition skips test [OK]

Hint: False condition means test does not run [OK]

Common Mistakes:

• Expecting test to run despite false condition
• Thinking it causes errors
• Confusing with @Disabled

4. Identify the error in the following test code using @EnabledIf:

public class SampleTest {
  @Test
  @EnabledIf("checkCondition")
  void testSomething() {}

  boolean checkCondition() { return true; }
}

medium

A. checkCondition must return String, not boolean

B. @EnabledIf requires expression attribute

C. checkCondition method must be static

D. Method checkCondition must be public

Solution

1. Step 1: Check method signature requirements

   The method used in @EnabledIf must be static because JUnit calls it without instance.

2. Step 2: Verify method return type and visibility

   Return type boolean is correct and method visibility can be default or public, but static is mandatory.

3. Final Answer:

   checkCondition method must be static -> Option C

4. Quick Check:

   Condition method must be static [OK]

Hint: Condition methods must be static [OK]

Common Mistakes:

• Making condition method non-static
• Expecting expression attribute in @EnabledIf
• Confusing return type requirements

5. You want to enable a test only if the system property env equals prod and a static method isReady() returns true. Which @EnabledIf expression correctly combines these conditions?

hard

A. @EnabledIf(expression = "System.getProperty('env').equals('prod') && isReady()")

B. @EnabledIf("System.getProperty('env') == 'prod' && isReady()")

C. @EnabledIf("System.getProperty('env').equals('prod') & isReady()")

D. @EnabledIf("'prod'.equals(System.getProperty('env')) && isReady()")

Solution

1. Step 1: Understand string comparison in Java expressions

   Use 'prod'.equals(System.getProperty('env')) to avoid NullPointerException if property is null.

2. Step 2: Combine conditions with logical AND

   Use && to combine boolean expressions correctly in the string.

3. Step 3: Validate syntax of @EnabledIf

   The expression is passed as a single string without attribute name; @EnabledIf("'prod'.equals(System.getProperty('env')) && isReady()") matches this.

4. Final Answer:

   @EnabledIf("'prod'.equals(System.getProperty('env')) && isReady()") -> Option D

5. Quick Check:

   Use safe equals and && in string expression [OK]

Hint: Use 'prod'.equals(...) and && for safe combined condition [OK]

Common Mistakes:

• Using == for string comparison
• Using single & instead of &&
• Adding expression attribute which is invalid