Por que você executaria testes de unidade em um servidor de IC?
Certamente, quando algo é comprometido em dominar, um desenvolvedor já executou todos os testes de unidade anteriores e corrigiu os erros que poderiam ter ocorrido com seu novo código. Não é esse o objetivo dos testes de unidade? Caso contrário, eles apenas confirmaram o código quebrado.
master
sempre deve ser sensato e, de preferência, implantado automaticamente em cada mesclagem em um ambiente de teste para controle de qualidade interno e testes.Respostas:
Ou não. Pode haver muitas razões pelas quais isso pode acontecer:
Mas o ponto real é executar os testes em uma máquina que não é a máquina do desenvolvedor. Um que está configurado de maneira diferente.
Isso ajuda a detectar problemas em que os testes e / ou o código dependem de algo específico para uma caixa de desenvolvedor (configuração, dados, fuso horário, localidade, o que for).
Outras boas razões para as compilações de IC executar testes:
fonte
Como desenvolvedor que não executa todos os testes de integração e unidade antes de confirmar o controle de origem, oferecerei minha defesa aqui.
Eu precisaria criar, testar e verificar se um aplicativo é executado corretamente em:
Adicione os componentes Fortran (com compiladores Intel e GNU), Python (e suas várias versões, dependendo do sistema operacional) e scripts de bash / bat e, bem, acho que você pode ver as coisas em espiral
Então, são dezesseis máquinas que eu teria que ter, apenas para executar alguns testes algumas vezes por dia. Seria quase um trabalho em tempo integral apenas para gerenciar a infraestrutura para isso. Acho que quase todo mundo concorda que isso não é razoável, especialmente multiplicando-o pelo número de pessoas no projeto. Então, deixamos nossos servidores de IC fazerem o trabalho.
Os testes de unidade não impedem que você cometa código quebrado, eles dizem se eles sabem que você quebrou algo. As pessoas podem dizer que "os testes de unidade devem ser rápidos" e continuar com os princípios, padrões e metodologias de projeto, mas, na realidade, às vezes é melhor deixar os computadores que projetamos para tarefas repetitivas e monótonas executá-los e se envolver apenas se eles diga-nos que encontraram algo.
fonte
Além da excelente resposta Oded:
Certa vez, trabalhei em uma empresa que apresentava muitos bugs na implantação devido ao processo de fusão e implantação. Isso foi causado por uma estrutura proprietária estranha que dificultou o teste e o IC. Não foi uma experiência feliz descobrir que o código que funcionava perfeitamente no desenvolvimento não chegava diretamente à produção.
fonte
Você pensaria que não, mas os desenvolvedores são humanos e às vezes esquecem.
Além disso, os desenvolvedores geralmente falham em obter o código mais recente. Seus testes mais recentes podem funcionar bem e, no momento do check-in, alguém comete uma alteração de última hora.
Seus testes também podem contar com um recurso local (não verificado). Algo que seus testes de unidade local não pegariam.
Se você acha que tudo isso é fantástico, existe um nível acima do IC (pelo menos no TFS) chamado Gated, em que as construções que têm testes falhos são arquivadas e não são comprometidas com a base de código.
fonte
Normalmente, configurei meu IC para executar em todas as confirmações. As ramificações não são mescladas no master até que a ramificação tenha sido testada. Se você está confiando na execução de testes no master, isso abre uma janela para a compilação ser quebrada.
A execução dos testes em uma máquina de IC é sobre resultados reproduzíveis. Como o servidor de IC possui um ambiente limpo conhecido extraído do seu VCS, você sabe que os resultados do teste estão corretos. Ao executar localmente, você pode esquecer de confirmar algum código necessário para que eles passem ou ter um código não confirmado que os faz passar quando deveriam estar falhando.
Ele também pode economizar tempo dos desenvolvedores executando conjuntos diferentes em paralelo, especialmente se alguns forem testes lentos e de vários minutos que provavelmente não serão executados localmente após cada alteração.
No meu trabalho atual, nossa implantação de produção depende do IC aprovado em todos os testes. Os scripts de implantação impedirão a implantação, a menos que estejam passando. Isso torna impossível esquecer acidentalmente de executá-los.
O IC fazendo parte do fluxo de trabalho também sobrecarrega os desenvolvedores. Como desenvolvedor, você costuma executar um teste de linter, analisador estático, teste de unidade, cobertura de código e integração para cada alteração? O CI pode, de forma totalmente automática e sem a necessidade de pensar nisso - reduzindo o cansaço da decisão.
fonte
Quando algo se compromete a dominar, um desenvolvedor já deve ter executado todos os testes de unidade ... mas e se não o fizerem? Se você não executar os testes de unidade no servidor de IC, não saberá até que outra pessoa faça as alterações na máquina e descubra os testes que acabaram de ser executados.
Além disso, o desenvolvedor pode ter cometido um erro e referenciado um recurso local específico para sua máquina. Quando eles fazem o check-in do código e a execução do IC falha, o problema é imediatamente identificado e pode ser corrigido.
fonte
Supondo (ao contrário de outras respostas) que os desenvolvedores são bastante disciplinados e executam testes de unidade antes de confirmar, pode haver vários motivos:
fonte
É possível imaginar casos em que a alteração A não interrompe o teste e a alteração B não interrompe o teste, mas A e B juntos o fazem. Se A e B forem criados por diferentes desenvolvedores, apenas o servidor de CI detectará o novo bug. A e B podem até ser duas partes da mesma sentença mais longa.
Imagine um trem dirigido pelas duas locomotivas A e B. Talvez uma seja mais que suficiente e essa é a solução a ser aplicada. No entanto, se as duas "correções" forem aplicadas removendo as duas, o trem não se moverá.
Além disso, nem todos os desenvolvedores executam todos os testes de unidade, enquanto a maioria dos bons desenvolvedores faz.
fonte
Vamos fazer uma pergunta equivalente:
Existem várias razões para executar o IC, mas o principal ponto do IC é ter uma idéia de qual é o estado do código ao longo do tempo. O principal benefício (dentre vários) que isso fornece é que podemos descobrir quando a compilação é interrompida, descobrir o que a quebrou e depois corrigi-la.
Se o código nunca é quebrado, por que usamos o CI? Para entregar compilações para teste, as compilações noturnas seriam boas o suficiente.
fonte