Devemos excluir o código para a análise de cobertura de código?

Estou trabalhando em várias aplicações, principalmente as herdadas. Atualmente, sua cobertura de código é bastante baixa: geralmente entre 10 e 50%.

Desde várias semanas, temos discussões recorrentes com as equipes de Bangalore (a parte principal do desenvolvimento é realizada no exterior na Índia) a respeito das exclusões de pacotes ou classes para Cobertura (nossa ferramenta de cobertura de código, mesmo se atualmente estamos migrando para JaCoCo).

O ponto de vista deles é o seguinte: como eles não gravam nenhum teste de unidade em algumas camadas do aplicativo (1) , essas camadas devem ser simplesmente excluídas da medida de cobertura do código. Em outras palavras, eles querem limitar a medida de cobertura do código ao código que é testado ou deve ser testado .

Além disso, quando eles trabalham no teste de unidade para uma classe complexa, os benefícios - puramente em termos de cobertura de código - passam despercebidos em um aplicativo grande. Reduzir o escopo da cobertura do código tornará esse tipo de esforço mais visível ...

O interesse dessa abordagem é que teremos uma medida de cobertura de código que indica o status atual da parte do aplicativo que consideramos testável .

No entanto, meu ponto de vista é que, de alguma forma, estamos fingindo os números. Esta solução é uma maneira fácil de alcançar um nível mais alto de cobertura de código sem nenhum esforço. Outro ponto que me incomoda é o seguinte: se mostrarmos um aumento de cobertura de uma semana para outra, como podemos saber se essas boas notícias se devem ao bom trabalho dos desenvolvedores ou simplesmente a novas exclusões?

Além disso, não poderemos saber exatamente o que é considerado na medida de cobertura do código. Por exemplo, se eu tiver um aplicativo de 10.000 linhas de código com 40% de cobertura de código, posso deduzir que 40% da minha base de código foi testada (2) . Mas o que acontece se definirmos exclusões? Se a cobertura do código agora é de 60%, o que posso deduzir exatamente? Que 60% da minha base de código "importante" é testada? Como posso

No que me diz respeito, prefiro manter o valor "real" da cobertura do código, mesmo que não possamos nos alegrar com isso. Além disso, graças ao Sonar, podemos navegar facilmente em nossa base de código e conhecer, para qualquer módulo / pacote / classe, sua própria cobertura de código. Mas é claro que a cobertura global do código ainda será baixa.

Qual a sua opinião sobre esse assunto? Como você se sai em seus projetos?

Obrigado.

(1) Essas camadas geralmente estão relacionadas à UI / Java beans, etc.

(2) Eu sei que isso não é verdade. De fato, isso significa apenas que 40% da minha base de código

Geralmente excluo o código gerado automaticamente, como os clientes WCF que o Visual Studio gera. Geralmente, existem muitas linhas de código e nunca iremos testá-las. Isso torna muito desmoralizante aumentar os testes em um grande pedaço de código em outro lugar e aumentar a cobertura do código em apenas 0,1%.

Também excluirei as interações da camada de dados, desde que a equipe possa dizer com certeza que essa camada é a mais fina possível. Embora você possa argumentar que, se a camada é fina, não terá um efeito maciço, ela deixa muitos componentes no relatório de cobertura com 0% contra eles, por isso não notamos necessariamente os que precisamos realmente se preocupar. A camada da interface do usuário pode ser discutida de maneira semelhante, dependendo da estrutura que está sendo usada.

Mas, como contraponto, também excluirei os testes de unidade. Eles sempre devem ter ~ 100% de cobertura e representam uma grande porcentagem da base de código, enviesando os números perigosamente para cima.

Boa pergunta. Em geral, costumo excluir o código da cobertura do código por alguns motivos, por exemplo, é:

• gerado
• legado (não atualizado mais)
• aí vem: certas camadas, não pretendo testar

Por que o último ponto? Eu acho que é uma boa prática focar nas coisas que me interessam, enquanto suprime as distrações. Se você não pretende testar a camada de interface do usuário, por que levá-la em consideração - isso desviaria a atenção da parte importante do seu software - a lógica de negócios.

MAS:

1. Você deve ter um bom motivo para excluir uma determinada camada dos testes de unidade (pode haver perguntas - do seu chefe, de seus colegas de equipe, da imprensa ;-)
2. Se você quiser que eles testem essas camadas, inclua-as nas estatísticas para mostrar a equipe inteira, todos os dias que é importante e precisa ser feito.

Finalmente: não leve números muito a sério. A cobertura de 30% pode provar que um software é sólido, quando é a parte essencial dele.

Costumo concordar com você e incluir todo o código relevante nas métricas de cobertura de código (e no Sonar em geral). Mesmo se você não planeja testar algumas partes do código (no futuro próximo), as métricas devem refletir o status real. Isso força você a ter um motivo convincente para não escrever testes para uma parte significativa da base de código. Eventualmente (uma vez que outras partes mais importantes do código já estão cobertas), você pode reconsiderar ou escolher uma maneira diferente de eliminar essa dissonância - por exemplo, refatorando o código em questão para torná-lo testável ou migrar toda a lógica dele para um parte diferente e testável da base de código, ou mesmo para eliminar toda a camada (se uma camada não vale a pena testar, ela tem uma razão suficientemente boa para existir?)

Nos meus projetos atuais, também incluímos todo o código nas métricas, com uma exceção: código gerado, produzindo montes de avisos de análise estática. Como esse código geralmente consiste em enormes classes de PODs sem lógica, não há nada para testar lá.

Agora, não estou muito familiarizado com as ferramentas de cobertura de código que você está usando, nem estou familiarizado com os Java beans, mas pelo que você diz que eles estão relacionados à interface do usuário.

Com meu conhecimento limitado, tenho o seguinte a dizer:

1. Não permita que números de qualquer tipo de ferramenta de teste atrapalhem seus testes.
2. Se as classes são complexas e não podem ser testadas por unidade, é sempre uma boa idéia recodificá-las em classes mais compactas e testáveis. Exigirá muito esforço e dedicação, mas pagará a longo prazo.
3. O teste dos componentes da interface do usuário pode ser difícil, mas você ainda pode testar a função que está sendo executada por esses componentes.
4. Se você estiver executando um projeto baseado na Web, poderá usar o QUnit para testar a unidade todo o código do lado do cliente.

Em suma, lembre-se de que a cobertura do código é apenas um número e a alta cobertura do código não indica bons testes. Concentre-se em tornar as bibliotecas principais mais robustas e testáveis, em vez de buscar uma porcentagem maior.

Algumas exclusões fazem sentido (código da placa da caldeira que não tem impacto real ou potencial de impacto no seu projeto funcionando corretamente). Mesmo assim, coletar a cobertura do código como uma métrica é inútil, porque de qualquer maneira não é útil. A cobertura de código de 100% não é uma meta real, e os números baixos de cobertura também podem não ser ruins, dependendo do projeto, é possível que 20 a 30% de cobertura de código cubra tudo o que vale a pena testar. a cobertura do código informa apenas X% do seu código que vale a pena cobrir, na verdade, é por algum tipo de teste de qualidade desconhecida.

Sugiro relatar um conjunto de métricas para cada camada do seu código. Essas métricas devem incluir informações de tamanho (por exemplo, LoC, número de bibliotecas, número de classes ou métodos etc.), informações de teste (por exemplo, cobertura) e informações de erros (por exemplo, taxas de localização e correção).

Suas camadas excluídas terão cobertura de 0% e as áreas testadas terão a cobertura de 60% que você mencionou. As informações de tamanho permitirão que as pessoas entendam o quanto não foi testado ou testado. As informações do erro informarão se você deve criar testes para as camadas excluídas e se os testes existentes estão funcionando.

É fácil para as organizações de software se concentrarem demais na pureza das métricas. Não fazemos métricas, fazemos um bom software. Uma métrica que ajuda você a fornecer software de alta qualidade em tempo hábil é a métrica mais honesta e pura que existe.