Use o Mockito para zombar de alguns métodos, mas não de outros

Existe alguma maneira, usando o Mockito, de zombar de alguns métodos de uma classe, mas não de outros?

Por exemplo, nesta Stockclasse (admitidamente inventada) , quero zombar dos valores getPrice()e getQuantity()retornar (como mostrado no trecho de teste abaixo), mas quero getValue()executar a multiplicação conforme codificado na Stockclasse

public class Stock {
  private final double price;
  private final int quantity;

  Stock(double price, int quantity) {
    this.price = price;
    this.quantity = quantity;
  }

  public double getPrice() {
    return price;
  }

  public int getQuantity() {
    return quantity;
  }
  public double getValue() {
    return getPrice() * getQuantity();
  }

  @Test
  public void getValueTest() {
    Stock stock = mock(Stock.class);
    when(stock.getPrice()).thenReturn(100.00);
    when(stock.getQuantity()).thenReturn(200);
    double value = stock.getValue();
    // Unfortunately the following assert fails, because the mock Stock getValue() method does not perform the Stock.getValue() calculation code.
    assertEquals("Stock value not correct", 100.00*200, value, .00001);
}

Para responder diretamente à sua pergunta, sim, você pode zombar de alguns métodos sem zombar de outros. Isso é chamado de simulação parcial . Consulte a documentação do Mockito sobre zombarias parciais para obter mais informações.

Para o seu exemplo, você pode fazer algo como o seguinte, em seu teste:

Stock stock = mock(Stock.class);
when(stock.getPrice()).thenReturn(100.00);    // Mock implementation
when(stock.getQuantity()).thenReturn(200);    // Mock implementation
when(stock.getValue()).thenCallRealMethod();  // Real implementation

Nesse caso, cada implementação de método é zombada, a menos que seja especificado thenCallRealMethod()na when(..)cláusula.

Existe também a possibilidade de o contrário com espião, em vez de simulação :

Stock stock = spy(Stock.class);
when(stock.getPrice()).thenReturn(100.00);    // Mock implementation
when(stock.getQuantity()).thenReturn(200);    // Mock implementation
// All other method call will use the real implementations

Nesse caso, toda a implementação do método é real, exceto se você definiu um comportamento simulado com when(..).

Há uma armadilha importante quando você usa o when(Object)espião, como no exemplo anterior. O método real será chamado (porque stock.getPrice()é avaliado antes when(..)no tempo de execução). Isso pode ser um problema se o seu método contiver lógica que não deve ser chamada. Você pode escrever o exemplo anterior assim:

Stock stock = spy(Stock.class);
doReturn(100.00).when(stock).getPrice();    // Mock implementation
doReturn(200).when(stock).getQuantity();    // Mock implementation
// All other method call will use the real implementations

Outra possibilidade pode ser o uso org.mockito.Mockito.CALLS_REAL_METHODS, como:

Stock MOCK_STOCK = Mockito.mock( Stock.class, CALLS_REAL_METHODS );

Isso delega chamadas não rotuladas para implementações reais.

No entanto, com o seu exemplo, acredito que ainda falhará, já que a implementação getValue()depende quantitye price, em vez de getQuantity()e getPrice(), é o que você zombou.

Outra possibilidade é evitar zombarias por completo:

@Test
public void getValueTest() {
    Stock stock = new Stock(100.00, 200);
    double value = stock.getValue();
    assertEquals("Stock value not correct", 100.00*200, value, .00001);
}

O mocking parcial de uma classe também é suportado via Spy no mockito

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

//optionally, you can stub out some methods:
when(spy.size()).thenReturn(100);

//using the spy calls real methods
spy.add("one");
spy.add("two");

//size() method was stubbed - 100 is printed
System.out.println(spy.size());

Verifique os documentos 1.10.19e 2.7.22para obter explicações detalhadas.

De acordo com os documentos :

Foo mock = mock(Foo.class, CALLS_REAL_METHODS);

// this calls the real implementation of Foo.getSomething()
value = mock.getSomething();

when(mock.getSomething()).thenReturn(fakeValue);

// now fakeValue is returned
value = mock.getSomething();

O que você deseja é de org.mockito.Mockito.CALLS_REAL_METHODSacordo com os documentos:

/**
 * Optional <code>Answer</code> to be used with {@link Mockito#mock(Class, Answer)}
 * <p>
 * {@link Answer} can be used to define the return values of unstubbed invocations.
 * <p>
 * This implementation can be helpful when working with legacy code.
 * When this implementation is used, unstubbed methods will delegate to the real implementation.
 * This is a way to create a partial mock object that calls real methods by default.
 * <p>
 * As usual you are going to read <b>the partial mock warning</b>:
 * Object oriented programming is more less tackling complexity by dividing the complexity into separate, specific, SRPy objects.
 * How does partial mock fit into this paradigm? Well, it just doesn't... 
 * Partial mock usually means that the complexity has been moved to a different method on the same object.
 * In most cases, this is not the way you want to design your application.
 * <p>
 * However, there are rare cases when partial mocks come handy: 
 * dealing with code you cannot change easily (3rd party interfaces, interim refactoring of legacy code etc.)
 * However, I wouldn't use partial mocks for new, test-driven & well-designed code.
 * <p>
 * Example:
 * <pre class="code"><code class="java">
 * Foo mock = mock(Foo.class, CALLS_REAL_METHODS);
 *
 * // this calls the real implementation of Foo.getSomething()
 * value = mock.getSomething();
 *
 * when(mock.getSomething()).thenReturn(fakeValue);
 *
 * // now fakeValue is returned
 * value = mock.getSomething();
 * </code></pre>
 */

Assim, seu código deve se parecer com:

import org.junit.Test;
import static org.mockito.Mockito.*;
import static org.junit.Assert.*;

public class StockTest {

    public class Stock {
        private final double price;
        private final int quantity;

        Stock(double price, int quantity) {
            this.price = price;
            this.quantity = quantity;
        }

        public double getPrice() {
            return price;
        }

        public int getQuantity() {
            return quantity;
        }

        public double getValue() {
            return getPrice() * getQuantity();
        }
    }

    @Test
    public void getValueTest() {
        Stock stock = mock(Stock.class, withSettings().defaultAnswer(CALLS_REAL_METHODS));
        when(stock.getPrice()).thenReturn(100.00);
        when(stock.getQuantity()).thenReturn(200);
        double value = stock.getValue();

        assertEquals("Stock value not correct", 100.00 * 200, value, .00001);
    }
}

A chamada para Stock stock = mock(Stock.class);chamadas org.mockito.Mockito.mock(Class<T>)assim:

 public static <T> T mock(Class<T> classToMock) {
    return mock(classToMock, withSettings().defaultAnswer(RETURNS_DEFAULTS));
}

Os documentos do valor RETURNS_DEFAULTSinformam:

/**
 * The default <code>Answer</code> of every mock <b>if</b> the mock was not stubbed.
 * Typically it just returns some empty value. 
 * <p>
 * {@link Answer} can be used to define the return values of unstubbed invocations. 
 * <p>
 * This implementation first tries the global configuration. 
 * If there is no global configuration then it uses {@link ReturnsEmptyValues} (returns zeros, empty collections, nulls, etc.)
 */

A zombaria parcial usando o método de espionagem do Mockito pode ser a solução para o seu problema, como já indicado nas respostas acima. Até certo ponto, concordo que, para o seu caso de uso concreto, talvez seja mais apropriado zombar da pesquisa do banco de dados. Pela minha experiência, isso nem sempre é possível - pelo menos não sem outras soluções alternativas - que consideraria muito complicadas ou pelo menos frágeis. Observe que essa zombaria parcial não funciona com versões aliadas do Mockito. Você usou pelo menos 1.8.0.

Eu teria acabado de escrever um comentário simples para a pergunta original, em vez de postar esta resposta, mas o StackOverflow não permite isso.

Só mais uma coisa: eu realmente não consigo entender que muitas vezes uma pergunta está sendo feita aqui, com o comentário "Por que você quer fazer isso" sem ao menos tentar entender o problema. Especialmente quando se trata de zombar parcialmente, há muitos casos de uso que eu poderia imaginar onde seria útil. É por isso que os caras da Mockito forneceram essa funcionalidade. Obviamente, esse recurso não deve ser usado em excesso. Mas quando falamos sobre configurações de casos de teste que de outra forma não poderiam ser estabelecidas de uma maneira muito complicada, a espionagem deve ser usada.