Questão de Engenharia de Software — Desenvolvimento de Software — INSTITUTO AOCP 2023
Engenharia de Software›Desenvolvimento de Software
Código
qq971005
Banca
INSTITUTO AOCP
Órgão
IF-MA
Ano
2023
Nível
Superior
Cargo
Analista De Tecnologia Da Informação - Desenvolvimento De Sistemas
Maria está trabalhando em um projeto de desenvolvimento de software e decide adotar a abordagem do Test Driven Development (TDD) para melhorar a qualidade do código e a colaboração entre os membros da equipe. Ela começa a implementar uma nova funcionalidade seguindo os princípios do TDD. Assinale a alternativa que apresenta corretamente o processo que Maria deve seguir.
AEscrever o teste, escrever o código, executar o teste, refatorar e, por fim, integrar o código ao repositório principal.
BEscrever o código, executar o teste, escrever o teste, refatorar e, por fim, integrar o código ao repositório principal.
CEscrever o teste, executar o teste, escrever o código, executar o teste novamente, refatorar e, por fim, integrar o código ao repositório principal.
DEscrever o código, escrever o teste, executar o teste, refatorar e, por fim, integrar o código ao repositório principal.
EEscrever o teste, escrever o código, executar o teste, integrar o código ao repositório principal e, por fim, refatorar.
Revelar gabarito e comentário▾
GabaritoC — Escrever o teste, executar o teste, escrever o código, executar o teste novamente, refatorar e, por fim, integrar o código ao repositório principal.
Comentário gerado por IA. É um apoio ao estudo, ancorado em fontes, mas pode conter imprecisões — confira sempre na fonte oficial (lei, súmula, edital e gabarito da banca). Encontrou um erro? Use “Reportar”.
Test-Driven Development (TDD): o ciclo Red-Green-Refactor
Gabarito: letra C. No TDD, o processo correto é: escrever o teste, executá-lo (e vê-lo falhar), escrever o código para passar no teste, executar o teste novamente (e vê-lo passar), refatorar e, por fim, integrar o código ao repositório principal. A alternativa C é a única que descreve fielmente o ciclo completo, incluindo a execução do teste antes e depois da codificação, além da refatoração antes da integração.
O Test-Driven Development (TDD), ou Desenvolvimento Guiado por Testes, é uma técnica de desenvolvimento de software que inverte a ordem tradicional: em vez de escrever o código e depois testá-lo, o desenvolvedor escreve primeiro um teste automatizado que define o comportamento desejado de uma nova funcionalidade. Esse teste, inicialmente, deve falhar, pois a funcionalidade ainda não existe. Em seguida, escreve-se o código mínimo necessário para fazer o teste passar. Depois, com o teste verde, o código é refatorado para melhorar sua estrutura interna sem alterar seu comportamento externo. Esse ciclo é conhecido como Red-Green-Refactor e é repetido em incrementos muito pequenos, garantindo que cada nova funcionalidade seja validada continuamente.
A essência do TDD está em três fases principais, que se repetem a cada iteração:
Red (Vermelho): Escrever um teste que falha. O teste define o comportamento esperado da nova funcionalidade. Nesta fase, o teste é executado e deve falhar, confirmando que a funcionalidade ainda não existe.
Green (Verde): Escrever o código mínimo necessário para fazer o teste passar. O objetivo é apenas satisfazer o teste, sem se preocupar com a qualidade do código nesta etapa.
Refactor (Refatorar): Melhorar a estrutura do código, eliminando duplicações e melhorando a legibilidade, mantendo todos os testes verdes. A refatoração é uma etapa crucial, pois garante que o código evolua de forma limpa e sustentável.
Após a refatoração, o ciclo recomeça com um novo teste para a próxima funcionalidade ou melhoria. A integração ao repositório principal ocorre após a conclusão do ciclo, quando o código está estável e todos os testes passam.
A banca explora a confusão entre a ordem dos passos, especialmente a necessidade de executar o teste antes de escrever o código e a importância da refatoração. Muitos candidatos podem pensar que o teste é escrito após o código, ou que a refatoração pode ser feita após a integração, o que está incorreto. O TDD é uma prática que exige disciplina e a sequência correta é fundamental para seus benefícios.
Guarde a sequência exata do ciclo TDD: teste → executa (falha) → código → executa (passa) → refatora → integra. É exatamente essa ordem que as alternativas tentam distorcer.
1Escrever o teste
2Executar (falha)
3Escrever o código
4Executar (passa)
5Refatorar
6Integrar
LEVEL · soulevel.com.br
Alternativa A — ❌ Incorreta
A alternativa A afirma que o processo é: escrever o teste, escrever o código, executar o teste, refatorar e integrar. O erro está em não executar o teste antes de escrever o código. No TDD, o teste deve ser escrito e executado (e falhar) antes da codificação, para confirmar que o teste é válido e que a funcionalidade ainda não existe. A ordem correta exige a execução do teste logo após escrevê-lo, e não apenas depois de escrever o código.
Alternativa B — ❌ Incorreta
A alternativa B inverte completamente a ordem: escrever o código, executar o teste, escrever o teste, refatorar e integrar. Isso contraria o princípio fundamental do TDD, que é escrever o teste antes do código. Escrever o código primeiro e depois o teste é a abordagem tradicional, não o TDD. Além disso, a execução do teste antes de escrevê-lo é essencial para validar o teste.
Alternativa C — ✅ Correta ⟵ GABARITO
A alternativa C descreve corretamente o ciclo TDD: escrever o teste, executar o teste (e vê-lo falhar), escrever o código, executar o teste novamente (e vê-lo passar), refatorar e, por fim, integrar o código ao repositório principal. Essa sequência segue exatamente o ciclo Red-Green-Refactor, com a execução do teste antes e depois da codificação, e a refatoração antes da integração. É a única alternativa que apresenta o processo completo e na ordem correta.
Alternativa D — ❌ Incorreta
A alternativa D também inverte a ordem: escrever o código, escrever o teste, executar o teste, refatorar e integrar. O erro é o mesmo da alternativa B: escrever o código antes do teste. No TDD, o teste deve ser escrito primeiro, e o código deve ser escrito para satisfazer o teste. A ordem apresentada é a do desenvolvimento tradicional, não do TDD.
Alternativa E — ❌ Incorreta
A alternativa E apresenta a ordem: escrever o teste, escrever o código, executar o teste, integrar o código ao repositório principal e, por fim, refatorar. O erro está em colocar a refatoração após a integração. No TDD, a refatoração deve ocorrer antes da integração, para garantir que o código esteja limpo e estável antes de ser integrado ao repositório principal. Além disso, a alternativa não menciona a execução do teste antes de escrever o código, o que é essencial no ciclo.