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

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
Workspace
tessl
Visibility
Public
Created
Last updated
Describes
mavenpkg:maven/org.mockito/mockito-junit-jupiter@4.11.x
Publish Source
CLI
Badge
tessl/maven-org-mockito--mockito-junit-jupiter badge