Как тестировать классы с приватными методами, полями и внутренними классами в Java?

Почему не стоит тестировать приватные методы напрямую

Короткий ответ: не нужно тестировать приватные методы, поля и внутренние классы напрямую. Это не проблема тестирования, а проблема дизайна кода. Приватные детали реализации — это то, что должно быть скрыто. Вы тестируете поведение класса через его публичный API, а не внутреннее устройство.

Если вам кажется, что нужно протестировать приватный метод, это почти всегда сигнал о том, что:

• Приватный метод содержит сложную логику, которую стоит вынести в отдельный класс и протестировать отдельно.
• У класса слишком много обязанностей (нарушение Single Responsibility Principle).
• Вы пытаетесь проверить реализацию, а не поведение.

Правильный подход: рефакторинг

Ваш класс OrderProcessor делает слишком много: валидирует заказ, считает сумму и проводит платеж. Вот как это можно улучшить:

// Выносим валидацию в отдельный класс
public class OrderValidator {
    public boolean validate(Order order) {
        return order != null && order.getItems() != null && !order.getItems().isEmpty();
    }
}

// Выносим расчет в отдельный класс
public class OrderCalculator {
    public double calculateTotal(Order order) {
        double sum = 0;
        for (OrderItem item : order.getItems()) {
            sum += item.getPrice() * item.getQuantity();
        }
        return sum;
    }
}

// Теперь OrderProcessor использует эти классы
public class OrderProcessor {
    private final PaymentGateway gateway;
    private final OrderValidator validator;
    private final OrderCalculator calculator;

    public OrderProcessor(PaymentGateway gateway, OrderValidator validator, OrderCalculator calculator) {
        this.gateway = gateway;
        this.validator = validator;
        this.calculator = calculator;
    }

    public boolean processOrder(Order order) {
        if (!validator.validate(order)) {
            return false;
        }
        double total = calculator.calculateTotal(order);
        return gateway.charge(order.getCustomer(), total);
    }
}

Теперь вы легко тестируете каждый класс отдельно:

@Test
void testOrderValidator() {
    OrderValidator validator = new OrderValidator();
    assertFalse(validator.validate(null));
    assertFalse(validator.validate(new Order(null)));
    assertTrue(validator.validate(validOrder()));
}

@Test
void testOrderCalculator() {
    OrderCalculator calculator = new OrderCalculator();
    Order order = createOrderWithItems(100.0, 2);
    assertEquals(200.0, calculator.calculateTotal(order), 0.001);
}

@Test
void testOrderProcessor() {
    PaymentGateway mockGateway = mock(PaymentGateway.class);
    OrderValidator mockValidator = mock(OrderValidator.class);
    OrderCalculator mockCalculator = mock(OrderCalculator.class);
    
    when(mockValidator.validate(any())).thenReturn(true);
    when(mockCalculator.calculateTotal(any())).thenReturn(200.0);
    when(mockGateway.charge(any(), eq(200.0))).thenReturn(true);
    
    OrderProcessor processor = new OrderProcessor(mockGateway, mockValidator, mockCalculator);
    assertTrue(processor.processOrder(validOrder()));
}

Когда reflection всё же уместен

Иногда вы работаете с легаси-кодом, который нельзя менять. Тогда можно использовать ReflectionTestUtils из Spring или обычный Java reflection:

@Test
void testPrivateMethodViaReflection() throws Exception {
    OrderProcessor processor = new OrderProcessor(mockGateway);
    Method method = OrderProcessor.class.getDeclaredMethod("validateOrder", Order.class);
    method.setAccessible(true);
    
    boolean result = (boolean) method.invoke(processor, null);
    assertFalse(result);
}

Но помните: это хрупкое решение. Если вы переименуете метод, тест упадет. Используйте reflection только как временное решение.

Что насчет внутренних классов?

Внутренние классы — деталь реализации. Если они нужны для тестирования, вынесите их в отдельные публичные классы или используйте статические внутренние классы с пакетной видимостью.

Итог: не воюйте с приватными методами. Лучше улучшайте дизайн кода, чтобы тестировать через публичный API. Это сделает ваш код чище, а тесты — надежнее.

@Test
void testProcessOrderWithNullOrder() {
    PaymentGateway mockGateway = mock(PaymentGateway.class);
    OrderProcessor processor = new OrderProcessor(mockGateway);
    
    // validateOrder вернет false для null, processOrder вернет false
    assertFalse(processor.processOrder(null));
    verify(mockGateway, never()).charge(any(), anyDouble());
}

@Test
void testProcessOrderWithValidOrder() {
    PaymentGateway mockGateway = mock(PaymentGateway.class);
    when(mockGateway.charge(any(), anyDouble())).thenReturn(true);
    
    OrderProcessor processor = new OrderProcessor(mockGateway);
    Order order = createValidOrderWithTwoItems(100.0, 3);
    
    assertTrue(processor.processOrder(order));
    // calculateTotal должен был посчитать 300.0
    verify(mockGateway).charge(any(), eq(300.0));
}