Mocking Class Member Variables with Mockito: Methods and Best Practices

Problem Background and Core Challenges

In unit testing practice, developers frequently encounter scenarios requiring mocking of class member variables. Consider the following typical code structure:

public class First {
    Second second;
    
    public First() {
        second = new Second();
    }
    
    public String doSecond() {
        return second.doSecond();
    }
}

class Second {
    public String doSecond() {
        return "Do Something";
    }
}

When testing the First.doSecond() method, directly creating a First instance causes the internal second member variable to point to a real Second object rather than a mock. This prevents test isolation from dependencies, violating core principles of unit testing.

Dependency Injection Solutions

The most elegant solution involves refactoring code design through dependency injection. This approach adheres to Test-Driven Development principles, making classes easier to test and maintain.

Constructor Injection

Passing dependencies through constructors is the most straightforward approach:

public class First {
    private Second second;
    
    public First(Second second) {
        this.second = second;
    }
    
    public String doSecond() {
        return second.doSecond();
    }
}

Corresponding test code:

@Test
public void testFirstWithConstructorInjection() {
    Second mockSecond = mock(Second.class);
    when(mockSecond.doSecond()).thenReturn("Stubbed Second");
    
    First first = new First(mockSecond);
    assertEquals("Stubbed Second", first.doSecond());
}

Setter Method Injection

For existing code or scenarios requiring flexible configuration, setter methods can be added:

public class First {
    private Second second;
    
    public First() {
        this.second = new Second();
    }
    
    public void setSecond(Second second) {
        this.second = second;
    }
    
    public String doSecond() {
        return second.doSecond();
    }
}

Test implementation:

@Test
public void testFirstWithSetterInjection() {
    Second mockSecond = mock(Second.class);
    when(mockSecond.doSecond()).thenReturn("Stubbed Second");
    
    First first = new First();
    first.setSecond(mockSecond);
    assertEquals("Stubbed Second", first.doSecond());
}

Mockito Annotation Support

Mockito provides specialized annotations to simplify dependency injection testing:

@RunWith(MockitoJUnitRunner.class)
public class FirstTest {
    @Mock
    private Second second;
    
    @InjectMocks
    private First first;
    
    @Test
    public void testDoSecond() {
        when(second.doSecond()).thenReturn("Stubbed Second");
        assertEquals("Stubbed Second", first.doSecond());
    }
}

The @InjectMocks annotation automatically injects mock objects into corresponding fields of the class under test, significantly simplifying test code writing.

Reflection Mechanism Solutions

When source code modification is not possible, Java Reflection API can be used to set private fields. While powerful, this approach should be used cautiously.

Basic Reflection Implementation

@Test
public void testFirstWithReflection() throws Exception {
    Second mockSecond = mock(Second.class);
    when(mockSecond.doSecond()).thenReturn("Stubbed Second");
    
    First first = new First();
    Field secondField = First.class.getDeclaredField("second");
    secondField.setAccessible(true);
    secondField.set(first, mockSecond);
    
    assertEquals("Stubbed Second", first.doSecond());
}

JUnit 5 Reflection Utilities

JUnit 5 provides more concise reflection utility classes:

@Test
public void testFirstWithJUnitReflection() throws Exception {
    Second mockSecond = mock(Second.class);
    when(mockSecond.doSecond()).thenReturn("Stubbed Second");
    
    First first = new First();
    Field field = ReflectionUtils
        .findFields(First.class, f -> f.getName().equals("second"), 
                   ReflectionUtils.HierarchyTraversalMode.TOP_DOWN)
        .get(0);
    field.setAccessible(true);
    field.set(first, mockSecond);
    
    assertEquals("Stubbed Second", first.doSecond());
}

Design Principles and Best Practices

When considering mocking member variables, the following design principles should be followed:

Dependency Inversion Principle

Classes should not directly create their dependencies but should receive them externally. This makes code more flexible and testable:

public class First {
    private final Second second;
    
    // Dependency injected through constructor
    public First(Second second) {
        this.second = Objects.requireNonNull(second);
    }
    
    // Business method remains unchanged
    public String doSecond() {
        return second.doSecond();
    }
}

Test-Driven Development

Writing tests before production code naturally leads to testable designs. If mocking a dependency proves difficult, it often indicates the need for code refactoring.

Solution Comparison and Selection Guide

Practical Application Recommendations

In actual projects, dependency injection solutions should be prioritized. Reflection mechanisms should only be considered when source code modification is truly impossible. Additionally, team coding standards should be established to explicitly prohibit abusive use of reflection that breaks encapsulation in tests.

Through reasonable design and appropriate testing strategies, codebases that are both easy to test and maintainable can be built. Remember that good tests should not depend on implementation details but should focus on behavioral contracts.