@EnabledIfSystemProperty in JUnit - Framework Patterns

Framework Mode - @EnabledIfSystemProperty

Folder Structure for JUnit Test Automation Framework

src/
├── main/
│   └── java/
│       └── com/example/app/          # Application source code
└── test/
    └── java/
        └── com/example/tests/        # Test classes
            ├── pages/                 # Page Object classes
            ├── utils/                 # Utility classes (e.g., waits, helpers)
            ├── config/                # Configuration classes
            └── tests/                 # Test classes using JUnit

Test Framework Layers

• Driver Layer: Manages WebDriver setup and teardown for browser automation.
• Page Objects: Encapsulate UI elements and actions for each page or component.
• Test Classes: Contain JUnit test methods, annotated with @Test and conditional annotations like @EnabledIfSystemProperty.
• Utilities: Helper methods for waits, logging, data handling.
• Configuration: Reads environment variables, system properties, and manages test settings.

Configuration Patterns

• System Properties: Use JVM system properties to control test execution, e.g., -Denv=staging.
• Environment Profiles: Define different config files or classes for dev, staging, prod.
• Credentials Management: Store sensitive data securely, inject via environment variables or secure vaults.
• Conditional Test Execution: Use @EnabledIfSystemProperty to run tests only if a system property matches a value.

Test Reporting and CI/CD Integration

• Use JUnit's built-in XML reports for test results.
• Integrate with CI tools like Jenkins, GitHub Actions to run tests on code commits.
• Configure CI pipelines to pass system properties to enable or disable tests conditionally.
• Use plugins (e.g., Surefire, Allure) for enhanced reporting and dashboards.

Best Practices for Using @EnabledIfSystemProperty in JUnit

1. Use @EnabledIfSystemProperty to run tests only in relevant environments, avoiding unnecessary failures.
2. Keep system property keys consistent and documented for easy configuration.
3. Combine with other conditional annotations for flexible test suites.
4. Use descriptive property values to clearly indicate test purpose (e.g., runSlowTests=true).
5. Ensure default behavior is safe by setting sensible defaults when properties are missing.

Self Check Question

Where in this framework structure would you add a new test class that should only run when the system property env equals staging using @EnabledIfSystemProperty?

Key Result

Use @EnabledIfSystemProperty in JUnit tests to conditionally enable tests based on JVM system properties for flexible environment-specific testing.

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