Questão de Engenharia de Software — Geral — FCC 2024

Teste de Software: Mockito

Gabarito: letra E. O Mockito é um framework de mocking para testes unitários em Java, e seus elementos centrais são as anotações @Mock, @InjectMocks e @Spy, além dos métodos when(), thenReturn() e verify(). As demais alternativas misturam elementos de outros frameworks ou de anotações do JUnit 5, que não fazem parte do Mockito.

O Mockito é uma ferramenta essencial para testes unitários, permitindo criar objetos simulados (mocks) para isolar a unidade de código que está sendo testada. Com ele, o desenvolvedor pode simular o comportamento de dependências externas, como bancos de dados, serviços web ou outras classes, sem precisar instanciá-las de fato. Isso é fundamental para testar uma classe de forma isolada, focando apenas na sua lógica interna.

Os principais elementos do Mockito são:

• @Mock: anotação que cria um objeto mock de uma classe ou interface. O mock é um objeto "falso" que não possui a implementação real, mas pode ter seu comportamento definido pelo testador.

• @InjectMocks: anotação que injeta os mocks criados com @Mock (ou @Spy) na classe que está sendo testada. O Mockito tenta injetar por construtor, setter ou campo, nessa ordem.

• @Spy: anotação que cria um objeto spy, que é um objeto real, mas que permite que alguns de seus métodos sejam "espionados" ou tenham seu comportamento alterado (stubbed). Diferente do mock, o spy mantém o comportamento real dos métodos não stubbed.

• when(): método estático usado para definir o comportamento de um mock ou spy. Por exemplo, when(mock.metodo()).thenReturn(valor) define que, quando o método metodo() for chamado no mock, ele deve retornar valor.

• thenReturn(): método usado em conjunto com when() para especificar o valor de retorno de um método mockado.

• verify(): método estático usado para verificar se um método de um mock ou spy foi chamado um determinado número de vezes. Por exemplo, verify(mock, times(1)).metodo() verifica se o método metodo() foi chamado exatamente uma vez.

É importante distinguir o Mockito do JUnit, que é o framework de testes mais comum em Java. O JUnit fornece anotações como @Test, @BeforeEach, @AfterEach, @BeforeAll e @AfterAll, que são usadas para estruturar os testes, mas não são elementos do Mockito. A confusão entre esses dois frameworks é uma pegadinha clássica em provas de concursos.

A banca explora exatamente essa confusão: misturar anotações do JUnit com elementos do Mockito. A alternativa correta é a única que contém apenas elementos do Mockito, sem nenhuma anotação do JUnit. As demais alternativas incluem anotações do JUnit 5, como @Test, @BeforeEach, @AfterEach, @BeforeAll e @AfterAll, que não fazem parte do Mockito.

Alternativa A — ❌ Incorreta

Inclui @Test e AftertEach (que seria @AfterEach), que são anotações do JUnit, não do Mockito. Além disso, @Mock, @InjectMocks e @Spy são do Mockito, mas a presença das anotações do JUnit torna a alternativa incorreta.

Alternativa B — ❌ Incorreta

Inclui @BeforeAll e @AfterAll, que são anotações do JUnit 5, não do Mockito. Os métodos when(), thenReturn() e verify() são do Mockito, mas a mistura com anotações do JUnit invalida a alternativa.

Alternativa C — ❌ Incorreta

Todas as anotações listadas (@Test, @BeforeEach, @AfterEach, @BeforeAll, @AfterAll) são do JUnit, não do Mockito. Nenhum elemento do Mockito está presente.

Alternativa D — ❌ Incorreta

Inclui @Test, @BeforeEach e @AfterEach, que são anotações do JUnit, não do Mockito. Embora @Mock, @InjectMocks e @Spy sejam do Mockito, a presença das anotações do JUnit torna a alternativa incorreta.

Alternativa E — ✅ Correta ⟵ GABARITO

Todos os elementos listados (when(), thenReturn(), verify(), @Mock, @InjectMocks e @Spy) são elementos do Mockito. Esta é a única alternativa que contém exclusivamente elementos do framework de mocking, sem misturar anotações do JUnit.

Gabarito: letra E