PHPUnit Mock objetos y métodos estáticos

Question

Busco la mejor manera de hacer las pruebas de la siguiente método estático (específicamente el uso de un modelo Doctrina):

class Model_User extends Doctrine_Record 
{ 
    public static function create($userData) 
    { 
     $newUser = new self(); 
     $newUser->fromArray($userData); 
     $newUser->save(); 
    } 
} 

Idealmente, me gustaría utilizar un objeto de burla para asegurar que "fromArray" (con los datos de usuario provistos) y "save" se llamaron, pero eso no es posible ya que el método es estático.

¿Alguna sugerencia?

Answer 1

Sebastian Bergmann, el autor de PHPUnit, recientemente publicó un blog sobre Stubbing and Mocking Static Methods. Con PHPUnit 3.5 y PHP 5.3, así como el uso constante de la ligadura dinámica estática, se puede hacer

$class::staticExpects($this->any()) 
     ->method('helper') 
     ->will($this->returnValue('bar')); 

Actualización:staticExpects es deprecated as of PHPUnit 3.8 y se eliminará por completo con versiones posteriores.

Answer 2

La prueba de métodos estáticos generalmente se considera como un poco difícil (como probablemente ya haya notado), especialmente antes de PHP 5.3.

¿No podría modificar su código para no usar un método estático? Realmente no veo por qué estás usando un método estático aquí, de hecho; esto probablemente podría volver a escribirse en algún código no estático, ¿no es así?

Por ejemplo, es posible que algo así no hacer el truco:

class Model_User extends Doctrine_Record 
{ 
    public function saveFromArray($userData) 
    { 
     $this->fromArray($userData); 
     $this->save(); 
    } 
} 

No estoy seguro que usted estará de pruebas; pero, al menos, hay un método estático ya ...

Answer 3

En la actualidad existe la biblioteca AspectMock para ayudar con esto:

https://github.com/Codeception/AspectMock

$this->assertEquals('users', UserModel::tableName()); 
$userModel = test::double('UserModel', ['tableName' => 'my_users']); 
$this->assertEquals('my_users', UserModel::tableName()); 
$userModel->verifyInvoked('tableName'); 

Answer 4

Otro enfoque posible es con la biblioteca Moka:

$modelClass = Moka::mockClass('Model_User', [ 
    'fromArray' => null, 
    'save' => null 
]); 

$modelClass::create('DATA'); 
$this->assertEquals(['DATA'], $modelClass::$moka->report('fromArray')[0]); 
$this->assertEquals(1, sizeof($modelClass::$moka->report('save'))); 

Answer 5

Haría una nueva clase en el espacio de nombres de prueba de la unidad que amplía el Model_User y lo prueba. He aquí un ejemplo:

clase original:

class Model_User extends Doctrine_Record 
{ 
    public static function create($userData) 
    { 
     $newUser = new self(); 
     $newUser->fromArray($userData); 
     $newUser->save(); 
    } 
} 

Mock clase para llamar en prueba de la unidad (s):

use \Model_User 
class Mock_Model_User extends Model_User 
{ 
    /** \PHPUnit\Framework\TestCase */ 
    public static $test; 

    // This class inherits all the original classes functions. 
    // However, you can override the methods and use the $test property 
    // to perform some assertions. 
} 

En la prueba de unidad:

use Module_User; 
use PHPUnit\Framework\TestCase; 

class Model_UserTest extends TestCase 
{ 
    function testCanInitialize() 
    { 
     $userDataFixture = []; // Made an assumption user data would be an array. 
     $sut = new Mock_Model_User::create($userDataFixture); // calls the parent ::create method, so the real thing. 

     $sut::test = $this; // This is just here to show possibilities. 

     $this->assertInstanceOf(Model_User::class, $sut); 
    } 
}