Custom argument providers in JUnit - Framework Patterns

Framework Mode - Custom argument providers

Folder Structure

src
└── test
    └── java
        └── com
            └── example
                ├── arguments
                │   └── CustomArgumentProvider.java
                ├── tests
                │   └── ParameterizedTestExample.java
                └── utils
                    └── TestUtils.java

Test Framework Layers

• Custom Argument Providers Layer: Classes implementing org.junit.jupiter.params.provider.ArgumentsProvider to supply test data dynamically.
• Test Layer: Parameterized test classes using @ParameterizedTest and @ArgumentsSource annotations to consume custom arguments.
• Utility Layer: Helper classes for data preparation or common test utilities.
• Configuration Layer: Handles environment setup, test properties, and test execution parameters.

Configuration Patterns

• Test Properties File: Use src/test/resources/test.properties to store environment variables or flags controlling test data sources.
• System Properties or Environment Variables: Control which argument provider to use or toggle data sources dynamically.
• JUnit Platform Configuration: Use junit-platform.properties for global test settings.
• Dependency Injection: Use constructor or method injection in argument providers if needed for complex data setup.

Test Reporting and CI/CD Integration

• JUnit Reports: Use built-in JUnit XML reports generated by Maven or Gradle for CI systems.
• Enhanced Reporting: Integrate with tools like Allure or ReportPortal for detailed parameterized test reports showing input data.
• CI/CD Pipelines: Configure pipelines (GitHub Actions, Jenkins, GitLab CI) to run parameterized tests and publish reports automatically.
• Fail Fast Option: Configure test runs to stop on first failure or continue to gather full test results.

Best Practices for Custom Argument Providers

1. Keep Argument Providers Focused: Each provider should supply data for a specific test scenario or domain area.
2. Use Streams for Efficiency: Return Stream<Arguments> to support lazy evaluation and large data sets.
3. Separate Data from Logic: Avoid embedding complex logic in argument providers; use utility classes if needed.
4. Readable Test Data: Provide descriptive argument names or use @DisplayName to clarify test cases.
5. Reuse Providers: Share argument providers across multiple tests when data sets overlap.

Self Check

Where in this folder structure would you add a new argument provider for testing user login scenarios?

Key Result

Organize custom argument providers in a dedicated package to supply dynamic test data for parameterized JUnit tests.

Practice

1. What is the main purpose of a custom argument provider in JUnit?

easy

A. To generate test reports

B. To create new test methods automatically

C. To supply test data to parameterized tests in a custom way

D. To replace the @Test annotation

Solution

1. Step 1: Understand the role of argument providers

   Argument providers supply data to parameterized tests, allowing tests to run multiple times with different inputs.

2. Step 2: Identify the purpose of custom argument providers

   Custom argument providers let you define your own way to supply test data beyond built-in sources.

3. Final Answer:

   To supply test data to parameterized tests in a custom way -> Option C

4. Quick Check:

   Custom argument providers = supply test data [OK]

Hint: Custom providers supply test data uniquely for parameterized tests [OK]

Common Mistakes:

• Confusing argument providers with test method creators
• Thinking they replace @Test annotation
• Assuming they generate reports

2. Which interface must you implement to create a custom argument provider in JUnit?

easy

A. ArgumentsSource

B. ArgumentsProvider

C. TestTemplateInvocationContextProvider

D. TestInstancePostProcessor

Solution

1. Step 1: Recall JUnit interfaces for argument providers

   The interface to implement for custom argument providers is ArgumentsProvider.

2. Step 2: Differentiate from other interfaces

   ArgumentsSource is an annotation, not an interface. The others serve different purposes.

3. Final Answer:

   ArgumentsProvider -> Option B

4. Quick Check:

   Implement ArgumentsProvider for custom data [OK]

Hint: Implement ArgumentsProvider interface for custom data supply [OK]

Common Mistakes:

• Confusing ArgumentsSource annotation with interface
• Choosing unrelated interfaces
• Not overriding provideArguments method

3. Given this custom argument provider code snippet, what will be the output when the parameterized test runs?

public class MyProvider implements ArgumentsProvider {
    @Override
    public Stream<Arguments> provideArguments(ExtensionContext context) {
        return Stream.of(Arguments.of("apple"), Arguments.of("banana"));
    }
}

@ParameterizedTest
@ArgumentsSource(MyProvider.class)
void testFruits(String fruit) {
    System.out.println(fruit);
}

medium

A. apple\nbanana (each on separate lines)

B. apple banana

C. Compilation error due to missing imports

D. Runtime error due to wrong method signature

Solution

1. Step 1: Analyze the provideArguments method

   The method returns a stream with two Arguments: "apple" and "banana".

2. Step 2: Understand parameterized test execution

   The test runs twice, once with "apple" and once with "banana", printing each on its own line.

3. Final Answer:

   apple\nbanana (each on separate lines) -> Option A

4. Quick Check:

   Stream of Arguments runs test twice [OK]

Hint: Each argument runs test once, prints on separate lines [OK]

Common Mistakes:

• Assuming output is on one line
• Thinking code has syntax errors without imports
• Confusing method signature correctness

4. Identify the error in this custom argument provider implementation:

public class BadProvider implements ArgumentsProvider {
    public Stream<Arguments> provideArguments() {
        return Stream.of(Arguments.of(1), Arguments.of(2));
    }
}

medium

A. Method provideArguments must have ExtensionContext parameter

B. Missing @Override annotation

C. Arguments.of() cannot take integers

D. Class must extend ArgumentsSource

Solution

1. Step 1: Check method signature requirements

   The provideArguments method must override the interface method and accept ExtensionContext as a parameter.

2. Step 2: Identify the missing parameter

   The code's provideArguments method lacks the ExtensionContext parameter, causing a signature mismatch.

3. Final Answer:

   Method provideArguments must have ExtensionContext parameter -> Option A

4. Quick Check:

   Correct method signature requires ExtensionContext [OK]

Hint: provideArguments must accept ExtensionContext parameter [OK]

Common Mistakes:

• Ignoring method signature parameters
• Thinking @Override is mandatory but not fixing signature
• Confusing Arguments.of() usage

5. You want to create a custom argument provider that supplies pairs of integers where the second is always double the first. Which implementation correctly achieves this?

public class DoubleProvider implements ArgumentsProvider {
    @Override
    public Stream<Arguments> provideArguments(ExtensionContext context) {
        // Fill in the blank
    }
}

hard

A. return Stream.of(Arguments.of(1, 3), Arguments.of(2, 5), Arguments.of(3, 7));

B. return Stream.of(Arguments.of(1, 1), Arguments.of(2, 2), Arguments.of(3, 3));

C. return Stream.empty();

D. return Stream.of(Arguments.of(1, 2), Arguments.of(2, 4), Arguments.of(3, 6));

Solution

1. Step 1: Understand the requirement

   Each pair must have the second integer double the first.

2. Step 2: Evaluate each option

   return Stream.of(Arguments.of(1, 2), Arguments.of(2, 4), Arguments.of(3, 6)); correctly pairs (1,2), (2,4), (3,6). Other options provide pairs like (1,3),(2,5),(3,7) or equal numbers (1,1),(2,2),(3,3), or an empty stream.

3. Final Answer:

   return Stream.of(Arguments.of(1, 2), Arguments.of(2, 4), Arguments.of(3, 6)); -> Option D

4. Quick Check:

   Second integer = 2 * first integer [OK]

Hint: Check if second number is double the first in pairs [OK]

Common Mistakes:

• Providing pairs where second is not double
• Returning empty stream by mistake
• Confusing argument order