Posso usare @depends per dipendere da un test usando @dataProvider?

Question

Ho un test in cui un test viene eseguito più volte tramite un @dataProvider e un altro test che @depends sul primo metodo. Tuttavia, quando ho chiamato var_dump su ciò che dovrebbe essere passato al secondo test, mi dà un solido NULL, che non mi aspettavo.

In altre parole: cosa dovrebbe fare questo:

<?php 
class DevicesTest extends PHPUnit_Framework_TestCase 
{ 
    /** 
    * @dataProvider registerDataProvider 
    */ 
    public function testRegister($device, $supposedResult) 
    { 
     //do a bunch of tests 
     return array($device, $supposedResult); 
    } 

    public function registerDataProvider() 
    { 
     return array(array("foo", "foo")); 
    } 

    /** 
    * @depends testRegister 
    */ 
    public function testSaveDevicePreferences($deviceArr) 
    { 
     $this->assertNotEmpty($deviceArr); 
    } 
} 
?> 

Answer 1

Normalmente @dataProvider è usato quando si desidera eseguire un test più volte con set di dati diversi per ciascuno. Esiste per evitare di scrivere codice di looping nel test e consentire a set di dati diversi di passare o fallire individualmente.

Come ho detto nei miei commenti, credo che PHPUnit utilizzerà sia @dependso@dataProvider, e dal vostro esempio la mia ipotesi è che la seconda vince. Un'altra possibilità è che i test con i fornitori di dati non possano essere usati come dipendenze perché PHPUnit non sa quale test-plus-dataset scegliere.

Poiché registerDataProvider restituisce un singolo set di dati, è possibile richiamarlo facilmente dal test stesso. Ciò consentirebbe a @depends di funzionare nel secondo test senza il @dataProvider. Supponendo che testRegister ha la necessità di modificare $device e/o $supposedResult, questo dovrebbe funzionare:

class DevicesTest extends PHPUnit_Framework_TestCase { 
    public function testRegister() { 
     list($device, $supposedResult) = $this->registerDataProvider(); 
     //do a bunch of tests 
     //register a device in the DB 
     return array($device, $supposedResult); 
    } 

    public function registerDataProvider() { 
     return array("foo", "foo"); 
    } 

    /** 
    * @depends testRegister 
    */ 
    public function testSaveDevicePreferences($data) { 
     list($device, $supposedResult) = $data; 
     // do stuff dependent on testRegister() 
     $this->assertEquals($device, $supposedResult); 
    } 
} 

Se queste variabili non hanno bisogno di essere modificato dal primo test, si può semplicemente chiamare registerDataProvider da entrambi i test. Si noti che PHPUnit non separerà un array restituito da un dipendente su un test in argomenti al test dipendente come fa il meccanismo del provider di dati. Questo perché non sa che la matrice restituita è più argomenti rispetto a un singolo argomento.

Answer 2

ho scoperto che no, questo non è possibile. Tuttavia, leggermente adattando il testclass, ho raggiunto sostanzialmente il medesimo risultato, tuttavia, il rapporto dipendente sembra essere perso dal fatto che se il primo test fallisce, il secondo corre felicemente:

<?php 
class DevicesTest extends PHPUnit_Framework_TestCase 
{ 
    /** 
    * @dataProvider registerDataProvider 
    */ 
    public function testRegister($device, $supposedResult) 
    { 
     //do a bunch of tests 
     //register a device in the DB 
     return array($device, $supposedResult); 
    } 

    public function registerDataProvider() 
    { 
     return array(array("foo", "foo")); 
    } 

    /** 
    * @depends testRegister 
    * @dataProvider registerDataProvider 
    */ 
    public function testSaveDevicePreferences($device, $supposedResult) 
    { 
     // do stuff dependent on testRegister() 
     $this->assertEquals($device, $supposedResult); 
    } 
} 
?> 

Answer 3

Nella versione corrente di PHPUnit (5.4 a oggi), è possibile.

Secondo il documentation:

Se una prova riceve input sia da un metodo @dataProvider e da uno o più test si @depends su argomenti, dal fornitore di dati verrà prima di quelli da dipendeva -solo test. Gli argomenti dei test dipendenti dipenderanno per ogni set di dati.

Ecco come apparirebbe in pratica:

<?php 

class DataProviderAndDependsCombinationTest extends AbstractUnittest{ 

    public function dataProviderForSomething() 
    { 
     return array(
      array(
       'someProvidedValue', 
       'someOtherProvidedValue' 
      ) 
     ); 
    } 

    public function testToDependOn() 
    { 
     $this->assertTrue(true); 
     return 'someDependedValue'; 
    } 

    /** 
    * @dataProvider dataProviderForSomething 
    * @depends testToDependOn 
    */ 
    public function testSomething($someProvidedValue, $someOtherProvidedValue, $someDependedValue) 
    { 
     $this->assertSame('someProvidedValue', $someProvidedValue); 
     $this->assertSame('someOtherProvidedValue', $someOtherProvidedValue); 
     $this->assertSame('someDependedValue', $someDependedValue); 
    } 
}