Extension model overview in JUnit - Build an Automation Script

Verify custom extension execution in JUnit 5

Preconditions (2)

Step 1: Create a test class and register the custom extension using @ExtendWith annotation

Step 2: Add a test method that performs a simple assertion

Step 3: Run the test class

✅ Expected Result: The custom extension's beforeEach method is executed before the test method, and the test passes

Automation Requirements - JUnit 5

Assertions Needed:

Verify the test method runs successfully

Verify the extension's beforeEach callback is invoked

Best Practices:

Use @ExtendWith to register extensions

Implement BeforeEachCallback interface for setup logic

Use assertions from org.junit.jupiter.api.Assertions

Keep extension logic simple and focused

Automated Solution

JUnit

import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.BeforeEachCallback;
import org.junit.jupiter.api.extension.ExtensionContext;
import org.junit.jupiter.api.extension.ExtendWith;
import static org.junit.jupiter.api.Assertions.assertTrue;

class CustomExtension implements BeforeEachCallback {
    static boolean beforeEachCalled = false;

    @Override
    public void beforeEach(ExtensionContext context) {
        beforeEachCalled = true;
        System.out.println("CustomExtension beforeEach called");
    }
}

@ExtendWith(CustomExtension.class)
public class ExtensionModelTest {

    @Test
    void testWithExtension() {
        assertTrue(CustomExtension.beforeEachCalled, "Extension beforeEach should be called before test");
    }
}

The CustomExtension class implements BeforeEachCallback to run code before each test method.

We use a static boolean beforeEachCalled to track if the extension method runs.

The test class ExtensionModelTest registers the extension with @ExtendWith.

The test method asserts that the extension's beforeEach method was called before the test runs.

This shows how JUnit 5 extensions can add behavior around tests.

Common Mistakes - 3 Pitfalls

{'mistake': 'Not registering the extension with @ExtendWith annotation', 'why_bad': "The extension code will never run if not registered, so tests won't have the expected behavior.", 'correct_approach': 'Always use @ExtendWith on the test class or method to activate the extension.'}

{'mistake': 'Using instance variables in the extension to track state', 'why_bad': "JUnit creates a new extension instance per test, so instance variables won't keep state across tests.", 'correct_approach': 'Use static variables or external storage if you need to track state across tests.'}

{'mistake': 'Not implementing the correct callback interface for the desired lifecycle event', 'why_bad': "The extension method won't be called if the interface doesn't match the lifecycle event you want to hook into.", 'correct_approach': 'Implement the appropriate interface like BeforeEachCallback, AfterEachCallback, etc., depending on when you want your code to run.'}

Bonus Challenge

Now add a second extension that implements AfterEachCallback and verify it runs after the test method

Show Hint

Practice

1. What is the main purpose of the JUnit extension model?

easy

A. To add extra behavior to tests without changing the test code

B. To write test cases faster using templates

C. To automatically generate test data

D. To replace assertions with custom logic

Solution

1. Step 1: Understand the extension model concept

   The extension model allows adding extra behavior to tests without modifying the original test code.

2. Step 2: Compare options with the concept

   Only To add extra behavior to tests without changing the test code correctly describes this purpose. Other options describe unrelated features.

3. Final Answer:

   To add extra behavior to tests without changing the test code -> Option A

4. Quick Check:

   Extension model purpose = add behavior without code change [OK]

Hint: Extension model = add behavior without changing tests [OK]

Common Mistakes:

• Confusing extension model with test data generation
• Thinking it replaces assertions
• Assuming it speeds up test writing

2. Which annotation is used to apply an extension to a JUnit test class?

easy

A. @ExtendWith

B. @TestExtension

C. @UseExtension

D. @EnableExtension

Solution

1. Step 1: Recall the correct annotation for extensions

   JUnit uses @ExtendWith to apply extensions to test classes or methods.

2. Step 2: Verify other options

   Options B, C, and D are not valid JUnit annotations for extensions.

3. Final Answer:

   @ExtendWith -> Option A

4. Quick Check:

   Extension annotation = @ExtendWith [OK]

Hint: Remember extension annotation is @ExtendWith [OK]

Common Mistakes:

• Using @TestExtension which does not exist
• Confusing with @UseExtension or @EnableExtension
• Forgetting the '@' symbol

3. Given the following code snippet, what will be printed when the test runs?

@ExtendWith(MyExtension.class)
class MyTest {
  @Test
  void testMethod() {
    System.out.println("Test running");
  }
}

class MyExtension implements BeforeTestExecutionCallback {
  public void beforeTestExecution(ExtensionContext context) {
    System.out.println("Before test");
  }
}

medium

A. Test running
Before test

B. Before test
Test running

C. Test running

D. Before test

Solution

1. Step 1: Understand the extension callback

   The BeforeTestExecutionCallback runs its method before the test method executes, printing "Before test" first.

2. Step 2: Order of print statements

   First "Before test" prints, then the test method prints "Test running".

3. Final Answer:

   Before test\nTest running -> Option B

4. Quick Check:

   BeforeTestExecutionCallback runs before test method [OK]

Hint: BeforeTestExecutionCallback runs before test method [OK]

Common Mistakes:

• Assuming test method prints first
• Confusing callback timing
• Ignoring extension execution order

4. Identify the error in this extension implementation:

public class MyExtension implements BeforeTestExecutionCallback {
  public void beforeTestExecution() {
    System.out.println("Before test");
  }
}

medium

A. Method beforeTestExecution should return boolean

B. Method name should be beforeTestStart

C. Class must extend AbstractExtension instead of implementing interface

D. Missing parameter ExtensionContext in beforeTestExecution method

Solution

1. Step 1: Check method signature for interface implementation

   The interface BeforeTestExecutionCallback requires beforeTestExecution(ExtensionContext context) method with one parameter.

2. Step 2: Identify missing parameter

   The method in the code has no parameters, so it does not correctly implement the interface.

3. Final Answer:

   Missing parameter ExtensionContext in beforeTestExecution method -> Option D

4. Quick Check:

   Interface method requires ExtensionContext parameter [OK]

Hint: Check method parameters match interface exactly [OK]

Common Mistakes:

• Omitting required method parameters
• Changing method return type incorrectly
• Using wrong method names

5. You want to create a JUnit extension that logs a message before and after each test method runs. Which combination of interfaces should your extension implement?

hard

A. BeforeTestExecutionCallback and AfterTestExecutionCallback

B. BeforeAllCallback and AfterAllCallback

C. BeforeEachCallback and AfterEachCallback

D. TestExecutionExceptionHandler and BeforeEachCallback

Solution

1. Step 1: Understand callback interfaces for test methods

   BeforeEachCallback runs before each test method, and AfterEachCallback runs after each test method.

2. Step 2: Match requirement to interfaces

   To log before and after each test method, implement both BeforeEachCallback and AfterEachCallback.

3. Final Answer:

   BeforeEachCallback and AfterEachCallback -> Option C

4. Quick Check:

   Before/After each test = BeforeEachCallback + AfterEachCallback [OK]

Hint: Before/After each test = BeforeEachCallback + AfterEachCallback [OK]

Common Mistakes:

• Using BeforeAllCallback which runs once per class
• Confusing AfterTestExecutionCallback with AfterEachCallback
• Choosing exception handler interfaces incorrectly