Simulacros de objetos que admiten métodos de encadenamiento

Question

Me pregunto si hay una forma bastante concisa de burlar objetos que admiten el encadenamiento de métodos ... así, por ejemplo, un objeto de consulta de base de datos puede tener una llamada a este método:

$result = $database->select('my_table')->where(array('my_field'=>'a_value'))->limit(1)->execute(); 

El problema surge si tengo que simular dos consultas de selección diferentes para que arrojen resultados diferentes. ¿Algunas ideas?

Esto es específicamente sobre PHPUnit, pero las experiencias de otros marcos de pruebas de unidades ayudarán.

Answer 1

no estoy seguro de que esto es lo que está buscando, así que por favor deje un comentario:

class StubTest extends PHPUnit_Framework_TestCase 
{ 
    public function testChainingStub() 
    { 
     // Creating the stub with the methods to be called 
     $stub = $this->getMock('Zend_Db_Select', array(
      'select', 'where', 'limit', 'execute' 
     ), array(), '', FALSE); 

     // telling the stub to return a certain result on execute 
     $stub->expects($this->any()) 
      ->method('execute') 
      ->will($this->returnValue('expected result')); 

     // telling the stub to return itself on any other calls 
     $stub->expects($this->any()) 
      ->method($this->anything()) 
      ->will($this->returnValue($stub)); 

     // testing that we can chain the stub 
     $this->assertSame(
      'expected result', 
      $stub->select('my_table') 
       ->where(array('my_field'=>'a_value')) 
       ->limit(1) 
       ->execute() 
     ); 
    } 
} 

Esto se puede combinar con las expectativas:

class StubTest extends PHPUnit_Framework_TestCase 
{ 
    public function testChainingStub() 
    { 
     // Creating the stub with the methods to be called 
     $stub = $this->getMock('Zend_Db_Select', array(
      'select', 'where', 'limit', 'execute' 
     ), array(), '', FALSE); 

     // overwriting stub to return something when execute is called 
     $stub->expects($this->exactly(1)) 
      ->method('execute') 
      ->will($this->returnValue('expected result')); 

     $stub->expects($this->exactly(1)) 
      ->method('limit') 
      ->with($this->equalTo(1)) 
      ->will($this->returnValue($stub)); 

     $stub->expects($this->exactly(1)) 
      ->method('where') 
      ->with($this->equalTo(array('my_field'=>'a_value'))) 
      ->will($this->returnValue($stub)); 

     $stub->expects($this->exactly(1)) 
      ->method('select') 
      ->with($this->equalTo('my_table')) 
      ->will($this->returnValue($stub)); 

     // testing that we can chain the stub 
     $this->assertSame(
      'expected result', 
      $stub->select('my_table') 
       ->where(array('my_field'=>'a_value')) 
       ->limit(1) 
       ->execute() 
     ); 
    } 
} 

Answer 2

Esto podría no ser la respuesta que está buscando, pero me escribió un marco de objeto de burla de un par de años atrás, que se encargará de este tipo de "depende de la entrada" afirmación bien:

http://code.google.com/p/yaymock/

http://code.google.com/p/yaymock/wiki/Expectations

lo he escrito para su uso en las pruebas de unidad que respaldan Swift Mailer, pero no ha sido ampliamente adoptado por cualquier otro proyecto (que yo sepa). El objetivo era proporcionar un mejor control e introspección de las invocaciones de objeto simuladas que las proporcionadas por PHPUnit y SimpleTest.

Answer 3

Sé que es una vieja cuestión, pero podría ayudar más a los futuros jugadores de Google.

También estaba teniendo problemas para encontrar un marco que proporcione una sintaxis simple y fácil para burlar & encadenamiento del método de troceo. luego decidí escribir una biblioteca burlona simple y fácil de usar.

ejemplo

Uso:

// Creating a new mock for SimpleClassForMocking 
$mock = ShortifyPunit::mock('SimpleClassForMocking'); 

    ShortifyPunit::when($mock)->first_method() 
          ->second_method(2,3)->returns(1); 

    ShortifyPunit::when($mock)->first_method() 
          ->second_method(2,3,4)->returns(2); 

    ShortifyPunit::when($mock)->first_method(1) 
          ->second_method(2,3,4)->returns(3); 

    ShortifyPunit::when($mock)->first_method(1,2,3) 
          ->second_method(1,2)->third_method()->returns(4); 

    $mock->first_method()->second_method(2,3); // returns 1 
    $mock->first_method()->second_method(2,3,4); // returns 2 
    $mock->first_method(1)->second_method(2,3,4); // returns 3 
    $mock->first_method(1,2,3)->second_method(1,2)->third_method(); // return 4 

GitHub:

https://github.com/danrevah/ShortifyPunit#stubbing-method-chanining