@EnabledIfSystemProperty in JUnit - Build an Automation Script

Test runs only if system property 'env' equals 'test'

Preconditions (2)

Step 1: Set system property 'env' to 'test'

Step 2: Run the test class containing the conditional test method

Step 3: Observe that the test method annotated with @EnabledIfSystemProperty runs

Step 4: Set system property 'env' to 'prod'

Step 5: Run the test class again

Step 6: Observe that the test method annotated with @EnabledIfSystemProperty is skipped

✅ Expected Result: The test method runs only when system property 'env' is 'test'. It is skipped otherwise.

Automation Requirements - JUnit 5

Assertions Needed:

Verify test method executes only when system property 'env' equals 'test'

Verify test method is skipped when system property 'env' is not 'test'

Best Practices:

Use @EnabledIfSystemProperty annotation correctly with 'named' and 'matches' attributes

Use assertions inside the test to confirm execution

Use @BeforeAll or @BeforeEach to set or clear system properties if needed

Keep tests independent and clean up system properties after tests

Automated Solution

JUnit

import org.junit.jupiter.api.*;
import org.junit.jupiter.api.condition.EnabledIfSystemProperty;

import static org.junit.jupiter.api.Assertions.assertTrue;

public class EnabledIfSystemPropertyTest {

    @BeforeEach
    void clearProperty() {
        System.clearProperty("env");
    }

    @Test
    @EnabledIfSystemProperty(named = "env", matches = "test")
    void testRunsOnlyIfEnvIsTest() {
        // This test runs only if system property 'env' equals 'test'
        String env = System.getProperty("env");
        assertTrue("test".equals(env), "System property 'env' should be 'test'");
    }

    @Test
    void testAlwaysRuns() {
        // Control test to show normal test execution
        assertTrue(true);
    }

    public static void main(String[] args) {
        // Example to run tests with system property set
        System.setProperty("env", "test");
        org.junit.platform.launcher.LauncherDiscoveryRequest request =
                org.junit.platform.engine.discovery.DiscoverySelectors.selectClass(EnabledIfSystemPropertyTest.class);
        // Normally tests run via IDE or build tool
    }
}

The test class EnabledIfSystemPropertyTest contains a test method testRunsOnlyIfEnvIsTest annotated with @EnabledIfSystemProperty. This annotation makes the test run only if the system property named env matches the value test.

Before each test, the system property env is cleared to avoid side effects. To run the conditional test, set the system property env to test before running the tests.

The assertion inside the test confirms that the system property is indeed test when the test runs.

Another test testAlwaysRuns is included to show a normal test that always runs.

This setup helps beginners understand how to use @EnabledIfSystemProperty to conditionally run tests based on environment settings.

Common Mistakes - 4 Pitfalls

Not setting the system property before running the test

Using incorrect property name or value in @EnabledIfSystemProperty

Not clearing or resetting system properties after tests

Putting assertions outside the conditional test method

Bonus Challenge

Now add data-driven testing with 3 different system property values ('test', 'dev', 'prod') and verify which tests run.

Show Hint

Practice

1. What is the primary purpose of the @EnabledIfSystemProperty annotation in JUnit tests?

easy

A. To enable a test only on weekends

B. To disable a test permanently

C. To run a test only if a specific system property matches a given value

D. To run a test multiple times automatically

Solution

1. Step 1: Understand the annotation's purpose

   <code>@EnabledIfSystemProperty

2. Step 2: Analyze the options

   To run a test only if a specific system property matches a given value correctly states that the test runs only if a system property matches a value. Options B, C, and D describe unrelated behaviors.

3. Final Answer:

   To run a test only if a specific system property matches a given value -> Option C

4. Quick Check:

   @EnabledIfSystemProperty = Conditional test run [OK]

Hint: It runs tests only when system property matches [OK]

Common Mistakes:

• Confusing it with @Disabled or @Enabled annotations
• Thinking it runs tests based on date or time
• Assuming it runs tests multiple times automatically

2. Which of the following is the correct syntax to enable a test only when the system property env equals prod using @EnabledIfSystemProperty?

easy

A. @EnabledIfSystemProperty(named = "env", matches = "prod")

B. @EnabledIfSystemProperty(name = "env", value = "prod")

C. @EnabledIfSystemProperty(property = "env", equals = "prod")

D. @EnabledIfSystemProperty(key = "env", match = "prod")

Solution

1. Step 1: Recall the annotation parameters

   The correct parameters are named for the system property name and matches for the regex pattern to match.

2. Step 2: Compare options with correct syntax

   @EnabledIfSystemProperty(named = "env", matches = "prod") uses named and matches correctly. Other options use incorrect parameter names.

3. Final Answer:

   @EnabledIfSystemProperty(named = "env", matches = "prod") -> Option A

4. Quick Check:

   named + matches = correct syntax [OK]

Hint: Use named and matches parameters exactly [OK]

Common Mistakes:

• Using 'name' instead of 'named'
• Using 'value' or 'equals' instead of 'matches'
• Mixing parameter names incorrectly

3. Consider the following JUnit test snippet:

@EnabledIfSystemProperty(named = "os.name", matches = "Windows.*")
void testWindowsFeature() {
    System.out.println("Windows test executed");
}

If the system property os.name is set to Windows 10, what will be the output when running this test?

medium

A. Test skipped silently

B. Windows test executed

C. Runtime exception occurs

D. Test fails with assertion error

Solution

1. Step 1: Understand the system property condition

   The test runs only if os.name matches the regex Windows.*. The value Windows 10 matches this pattern.

2. Step 2: Predict test behavior

   Since the condition is true, the test runs and prints "Windows test executed".

3. Final Answer:

   Windows test executed -> Option B

4. Quick Check:

   Property matches regex = test runs [OK]

Hint: Regex match true means test runs and prints output [OK]

Common Mistakes:

• Assuming test skips because of partial match
• Expecting exceptions from annotation
• Confusing output with test failure

4. Given this test method:

@EnabledIfSystemProperty(named = "user.language", matches = "en")
void testEnglishFeature() {
    // test code
}

The test never runs even when the system property user.language is set to en. What is the most likely cause?

medium

A. The system property is not set before test execution

B. The regex pattern should be "en.*" to match properly

C. The annotation parameter should be 'name' not 'named'

D. JUnit does not support @EnabledIfSystemProperty

Solution

1. Step 1: Check system property availability

   If the system property user.language is not set before running tests, the condition fails and test is skipped.

2. Step 2: Validate other options

   The regex pattern should be "en.*" to match properly is unnecessary because exact match "en" works. The annotation parameter should be 'name' not 'named' is incorrect because 'named' is the correct parameter. JUnit does not support @EnabledIfSystemProperty is false; JUnit supports this annotation.

3. Final Answer:

   The system property is not set before test execution -> Option A

4. Quick Check:

   Property must be set before test runs [OK]

Hint: Ensure system property is set before running tests [OK]

Common Mistakes:

• Confusing 'named' with 'name' parameter
• Assuming regex must be partial match
• Believing JUnit lacks support for this annotation

5. You want to write a test that runs only if the system property env is set to either dev or test. Which @EnabledIfSystemProperty annotation correctly implements this?

hard

A. @EnabledIfSystemProperty(named = "env", matches = "dev?test")

B. @EnabledIfSystemProperty(named = "env", matches = "dev,test")

C. @EnabledIfSystemProperty(named = "env", matches = "[dev,test]")

D. @EnabledIfSystemProperty(named = "env", matches = "dev|test")

Solution

1. Step 1: Understand regex for multiple options

   The regex dev|test means match either "dev" or "test" exactly.

2. Step 2: Evaluate each option's regex

   @EnabledIfSystemProperty(named = "env", matches = "dev|test") uses correct regex with alternation. @EnabledIfSystemProperty(named = "env", matches = "dev,test") uses comma which matches literal comma, not alternation. @EnabledIfSystemProperty(named = "env", matches = "[dev,test]") uses square brackets which match single characters, not words. @EnabledIfSystemProperty(named = "env", matches = "dev?test") uses question mark which means optional character, not alternation.

3. Final Answer:

   @EnabledIfSystemProperty(named = "env", matches = "dev|test") -> Option D

4. Quick Check:

   Use regex alternation with | for multiple matches [OK]

Hint: Use regex 'dev|test' to match either value [OK]

Common Mistakes:

• Using commas instead of | in regex
• Using square brackets which match single chars
• Misusing ? for alternation