Devo interromper intencionalmente a compilação quando um bug é encontrado na produção?

Parece-me razoável que, se um erro sério for encontrado na produção pelos usuários finais, um teste de unidade com falha deve ser adicionado para cobrir esse erro, interrompendo intencionalmente a construção até que o bug seja corrigido. Minha justificativa para isso é que a compilação deveria ter falhado o tempo todo , mas não se devia à cobertura inadequada de testes automatizados.

Vários de meus colegas discordaram dizendo que um teste de unidade com falha não deveria ser verificado. Concordo com esse ponto de vista em termos de práticas normais de TDD, mas acho que os erros de produção devem ser tratados de maneira diferente - afinal, por que você deseja permitir uma compilação para ter sucesso com defeitos conhecidos?

Alguém mais tem estratégias comprovadas para lidar com esse cenário? Entendo que a interrupção intencional da compilação pode ser perturbadora para outros membros da equipe, mas isso depende inteiramente de como você está usando filiais.

Nossa estratégia é:

Faça o check-in de um teste com falha, mas anote-o com @Ignore("fails because of Bug #1234").

Dessa forma, o teste está lá, mas a compilação não quebra.

É claro que você observa o teste ignorado no db do bug; portanto, ele @Ignoreé removido assim que o teste é corrigido. Isso também serve como uma verificação fácil para a correção de erros.

O ponto de interromper a construção de falhas nos testes não é de alguma forma colocar a equipe sob pressão - é alertá-los para um problema. Depois que o problema é identificado e arquivado no banco de dados de erros, não faz sentido que o teste seja executado para cada build - você sabe que ele falhará.

Obviamente, o bug ainda deve ser corrigido. Mas agendar a correção é uma decisão comercial e, portanto, não é realmente uma preocupação do desenvolvedor ... Para mim, uma vez que um bug é arquivado no banco de dados do bug, ele não é mais problema meu, até que o cliente / proprietário do produto me diga que deseja corrigi-lo .

Por que você deseja permitir que uma compilação seja bem-sucedida com defeitos conhecidos?

Porque, às vezes, você tem restrições de tempo. Ou o bug é tão pequeno que não vale a pena adiar o envio do produto por alguns dias necessários para o teste de unidade e para corrigi-lo.

Além disso, qual é o objetivo de interromper a compilação intencionalmente toda vez que você encontrar um bug? Se você o encontrou, conserte-o (ou atribua-o à pessoa que o consertará), sem perturbar toda a equipe. Se você deseja se lembrar de corrigir um erro, marque-o como muito importante no seu sistema de rastreamento de erros.

Os testes existem para garantir que você não (re) introduza problemas. A lista de testes com falha não substitui um sistema de rastreamento de bugs. Há alguma validade no POV de que os testes reprovados não são apenas indicação de bugs, eles também são uma indicação de falha no processo de desenvolvimento (do descuido à dependência mal identificada).

"Quebrar a compilação" significa impedir que uma compilação seja concluída com êxito . Um teste com falha não faz isso. É uma indicação de que a construção possui defeitos conhecidos, o que é exatamente correto.

A maioria dos servidores de build controla o status dos testes ao longo do tempo e atribui uma classificação diferente a um teste que está falhando desde que foi adicionado versus uma regressão (teste que costumava passar e não faz mais) e também detecta a revisão na qual o regressão ocorreu.

Eu argumentaria que o teste com falha deveria ser adicionado, mas não explicitamente como "um teste com falha".

Como o @BenVoigt aponta em sua resposta , um teste que falha não necessariamente "quebra a compilação". Acho que a terminologia pode variar de equipe para equipe, mas o código ainda é compilado e o produto ainda pode ser enviado com um teste com falha.

O que você deve se perguntar nessa situação é:

O que os testes devem realizar?

Se os testes existem apenas para fazer com que todos se sintam bem com o código, adicionar um teste com falha apenas para fazer com que todos se sintam mal com o código não parece produtivo. Mas então, quão produtivos são os testes em primeiro lugar?

Minha afirmação é que os testes devem refletir os requisitos de negócios . Portanto, se foi encontrado um "bug" que indica que um requisito não foi atendido adequadamente, também é uma indicação de que os testes não refletem adequada ou totalmente os requisitos de negócios.

Esse é o bug a ser corrigido primeiro. Você não está "adicionando um teste que falhou". Você está corrigindo os testes para refletir melhor os requisitos de negócios. Se o código falhar na aprovação nesses testes, isso é bom. Isso significa que os testes estão fazendo seu trabalho.

A prioridade da fixação do código deve ser determinada pela empresa. Mas até que os testes sejam corrigidos, essa prioridade pode realmente ser determinada? A empresa deve estar armada com o conhecimento exatamente do que está falhando, como está falhando e por que está falhando para tomar suas decisões com prioridade. Os testes devem indicar isso.

Ter testes que não passam completamente não é uma coisa ruim. Ele cria um grande artefato de problemas conhecidos a serem priorizados e tratados de acordo. Ter testes que não são totalmente testados , no entanto, é um problema. Isso questiona o valor dos próprios testes.

Para dizer de outra maneira ... A compilação já está quebrada. Tudo o que você decide é se deve ou não chamar atenção para esse fato.

Em nossa equipe de automação de teste, verificamos os testes com falha, desde que eles falhem devido a um defeito no produto e não a um defeito no teste. Dessa forma, temos provas para a equipe de desenvolvimento de que, ei, eles a quebraram. Quebrar a construção é altamente desaprovado, mas isso não é o mesmo que fazer o check-in em testes perfeitamente compiláveis, mas com falha.

Escrever um teste que você sabe que falhará até que o bug seja corrigido é uma boa idéia, é a base do TDD.

Quebrar a compilação é uma má ideia. Por quê? Porque isso significa que nada pode seguir em frente até que seja corrigido. Ele essencialmente bloqueia todos os outros aspectos do desenvolvimento.

Exemplo 1
E se o seu aplicativo for grande, com muitos componentes? E se esses componentes forem trabalhados por outras equipes com seu próprio ciclo de lançamento? Difícil! Eles têm que esperar pela sua correção de bug!

Exemplo 2
E se o primeiro erro for difícil de corrigir e você encontrar outro erro com maior prioridade? Você também interrompe a construção do segundo bug? Agora você não pode construir até que ambos sejam corrigidos. Você criou uma dependência artificial.

Não há razão lógica para que a falha em um teste interrompa uma compilação. Essa é uma decisão que a equipe de desenvolvimento precisa tomar (talvez com discussão sobre gerenciamento) avaliando os prós e os contras de liberar uma compilação com erros conhecidos. Isso é muito comum no desenvolvimento de software, praticamente todos os principais softwares são lançados com pelo menos alguns problemas conhecidos.

Depende do papel que os testes devem desempenhar e de como seus resultados afetam o sistema / processo de construção adotado. Meu entendimento de interromper a compilação é o mesmo de Ben e, ao mesmo tempo, não devemos verificar conscientemente o código que quebra os testes existentes. Se esses testes vierem "mais tarde", pode ser "bom" ignorá-los apenas para torná-los menos desnecessariamente perturbadores para os outros, mas acho essa prática de ignorar testes com falha (para que pareçam passar) bastante perturbadora (especialmente para testes de unidade), a menos que haja uma maneira de indicar esses testes como vermelho ou verde.

Depende do bug, é claro, mas geralmente se algo der errado e não for identificado durante o teste manual ou automatizado, isso implica que há uma lacuna na sua cobertura. Definitivamente, eu incentivaria descobrir a causa raiz e colocar um caso de teste de unidade em cima do problema.

Se for um problema de produção planejado para uma correção hot de uma filial de manutenção, você também precisará garantir que a correção funcione na linha principal e que um desenvolvedor não possa erroneamente eliminar a correção com uma resolução de conflito de mesclagem excessivamente zelosa .

Além disso, dependendo da sua política de lançamento, a presença de testes de unidade atualizados recentemente pode ajudar a confirmar que um desenvolvedor realmente corrigiu o problema, em vez de apenas alterá-lo [(o problema ou os testes?)], Embora isso dependa de ter codificado o requisitos corretos nos novos testes de unidade.

Um problema ao adicionar um teste de falha na construção é que sua equipe pode ter o hábito de ignorar testes de falha porque espera que a construção falhe. Depende do seu sistema de construção, mas se um teste com falha nem sempre significa "algo acabou de quebrar", é fácil prestar menos atenção às falhas nos testes.

Você não quer ajudar sua equipe a entrar nessa mentalidade.

Portanto, concordo com o sleske que você deve adicionar o teste, mas marque-o como 'ignorado' para fins de criação automática, até que o bug seja corrigido.

Embora eu ache que você deva, de alguma forma, fazer o check-in do bug como teste, para que, quando você o conserte, não ocorra novamente e, de alguma forma, priorize-o, acho que é melhor não quebrar a compilação (/ os testes) . O motivo é que as confirmações subsequentes de construção ficarão ocultas atrás do teste quebrado. Portanto, ao verificar um teste quebrado para esse bug, você exige que toda a equipe reserve seu trabalho de lado para corrigi-lo. Se isso não acontecer, você poderá acabar com os commits que não são rastreáveis ​​como tal.

Portanto, eu diria que é melhor enviá-lo como um teste pendente e fazer da sua equipe uma prioridade não ter testes pendentes.

Outra opção é verificar o teste com falha em uma ramificação separada no seu sistema de controle de origem. Dependendo de suas práticas, isso pode ser viável ou não. Às vezes, abrimos uma nova ramificação para o trabalho em andamento, como corrigir um erro que não é trivial.