test double

Teste duplo

Cansado de lembrar a diferença entre zombadores, parciais e espiões em Mockery? Estou, e é por isso que criei double() - um método auxiliar simples para facilitar o uso do Mockery.

Ao escrever testes, não quero pensar nas diferenças entre fakes , mocks e spies . Eu apenas criei um teste duplo genérico e me concentrei em escrever meu teste. Essa generalização é comum em outras estruturas de teste, como RSpec, td.js e muito mais.

Instalação

Para instalar a versão mais recente do auxiliar double() , execute o comando:

composer require --dev jasonmccreary/test-double

Uso

Sempre que você precisar criar um teste duplo, basta chamar double()

Por padrão, double() retorna um objeto que permitirá que você faça stub de métodos, bem como verifique chamadas de métodos.

 <?php
$ td = double ();

$ td -> shouldReceive ( ' someMethod ' )-> andReturn ( 5 );

$ td -> someMethod ();       // returns 5
$ td -> unstubbedMethod ();  // returns null, does not throw an exception

$ td -> anotherMethod ();
$ td -> shouldHaveReceived ( ' anotherMethod ' );

No Mockery, esse teste duplo é equivalente a Mockery::mock()->shouldIgnoreMissing() ou, em versões recentes, Mockery::spy() .

Você também pode passar double() uma referência para uma classe ou interface. Isto criará um objeto de teste que estende a classe ou implementa a interface. Isso permite que o double passe qualquer dica de tipo ou verificação de tipo em sua implementação.

 <?php
$ td = double (Str::class);

$ td -> shouldReceive ( ' length ' )-> andReturn ( 5 );

$ td -> length ();           // 5
$ td -> substr ( 1 , 3 );       // null

$ td instanceof Str;      // true

$ td -> shouldHaveReceived ( ' substr ' )-> with ( 1 , 3 );

Finalmente, double() aceita um segundo argumento passthru . Por padrão, passthru é false . Quando definido como true , o objeto de teste passará todas as chamadas de método para o objeto subjacente.

No Mockery, isso é equivalente a Mockery::mock(Number::class)->shouldDeferMissing() .

 <?php
class Number
{
    public function one ()
    {
        return 1 ;
    }

    public function random ()
    {
        return 5 ;
    }
}

$ td = double (Number::class, true );

$ td -> shouldReceive ( ' random ' )-> andReturn ( 21 );

$ td -> random ();            // 21
$ td -> one ();               // 1

$ td instanceof Number;    // true

$ td -> shouldHaveReceived ( ' one ' );

Nota: passthru só pode ser usado ao criar um teste duplo com uma referência de classe, pois é o único momento em que existe uma implementação subjacente.

No final das contas, double() é uma forma opinativa de criar objetos de teste para seu código subjacente. Se não atender às suas necessidades, você sempre pode criar um Mockery::mock() diretamente. No entanto, fazer isso provavelmente significa que você está testando sua implementação de uma forma que não reflete o comportamento do mundo real. Lembre-se, double() retorna um objeto que implementa MockeryInterface . Portanto, pode ser tratado como qualquer outro objeto Mockery::mock() .