Como posso obter que o PHPUnit MockObjects retorne valores diferentes com base em um parâmetro?

Eu tenho um objeto simulado PHPUnit que retorna, 'return value'independentemente de seus argumentos:

// From inside a test...
$mock = $this->getMock('myObject', 'methodToMock');
$mock->expects($this->any))
     ->method('methodToMock')
     ->will($this->returnValue('return value'));

O que eu quero poder fazer é retornar um valor diferente com base nos argumentos passados ​​para o método mock. Eu tentei algo como:

$mock = $this->getMock('myObject', 'methodToMock');

// methodToMock('one')
$mock->expects($this->any))
     ->method('methodToMock')
     ->with($this->equalTo('one'))
     ->will($this->returnValue('method called with argument "one"'));

// methodToMock('two')
$mock->expects($this->any))
     ->method('methodToMock')
     ->with($this->equalTo('two'))
     ->will($this->returnValue('method called with argument "two"'));

Mas isso faz com que o PHPUnit se queixe se o mock não for chamado com o argumento 'two', então suponho que a definição de methodToMock('two')sobrescreva a definição do primeiro.

Então, minha pergunta é: Existe alguma maneira de obter um objeto mock do PHPUnit para retornar um valor diferente com base em seus argumentos? E se sim, como?

Use um retorno de chamada. por exemplo (direto da documentação do PHPUnit):

<?php
class StubTest extends PHPUnit_Framework_TestCase
{
    public function testReturnCallbackStub()
    {
        $stub = $this->getMock(
          'SomeClass', array('doSomething')
        );

        $stub->expects($this->any())
             ->method('doSomething')
             ->will($this->returnCallback('callback'));

        // $stub->doSomething() returns callback(...)
    }
}

function callback() {
    $args = func_get_args();
    // ...
}
?>

Faça o processamento que quiser no retorno de chamada () e retorne o resultado com base em seus $ args, conforme apropriado.

Dos documentos mais recentes do phpUnit: "Às vezes, um método stubbed deve retornar valores diferentes, dependendo de uma lista predefinida de argumentos. Você pode usar returnValueMap () para criar um mapa que associe argumentos aos valores de retorno correspondentes."

$mock->expects($this->any())
    ->method('getConfigValue')
    ->will(
        $this->returnValueMap(
            array(
                array('firstparam', 'secondparam', 'retval'),
                array('modes', 'foo', array('Array', 'of', 'modes'))
            )
        )
    );

Eu tive um problema semelhante (embora um pouco diferente ... eu não precisava de um valor de retorno diferente com base em argumentos, mas tive que testar para garantir que dois conjuntos de argumentos estavam sendo transmitidos para a mesma função). Eu tropecei em usar algo como isto:

$mock = $this->getMock();
$mock->expects($this->at(0))
    ->method('foo')
    ->with(...)
    ->will($this->returnValue(...));

$mock->expects($this->at(1))
    ->method('foo')
    ->with(...)
    ->will($this->returnValue(...));

Não é perfeito, pois exige que a ordem das 2 chamadas para foo () seja conhecida, mas na prática isso provavelmente não é tão ruim.

Você provavelmente desejaria fazer um retorno de chamada da maneira OOP:

<?php
class StubTest extends PHPUnit_Framework_TestCase
{
    public function testReturnAction()
    {
        $object = $this->getMock('class_name', array('method_to_mock'));
        $object->expects($this->any())
            ->method('method_to_mock')
            ->will($this->returnCallback(array($this, 'returnCallback'));

        $object->returnAction('param1');
        // assert what param1 should return here

        $object->returnAction('param2');
        // assert what param2 should return here
    }

    public function returnCallback()
    {
        $args = func_get_args();

        // process $args[0] here and return the data you want to mock
        return 'The parameter was ' . $args[0];
    }
}
?>

Não é exatamente o que você pergunta, mas, em alguns casos, pode ajudar:

$mock->expects( $this->any() ) )
 ->method( 'methodToMock' )
 ->will( $this->onConsecutiveCalls( 'one', 'two' ) );

onConsecutiveCalls - retorna uma lista de valores na ordem especificada

Passe uma matriz de dois níveis, em que cada elemento é uma matriz de:

• primeiro são os parâmetros do método e o mínimo é o valor de retorno.

exemplo:

->willReturnMap([
    ['firstArg', 'secondArg', 'returnValue']
])

Você também pode retornar o argumento da seguinte maneira:

$stub = $this->getMock(
  'SomeClass', array('doSomething')
);

$stub->expects($this->any())
     ->method('doSomething')
     ->will($this->returnArgument(0));

Como você pode ver na documentação de zombaria , o método returnValue($index)permite retornar o argumento fornecido.

Você quer dizer algo assim?

public function TestSomeCondition($condition){
  $mockObj = $this->getMockObject();
  $mockObj->setReturnValue('yourMethod',$condition);
}

Eu tive um problema semelhante que também não consegui resolver (há surpreendentemente pouca informação sobre o PHPUnit). No meu caso, acabei de fazer cada teste separadamente - entrada e saída conhecidas. Percebi que não precisava criar um objeto fictício de pau para toda obra, só precisava de um específico para um teste específico e, portanto, separei os testes e posso testar aspectos individuais do meu código como um separado. unidade. Não tenho certeza se isso pode ser aplicável a você ou não, mas isso depende do que você precisa testar.

$this->BusinessMock = $this->createMock('AppBundle\Entity\Business');

    public function testBusiness()
    {
        /*
            onConcecutiveCalls : Whether you want that the Stub returns differents values when it will be called .
        */
        $this->BusinessMock ->method('getEmployees')
                                ->will($this->onConsecutiveCalls(
                                            $this->returnArgument(0),
                                            $this->returnValue('employee')                                      
                                            )
                                      );
        // first call

        $this->assertInstanceOf( //$this->returnArgument(0),
                'argument',
                $this->BusinessMock->getEmployees()
                );
       // second call


        $this->assertEquals('employee',$this->BusinessMock->getEmployees()) 
      //$this->returnValue('employee'),


    }

Experimentar :

->with($this->equalTo('one'),$this->equalTo('two))->will($this->returnValue('return value'));