How can I write my own Whitebox equivalent in Mockito 2.x

Understanding Whitebox's Role

Whitebox was used to set internal state of objects by accessing private fields directly. This was particularly useful in testing scenarios where you needed to inject mocks into objects that did not support dependency injection through their constructors or setters.

Using Java Reflection

You can replicate Whitebox's functionality using Java's built-in reflection API. Here's an example of how you can create a utility class to set internal state:

java
import java.lang.reflect.Field;

public class ReflectionUtil {

    /**
     * Sets the value of a field in an object using reflection.
     * 
     * @param target     The object whose field is to be modified.
     * @param fieldName The name of the field to modify.
     * @param value     The new value for the field.
     * @throws NoSuchFieldException   If the field does not exist.
     * @throws IllegalAccessException If the field is inaccessible.
     */
    public static void setField(Object target, String fieldName, Object value) throws NoSuchFieldException, IllegalAccessException {
        Field field = target.getClass().getDeclaredField(fieldName);
        field.setAccessible(true); // Make private fields accessible
        field.set(target, value);
    }

    /**
     * Recursively searches for a field in the class hierarchy.
     * 
     * @param target     The object whose field is to be modified.
     * @param fieldName The name of the field to modify.
     * @param value     The new value for the field.
     * @throws NoSuchFieldException   If the field does not exist.
     * @throws IllegalAccessException If the field is inaccessible.
     */
    public static void setFieldRecursive(Object target, String fieldName, Object value) throws NoSuchFieldException, IllegalAccessException {
        Class clazz = target.getClass();
        while (clazz != null) {
            try {
                Field field = clazz.getDeclaredField(fieldName);
                field.setAccessible(true); // Make private fields accessible
                field.set(target, value);
                return;
            } catch (NoSuchFieldException e) {
                clazz = clazz.getSuperclass();
            }
        }
        throw new NoSuchFieldException("Field not found in class hierarchy");
    }
}

Using the Utility Class

You can use the `ReflectionUtil` class in your tests to set internal state similar to how Whitebox was used:

java
public class MyTest {

    @Before
    public void setUp() {
        MyObject obj = new MyObject();
        MockDependency mockDependency = mock(MockDependency.class);
        
        try {
            ReflectionUtil.setField(obj, "dependency", mockDependency);
        } catch (NoSuchFieldException | IllegalAccessException e) {
            // Handle exceptions appropriately
        }
    }
}

Alternatives

If you are using Spring, you can leverage `ReflectionTestUtils` from the Spring Test library, which provides a similar functionality:

java
import org.springframework.test.util.ReflectionTestUtils;

// ...

ReflectionTestUtils.setField(obj, "dependency", mockDependency);

For non-Spring projects, you might consider using Apache Commons Lang's `FieldUtils` for a more robust reflection utility.

Conclusion

While Mockito 2.x does not include Whitebox, you can easily replicate its functionality using Java reflection or third-party libraries like Apache Commons Lang. This approach allows you to set internal state in objects for testing purposes without relying on PowerMock or other additional dependencies. However, it's always a good practice to refactor your code to improve testability whenever possible.