Burlarse contra espiar en marcos burlones

En los frameworks burlones, puedes burlarte de un objeto o espiarlo . ¿Cuál es la diferencia entre los dos y cuándo usaría / debería usar uno sobre el otro?

Al observar a Mockito , por ejemplo, veo que se hacen cosas similares usando espías y simulacros , pero no estoy seguro de la distinción entre los dos.

El objeto simulado reemplaza completamente la clase simulada, devolviendo valores grabados o predeterminados. Puede crear simulacros de "aire fino". Esto es lo que se usa principalmente durante las pruebas unitarias.

Cuando espías, tomas un objeto existente y "reemplazas" solo algunos métodos. Esto es útil cuando tienes una gran clase y solo quieres burlarte de ciertos métodos (burla parcial). Permítanme citar la documentación de Mockito :

Puedes crear espías de objetos reales. Cuando usa el espía , se llaman los métodos reales (a menos que se haya tropezado con un método).

Los espías reales deben usarse con cuidado y ocasionalmente , por ejemplo, cuando se trata de código heredado.

En caso de duda, use simulacros.

Mockito advierte que la burla parcial no es una buena práctica y debe revisar su arquitectura orientada a objetos. Se recomienda espiar (o burla parcial) para probar el código heredado .

Trataré de explicar usando un ejemplo aquí:

// Difference between mocking, stubbing and spying
@Test
public void differenceBetweenMockingSpyingAndStubbing() {
    List list = new ArrayList();
    list.add("abc");
    assertEquals(1, list.size());

    List mockedList = spy(list);
    when(mockedList.size()).thenReturn(10);
    assertEquals(10, mockedList.size());
}

Aquí, teníamos un objeto real inicial list, en el que agregamos un elemento y esperamos que el tamaño sea uno.

Nos espía significado objeto real que podemos instruir a qué método se apagó . Por lo tanto, declaramos que aplicamos el método, size()en un objeto espía que devolverá 10, sin importar el tamaño real.

En pocas palabras, espiarás objetos reales y tropezarás con algunos de los métodos .

Referencia: http://javapointers.com/tutorial/difference-between-spy-and-mock-in-mockito/

Cuando se utilizan objetos simulados, el comportamiento predeterminado del método cuando no es stub es no hacer nada. Simple significa que si es un método nulo, no hará nada cuando llame al método o si es un método con un retorno, entonces puede devolver un valor nulo, vacío o predeterminado.

Mientras está en objetos espía, por supuesto, dado que es un método real, cuando no está tropezando con el método, llamará al comportamiento real del método. Si desea cambiar y burlarse del método, entonces debe tropezarlo.

Los objetos ficticios se pasan pero nunca se usan realmente. Por lo general, solo se usan para completar listas de parámetros.

Los objetos falsos en realidad tienen implementaciones que funcionan, pero generalmente toman un atajo que los hace no adecuados para la producción (una base de datos en memoria es un buen ejemplo).

Los talones proporcionan respuestas enlatadas a las llamadas realizadas durante la prueba, por lo general no responden en absoluto a nada fuera de lo programado para la prueba.

Los espías son trozos que también registran cierta información en función de cómo fueron llamados. Una forma de esto podría ser un servicio de correo electrónico que registra cuántos mensajes se envió.

Estamos hablando de simulacros : objetos preprogramados con expectativas que forman una especificación de las llamadas que se espera que reciban.

Las burlas no son trozos de Martin Fowler

Los espías tienen dos definiciones. Uno, es donde se llama al método real, otro donde no se llama a ninguna funcionalidad y solo se devuelven valores nulos o equivalentes nulos, pero se llamaron a los métodos y se registró su estado, comúnmente, como el método x se llamó y veces.

En Mockito, si asigna cualquier objeto a la variable de instancia de Mock Object, entonces no afecta a Mock Object.

Pero en el caso de Spy, si asigna cualquier objeto a una variable de instancia de Spy Object, entonces sí afecta a Spy Object debido a que Spy actúa como una modificación de objeto en tiempo real.

Para un ejemplo de referencia son

@RunWith(MockitoJUnitRunner.class)
public class MockSpyExampleTest {

    @Mock
    private List<String> mockList;

    @Spy
    private List<String> spyList = new ArrayList();

    @Test
    public void testMockList() {
        //by default, calling the methods of mock object will do nothing
        mockList.add("test");
        assertNull(mockList.get(0));
    }

    @Test
    public void testSpyList() {
        //spy object will call the real method when not stub
        spyList.add("test");
        assertEquals("test", spyList.get(0));
    }
}