Не идеально использовать at(), Если вы можете избежать этого, потому что , как утверждают их документы

Параметр $index для сопоставления at() ссылается на индекс, начинающийся с нуля, во всех вызовах метода для данного макетного объекта. Будьте осторожны при использовании этого сопоставления, так как оно может привести к хрупким тестам, которые слишком тесно связаны с конкретными деталями реализации.

Начиная с 4.1 вы можете использовать withConsecutive например.

$mock->expects($this->exactly(2))
     ->method('set')
     ->withConsecutive(
         [$this->equalTo('foo'), $this->greaterThan(0)],
         [$this->equalTo('bar'), $this->greaterThan(0)]
       );

Если вы хотите, чтобы он вернулся на последовательный звонки:

  $mock->method('set')
         ->withConsecutive([$argA1, $argA2], [$argB1], [$argC1, $argC2])
         ->willReturnOnConsecutiveCalls($retValueA, $retValueB, $retValueC);

Из того, что я нашел, лучший способ решить эту проблему-использовать функциональность карты значений PHPUnit.

Пример из документации PHPUnit :

class SomeClass {
    public function doSomething() {}   
}

class StubTest extends \PHPUnit_Framework_TestCase {
    public function testReturnValueMapStub() {

        $mock = $this->getMock('SomeClass');

        // Create a map of arguments to return values.
        $map = array(
          array('a', 'b', 'd'),
          array('e', 'f', 'h')
        );  

        // Configure the mock.
        $mock->expects($this->any())
             ->method('doSomething')
             ->will($this->returnValueMap($map));

        // $mock->doSomething() returns different values depending on
        // the provided arguments.
        $this->assertEquals('d', $stub->doSomething('a', 'b'));
        $this->assertEquals('h', $stub->doSomething('e', 'f'));
    }
}

Это испытание проходит. Как видите:

• когда функция вызывается с параметрами " a " и "b", возвращается "d"
• когда функция вызывается с параметрами " e " и "f", возвращается "h"

Из того, что я могу сказать, эта функция была введена в PHPUnit 3.6 , так что он достаточно "стар", чтобы его можно было безопасно использовать практически в любой среде разработки или промежуточной среде и с любым инструментом непрерывной интеграции.

Это кажется издевательством (https://github.com/padraic/mockery ) поддерживает это. В моем случае я хочу проверить, что в базе данных созданы 2 индекса:

Издевательство, произведения:

use Mockery as m;

//...

$coll = m::mock(MongoCollection::class);
$db = m::mock(MongoDB::class);

$db->shouldReceive('selectCollection')->withAnyArgs()->times(1)->andReturn($coll);
$coll->shouldReceive('createIndex')->times(1)->with(['foo' => true]);
$coll->shouldReceive('createIndex')->times(1)->with(['bar' => true], ['unique' => true]);

new MyCollection($db);

PHPUnit, это не удается:

$coll = $this->getMockBuilder(MongoCollection::class)->disableOriginalConstructor()->getMock();
$db  = $this->getMockBuilder(MongoDB::class)->disableOriginalConstructor()->getMock();

$db->expects($this->once())->method('selectCollection')->with($this->anything())->willReturn($coll);
$coll->expects($this->atLeastOnce())->method('createIndex')->with(['foo' => true]);
$coll->expects($this->atLeastOnce())->method('createIndex')->with(['bar' => true], ['unique' => true]);

new MyCollection($db);

Издевательство также имеет более приятный синтаксис ИМХО. Это, кажется, немного медленнее, чем встроенная в PHPUnits возможность издеваться, но YMMV.

Вступление

Хорошо, я вижу, что есть одно решение, предусмотренное для насмешки, так как я не люблю насмешки,я собираюсь дать вам альтернативу пророчеству, но я бы предложил вам сначала прочитать о разнице между насмешкой и пророчеством.

Длинная история коротко: "пророчество использует подход, называемыйсвязывание сообщений - это означает, что поведение метода не меняется с течением времени, а скорее изменяется другим методом."

Реальный мир проблемный код для покрытия

class Processor
{
    /**
     * @var MutatorResolver
     */
    private $mutatorResolver;

    /**
     * @var ChunksStorage
     */
    private $chunksStorage;

    /**
     * @param MutatorResolver $mutatorResolver
     * @param ChunksStorage   $chunksStorage
     */
    public function __construct(MutatorResolver $mutatorResolver, ChunksStorage $chunksStorage)
    {
        $this->mutatorResolver = $mutatorResolver;
        $this->chunksStorage   = $chunksStorage;
    }

    /**
     * @param Chunk $chunk
     *
     * @return bool
     */
    public function process(Chunk $chunk): bool
    {
        $mutator = $this->mutatorResolver->resolve($chunk);

        try {
            $chunk->processingInProgress();
            $this->chunksStorage->updateChunk($chunk);

            $mutator->mutate($chunk);

            $chunk->processingAccepted();
            $this->chunksStorage->updateChunk($chunk);
        }
        catch (UnableToMutateChunkException $exception) {
            $chunk->processingRejected();
            $this->chunksStorage->updateChunk($chunk);

            // Log the exception, maybe together with Chunk insert them into PostProcessing Queue
        }

        return false;
    }
}

Решение пророчества PhpUnit

class ProcessorTest extends ChunkTestCase
{
    /**
     * @var Processor
     */
    private $processor;

    /**
     * @var MutatorResolver|ObjectProphecy
     */
    private $mutatorResolverProphecy;

    /**
     * @var ChunksStorage|ObjectProphecy
     */
    private $chunkStorage;

    public function setUp()
    {
        $this->mutatorResolverProphecy = $this->prophesize(MutatorResolver::class);
        $this->chunkStorage            = $this->prophesize(ChunksStorage::class);

        $this->processor = new Processor(
            $this->mutatorResolverProphecy->reveal(),
            $this->chunkStorage->reveal()
        );
    }

    public function testProcessShouldPersistChunkInCorrectStatusBeforeAndAfterTheMutateOperation()
    {
        $self = $this;

        // Chunk is always passed with ACK_BY_QUEUE status to process()
        $chunk = $this->createChunk();
        $chunk->ackByQueue();

        $campaignMutatorMock = $self->prophesize(CampaignMutator::class);
        $campaignMutatorMock
            ->mutate($chunk)
            ->shouldBeCalled();

        $this->mutatorResolverProphecy
            ->resolve($chunk)
            ->shouldBeCalled()
            ->willReturn($campaignMutatorMock->reveal());

        $this->chunkStorage
            ->updateChunk($chunk)
            ->shouldBeCalled()
            ->will(
                function($args) use ($self) {
                    $chunk = $args[0];
                    $self->assertTrue($chunk->status() === Chunk::STATUS_PROCESSING_IN_PROGRESS);

                    $self->chunkStorage
                        ->updateChunk($chunk)
                        ->shouldBeCalled()
                        ->will(
                            function($args) use ($self) {
                                $chunk = $args[0];
                                $self->assertTrue($chunk->status() === Chunk::STATUS_PROCESSING_UPLOAD_ACCEPTED);

                                return true;
                            }
                        );

                    return true;
                }
            );

        $this->processor->process($chunk);
    }
}

Резюме

Еще раз, пророчество более удивительное! Мой трюк заключается в том, чтобы использовать привязку сообщений к пророчеству, и хотя это, к сожалению, выглядит как типичный код javascript для обратного вызова, начиная с $self = $this; поскольку вам очень редко приходится писать модульные тесты, подобные этому, я думаю, что это хорошее решение, и его определенно легко выполнить, отладить, так как оно на самом деле описывает программу. исполнение.

Кстати: есть и вторая альтернатива, но она требует изменения кода, который мы тестируем. Мы могли бы завернуть нарушителей спокойствия и переместить их в отдельный класс:

$chunk->processingInProgress();
$this->chunksStorage->updateChunk($chunk);

Можно обернуть следующим образом:

$processorChunkStorage->persistChunkToInProgress($chunk);

И это все, но поскольку я не хотел создавать для него другой класс, я предпочитаю первый.