Wie kann ich PHPUnit MockObjects dazu bringen, basierend auf einem Parameter unterschiedliche Werte zurückzugeben?

Ich habe ein PHPUnit-Scheinobjekt, das 'return value'unabhängig von seinen Argumenten zurückgibt :

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

Ich möchte in der Lage sein, einen anderen Wert zurückzugeben, der auf den an die Mock-Methode übergebenen Argumenten basiert. Ich habe so etwas versucht wie:

$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"'));

Dies führt jedoch dazu, dass sich PHPUnit beschwert, wenn der Mock nicht mit dem Argument aufgerufen wird. Daher gehe 'two'ich davon aus, dass die Definition von methodToMock('two')die Definition der ersten überschreibt.

Meine Frage lautet also: Gibt es eine Möglichkeit, ein PHPUnit-Scheinobjekt dazu zu bringen, basierend auf seinen Argumenten einen anderen Wert zurückzugeben? Und wenn ja, wie?

Verwenden Sie einen Rückruf. zB (direkt aus der PHPUnit-Dokumentation):

<?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();
    // ...
}
?>

Führen Sie die gewünschte Verarbeitung in callback () aus und geben Sie das Ergebnis basierend auf Ihren $ args zurück.

Aus den neuesten phpUnit-Dokumenten: "Manchmal sollte eine Stubbed-Methode abhängig von einer vordefinierten Liste von Argumenten unterschiedliche Werte zurückgeben. Mit returnValueMap () können Sie eine Zuordnung erstellen, die Argumente mit entsprechenden Rückgabewerten verknüpft."

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

Ich hatte ein ähnliches Problem (obwohl etwas anders ... Ich brauchte keinen anderen Rückgabewert basierend auf Argumenten, sondern musste testen, um sicherzustellen, dass 2 Sätze von Argumenten an dieselbe Funktion übergeben wurden). Ich bin auf so etwas gestoßen:

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

Es ist nicht perfekt, da es erfordert , dass die Reihenfolge der zwei Anrufe zu foo () bekannt ist , aber in der Praxis ist dies wahrscheinlich nicht allzu schlecht.

Sie möchten wahrscheinlich einen Rückruf auf OOP-Weise durchführen:

<?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];
    }
}
?>

Es ist nicht genau das, was Sie fragen, aber in einigen Fällen kann es helfen:

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

onConsecutiveCalls - Gibt eine Liste von Werten in der angegebenen Reihenfolge zurück

Übergeben Sie ein Array mit zwei Ebenen, wobei jedes Element ein Array von:

• Zuerst sind Methodenparameter und am wenigsten der Rückgabewert.

Beispiel:

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

Sie können das Argument auch wie folgt zurückgeben:

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

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

Wie Sie in der Mocking-Dokumentation sehen können , können Sie mit der Methode returnValue($index)das angegebene Argument zurückgeben.

Meinst du so etwas?

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

Ich hatte ein ähnliches Problem, das ich auch nicht lösen konnte (es gibt überraschend wenig Informationen für PHPUnit). In meinem Fall habe ich gerade jeden Test separat durchgeführt - bekannte Eingabe und bekannte Ausgabe. Mir wurde klar, dass ich kein Allround-Scheinobjekt erstellen musste, sondern nur ein bestimmtes für einen bestimmten Test. Daher habe ich die Tests getrennt und kann einzelne Aspekte meines Codes als separate testen Einheit. Ich bin mir nicht sicher, ob dies auf Sie zutrifft oder nicht, aber das hängt davon ab, was Sie testen müssen.

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


    }

Versuchen :

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