CtrlK
BlogDocsLog inGet started
Tessl Logo

tessl/maven-org-mockito--mockito-junit-jupiter

Mockito JUnit 5 support - Extension library that integrates Mockito mocking framework with JUnit 5 testing platform

—

Pending
Quality

Pending

Does it follow best practices?

Impact

Pending

No eval scenarios have been run

SecuritybySnyk

Pending

The risk profile of this skill

Overview
Eval results
Files

index.mddocs/

Mockito JUnit Jupiter

Mockito JUnit Jupiter provides seamless integration between the Mockito mocking framework and JUnit 5 testing platform through the MockitoExtension. It enables automatic mock creation, injection, and cleanup in JUnit 5 test classes using annotations like @Mock, @Spy, and @InjectMocks.

Package Information

  • Package Name: mockito-junit-jupiter
  • Package Type: maven
  • Language: Java
  • Maven Coordinates: org.mockito:mockito-junit-jupiter:4.11.0
  • Installation: Add to your Maven dependencies or Gradle build file

Core Imports

// Main classes from mockito-junit-jupiter
import org.mockito.junit.jupiter.MockitoExtension;
import org.mockito.junit.jupiter.MockitoSettings;

// JUnit 5 extension support
import org.junit.jupiter.api.extension.ExtendWith;
import org.junit.jupiter.api.extension.ParameterResolutionException;

// Standard Mockito annotations
import org.mockito.Mock;
import org.mockito.Spy;
import org.mockito.InjectMocks;

// Strictness configuration
import org.mockito.quality.Strictness;

Basic Usage

import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import java.util.List;

@ExtendWith(MockitoExtension.class)
public class ExampleTest {

    @Mock
    private List<String> mockList;

    @Test
    void testMockCreation() {
        // Mock is automatically initialized by MockitoExtension
        mockList.add("test");
        // Verify or stub the mock as needed
    }
}

Architecture

Mockito JUnit Jupiter is built around the JUnit 5 extension model:

  • MockitoExtension: Core extension that handles mock lifecycle and parameter injection
  • MockitoSettings: Configuration annotation for customizing mock behavior
  • JUnit 5 Integration: Uses BeforeEachCallback, AfterEachCallback, and ParameterResolver
  • Mock Lifecycle: Automatic initialization before each test and cleanup after each test
  • Parameter Resolution: Support for injecting mocks into test method and constructor parameters

Capabilities

Extension Setup

The MockitoExtension integrates Mockito with JUnit 5's extension model to provide automatic mock management.

/**
 * Extension that initializes mocks and handles strict stubbings.
 * This extension is the JUnit Jupiter equivalent of MockitoJUnitRunner.
 */
public class MockitoExtension implements BeforeEachCallback, AfterEachCallback, ParameterResolver {
    
    /**
     * Default constructor invoked by JUnit Jupiter via reflection or ServiceLoader
     */
    public MockitoExtension();
    
    /**
     * Callback invoked before each test is invoked
     * @param context the current extension context; never null
     */
    public void beforeEach(final ExtensionContext context);
    
    /**
     * Callback invoked after each test has been invoked
     * @param context the current extension context; never null
     */
    public void afterEach(ExtensionContext context);
    
    /**
     * Determine if this resolver supports resolution of an argument for the Parameter
     * @param parameterContext the context for the parameter for which an argument should be resolved
     * @param context the extension context for the test method about to be invoked
     * @return true if parameter is annotated with @Mock
     */
    public boolean supportsParameter(ParameterContext parameterContext, ExtensionContext context) throws ParameterResolutionException;
    
    /**
     * Resolve an argument for the Parameter in the supplied ParameterContext
     * @param parameterContext the context for the parameter for which an argument should be resolved
     * @param context the extension context for the test method about to be invoked
     * @return the resolved argument for the parameter
     */
    public Object resolveParameter(ParameterContext parameterContext, ExtensionContext context) throws ParameterResolutionException;
}

Usage Examples:

// Basic extension usage
@ExtendWith(MockitoExtension.class)
public class MyTest {
    @Mock private Service service;
    
    @Test
    void testMethod() {
        // service mock is automatically initialized
    }
}

// Method parameter injection
@ExtendWith(MockitoExtension.class)
public class MyTest {
    @Test
    void testWithParameter(@Mock Repository repository) {
        // repository mock is injected as method parameter
    }
}

// Constructor parameter injection
@ExtendWith(MockitoExtension.class)
public class MyTest {
    private final Database database;
    
    MyTest(@Mock Database database) {
        this.database = database;
    }
    
    @Test
    void testMethod() {
        // database mock is available as instance field
    }
}

Mock Configuration

The MockitoSettings annotation allows configuration of mock behavior when used with MockitoExtension.

/**
 * Annotation that can configure Mockito as invoked by the MockitoExtension.
 * Automatically applies @ExtendWith(MockitoExtension.class).
 */
@ExtendWith(MockitoExtension.class)
@Inherited
@Retention(RUNTIME)
public @interface MockitoSettings {
    
    /**
     * Configure the strictness used in this test.
     * @return The strictness to configure, by default Strictness.STRICT_STUBS
     */
    Strictness strictness() default Strictness.STRICT_STUBS;
}

Usage Examples:

// Default strictness (STRICT_STUBS)
@MockitoSettings
public class StrictTest {
    @Mock private Service service;
    
    @Test
    void testMethod() {
        // Runs with strict stub validation
    }
}

// Custom strictness configuration
@MockitoSettings(strictness = Strictness.LENIENT)
public class LenientTest {
    @Mock private Service service;
    
    @Test
    void testMethod() {
        // Runs with lenient stub validation
    }
}

// Inherited by nested classes
@MockitoSettings(strictness = Strictness.WARN)
public class ParentTest {
    @Nested
    class NestedTest {
        @Mock private Service service;
        
        @Test
        void testMethod() {
            // Inherits WARN strictness from parent
        }
    }
}

Types

/**
 * JUnit 5 extension context namespace for Mockito state storage
 */
interface ExtensionContext {
    // Standard JUnit 5 ExtensionContext interface
}

/**
 * JUnit 5 parameter context for parameter resolution
 */
interface ParameterContext {
    // Standard JUnit 5 ParameterContext interface
}

/**
 * Exception thrown when parameter resolution fails
 */
class ParameterResolutionException extends RuntimeException {
    // Standard JUnit 5 ParameterResolutionException
}

/**
 * Mockito strictness levels for stub validation
 */
enum Strictness {
    STRICT_STUBS,  // Default - validates all stubs are used
    LENIENT,       // Allows unused stubs
    WARN          // Warns about unused stubs
}

/**
 * Mockito session for managing mock lifecycle
 */
interface MockitoSession {
    // Internal Mockito session management
}

/**
 * Scoped mock for automatic cleanup
 */
interface ScopedMock {
    // Internal Mockito scoped mock management
}

Integration with Standard Mockito Annotations

The extension works seamlessly with standard Mockito annotations:

  • @Mock: Creates a mock instance
  • @Spy: Creates a spy instance (partial mock)
  • @InjectMocks: Injects mocks into the annotated instance
  • @Captor: Creates an ArgumentCaptor instance

Error Handling

The extension handles various error scenarios:

  • ParameterResolutionException: Thrown when parameter resolution fails for unsupported parameters
  • Mock Creation Failures: Handled through Mockito's standard error reporting
  • Session Management: Automatic cleanup ensures proper mock lifecycle management
  • Strictness Violations: Configured strictness level determines how unused stubs are handled

Nested Test Support

The extension fully supports JUnit 5 nested test classes:

  • Mocks from parent test classes are available in nested classes
  • Nested classes can define additional mocks
  • Settings inheritance follows JUnit 5 semantics
  • Duplicate extension registration is automatically handled

docs

index.md

tile.json