Questão de Engenharia de Software — Conceitos e Tipos de Testes de Software — FCC 2025

Testes de software: unitário, integração, funcional e ferramentas (JUnit e Mockito)

Gabarito: letra E. O uso conjunto de JUnit e Mockito permite criar testes unitários eficazes, pois o Mockito simula o comportamento de dependências externas (mocks), isolando a unidade testada — exatamente o que a alternativa E afirma. As demais alternativas distorcem conceitos fundamentais: testes de integração não são substituídos por unitários, testes funcionais não são equivalentes a unitários, Mockito não é ferramenta de teste funcional de interface, e cobertura de código não garante ausência de erros.

Para entender a questão, é preciso dominar a hierarquia dos níveis de teste e o papel de cada ferramenta. Os testes unitários (ou de unidade, componente ou módulo) focam na menor parte testável do software — um método, uma função ou uma classe —, verificando se essa unidade isolada se comporta conforme o esperado. Já os testes de integração verificam a interação entre dois ou mais módulos, garantindo que eles funcionem corretamente quando combinados. Os testes funcionais (ou de sistema, caixa-preta) validam o sistema como um todo, a partir das entradas e saídas, sem se preocupar com a implementação interna — simulam o uso real pelo usuário.

A cobertura de código é uma métrica que indica a porcentagem de linhas, branches ou caminhos do código que foram executados durante os testes. Ela é uma ferramenta valiosa para identificar partes não testadas, mas não garante a ausência de erros: mesmo com 100% de cobertura, podem existir defeitos lógicos, de integração ou de requisitos que não foram capturados. A cobertura mede o que foi executado, não se o comportamento está correto.

As ferramentas JUnit e Mockito são complementares no contexto de testes unitários em Java. O JUnit é o framework de testes que fornece a estrutura para escrever e executar os casos de teste, com anotações como @Test, @BeforeEach e @AfterEach. O Mockito é uma biblioteca de mocking que permite criar objetos simulados (mocks) de dependências externas — como bancos de dados, serviços web ou outras classes —, de modo que o teste da unidade fique isolado e não dependa do comportamento real dessas dependências. Essa combinação é a prática padrão para testes unitários eficazes.

A pegadinha central da questão está na troca de papéis entre os tipos de teste e as ferramentas. A banca explora a confusão comum entre:

Guarde essa distinção: é exatamente nela que as alternativas se dividem. A alternativa correta é a única que associa corretamente as ferramentas ao seu propósito real.

Alternativa A — ❌ Incorreta

Afirma que testes de integração são substituídos por testes unitários, pois ambos focam na menor parte testável. Há dois erros: (1) testes de integração não são substituídos por unitários — eles são complementares e verificam a interação entre módulos, algo que o teste unitário não cobre; (2) o foco do teste de integração não é a menor parte testável, mas sim a integração entre partes. O teste unitário é que foca na menor unidade (método, classe).

Alternativa B — ❌ Incorreta

Afirma que testes funcionais são equivalentes a testes unitários, pois ambos validam métodos específicos. Erro duplo: testes funcionais validam o sistema como um todo (funcionalidades, entradas e saídas), enquanto testes unitários validam métodos específicos dentro de classes. São níveis distintos e não equivalentes.

Alternativa C — ❌ Incorreta

Afirma que Mockito é uma ferramenta para testes funcionais que simula interações de usuários com a interface. Mockito é uma biblioteca de mocking para testes unitários, que simula o comportamento de dependências externas (objetos, serviços), não interações de usuário com interface. Ferramentas de teste funcional de interface seriam Selenium, Cypress, entre outras.

Alternativa D — ❌ Incorreta

Afirma que a cobertura de código garante que o sistema está livre de erros, desde que atinja 100% de linhas executadas. A cobertura de código é uma métrica que indica quais linhas foram executadas, mas não garante a ausência de erros. Mesmo com 100% de cobertura, podem existir defeitos lógicos, de integração, de requisitos ou de performance que não são detectados. A cobertura é um indicador de quanto foi testado, não de qualidade do teste.

Alternativa E — ✅ Correta ⟵ GABARITO

Afirma que o uso conjunto de JUnit e Mockito permite criar testes unitários eficazes, simulando comportamentos de dependências externas para isolar a unidade testada. Isso está correto: o JUnit fornece a estrutura para escrever e executar os testes, e o Mockito cria mocks das dependências, permitindo que o teste da unidade seja isolado e não dependa de componentes externos (banco de dados, serviços, etc.). Essa é a prática padrão para testes unitários eficazes.

Gabarito: letra E