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


    }