Teste de unidade e integração: como pode se tornar um reflexo

Todos os programadores da minha equipe estão familiarizados com testes de unidade e testes de integração. Todos nós trabalhamos com isso. Temos todos os testes escritos com ele. Alguns de nós até sentimos um senso aprimorado de confiança em seu próprio código.

No entanto, por algum motivo, escrever testes de unidade / integração não se tornou um reflexo para nenhum dos membros da equipe. Na verdade, nenhum de nós se sente mal ao não escrever testes de unidade ao mesmo tempo que o código real. Como resultado, nossa base de código é descoberta principalmente por testes de unidade, e os projetos entram em produção não testados.

O problema é que, uma vez que seus projetos estão em produção e já estão funcionando bem, é praticamente impossível obter tempo e / ou orçamento para adicionar testes de unidade / integração.

Os membros da minha equipe e eu já estamos familiarizados com o valor do teste de unidade ( 1 , 2 ), mas não parece ajudar a incluir o teste de unidade em nosso fluxo de trabalho natural. Na minha experiência em tornar obrigatórios os testes de unidade e / ou a cobertura de um objetivo, resulta apenas em testes de baixa qualidade e atrasa os membros da equipe simplesmente porque não há motivação auto-gerada para produzir esses testes. Assim que a pressão diminui, os testes de unidade não são mais escritos.

Minha pergunta é a seguinte: Existem métodos que você experimentou que ajudam a criar uma dinâmica / momento dentro da equipe, levando as pessoas a quererem naturalmente criar e manter esses testes?

Na verdade, nenhum de nós se sente mal ao não escrever testes de unidade ao mesmo tempo que o código real.

Este é o ponto que você precisa abordar. A cultura da sua equipe precisa mudar, de modo que não escrever testes durante o sprint (ou qualquer unidade de tempo que você use) se torne tanto um cheiro de código quanto valores codificados. Muito disso envolve pressão dos colegas. Ninguém realmente quer ser visto como abaixo do padrão.

Faça você mesmo os testes. Se repreende visivelmente quando não os faz. Indique onde um programador "bom" teria detectado esse erro se escrevesse testes de unidade. Ninguém quer ser ruim. Faça com que esse comportamento indesejável seja ruim e as pessoas o sigam.

Conseguir que uma equipe inteira realmente queira a mesma coisa pode ser bastante difícil. Geralmente, ver o valor de algo não basta para incentivar as pessoas a mudarem o comportamento arraigado. Mesmo aqueles que valorizam a mudança e que a desejam especificamente às vezes também podem ser responsáveis ​​por combatê-la subconscientemente.

A questão é realmente de motivação individual e não de equipe, como tal. Chega um momento em que um momento de clareza chega até você, como resultado de algo que você sentiu que finalmente entendeu, ou por causa de alguma ferramenta nova ou de outra coisa subjetiva que faz com que o programador médio jogue tudo e mude completamente o processo. Seu trabalho - caso você opte por excluí-lo - é verificar se existe uma maneira de você ou a equipe descobrir quais coisas serão os gatilhos de clareza para cada membro da equipe.

Para mim, pessoalmente, foi simplesmente descobrir a estrutura do StoryQ para BDD no DotNet, o que tornou muito fácil ignorar e me superou completamente na "barreira" teste primeiro versus teste simultaneamente. Mais tarde, reafirmei minhas escolhas quando encontrei o NCrunch for Visual Studio. Às vezes, metade da batalha não é vender a idéia, mas simplesmente diminuir o esforço necessário para introduzir uma mudança radical de hábitos ... e mesmo assim pode levar um pouco de tempo e trabalho. Esses mesmos gatilhos pessoais, no entanto, não foram suficientes para influenciar a abordagem de meus colegas na época, que ainda escreviam o mesmo código de teste simultaneamente ou mesmo após o código de implementação.

Às vezes, também há relutância em mudar a maneira como as coisas são feitas, devido a um medo inerente, desconfiança ou visão desagradável do esforço necessário para aprender a fazer algo de maneira diferente, mesmo quando o raciocínio da mudança é sólido. Se toda a sua plataforma de teste for trabalhada de maneira específica, pode ser difícil justificar a mudança na maneira como as coisas são feitas e potencialmente mudar a ferramenta , especialmente quando testes antigos e novos precisarão continuar a coexistir durante toda a vida útil do projeto - e você certamente não precisaria reescrever todos os testes que já criou. O estranho é que, às vezes, as pessoas sentem que esta é a única maneira de adotar uma nova metodologia de teste, e isso por si só torna mais difícil para essas pessoas aceitar mudanças sensatas para melhor.

Realmente, a única maneira de algo se tornar reflexivo é forçar-se a fazê-lo repetidamente até que você não perceba mais a necessidade de se concentrar demais em como fazê-lo. Às vezes, a única maneira de fazer isso em uma equipe é definir políticas que podem parecer um pouco draconianas e praticar a programação em pares e a revisão de códigos e qualquer outra coisa que possa ajudar os membros da equipe a se apoiarem e forçarem literalmente a mudança em comportamento a ocorrer. No entanto, para que essa estratégia seja realmente bem-sucedida, ainda é necessário um compromisso firme e honesto de cada membro da equipe para aceitar as medidas necessárias e participar do processo ... e muita paciência de todos os envolvidos. .

Na verdade, nenhum de nós se sente mal ao não escrever testes de unidade ao mesmo tempo que o código real

Não sabe o que quer dizer com "ao mesmo tempo", mas que tal escrevê-los antes do código real?

É facilmente compreensível, do ponto de vista psicológico, por que qualquer ser humano não gostaria de se preocupar em escrever testes de unidade após o código. Nesse ponto, o código já está funcionando, então por que diabos precisamos testá-lo? Algum tipo de preguiça ocorre automaticamente porque é tedioso, aparentemente inútil e não é necessário escrever testes não parece perigoso. Como resultado, não conheço muitas equipes que continuaram com uma abordagem de teste após um longo período de tempo.

Na minha experiência, o teste primeiro (estilo TDD), no entanto, é algo com o qual você pode se viciar rapidamente, porque há pelo menos dois benefícios imediatos, tangíveis e liberadores de endorfina:

• Ele ajuda a projetar seu código frente a frente com requisitos executáveis ​​concretos e a tornar o design cada vez melhor à medida que você refatora, o que é muito mais objetivo e gratificante do que apenas verificar duas vezes algo que já funciona.

• O ciclo TDD é pontuado com freqüentes momentos de "barra verde", onde você pode apreciar o sabor do sucesso imediato. Ele constantemente mantém sua mente satisfeita e pronta para o próximo recurso a ser implementado.

Portanto, eu não tentaria fazer sua equipe se sentir mal quando não escrevesse os testes. Em vez disso, tentaria fazê-los se sentir bem como eles. TDD é uma maneira de fazer isso.

primeiro, você deve garantir que a escrita de um teste e a execução sejam fáceis, obtenha a estrutura configurada nos projetos atuais e simplifique a inclusão desse procedimento de configuração em projetos futuros

Dessa maneira, quando um programador deseja unittest um novo recurso, ele está tentando depurar, ele não precisa pular uma dúzia de argolas para fazer os testes funcionar corretamente

quanto mais desajeitado é fazer, menor a probabilidade de você criar um hábito

Uma coisa que fiz e que tem sido bem-sucedida em instigar uma mudança de cultura é criar uma queda semanal no seminário "curadoria de teste de unidade". O objetivo oficial disso é ajudar a manter o conjunto de testes de unidade funcionando rapidamente e atualizado, mas o objetivo mais importante, em minha opinião, é oferecer às pessoas uma maneira de baixa pressão para entrar, fazer perguntas e praticar testes. . O fato de você estar disposto a gastar uma hora ou o que quer que seja por semana exclusivamente nos testes também envia a mensagem de que isso é importante.

Eu acho que você passa por uma mudança de cultura dessa maneira e começa a remover a barreira para fazê-lo "reflexivamente", como você diz. As pessoas tenderão a voltar aos velhos hábitos ao primeiro sinal de adversidade - ter uma reunião como essa não resolverá isso de uma só vez, mas acho que iniciará uma mudança de cultura e removerá a barreira que resulta de resultados não reais. sabendo o que você está fazendo.

Ter um grupo de programadores em que todos naturalmente querem fazer algo é uma utopia (especialmente quando se fala de um grupo grande).

O teste de unidade e integração é uma coisa dos padrões . Você cria um padrão para um fluxo de trabalho e cada membro da equipe deve respeitá-lo. Os padrões devem ser estabelecidos com a ajuda de profissionais de controle de qualidade, porque eles o conhecem melhor. Um programador deve respeitar os padrões. O que você pode fazer é tornar os padrões limpos, fáceis de entender e seguir.

Não se trata de confiar em seu próprio código e deseja usá-lo, é sobre a necessidade de ter padrões de codificação e teste que todos usem para fazer coisas boas, e qualquer programador deve entender isso.

Quando você faz as pessoas desde o início seguirem o padrão, ele se torna um reflexo e será seguido. Estabelecer uma regra de que nenhum código pode ser colocado na base de código sem um teste de unidade convenceria as pessoas de que precisam fazê-lo. Para repositórios de projetos, existem regras ainda mais restritivas. Por exemplo, as empresas fazem testes de unidade antes de realmente codificar a unidade (quando fazem a especificação do módulo) e esse é um método muito bom. Se um programador coloca código no projeto / base de código, o código é executado no módulo de teste e, se os testes de unidade não forem aprovados, eles voltarão ao trabalho.

Se for difícil no momento adicionar padrões e regras, pelo menos pense em adicioná-los em projetos futuros.