test - PHPUnit objetos falsos y métodos estáticos

symfony test app

Question

Estoy buscando la mejor manera de probar el siguiente método estático (específicamente usando un Modelo de Doctrina):

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

Idealmente, usaría un objeto simulado para asegurarme de que se llamaba "fromArray" (con los datos de usuario suministrados) y "save", pero eso no es posible ya que el método es estático.

¿Alguna sugerencia?

Answer 1

Ahora está 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 2

Haría una nueva clase en el espacio de nombres de la prueba de la unidad que extendería el Model_User y lo probaría. Aquí hay un ejemplo:

Clase original:

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

Clase falsa para llamar en pruebas unitarias:

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

Answer 3

La biblioteca doublit también podría ayudarlo a probar métodos estáticos:

/* Create a mock instance of your class */
$double = Doublit::mock_instance(Model_User::class);

/* Test the "create" method */
$double::_method(''create'')
   ->count(1) // test that the method is called once
   ->args([Constraints::isInstanceOf(''array'')]) // test that first argument is an array
   ->stub(''my_value'') // stub the method to return "myvalue"

Answer 4

Otro posible enfoque 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

Probar métodos estáticos generalmente se considera un poco difícil (como probablemente ya habrás 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, podría algo como esto no hacer el truco:

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

No estoy seguro de lo que probará; pero, al menos, ya no hay un método estático ...

Answer 6

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 enlaces estáticos tardíos, puede hacer

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

Actualización: staticExpects está en desuso a partir de PHPUnit 3.8 y se eliminará por completo con las versiones posteriores.