A anotação @Spy no JUnit, especialmente quando usada com Mockito, é aplicada para criar um espião em um objeto real. Um espião é uma simulação parcial, o que significa que você pode simular alguns métodos do objeto enquanto mantém o comportamento real de outros métodos.

Aqui estão alguns usos comuns da anotação @Spy:

1. Zombaria parcial:

   • Se você tiver um objeto onde a maioria dos métodos precisa manter seu comportamento real, mas um ou dois métodos precisam ser ridicularizados, você pode usar um espião.
   • Exemplo:

    @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. Substituindo o comportamento do método real:

   • Você pode usar um espião para substituir o comportamento de um método específico de um objeto real, mantendo o restante dos métodos intactos.
   • Exemplo:

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

3. Verificando chamadas de método:

   • Você pode verificar se determinados métodos foram chamados no espião, o que é útil ao testar interações.
   • Exemplo:

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

4. Combinando com @InjectMocks:

   • @Spy pode ser usado em conjunto com @InjectMocks para injetar objetos espionados no objeto que está sendo testado, permitindo zombaria parcial dentro da classe testada.
   • Exemplo:

    @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. Testando código legado:

   • Ao lidar com código legado que você não pode refatorar facilmente, usar um espião permite isolar e simular métodos específicos sem alterar o código original.

Em resumo, a anotação @Spy é útil quando você precisa controlar ou verificar comportamentos específicos de um objeto real enquanto mantém o restante do comportamento do objeto inalterado.