PHPUnit ile korunan yöntemleri test etmek için en iyi uygulamalar

Özel yöntemi bilgilendirici test ediyor musunuz?

Bazı sınıflarda korunan yöntemlere sahip olmak istediğime karar verdim, ancak bunları test ediyorum. Bu yöntemlerin bazıları statik ve kısadır. Genel yöntemlerin çoğu bunları kullandığından, muhtemelen testleri daha sonra güvenle kaldırabileceğim. Ancak bir TDD yaklaşımı ile başlamak ve hata ayıklamaktan kaçınmak için onları gerçekten test etmek istiyorum.

Aşağıdakileri düşündüm:

• Yöntem Bir cevapta tavsiye edilen nesne bunun için aşırıya kaçmış gibi görünüyor.
• Herkese açık yöntemlerle başlayın ve daha yüksek düzey testlerle kod kapsamı verildiğinde, bunları korumalı hale getirin ve testleri kaldırın.
• Korumalı yöntemleri herkese açık hale getiren test edilebilir bir arayüzle bir sınıfı devralma

Hangisi en iyi uygulama? Başka bir şey var mı?

Görünüşe göre, JUnit korumalı yöntemleri herkese açık olacak şekilde otomatik olarak değiştiriyor, ancak daha derinlemesine bir bakışım yoktu. PHP yansıma yoluyla buna izin vermez .

PHPUnit ile PHP5 (> = 5.3.2) kullanıyorsanız, testlerinizi çalıştırmadan önce herkese açık olacak şekilde ayarlamak için yansımayı kullanarak özel ve korumalı yöntemlerinizi test edebilirsiniz:

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

Zaten farkında gibi görünüyorsun, ama ben yine de yeniden ifade edeceğim; Korumalı yöntemleri test etmeniz gerekiyorsa, bu kötü bir işarettir. Bir birim testinin amacı, bir sınıfın arayüzünü test etmektir ve korunan yöntemler uygulama detaylarıdır. Bununla birlikte, mantıklı olduğu durumlar vardır. Kalıtım kullanıyorsanız, üst sınıfı alt sınıf için arabirim olarak görebilirsiniz. Yani burada, korunan yöntemi test etmeniz gerekir (Ama asla özel bir yöntem ). Bunun çözümü, test amacıyla bir alt sınıf oluşturmak ve bunu yöntemleri ortaya çıkarmak için kullanmaktır. Örneğin.:

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

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

Kalıtımı her zaman kompozisyonla değiştirebileceğinizi unutmayın. Kodu test ederken, genellikle bu kalıbı kullanan kodla uğraşmak çok daha kolaydır, bu nedenle bu seçeneği düşünmek isteyebilirsiniz.

teastburn doğru yaklaşıma sahiptir. Daha da basit olan yöntemi doğrudan aramak ve cevabı döndürmektir:

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

Bunu sadece testlerinizde şu şekilde arayabilirsiniz:

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

Ben tanımlanan GetMethod hafif bir varyasyonu () önermek istiyorum uckelman cevabı .

Bu sürüm, sabit kodlanmış değerleri kaldırarak ve kullanımı biraz basitleştirerek getMethod () yöntemini değiştirir. Aşağıdaki örnekte olduğu gibi PHPUnitUtil sınıfınıza veya PHPUnit_Framework_TestCase genişletme sınıfınıza (veya genel olarak PHPUnitUtil dosyanıza) eklemenizi öneririm.

MyClass yine de başlatıldığından ve ReflectionClass bir dize veya bir nesne alabilir ...

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
}

Ayrıca beklenen ne açık olmak için getProtectedMethod () bir takma ad işlevi oluşturdum, ama bu size kalmış.

Şerefe!

Bence troelskn yakın. Bunun yerine bunu yapardım:

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

Sonra böyle bir şey uygulayın:

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

Daha sonra TestClassToTest karşı testlerinizi çalıştırın.

Kodu ayrıştırarak bu tür uzantı sınıflarını otomatik olarak oluşturmak mümkün olmalıdır. PHPUnit zaten böyle bir mekanizma sunuyorsa şaşırdım (gerçi kontrol etmedim).

Şapkamı buradaki yüzüğe atacağım:

__Call kesmek için karışık derecelerde başarı elde ettim. Geldiğim alternatif Ziyaretçi desenini kullanmaktı:

1: bir stdClass veya özel sınıf oluşturun (türü zorlamak için)

2: gerekli yöntem ve argümanlarla hazırlayın

3: SUT'nuzun, ziyaret eden sınıfta belirtilen bağımsız değişkenlerle yöntemi yürütecek bir acceptVisitor yöntemine sahip olduğundan emin olun

4: test etmek istediğiniz sınıfa enjekte edin

5: SUT, operasyonun sonucunu ziyaretçiye enjekte ediyor

6: Test koşullarınızı Ziyaretçinin sonuç özelliğine uygulayın

Korumalı yöntemlere erişmek için __call () yöntemini genel bir şekilde kullanabilirsiniz. Bu sınıfı test edebilmek

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

ÖrnekTest.php içinde bir alt sınıf oluşturun:

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 () yönteminin sınıfa herhangi bir şekilde başvurmadığını unutmayın, böylece her sınıf için yukarıdakileri sınamak istediğiniz korumalı yöntemlerle kopyalayabilir ve yalnızca sınıf bildirimini değiştirebilirsiniz. Bu işlevi ortak bir temel sınıfa yerleştirebilirsiniz, ancak denemedim.

Şimdi, test senaryosunun kendisi sadece test edilecek nesneyi oluşturduğunuz yerde farklıdır ve Örnek için Expozion'da değiştirilmiştir.

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

PHP 5.3, yöntemlerin erişilebilirliğini doğrudan değiştirmek için yansımayı kullanmanıza izin verdiğine inanıyorum, ancak her yöntem için ayrı ayrı yapmanız gerektiğini varsayıyorum.

"Henrik Paul" için geçici çözümü takip etmenizi öneririm :)

Sınıfınızın özel yöntemlerinin adlarını biliyorsunuz. Örneğin _add (), _edit (), _delete () vb.

Bu nedenle, birim testi açısından test etmek istediğinizde, bazı yaygın yöntemleri ön ekleyerek ve / veya ekleyerek özel yöntemleri çağırmanız yeterlidir. , __call () yöntemi çağrıldığında (_addPhpunit () yöntemi çağrılmadığından) sözcükleri (örneğin _addPhpunit) çağırmanız yeterlidir. owner), sınıfın ön ekli / sonlu sözcüğünü kaldırmak için __call () yöntemine gerekli kodu koydunuz ve sonra o çıkarılan özel yöntemi oradan çağırabilirsiniz. Bu, sihirli yöntemlerin bir başka iyi kullanımıdır.

Denemek.