Em que ponto um servidor de integração contínua é interessante?

Eu tenho lido um pouco sobre servidores de CI como Jenkins e estou me perguntando: em que momento é útil?

Porque certamente para um projeto minúsculo em que você teria apenas 5 classes e 10 testes de unidade, não há necessidade real.

Aqui temos cerca de 1500 testes de unidade e eles passam (em estações de trabalho antigas do Core 2 Duo) em cerca de 90 segundos (porque eles realmente estão testando "unidades" e, portanto, são muito rápidos). A regra que temos é que não podemos confirmar o código quando um teste falha.

Portanto, cada desenvolvedor lança todos os seus testes para impedir a regressão.

Obviamente, como todos os desenvolvedores sempre iniciam todos os testes, detectamos erros devido a alterações conflitantes assim que um desenvolvedor realiza a alteração de outro (quando houver).

Ainda não está muito claro para mim: devo configurar um servidor de IC como o Jenkins? O que isso traria?

É apenas útil para o ganho de velocidade? (não é um problema no nosso caso)

É útil porque construções antigas podem ser recriadas? (mas podemos fazer isso com o Mercurial, verificando antigas rotações)

Basicamente, entendo que pode ser útil, mas não consigo entender exatamente o porquê.

Qualquer explicação que leve em consideração os pontos que levantei acima seria bem-vinda.

É apenas útil para o ganho de velocidade? (não é um problema no nosso caso)

Qualquer tempo gasto no ciclo do seu processo é o tempo que você poderia ter gasto entrando no fluxo do desenvolvimento.

Você também economizará tempo em etapas, porque idealmente está criando bits totalmente empacotados e prontos para serem enviados, que podem ser gravados diretamente em CD, enviados para a Web etc.

É útil porque construções antigas podem ser recriadas? (mas podemos fazer isso com o Mercurial, verificando antigas rotações)

Não, você não recria construções. Você usa a compilação criada e a mantém por perto até que as configurações de retenção sejam descartadas.

Você o constrói no servidor de compilação, ao contrário de algumas caixas de desenvolvedores.

Aqui temos cerca de 1500 testes de unidade e eles passam (em estações de trabalho antigas do Core 2 Duo) em cerca de 90 segundos (porque eles realmente estão testando "unidades" e, portanto, são muito rápidos). A regra que temos é que não podemos confirmar o código quando um teste falha.

Além disso, você não gostaria de poder executar integração automatizada ou testes de ponta a ponta no seu código e detectar problemas que os testes de unidade não detectam?

Você não gostaria de executá-los nas caixas de desenvolvimento, porque seria difícil configurar e manter esse ambiente. Os testes de integração também tendem a ser muito lentos para executar.

em que momento é útil?

É um investimento como outro qualquer.

Use-o uma vez e poderá ficar para trás ou apenas empatar. Use-o em vários projetos e você provavelmente sairá à frente.

Também depende do tipo de aplicativo que você faz.

Se você criar aplicativos da Web que precisam ser implantados em um Java Application Server ou IIS, o CI se tornará um acéfalo. Mesmo se você tiver um banco de dados como parte do seu projeto. A implantação é dolorosa para ser executada manualmente, e sua equipe de controle de qualidade (se você tiver uma) precisará dela quantas vezes por dia em algum momento.

Além disso, você pode querer ver como suas necessidades e problemas se alinham aos 12 passos para um código melhor de Joel Spolsky . Particularmente 2, 3 e 10 (embora todos sejam interessantes e importantes).

Em que momento é útil?

• Seu ciclo de compilação + teste dura alguns minutos. Com a execução de teste de 5 minutos, você não precisará mais executar todos os testes, especialmente para pequenas alterações.
• Você começa a criar várias variantes. Se você tiver alguns clientes com personalizações diferentes, execute os testes em cada variante, para que a quantidade de trabalho comece a crescer rapidamente. Depois, você executaria o conjunto de testes para uma variante na máquina do desenvolvedor e deixaria para a CI executá-lo no restante.
• Você escreve testes de integração automatizados que precisam de alguma configuração não trivial do ambiente de teste. Do que você deseja testar em um ambiente de teste canônico, já que os desenvolvedores podem ter seu ambiente modificado de várias maneiras devido às alterações no desenvolvimento. O IC é o local mais adequado para o ambiente canônico.
• Os testadores podem simplesmente obter a versão mais recente do CI. Portanto, eles não precisam ter, aprender e usar as ferramentas de desenvolvimento, e nenhum desenvolvedor precisa enviar sua compilação manualmente.
• Quando você está se preparando para a liberação:
  • O teste se torna mais importante, portanto, ter um local com compilações preparadas para teste é ainda mais útil.
  • Você está certo de que todas as compilações são construídas com o mesmo ambiente de compilação, para evitar problemas que podem ser introduzidos por diferenças sutis entre as instalações do desenvolvedor.
  • Você tem certeza de que está construindo exatamente o que foi verificado no sistema de controle de versão. Durante o desenvolvimento, se alguém se esquecer de fazer o check-in, você encontrará rapidamente, pois isso falhará para o próximo desenvolvedor. Porém, se essa construção cair para controle de qualidade ou produção e eles reportarem um erro, seria muito difícil rastrear.

Você provavelmente ainda não precisa de CI, mas acho que será útil quando você chegar à fase de teste. O Jenkins é configurado em poucas horas e simplificará seus testes e ajudará a evitar erros tolos (que acontecem especialmente quando você faz uma correção rápida na produção).

Para mim, um IC fica interessante se sua equipe tiver mais de um membro.

Você precisa parar de pensar no CI como "outro PC executando os testes para mim". IC sobre ter um processo de compilação definido e automatizado e gerenciamento de versão.

O IC é a entidade autorizada única que cria sua versão do software. Se não se baseia no IC, simplesmente não aconteceu.

Com um IC, você tem restrições para automatizar tudo o que mostrará todos os ajustes manuais, hacks e atalhos que você possui e simplesmente não funciona com um IC e deve ser evitado em primeiro lugar.

Problemas que evita:

• Quem é responsável por criar o release
• Esta pessoa está disponível 24/7
• Mas se baseia na minha síndrome de máquina
• Remove toda ambiguidade sobre qual foi a versão que lançamos

Vantagens (muitas para mencionar tudo):

• Numeração de versão automatizada
• Integração de rastreamento de problemas
• Geração de métrica automatizada
• Análise de código estático
• Implantação automatizada
• Configurações de vários estágios

Há um problema fundamental sobre a integração contínua (IC) que é perfeitamente espelhado na sua pergunta: as práticas de IC são difíceis de implementar e defender, porque o software do servidor de CI não é trivial para configuração, nem é trivial para colocar seus projetos em execução por um IC servidor. Com isso, torna-se difícil realmente ver onde está o ganho em adotar o IC.

Antes de tudo, o IC trata de insight e qualidade. O bom IC aproxima você do seu projeto, fornece feedback adequado sobre métricas de qualidade, documentação, conformidade com os padrões de codificação etc. Ele deve fornecer as ferramentas para visualizar facilmente tudo isso e permitir que você reconheça e veja rapidamente associe um conjunto de alterações a um instantâneo específico de todas essas métricas do projeto.

Não se trata apenas de executar testes de unidade. De modo nenhum! O que me leva à qualidade. O IC adota erros, não os evita ou os joga fora. O que ele faz é simplesmente fornecer uma ferramenta para erros no início, em vez de mais tarde. Portanto, você realmente não confirma o código testado anteriormente em um servidor de IC. Embora você deva se esforçar para confirmar um código limpo e não quebrado, você realmente usa o servidor de IC para executar automaticamente um construtor de integração automaticamente através do seu código e avaliar se tudo deu certo. Se tiver, arrumado! Se não tiver, não há problema - as boas práticas de IC afirmam que sua próxima prioridade deve ser apenas corrigir o que está quebrado. O qual, em um bom servidor de CI, deve ser facilmente apontado para você.

À medida que o tamanho de uma equipe aumenta, a integração do código de todos naturalmente se torna mais difícil. Deveria ser tarefa de um servidor de IC centralizado testar todas as partes integradas e aliviar esse fardo dos membros da equipe. Portanto, você deve ter todos comprometidos o mais cedo possível (e da maneira mais limpa possível) e monitorando o status das compilações (geralmente há notificações envolvidas). E, novamente, se algo for quebrado por causa do comprometimento de algum desenvolvedor, torna-se imediatamente sua responsabilidade corrigir isso e recuperar essas construções automatizadas de volta ao status OK imediatamente.

Então você vê, na minha opinião, todo projeto se beneficia de ser continuamente integrado. O problema é que, até agora, e devido à complexidade incompreensível de cada servidor de CI que eu conheço, as pessoas realmente se opuseram às práticas de IC em projetos menores / mais simples. Porque, vamos lá, as pessoas têm coisas melhores a fazer do que passar dias configurando um software feio, excessivamente complexo, com entrega insuficiente e inchada.

Eu tive exatamente o mesmo problema, e foi isso que me levou a desenvolver o Cintient em meu tempo livre desde cerca de um ano atrás. Minha premissa era simplificar a instalação, a configuração e o uso, além de fornecer as métricas de qualidade que todos os demais praticamente falham ou fornecem de forma insuficiente. Então, após essa longa resposta, aparece meu ponto descarado de apontar o link do GitHub para o projeto (que é gratuito e de código aberto, natch). Ele também tem algumas imagens legais, aparentemente. :-) https://github.com/matamouros/cintient

Espero ter ajudado você.

(NOTA: Editado após o comentário de Bryan Oakley, sobre o fato de que eu deveria ter levado mais tempo para criar uma resposta melhor. Também acho que ele estava certo.)