Questão de Engenharia de Software — Teste de Software — Avança SP 2023

Níveis de Teste de Software: Unitário, Integração e Ponta a Ponta

Gabarito: letra D. Estão corretas as afirmativas I, II e IV: os testes de integração vêm após os unitários (I), os testes de ponta a ponta simulam o ambiente de produção (II) e os testes unitários operam no nível mais baixo, próximo ao código-fonte, sendo realizados pelos programadores (IV). A afirmativa III está incorreta porque inverte o conceito: quem verifica as menores unidades isoladamente é o teste unitário, não o de integração.

Os testes de software são organizados em níveis, cada um com um escopo e um objetivo específico. A sequência clássica começa no nível mais granular — o teste unitário, que valida uma unidade isolada do código (uma função, um método, uma classe) — e progride para o teste de integração, que combina essas unidades já testadas para verificar se elas funcionam em conjunto, especialmente nas interfaces entre elas. Depois vêm o teste de sistema, que avalia o sistema completo como um todo, e o teste de aceitação, que verifica se o sistema atende aos requisitos do usuário final.

A lógica dessa ordem é incremental: primeiro garante-se que cada peça funciona sozinha, depois que as peças se encaixam, depois que o conjunto completo opera corretamente e, por fim, que o produto entrega o valor esperado ao cliente. É por isso que a afirmativa I está correta — o ideal é realizar os testes de integração após os unitários, pois integrar unidades defeituosas dificulta a identificação da origem dos problemas.

Os testes de ponta a ponta (end-to-end) simulam o fluxo completo de uma atividade do usuário final, percorrendo todas as camadas do sistema (interface, serviços, banco de dados), em um ambiente preparado para ser o mais semelhante possível ao de produção. Eles validam o comportamento do sistema como o usuário o experimentaria, mas em um ambiente controlado, sem os riscos de um ambiente real. A afirmativa II captura exatamente essa essência.

A afirmativa III é a pegadinha da questão: ela atribui ao teste de integração a função de verificar as menores unidades isoladamente, quando isso é justamente o papel do teste unitário. A banca inverteu os conceitos. Já a afirmativa IV está correta ao afirmar que os testes unitários são feitos em um nível muito baixo, próximo ao código-fonte, e que geralmente são realizados pelos próprios programadores, pois exigem conhecimento profundo da implementação.

Guarde a fronteira entre o que cada nível testa: unitário = unidade isolada; integração = interação entre unidades; sistema = sistema completo; aceitação = requisitos do usuário. É exatamente nessa fronteira que as alternativas se dividem.

Item I — ✅ Correto

A afirmativa está correta. A ordem natural dos testes é do nível mais baixo para o mais alto: primeiro os testes unitários, para garantir que cada unidade está correta individualmente, e depois os testes de integração, para verificar que as unidades funcionam em conjunto. Essa sequência é amplamente aceita na engenharia de software, pois isola falhas de implementação (unidade) de falhas de interface (integração).

Item II — ✅ Correto

A afirmativa está correta. Os testes de ponta a ponta (end-to-end) simulam a atividade que o usuário final teria, mas em um ambiente preparado para ser muito semelhante ao de produção. Eles percorrem todo o fluxo do sistema, validando a experiência completa do usuário, desde a interface até as camadas de serviço e dados.

Item III — ❌ Incorreto

A afirmativa está incorreta. Ela inverte o conceito: verificar as menores unidades isoladamente, garantindo que a lógica de cada uma está correta, é a definição de teste unitário, não de teste de integração. O teste de integração tem como objetivo verificar a interação entre unidades já testadas, descobrindo erros associados às interfaces. A banca trocou os papéis dos dois níveis.

Item IV — ✅ Correto

A afirmativa está correta. Os testes unitários são feitos em um nível muito baixo, próximo ao código-fonte, testando funções, métodos ou classes individualmente. Por essa proximidade com a implementação, geralmente são os próprios programadores que os realizam, pois precisam entender profundamente o código para criar os casos de teste.

Conclusão: Corretos: I, II e IV → portanto a alternativa é a letra D.

Gabarito: letra D