Najlepsze praktyki testowania chronionych metod za pomocą PHPUnit

Dyskusja na temat Czy testujesz metodę prywatną ma charakter informacyjny.

Zdecydowałem, że na niektórych zajęciach chcę mieć metody chronione, ale je przetestuj. Niektóre z tych metod są statyczne i krótkie. Ponieważ większość publicznych metod korzysta z nich, prawdopodobnie będę mógł później bezpiecznie usunąć testy. Ale aby zacząć od podejścia TDD i uniknąć debugowania, naprawdę chcę je przetestować.

Myślałem o następujących kwestiach:

• Metoda Obiekt wskazana w odpowiedzi wydaje się być nadmierną umiejętnością w tym zakresie.
• Zacznij od metod publicznych, a gdy kod zostanie objęty testami wyższego poziomu, włącz ich ochronę i usuń testy.
• Dziedzicz klasę z testowalnym interfejsem upubliczniającym chronione metody

Jaka jest najlepsza praktyka? Czy jest coś jeszcze?

Wygląda na to, że JUnit automatycznie zmienia chronione metody na publiczne, ale nie przyjrzałem się temu głębiej. PHP nie pozwala na to poprzez refleksję .

Jeśli używasz PHP5 (> = 5.3.2) z PHPUnit, możesz przetestować swoje prywatne i chronione metody, używając refleksji, aby ustawić je jako publiczne przed uruchomieniem testów:

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(...));
  ...
}

Wygląda na to, że już jesteś świadomy, ale i tak to powtórzę; To zły znak, jeśli musisz przetestować chronione metody. Celem testu jednostkowego jest przetestowanie interfejsu klasy, a chronione metody są szczegółami implementacji. To powiedziawszy, są przypadki, w których ma to sens. Jeśli używasz dziedziczenia, możesz zobaczyć nadklasę jako interfejs dla podklasy. Więc tutaj musiałbyś przetestować metodę chronioną (ale nigdy prywatną ). Rozwiązaniem tego jest utworzenie podklasy do celów testowych i wykorzystanie jej do ujawnienia metod. Na przykład.:

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

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

Pamiętaj, że zawsze możesz zastąpić dziedziczenie kompozycją. Podczas testowania kodu zwykle łatwiej jest radzić sobie z kodem korzystającym z tego wzorca, więc warto rozważyć tę opcję.

teastburn ma właściwe podejście. Jeszcze prostsze jest bezpośrednie wywołanie metody i zwrócenie odpowiedzi:

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);
    }
}

Możesz to nazwać w testach:

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

Chciałbym zaproponować niewielką odmianę metody getMethod () zdefiniowanej w odpowiedzi uckelman .

Ta wersja zmienia getMethod () poprzez usunięcie zakodowanych wartości i uproszczenie użytkowania. Polecam dodanie go do swojej klasy PHPUnitUtil, jak w poniższym przykładzie, lub do klasy rozszerzającej PHPUnit_Framework_TestCase (lub, jak sądzę, globalnie do pliku PHPUnitUtil).

Ponieważ i tak tworzona jest instancja MyClass, a ReflectionClass może pobrać ciąg znaków lub obiekt ...

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
}

Stworzyłem również funkcję aliasu getProtectedMethod (), aby wyraźnie określić, czego się oczekuje, ale to zależy od ciebie.

Twoje zdrowie!

Myślę, że troelskn jest blisko. Zrobiłbym to zamiast tego:

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

Następnie zaimplementuj coś takiego:

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

Następnie uruchamiasz testy przeciwko TestClassToTest.

Powinna istnieć możliwość automatycznego generowania takich klas rozszerzeń przez analizowanie kodu. Nie zdziwiłbym się, gdyby PHPUnit już oferował taki mechanizm (chociaż nie sprawdziłem).

Wrzucę tutaj kapelusz na ring:

Użyłem hacka __call z różnym powodzeniem. Alternatywą, którą wymyśliłem, było użycie wzoru Visitor:

1: wygeneruj stdClass lub klasę niestandardową (aby wymusić typ)

2: zagruntuj to wymaganą metodą i argumentami

3: upewnij się, że twój SUT ma metodę acceptVisitor, która wykona metodę z argumentami określonymi w klasie odwiedzającej

4: wstrzyknij do klasy, którą chcesz przetestować

5: SUT wstrzykuje odwiedzającemu wynik operacji

6: zastosuj warunki testu do atrybutu wyniku Odwiedzającego

Rzeczywiście możesz użyć __call () w sposób ogólny, aby uzyskać dostęp do chronionych metod. Aby móc przetestować tę klasę

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

tworzysz podklasę w 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);
    }
}

Zauważ, że metoda __call () nie odwołuje się w żaden sposób do klasy, więc możesz skopiować powyższe dla każdej klasy za pomocą chronionych metod, które chcesz przetestować, i po prostu zmienić deklarację klasy. Możesz być w stanie umieścić tę funkcję we wspólnej klasie bazowej, ale ja jej nie wypróbowałem.

Teraz sam przypadek testowy różni się tylko tym, w którym konstruuje się obiekt do testowania, zamieniając w PrzykładExposed na Przykład.

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

Wierzę, że PHP 5.3 pozwala używać refleksji do bezpośredniej zmiany dostępności metod, ale zakładam, że będziesz musiał to zrobić dla każdej metody osobno.

Proponuję następujące obejście obejścia / pomysłu Henrika Paula :)

Znasz nazwy prywatnych metod swojej klasy. Na przykład są one jak _add (), _edit (), _delete () itp.

Dlatego jeśli chcesz go przetestować pod kątem testowania jednostkowego, po prostu wywołaj metody prywatne przez prefiks i / lub sufiks jakiegoś wspólnego słowa (na przykład _addPhpunit), aby po wywołaniu metody __call () (ponieważ metoda _addPhpunit () nie istnieje) klasy właściciela, wystarczy wstawić potrzebny kod w metodzie __call (), aby usunąć prefiks / sufiks słowo / s (Phpunit), a następnie wywołać stamtąd wywnioskowaną metodę prywatną. To kolejne dobre użycie magicznych metod.

Wypróbuj to.