Расскажите о Unit и Functional тестах. Как вызвать приватный метод в тесте?

Различия между Unit и Functional тестами

Unit-тесты (Модульные тесты)

Unit-тесты — это изолированные тесты, проверяющие работу отдельных компонентов системы (обычно классов или методов) в полной изоляции от внешних зависимостей. Их ключевые характеристики:

• Изоляция компонентов: Каждый тест проверяет только одну "единицу" кода
• Mocking и Stubbing: Внешние зависимости заменяются заглушками (моками)
• Высокая скорость: Выполняются очень быстро, так как не требуют запуска всей инфраструктуры
• Детальная проверка: Фокусируются на внутренней логике компонента
• Пример тестируемого кода:

<?php
// Класс для тестирования
class Calculator {
    public function add(int $a, int $b): int {
        return $a + $b;
    }
    
    private function validateInput($value): bool {
        return is_numeric($value);
    }
}

Пример unit-теста:

<?php
use PHPUnit\Framework\TestCase;

class CalculatorTest extends TestCase {
    public function testAddPositiveNumbers(): void {
        $calculator = new Calculator();
        $result = $calculator->add(2, 3);
        $this->assertEquals(5, $result);
    }
}

Functional-тесты (Функциональные тесты)

Functional-тесты проверяют работу системы в целом, имитируя поведение реального пользователя или клиента:

• Интеграционное тестирование: Проверяют взаимодействие нескольких компонентов
• Работа с реальной инфраструктурой: Часто используют реальные базы данных, API, файловые системы
• Проверка бизнес-логики: Фокусируются на выполнении конкретных пользовательских сценариев
• Более медленные: Требуют настройки окружения и больше времени на выполнение

Пример functional-теста для API:

<?php
use Symfony\Bundle\FrameworkBundle\Test\WebTestCase;

class ApiEndpointTest extends WebTestCase {
    public function testUserCreation(): void {
        $client = static::createClient();
        
        // Отправляем POST-запрос с данными пользователя
        $client->request('POST', '/api/users', [], [], [
            'CONTENT_TYPE' => 'application/json',
        ], json_encode([
            'name' => 'John Doe',
            'email' => 'john@example.com'
        ]));
        
        $this->assertEquals(201, $client->getResponse()->getStatusCode());
        $responseData = json_decode($client->getResponse()->getContent(), true);
        $this->assertArrayHasKey('id', $responseData);
    }
}

Тестирование приватных методов

Философская позиция

Существует два основных подхода к тестированию приватных методов:

1. Не тестировать напрямую: Приватные методы должны тестироваться через публичные методы, которые их используют. Если приватный метод настолько сложен, что требует отдельного тестирования, возможно, его стоит вынести в отдельный класс.

2. Тестировать при необходимости: В некоторых случаях (легаси-код, критическая бизнес-логика) прямое тестирование приватных методов оправдано.

Способы вызова приватных методов в тестах

1. Reflection API (Наиболее правильный способ)

Использование Reflection позволяет получить доступ к приватным методам без изменения исходного кода:

<?php
use PHPUnit\Framework\TestCase;
use ReflectionClass;
use ReflectionMethod;

class CalculatorTest extends TestCase {
    public function testPrivateValidateInput(): void {
        $calculator = new Calculator();
        
        // Создаем ReflectionClass для доступа к приватным элементам
        $reflection = new ReflectionClass($calculator);
        
        // Получаем приватный метод
        $method = $reflection->getMethod('validateInput');
        
        // Делаем метод доступным для вызова
        $method->setAccessible(true);
        
        // Вызываем приватный метод
        $result = $method->invoke($calculator, '123');
        
        $this->assertTrue($result);
        $this->assertFalse($method->invoke($calculator, 'abc'));
    }
    
    public function testPrivateMethodWithParameters(): void {
        $calculator = new Calculator();
        $reflection = new ReflectionClass($calculator);
        $method = $reflection->getMethod('validateInput');
        $method->setAccessible(true);
        
        // Вызов с передачей аргументов
        $result = $method->invokeArgs($calculator, ['456']);
        $this->assertTrue($result);
    }
}

2. Наследование с изменением видимости

Создание класса-наследника в тестовом пространстве:

<?php
class TestableCalculator extends Calculator {
    // Делаем приватный метод доступным для тестов
    public function publicValidateInput($value): bool {
        return $this->validateInput($value);
    }
}

class CalculatorInheritanceTest extends TestCase {
    public function testViaInheritance(): void {
        $calculator = new TestableCalculator();
        $this->assertTrue($calculator->publicValidateInput('789'));
    }
}

3. PHPUnit встроенные возможности (устаревшие)

В старых версиях PHPUnit были специальные методы, но сейчас они не рекомендуются:

<?php
// УСТАРЕВШИЙ СПОСОБ - не рекомендуется к использованию
class LegacyCalculatorTest extends TestCase {
    public function testOldWay(): void {
        $calculator = new Calculator();
        
        // Этот подход deprecated в современных версиях PHPUnit
        $this->assertTrue(
            $this->invokeMethod($calculator, 'validateInput', ['123'])
        );
    }
    
    private function invokeMethod($object, $methodName, array $parameters = []) {
        $reflection = new ReflectionClass(get_class($object));
        $method = $reflection->getMethod($methodName);
        $method->setAccessible(true);
        return $method->invokeArgs($object, $parameters);
    }
}

Лучшие практики и рекомендации

Когда стоит тестировать приватные методы:

• Сложная бизнес-логика в приватных методах
• Критический код, от которого зависит безопасность
• Легаси-системы, где рефакторинг невозможен
• Методы с большим количеством edge cases

Альтернативные подходы:

1. Рефакторинг: Вынести сложную логику в отдельный публичный класс
2. Интеграционное тестирование: Проверять поведение через публичный API
3. Паттерн "Шаблонный метод": Сделать метод protected и переопределять в тестовом классе

<?php
// Альтернатива: вынос логики в отдельный класс
class InputValidator {
    public function validate($value): bool {
        return is_numeric($value);
    }
}

class RefactoredCalculator {
    private $validator;
    
    public function __construct(InputValidator $validator = null) {
        $this->validator = $validator ?? new InputValidator();
    }
    
    public function add($a, $b): int {
        if (!$this->validator->validate($a) || !$this->validator->validate($b)) {
            throw new InvalidArgumentException('Invalid input');
        }
        return $a + $b;
    }
}

Заключение

Выбор между unit и functional тестами зависит от целей тестирования: unit-тесты обеспечивают быстрое и изолированное тестирование компонентов, тогда как functional-тесты проверяют работу системы в целом. Для тестирования приватных методов предпочтительнее использовать Reflection API, но следует всегда оценивать необходимость такого тестирования — часто лучшим решением является рефакторинг кода для улучшения его архитектуры и тестируемости.