Le fournisseur PHPUnit ne fonctionne pas avec les dépendances

Question

J'utilise PHPUnit 3.4.9, mais j'ai des problèmes avec l'annotation @depends. Cela fonctionne comme dans les exemples, mais se casse quand le producteur se repose sur un fournisseur. Je ne sais pas si cela est censé travailler ou non, mais mon code est essentiellement sous la forme:

<?php 
    class StackTest extends PHPUnit_Framework_TestCase 
    { 
     /** 
     * @dataProvider provider 
     */ 
     public function testEmpty ($data) 
     { 
     $stack = array(); 
     $this->assertTrue(empty($stack)); 

     return $stack; 
     } 

     /** 
     * @depends testEmpty 
     */ 
     public function testPush (array $stack) 
     { 
     array_push($stack, 'foo'); 
     $this->assertEquals('foo', $stack[count($stack)-1]); 
     $this->assertFalse(empty($stack)); 

     return $stack; 
     } 

     /** 
     * @depends testPush 
     */ 
     public function testPop (array $stack) 
     { 
     $this->assertEquals('foo', array_pop($stack)); 
     $this->assertTrue(empty($stack)); 
     } 

     public function provider() 
     { 
     return array(
      // Some testing data here... 
     ); 
     } 
    } 

Le code ci-dessus est juste un exemple, mais montre ce que la structure de mon code est. Lorsqu'il est exécuté, il ignore les tests du consommateur, agissant comme si le producteur avait échoué. Je m'attends à ce que pour chaque ensemble de données de test dans le fournisseur, le producteur sera exécuté avec ces données, et tous ses consommateurs fonctionneront en conséquence.

Answer 1

Puisque la question est déjà 2 jours je donne un coup de feu:

Il ne semble pas fonctionner comme vous le souhaitez.

@depends regarde juste si un test avec le nom fourni a couru et obtient le résultat. Il ne sait même pas ou ne se soucie pas des annotations du test. Je suppose (n'ont pas creusé assez profond dans la source de phpunit pour être sûr à 100%) que les tests avec @depends sont exécutés en tant que "groupe de tests" en interne et non pas comme un seul donc il n'y a pas de test nommé " testEmpty "et le dépend échoue. Donc, pour fournir une solution de contournement, la seule chose à laquelle je peux penser maintenant est d'appeler directement ces "sous-tests".

<?php 
class StackTest extends PHPUnit_Framework_TestCase { 
    /** 
    * @dataProvider provider 
    */ 
    public function testEmpty($data) { 
    $stack = array(); 
    $this->assertTrue(empty($stack)); 
    $this->nextTestOrJustAllInOneTestcaseSaidly($stack); 
    return $stack; 
    } 

    protected function nextTestOrJustAllInOneTestcaseSaidly($data) { ... } 

espoir qui aide ou au moins motive quelqu'un d'autre à répondre;)

Answer 2

J'ai eu exactement le même problème avec un test qui dépend d'un autre test (et plus précisément les données renvoyées par ce test) qui utilise un fournisseur de données. J'ai surmonté le problème en définissant la valeur (que je reviendrais normalement du test dépendant) comme une variable statique, à laquelle j'ai ensuite pu accéder dans mes autres tests plus tard.

<?php 
class StackTest extends PHPUnit_Framework_TestCase { 
    protected static $foo; 

    public function provider() { ... } 

    /** 
    * @dataProvider provider 
    */ 
    public function testOne($data) { 
     self::$foo = array(); 
     $this->assertTrue(empty(self::$foo)); 
    } 

    /** 
    * @depends testOne 
    */ 
    public function testTwo() { 
     $this->assertTrue(empty(self::$foo)); 
    } 

encore hacky, mais un peu moins que d'appeler peut-être la prochaine fonction de test à partir d'un autre test.

Answer 3

Si un test a un fournisseur de données, toutes les données fournies seront intégrées à ce test. Seulement alors le prochain test est exécuté, ce qui peut dépendre du premier test pour réussir. Ce qui n'est PAS fait, c'est que toutes les données fournies au premier test sont également transmises à la seconde.

@dataProvider est prioritaire sur @depends. Un test peut dépendre d'un autre test qui teste complètement toutes ses données fournies, mais il n'obtiendra pas ces données pour lui-même. Pour obtenir une telle chose, vous devez vraiment combiner tous les tests dépendants en une seule fonction. D'un autre côté, une telle configuration de test peut ne pas être évidente en premier lieu, mais les tests doivent être faciles à comprendre. Envisager de refactoriser les tests.