Hacemos una revisión completa cada escrito en nuestro sitio web con el objetivo de mostrarte siempre la información certera y actualizada.
Solución:
Para responder directamente a su pregunta, sí, puede burlarse de algunos métodos sin burlarse de otros. Esto se llama un simulacro parcial. Consulte la documentación de Mockito sobre simulacros parciales para obtener más información.
Para su ejemplo, puede hacer algo como lo siguiente, en su prueba:
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
En ese caso, se simula cada implementación del método, a menos que se especifique thenCallRealMethod() en el when(..) cláusula.
También existe la posibilidad al revés con espiar en lugar de burlarse de:
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
En ese caso, toda la implementación del método es la real, excepto si ha definido un comportamiento simulado con when(..).
Hay un escollo importante cuando usas when(Object) con spy como en el ejemplo anterior. El método real será llamado (porque stock.getPrice() se evalúa antes when(..) en tiempo de ejecución). Esto puede ser un problema si su método contiene lógica a la que no se debe llamar. Puedes escribir el ejemplo anterior así:
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
Otra posibilidad puede ser utilizar org.mockito.Mockito.CALLS_REAL_METHODStal como:
Stock MOCK_STOCK = Mockito.mock( Stock.class, CALLS_REAL_METHODS );
Esto delega las llamadas no conectadas a implementaciones reales.
Sin embargo, con su ejemplo, creo que todavía fallará, ya que la implementación de getValue() se basa en quantity y priceen vez de getQuantity() y getPrice()que es de lo que te has burlado.
Otra posibilidad es evitar las simulaciones 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);
La simulación parcial de una clase también se admite a través de Espiar en maqueta
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());
Comprobar el 1.10.19 y 2.7.22 docs para una explicación detallada.
Según los 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();