La anotación @Spy en JUnit, particularmente cuando se usa con Mockito, se aplica para crear un espía en un objeto real. Un espía es una simulación parcial, lo que significa que puedes simular algunos métodos del objeto manteniendo el comportamiento real de otros métodos.

Estos son algunos usos comunes de la anotación @Spy:

1. Burla parcial:

   • Si tienes un objeto donde la mayoría de los métodos necesitan conservar su comportamiento real pero es necesario burlarse de uno o dos métodos, puedes usar un espía.
   • Ejemplo:

    @Spy
    private List spyList = new ArrayList();
   
    @Test
    public void testSpy() {
        spyList.add("Mockito");
        Mockito.verify(spyList).add("Mockito");
        assertEquals(1, spyList.size());
   
        Mockito.doReturn(100).when(spyList).size();
        assertEquals(100, spyList.size());
    }
   

2. Anulación del comportamiento del método real:

   • Puedes usar un espía para anular el comportamiento de un método específico de un objeto real mientras mantienes el resto de los métodos intactos.
   • Ejemplo:

    @Spy
    private MyClass myClass = new MyClass();
   
    @Test
    public void testSpyWithMethodOverride() {
        Mockito.doReturn("Mocked Value").when(myClass).someMethod();
        assertEquals("Mocked Value", myClass.someMethod());
    }
   

3. Verificación de llamadas a métodos:

   • Puedes verificar si se invocaron ciertos métodos en el espía, lo cual es útil al probar interacciones.
   • Ejemplo:

    @Spy
    private MyClass myClass = new MyClass();
   
    @Test
    public void testMethodCallVerification() {
        myClass.someMethod();
        Mockito.verify(myClass).someMethod();
    }
   

4. Combinando con @InjectMocks:

   • @Spy se puede utilizar junto con @InjectMocks para inyectar objetos espiados en el objeto que se está probando, lo que permite una burla parcial dentro de la clase probada.
   • Ejemplo:

    @Spy
    private MyDependency dependency;
   
    @InjectMocks
    private MyService service;
   
    @Test
    public void testService() {
        Mockito.doReturn("Mocked Result").when(dependency).doSomething();
        assertEquals("Mocked Result", service.performAction());
    }
   

5. Prueba del código heredado:

   • Cuando se trata de código heredado que no se puede refactorizar fácilmente, el uso de un espía le permite aislar y simular métodos específicos sin cambiar el código original.

En resumen, la anotación @Spy es útil cuando necesitas controlar o verificar comportamientos específicos de un objeto real mientras mantienes el resto del comportamiento del objeto sin cambios.