@EnabledIfEnvironmentVariable in JUnit - Practice Problems & Coding Challenges

Challenge - 5 Problems

🧠 Conceptual

intermediate

Understanding @EnabledIfEnvironmentVariable Usage

What is the primary purpose of the JUnit annotation @EnabledIfEnvironmentVariable?

A To enable a test only when a system property is set

B To disable a test permanently regardless of environment variables

C To run a test only if a specific environment variable matches a given value

D To run a test only if the JVM version is above a certain number

💡 Hint

Think about controlling test execution based on environment settings.

The annotation @EnabledIfEnvironmentVariable allows tests to run conditionally based on the value of an environment variable. It checks if the variable matches the specified value before enabling the test.

❓ Predict Output

intermediate

Test Execution Result with @EnabledIfEnvironmentVariable

Given the following test code, what will be the test execution result if the environment variable TEST_MODE is set to production?

JUnit

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

public class EnvVarTest {

    @Test
    @EnabledIfEnvironmentVariable(named = "TEST_MODE", matches = "development")
    void testOnlyInDevelopment() {
        System.out.println("Running test in development mode");
    }
}

A Test will run but not print anything

B Test will be skipped (disabled) because TEST_MODE is 'production'

C Test will fail with an exception due to environment variable mismatch

D Test will run and print the message

💡 Hint

Check the value the annotation expects versus the actual environment variable.

The test is enabled only if TEST_MODE equals development. Since it is production, the test is skipped.

❓ assertion

advanced

Correct Assertion for Environment Variable Check

Which assertion correctly verifies that a test method annotated with @EnabledIfEnvironmentVariable(named = "MODE", matches = "test") runs only when the environment variable MODE is set to test?

A assertTrue(System.getenv("MODE").equals("test"))

B assertEquals("test", System.getProperty("MODE"))

C assertNotNull(System.getenv("MODE"))

D assertFalse(System.getenv("MODE").isEmpty())

💡 Hint

Remember environment variables are accessed differently than system properties.

Environment variables are accessed via System.getenv(). The assertion checks if the variable MODE equals test, matching the annotation condition.

🔧 Debug

advanced

Debugging @EnabledIfEnvironmentVariable Not Working

A developer writes a test with @EnabledIfEnvironmentVariable(named = "APP_ENV", matches = "staging") but the test is skipped even when APP_ENV is set to staging. What is the most likely cause?

A The environment variable <code>APP_ENV</code> is not set in the test runtime environment

B The annotation <code>@EnabledIfEnvironmentVariable</code> does not support the <code>matches</code> attribute

C The test method is missing the <code>@Test</code> annotation

D JUnit version does not support conditional annotations

💡 Hint

Consider how environment variables are passed to the test process.

If the environment variable is missing, the condition defaults to false and the test is skipped. The developer should ensure the variable is set in the environment where tests run.

❓ framework

expert

Combining @EnabledIfEnvironmentVariable with Other Conditions

Consider a test annotated with both @EnabledIfEnvironmentVariable(named = "REGION", matches = "US") and @EnabledIfEnvironmentVariable(named = "VERSION", matches = "1.0"). Under which condition will the test run?

A The test will never run because multiple @EnabledIfEnvironmentVariable annotations are not supported

B If either REGION equals 'US' or VERSION equals '1.0'

C Only if REGION equals 'US', VERSION is ignored

D Only if both REGION equals 'US' and VERSION equals '1.0'

💡 Hint

Think about how multiple conditional annotations combine in JUnit.

Multiple @EnabledIfEnvironmentVariable annotations combine with logical AND, so all conditions must be true for the test to run.

Practice

1. What is the main purpose of the @EnabledIfEnvironmentVariable annotation in JUnit?

easy

A. To set environment variables before running tests

B. To disable all tests in a test class

C. To run a test only if a specific environment variable has a certain value

D. To run tests in parallel threads

Solution

1. Step 1: Understand the annotation's role

   <code>@EnabledIfEnvironmentVariable

2. Step 2: Identify its effect on tests

   It enables tests only when the environment variable matches the given value, skipping otherwise.

3. Final Answer:

   To run a test only if a specific environment variable has a certain value -> Option C

4. Quick Check:

   Runs test if env var matches = A [OK]

Hint: Think: runs test only if env var matches value [OK]

Common Mistakes:

• Confusing it with disabling tests
• Assuming it sets environment variables
• Thinking it controls test parallelism

2. Which of the following is the correct syntax to enable a test only when the environment variable ENV equals prod using @EnabledIfEnvironmentVariable?

easy

A. @EnabledIfEnvironmentVariable(named = "ENV", matches = "prod")

B. @EnabledIfEnvironmentVariable(name = "ENV", value = "prod")

C. @EnabledIfEnvironmentVariable(variable = "ENV", equals = "prod")

D. @EnabledIfEnvironmentVariable(env = "ENV", match = "prod")

Solution

1. Step 1: Recall correct attribute names

   The annotation uses named for the environment variable name and matches for the expected value.

2. Step 2: Match syntax with options

   @EnabledIfEnvironmentVariable(named = "ENV", matches = "prod") correctly uses named = "ENV" and matches = "prod".

3. Final Answer:

   @EnabledIfEnvironmentVariable(named = "ENV", matches = "prod") -> Option A

4. Quick Check:

   Correct attribute names = A [OK]

Hint: Remember: named and matches are correct attributes [OK]

Common Mistakes:

• Using incorrect attribute names like name or value
• Mixing attribute names with variable or env
• Using equals or match instead of matches

3. Given the following test code snippet, what will happen if the environment variable MODE is set to test?

@EnabledIfEnvironmentVariable(named = "MODE", matches = "prod")
void runOnlyInProd() {
    System.out.println("Running in prod mode");
}

medium

A. The test will be skipped and not run

B. The test will run and print "Running in prod mode"

C. The test will fail with an exception

D. The test will run but print nothing

Solution

1. Step 1: Check environment variable value

   The environment variable MODE is set to test, but the annotation requires prod.

2. Step 2: Understand annotation behavior

   Since the value does not match, the test is skipped and does not run.

3. Final Answer:

   The test will be skipped and not run -> Option A

4. Quick Check:

   Env var mismatch skips test = B [OK]

Hint: If env var value differs, test is skipped [OK]

Common Mistakes:

• Assuming test runs regardless of env var
• Expecting an exception on mismatch
• Thinking test runs but prints nothing

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

@EnabledIfEnvironmentVariable(named = "APP_ENV", match = "dev")
void testInDev() {
    // test code
}

medium

A. The annotation must be placed on the class, not the method

B. The attribute name should be 'matches' instead of 'match'

C. The method must be static

D. The environment variable name cannot be 'APP_ENV'

Solution

1. Step 1: Check attribute names in annotation

   The correct attribute for matching value is matches, not match.

2. Step 2: Verify other code aspects

   Environment variable name can be any string, method need not be static, and annotation can be on method.

3. Final Answer:

   The attribute name should be 'matches' instead of 'match' -> Option B

4. Quick Check:

   Correct attribute is matches, not match [OK]

Hint: Use 'matches' attribute, not 'match' [OK]

Common Mistakes:

• Using 'match' instead of 'matches'
• Thinking method must be static
• Believing annotation only works on class

5. You want to run a test only if the environment variable DEPLOY_ENV is set to either staging or production. How can you achieve this using @EnabledIfEnvironmentVariable in JUnit?

hard

A. Use @EnabledIfEnvironmentVariable(named = "DEPLOY_ENV", matches = "staging,production") with comma-separated values

B. Use two test methods each annotated with @EnabledIfEnvironmentVariable(named = "DEPLOY_ENV", matches = "staging") and @EnabledIfEnvironmentVariable(named = "DEPLOY_ENV", matches = "production") respectively

C. Use @EnabledIfEnvironmentVariable(named = "DEPLOY_ENV", matches = "staging") and add an OR condition inside the test method

D. Use @EnabledIfEnvironmentVariable(named = "DEPLOY_ENV", matches = "staging|production") with regex matching

Solution

1. Step 1: Understand annotation supports regex

   The matches attribute supports regular expressions to match multiple values.

2. Step 2: Use regex for multiple values

   Using staging|production matches either value in one annotation.

3. Final Answer:

   Use @EnabledIfEnvironmentVariable(named = "DEPLOY_ENV", matches = "staging|production") with regex matching -> Option D

4. Quick Check:

   Regex in matches handles multiple values = B [OK]

Hint: Use regex in matches to cover multiple values [OK]

Common Mistakes:

• Trying to list multiple values with commas
• Splitting into multiple test methods unnecessarily
• Adding logic inside test instead of annotation