Qual é a relevância do teste de unidade em um ambiente de "liberação antecipada de release frequentemente"?

Nos últimos um ano, conduzi minha equipe para o modo de desenvolvimento release-release-release-freqüentemente (AKA: Desenvolvimento Rápido de Aplicativos, não Agile). Para obter mais informações sobre a maneira pela qual fechamos a compilação, consulte minha resposta aqui: Maneiras simples de melhorar a qualidade da versão no ambiente RAD

Quando adotamos o RAD, as pessoas eram bastante independentes e estavam fazendo testes de unidade primeiro; os testes integrados aconteceram muito mais tarde no processo. Foi um processo natural para eles sem muita aplicação formal. Agora a situação é bem diferente:

1. Toda a plataforma está bem integrada com compilações / lançamentos estabelecidos, trabalhando no lado do cliente sem pontos de acesso.

2. Novos requisitos de funcionalidade continuam chegando e nós os construímos gradualmente à medida que avançamos.

3. A dinâmica geral do sistema é muito importante porque, embora grupos de desenvolvimento independentes possam estar seguindo os processos corretamente, surgiram grandes falhas devido a circunstâncias complicadas e não óbvias.

4. Muitas partes do sistema envolvem novos algoritmos e dados de pesquisa, portanto os desafios (e, portanto, o mecanismo de teste) nem sempre são previstos corretamente, como o teste de recursos em software bem definido.

Recentemente, eu estava tentando obter uma melhor visão geral para ver se precisamos melhorar o processo. Quando me sentei com minha equipe, muitos deles hesitaram: "Não fazemos mais testes de unidade!" enquanto outros pensavam que não deveríamos começar agora, porque nunca será eficaz.

Os testes de unidade são úteis em um sistema relativamente maduro? Deveríamos, pelo menos, pesar o escopo do teste, dependendo da maturidade das unidades? Os testes de unidade desacelerarão o ritmo do desenvolvimento? É necessário avaliar o teste de unidade de uma maneira diferente?

Quais são as melhores práticas de teste para uma plataforma madura em um ambiente de lançamento antecipado e lançamento frequente?

Os testes de unidade não são principalmente para encontrar erros em primeiro lugar - eles são para garantir que a próxima versão do seu sistema seja tão estável quanto a versão anterior. Quanto menor o seu ciclo de lançamento, mais importante é que você possa executar esses testes automaticamente em vez de executá-los manualmente.

Obviamente, se você possui um sistema com algumas partes independentes e estava trabalhando entre duas versões apenas em uma pequena parte do sistema, provavelmente poderá omitir alguns testes de unidade que são para outras partes do sistema. Mas você definitivamente deve usar (e estender) os testes de unidade para as partes em que está trabalhando.

Outra coisa é que, quando um sistema cresce, haverá cada vez mais necessidade de testes de integração adicionais - mas isso não significa que você precisará de menos testes de unidade.

A verdadeira questão por trás da sua pode ser talvez outra. Tornou-se mais difícil escrever testes de unidade, pois o sistema ficou cada vez maior? Seus testes "unitários" são realmente testes unitários ou não testam mais as coisas isoladamente? Isso pode ocorrer porque eles dependem de partes de nível inferior do sistema que se estabilizaram ao longo do tempo.

Essas coisas acontecem porque os desenvolvedores tendem a reutilizar bibliotecas e códigos existentes fazendo referência direta a elas. Geralmente, o efeito é que os testes de unidade de escrita ficam mais difíceis, porque geralmente precisam fornecer um ambiente mais complexo e mais dados de teste. Se esse for o seu problema, você deve aprender sobre os principais conceitos Injeção de Dependência e Princípio de Segregação de Interface , que podem ajudá-lo a tornar o código mais testável por unidade.

Você deve considerar o desenvolvimento orientado a testes, onde os testes são projetados primeiro e descrever como o novo código funcionará quando gravado. Você faz os testes passarem.

Na minha experiência, isso tende a tornar o código mais enxuto e mais bem pensado, especialmente para bibliotecas, e é uma parte executável da especificação (o que significa que sempre será a documentação correta).

Dito isto, os testes existentes são usados ​​para garantir que o código ainda funcione conforme o esperado. Ele pode detectar a quebra de código e permitir que você garanta que o código de terceiros ainda funcione conforme o esperado durante a atualização.

Conforme sugerido por Doc Brown e Thorbjørn Ravn Andersen , um ambiente de release antecipado do Release geralmente pode se beneficiar ainda mais de um bom teste de unidade e desenvolvimento orientado a testes do que um com ciclos de release longos.

Se você tiver um bom sistema de integração contínua instalado e testes que representem bem a funcionalidade, terá uma boa idéia a qualquer momento do que está funcionando (porque os testes para essa funcionalidade estão passando) e o que ainda não foi implementado ( porque não há testes para essa funcionalidade).