Custom conditions with @EnabledIf in JUnit - Build an Automation Script

Automate a test that runs only if a custom condition is true using @EnabledIf

Preconditions (2)

Step 1: Create a test method annotated with @Test and @EnabledIf

Step 2: Implement a static method that returns a boolean for the condition

Step 3: Annotate the test method with @EnabledIf referencing the condition method

Step 4: Run the test suite

Step 5: Verify the test runs only if the condition method returns true

✅ Expected Result: The test method executes only when the custom condition method returns true; otherwise, it is skipped.

Automation Requirements - JUnit 5

Assertions Needed:

Verify the test method runs when the condition is true

Verify the test method is skipped when the condition is false

Best Practices:

Use static methods for @EnabledIf conditions

Keep condition methods simple and side-effect free

Use descriptive method names for conditions

Use assertions inside the test method to verify functionality

Automated Solution

JUnit

import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.condition.EnabledIf;
import static org.junit.jupiter.api.Assertions.assertTrue;

public class CustomConditionTest {

    @Test
    @EnabledIf("customCondition")
    void testRunsOnlyIfConditionTrue() {
        // This test runs only if customCondition() returns true
        assertTrue(true, "Test executed because condition is true");
    }

    static boolean customCondition() {
        // Custom logic for enabling the test
        // For example, enable test only if system property 'runCustomTest' is 'true'
        return "true".equals(System.getProperty("runCustomTest"));
    }
}

The test method testRunsOnlyIfConditionTrue is annotated with @EnabledIf("customCondition"). This means JUnit will call the static method customCondition() before running the test.

If customCondition() returns true, the test runs and asserts true to confirm execution.

If it returns false, JUnit skips the test.

The condition method checks a system property runCustomTest. This allows controlling test execution externally, like from command line or build scripts.

This approach keeps tests clean and allows flexible enabling/disabling based on custom logic.

Common Mistakes - 4 Pitfalls

Using non-static methods for @EnabledIf condition

Putting complex logic or side effects inside the condition method

Not referencing the condition method name correctly in @EnabledIf

Using @EnabledIf on non-test methods

Bonus Challenge

Now add data-driven testing with @EnabledIf so that each test case runs only if a custom condition for that data is true

Show Hint

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