Лучшие практики для тестирования защищенных методов с помощью PHPUnit

Я нашел дискуссию о том , тестируешь ли ты частный метод информативно.

Я решил, что в некоторых классах я хочу иметь защищенные методы, но тестировать их. Некоторые из этих методов являются статическими и короткими. Поскольку большинство открытых методов используют их, я, вероятно, смогу безопасно удалить тесты позже. Но для того, чтобы начать с подхода TDD и избежать отладки, я действительно хочу проверить их.

Я думал о следующем:

• Метод Object, как указано в ответе, кажется излишним для этого.
• Начните с общедоступных методов и, когда покрытие кода обеспечивается тестами более высокого уровня, включите их защиту и удалите тесты.
• Наследуйте класс с тестируемым интерфейсом, делая защищенные методы общедоступными

Что является лучшей практикой? Есть ли еще что-нибудь?

Кажется, что JUnit автоматически меняет защищенные методы на общедоступные, но я не смотрел на это глубже. PHP не позволяет этого через отражение .

Если вы используете PHP5 (> = 5.3.2) с PHPUnit, вы можете протестировать свои закрытые и защищенные методы, используя отражение, чтобы сделать их общедоступными до запуска ваших тестов:

protected static function getMethod($name) {
  $class = new ReflectionClass('MyClass');
  $method = $class->getMethod($name);
  $method->setAccessible(true);
  return $method;
}

public function testFoo() {
  $foo = self::getMethod('foo');
  $obj = new MyClass();
  $foo->invokeArgs($obj, array(...));
  ...
}

Вы, кажется, уже знаете, но я все равно просто повторю это; Это плохой знак, если вам нужно проверить защищенные методы. Целью модульного тестирования является тестирование интерфейса класса, а защищенные методы являются деталями реализации. Тем не менее, есть случаи, когда это имеет смысл. Если вы используете наследование, вы можете видеть, что суперкласс обеспечивает интерфейс для подкласса. Итак, здесь вам нужно будет протестировать защищенный метод (но никогда не закрытый ). Решением этой проблемы является создание подкласса для целей тестирования и использование его для предоставления методов. Например.:

class Foo {
  protected function stuff() {
    // secret stuff, you want to test
  }
}

class SubFoo extends Foo {
  public function exposedStuff() {
    return $this->stuff();
  }
}

Обратите внимание, что вы всегда можете заменить наследование композицией. При тестировании кода, как правило, гораздо проще иметь дело с кодом, использующим этот шаблон, поэтому вы можете рассмотреть этот вариант.

Teastburn имеет правильный подход. Еще проще вызвать метод напрямую и вернуть ответ:

class PHPUnitUtil
{
  public static function callMethod($obj, $name, array $args) {
        $class = new \ReflectionClass($obj);
        $method = $class->getMethod($name);
        $method->setAccessible(true);
        return $method->invokeArgs($obj, $args);
    }
}

Вы можете назвать это просто в своих тестах:

$returnVal = PHPUnitUtil::callMethod(
                $this->object,
                '_nameOfProtectedMethod', 
                array($arg1, $arg2)
             );

Я хотел бы предложить небольшое изменение для getMethod (), определенного в ответе Укельмана .

Эта версия изменяет getMethod (), удаляя жестко запрограммированные значения и немного упрощая использование. Я рекомендую добавить его в ваш класс PHPUnitUtil, как в примере ниже, или в ваш класс, расширяющий PHPUnit_Framework_TestCase (или, я полагаю, глобально в ваш файл PHPUnitUtil).

Так как MyClass создается в любом случае, а ReflectionClass может принимать строку или объект ...

class PHPUnitUtil {
    /**
     * Get a private or protected method for testing/documentation purposes.
     * How to use for MyClass->foo():
     *      $cls = new MyClass();
     *      $foo = PHPUnitUtil::getPrivateMethod($cls, 'foo');
     *      $foo->invoke($cls, $...);
     * @param object $obj The instantiated instance of your class
     * @param string $name The name of your private/protected method
     * @return ReflectionMethod The method you asked for
     */
    public static function getPrivateMethod($obj, $name) {
      $class = new ReflectionClass($obj);
      $method = $class->getMethod($name);
      $method->setAccessible(true);
      return $method;
    }
    // ... some other functions
}

Я также создал функцию псевдонима getProtectedMethod () для явного определения ожидаемого, но это зависит от вас.

Ура!

Я думаю, что troelskn близко. Я бы сделал это вместо этого:

class ClassToTest
{
   protected function testThisMethod()
   {
     // Implement stuff here
   }
}

Затем реализуйте что-то вроде этого:

class TestClassToTest extends ClassToTest
{
  public function testThisMethod()
  {
    return parent::testThisMethod();
  }
}

Затем вы запускаете свои тесты для TestClassToTest.

Должна быть возможность автоматически генерировать такие классы расширений путем анализа кода. Я не удивлюсь, если PHPUnit уже предлагает такой механизм (хотя я не проверял).

Я собираюсь бросить свою шляпу в кольцо здесь:

Я использовал взлом __call с разной степенью успеха. Альтернативой, которую я придумал, было использование шаблона Visitor:

1: создать класс stdClass или пользовательский класс (для принудительного применения типа)

2: начните с требуемого метода и аргументов

3: убедитесь, что ваша SUT имеет метод acceptVisitor, который будет выполнять метод с аргументами, указанными в классе посещения

4: введите его в класс, который вы хотите проверить

5: SUT внедряет результат операции в посетителя

6: применить ваши условия теста к атрибуту результата посетителя

Вы действительно можете использовать __call () для доступа к защищенным методам. Чтобы иметь возможность проверить этот класс

class Example {
    protected function getMessage() {
        return 'hello';
    }
}

вы создаете подкласс в ExampleTest.php:

class ExampleExposed extends Example {
    public function __call($method, array $args = array()) {
        if (!method_exists($this, $method))
            throw new BadMethodCallException("method '$method' does not exist");
        return call_user_func_array(array($this, $method), $args);
    }
}

Обратите внимание, что метод __call () никоим образом не ссылается на класс, поэтому вы можете скопировать вышеприведенное для каждого класса с защищенными методами, которые вы хотите протестировать, и просто изменить объявление класса. Возможно, вы сможете поместить эту функцию в общий базовый класс, но я не пробовал.

Теперь сам контрольный пример отличается только тем, где вы создаете объект для тестирования, меняя его в ExampleExposed for Example.

class ExampleTest extends PHPUnit_Framework_TestCase {
    function testGetMessage() {
        $fixture = new ExampleExposed();
        self::assertEquals('hello', $fixture->getMessage());
    }
}

Я считаю, что PHP 5.3 позволяет вам использовать отражение для непосредственного изменения доступности методов, но я предполагаю, что вам придется делать это для каждого метода в отдельности.

Я предлагаю следующий обходной путь для обходного пути / идеи "Henrik Paul" :)

Вы знаете имена частных методов вашего класса. Например, они похожи на _add (), _edit (), _delete () и т. Д.

Следовательно, когда вы хотите проверить это с точки зрения модульного тестирования, просто вызовите частные методы, добавив префикс и / или суффикс какого-нибудь общего слова (например, _addPhpunit), чтобы при вызове метода __call () (так как метод _addPhpunit () не существует) класса владельца, вы просто помещаете необходимый код в метод __call (), чтобы удалить префиксное / суффиксное слово / с (Phpunit), а затем вызвать оттуда этот выведенный приватный метод. Это еще одно хорошее использование магических методов.

Попробуйте это.