Mockito - diferença entre doReturn () e quando ()

Atualmente, estou no processo de usar o Mockito para simular meus objetos da camada de serviço em um aplicativo Spring MVC no qual desejo testar meus métodos do Controller. No entanto, como eu tenho lido sobre as especificidades do Mockito, descobri que os métodos doReturn(...).when(...)são equivalentes when(...).thenReturn(...). Então, minha pergunta é: qual é o sentido de ter dois métodos que fazem a mesma coisa ou qual é a diferença sutil entre doReturn(...).when(...)ewhen(...).thenReturn(...) ?

Qualquer ajuda seria apreciada.

As duas sintaxes para stub são aproximadamente equivalentes. No entanto, você sempre pode usar doReturn/whenpara stubbing; mas há casos em que você não pode usar when/thenReturn. Stubbing void methods é um desses. Outros incluem o uso de espiões de Mockito e a remoção do mesmo método mais de uma vez.

Uma coisa que when/thenReturnte dá, quedoReturn/when e não fornece, é a verificação de tipo do valor que você está retornando, no momento da compilação. No entanto, acredito que isso quase não tem valor - se você errou o tipo, descobrirá assim que executar o teste.

Eu recomendo fortemente apenas o uso doReturn/when. Não há sentido em aprender duas sintaxes quando uma delas funciona.

Você pode consultar a minha resposta em Formando Mockito "gramáticas" - uma resposta mais detalhada a uma questão muito relacionada.

Ambas as abordagens se comportam de maneira diferente se você usar um objeto espionado (anotado com @Spy) em vez de um mock (anotado com @Mock):

• when(...) thenReturn(...) faz uma chamada de método real pouco antes do valor especificado ser retornado. Portanto, se o método chamado lança uma exceção, você precisa lidar com isso / zombar etc. É claro que você ainda obtém seu resultado (o que você define thenReturn(...))

• doReturn(...) when(...) não chama o método .

Exemplo:

public class MyClass {
     protected String methodToBeTested() {
           return anotherMethodInClass();
     }

     protected String anotherMethodInClass() {
          throw new NullPointerException();
     }
}

Teste:

@Spy
private MyClass myClass;

// ...

// would work fine
doReturn("test").when(myClass).anotherMethodInClass();

// would throw a NullPointerException
when(myClass.anotherMethodInClass()).thenReturn("test");

O javadoc do Mockito parece dizer por que usar em doReturn()vez de when() Usar doReturn () nas raras ocasiões em que você não pode usar o Mockito.when (Object).

Lembre-se de que Mockito.when (Object) é sempre recomendado para stubbing porque é seguro para o tipo de argumento e mais legível (especialmente ao stubing de chamadas consecutivas).

Aqui estão aquelas raras ocasiões em que doReturn () é útil:

1. Espiar objetos reais e chamar métodos reais em um espião traz efeitos colaterais

List list = new LinkedList(); List spy = spy(list);

// Impossível: método real é chamado para que spy.get (0) lança IndexOutOfBoundsException (a lista ainda está vazia)

when(spy.get(0)).thenReturn("foo");

// Você precisa usar doReturn () para stub: doReturn("foo").when(spy).get(0);

2. Substituindo um stub de exceção anterior:

when(mock.foo()).thenThrow(new RuntimeException());

// Impossível: o método foo () com exceção de stubbed é chamado para que RuntimeException seja lançada. when(mock.foo()).thenReturn("bar");

// Você precisa usar doReturn () para stub:

doReturn("bar").when(mock).foo(); Os cenários acima mostram uma troca da elegante sintaxe de Mockito. Observe que os cenários são muito raros, no entanto. A espionagem deve ser esporádica e a substituição de exceções é muito rara. Sem mencionar que, em geral, a substituição de stubbing é um cheiro de código em potencial que aponta muitos stubbing.

Continuando com esta resposta , há outra diferença: se você deseja que seu método retorne valores diferentes, por exemplo, quando é chamado pela primeira vez, chamado pela segunda vez, etc., você pode passar valores, por exemplo ...

PowerMockito.doReturn(false, false, true).when(SomeClass.class, "SomeMethod", Matchers.any(SomeClass.class));

Portanto, ele retornará falso quando o método for chamado no mesmo caso de teste e, em seguida, retornará falso novamente e, finalmente, verdadeiro.

A última alternativa é usada para métodos em zombarias que retornam void .

Por favor, dê uma olhada, por exemplo, aqui: Como criar métodos mock to void com mockito