Pular para o conteúdo principal

Questão de Engenharia de Software — Desenvolvimento de Software — INSTITUTO AOCP 2023

Engenharia de SoftwareDesenvolvimento 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.
  1. AEscrever o teste, escrever o código, executar o teste, refatorar e, por fim, integrar o código ao repositório principal.
  2. BEscrever o código, executar o teste, escrever o teste, refatorar e, por fim, integrar o código ao repositório principal.
  3. 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.
  4. DEscrever o código, escrever o teste, executar o teste, refatorar e, por fim, integrar o código ao repositório principal.
  5. 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:

  1. 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.

  2. 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.

  3. 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.

  1. 1Escrever o teste
  2. 2Executar (falha)
  3. 3Escrever o código
  4. 4Executar (passa)
  5. 5Refatorar
  6. 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.

Gabarito: letra C

Link permanente: /questoes/qq971005