retornan - retornar valores de php a html

¿Cómo puedo obtener PHPUnit MockObjects para devolver diferentes valores basados en un parámetro?

Question

Tengo un objeto falso de PHPUnit que devuelve ''return value'' sin importar sus argumentos:

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

Lo que quiero poder hacer es devolver un valor diferente en función de los argumentos pasados ​​al método simulado. He intentado 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"''));

Pero esto hace que PHPUnit se queje si el simulacro no se llama con el argumento ''two'' , así que supongo que la definición de methodToMock(''two'') sobrescribe la definición del primero.

Entonces mi pregunta es: ¿hay alguna forma de obtener un objeto simulado PHPUnit para devolver un valor diferente en función de sus argumentos? Y si es así, ¿cómo?

Answer 1

¿Te refieres a algo como esto?

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

Answer 2

De los últimos documentos phpUnit: "A veces, un método stubped debe devolver diferentes valores según una lista predefinida de argumentos. Puede usar returnValueMap() para crear un mapa que asocie argumentos con los valores devueltos correspondientes".

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

Answer 3

Es probable que desee hacer una devolución de llamada en forma de 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];
}
}
?>

Answer 4

No es exactamente lo que preguntas, pero en algunos casos puede ser útil:

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

onConsecutiveCalls - devuelve una lista de valores en el orden especificado

Answer 5

Pasar una matriz de dos niveles, donde cada elemento es una matriz de:

• primero son los parámetros del método, y menos es el valor de retorno.

ejemplo:

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

Answer 6

También puede devolver el argumento de la siguiente manera:

$stub = $this->getMock(
''SomeClass'', array(''doSomething'')
);
$stub->expects($this->any())
->method(''doSomething'')
->will($this->returnArgument(0));

Como puede ver en la documentación de Mocking , el método returnValue($index) permite devolver el argumento dado.

Answer 7

Tratar :

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

Answer 8

Tuve un problema similar (aunque ligeramente diferente ... No necesité un valor de retorno diferente en función de los argumentos, pero tuve que probar para asegurar que se pasaran 2 conjuntos de argumentos a la misma función). Me encontré con usar algo como esto:

$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(...));

No es perfecto, ya que requiere que se conozca el orden de las 2 llamadas a foo (), pero en la práctica esto probablemente no sea tan malo.

Answer 9

Tuve un problema similar que tampoco pude resolver (hay muy poca información sobre PHPUnit). En mi caso, acabo de hacer cada prueba por separado: entrada conocida y salida conocida. Me di cuenta de que no era necesario hacer un objeto falso simulacro, solo necesitaba uno específico para una prueba específica, y así separé las pruebas y pude probar aspectos individuales de mi código como un elemento separado unidad. No estoy seguro de si esto podría aplicarse a usted o no, pero eso es lo que necesita para probar.

Answer 10

Use una devolución de llamada. ej. (directamente de la documentación de 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();
// ...
}
?>

Haga el procesamiento que desee en la devolución de llamada () y devuelva el resultado según sus $ args, según corresponda.

Answer 11

$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''),
}