Automação de Testes de CI/CD

A automação de testes é uma peça central de qualquer pipeline de CI/CD e um passo essencial na direção de lançamentos mais frequentes de versões. O TeamCity oferece uma grande variedade de recursos que permitem a você obter o máximo dos seus testes automatizados, incluindo a reordenação e a paralelização de testes, a análise inteligente de falhas, portões de qualidade e muitos outros. Com suporte incorporado a frameworks populares de testes para .NET, Java, Python, JavaScript e outras linguagens de programação, o TeamCity abre o caminho para um código melhor e um processo mais confiável de lançamento de versões para todo o conjunto do seu software.

Adaptado ao seu workflow

Workflows de teste de software são tão diversos quanto o próprio software. Organizar containers do Docker, configurar ambientes de teste, mudar o escopo dos testes com base em vários parâmetroe e configurar portões de qualidade são só algumas atividades comuns que você talvez queira fazer com a sua ferramenta de CI/CD. A boa notícia é que o TeamCity dá suporte a todos esses cenários, permitindo que você configure facilmente pipelines automatizados sob medida para o seu workflow específico de testes.

Integração com todas as ferramentas populares de build e teste

O TeamCity se integra a ferramentas de build e frameworks de teste como nenhuma outra solução de CI/CD. Ele paraleliza a execução dos seus testes, identifica testes não confiáveis e mantém um histórico de cada teste que ele executar, incluindo o log de builds, a duração, a ordem de execução, a cobertura do código e os resultados da análise estática, além de outros dados. À medida que o TeamCity coleta mais estatísticas de testes, ele se torna indispensável para compreender os tipos de alterações que tipicamente provocam falhas nos seus testes.

Adequado para projetos de qualquer tamanho e complexidade

Se você já tiver mudado de uma ferramenta de CI/CD para outra, sabe que esse processo pode demandar muitos meses de trabalho. Com o TeamCity, você nunca terá que se preocupar com a sua empresa crescendo mais que o seu sistema de build e você tendo que mudar para outro. Nossa solução foi feita para lidar com os maiores e mais complexos projetos. Por exemplo, dentro da JetBrains, mais de 1.000 desenvolvedores usam uma única instalação do TeamCity para executarem mais de 5.000 builds em paralelo.

Aumente sua produtividade com relatórios avançados de testes

Ao automatizar seus testes e executaá-los regularmente, você e sua equipe se beneficiarão de um feedback imediato com relação às suas alterações. Como resultado, novos bugs serão identificados mais cedo e corrigidos mais rapidamente, enquanto a alteração ainda estiver fresca na sua mente.

Com o TeamCity, você pode configurar testes automáticos como partes dos seus pipelines de CI/CD. Os resultados dos testes são fornecidos em tempo real, para garantir um feedback rápido. Quando os testes falham, o TeamCity dá detalhes das alterações de código associadas, juntamente com rastreamento de pilhas, logs e artefatos de build, para ajudar você a iniciar o processo de depuração. Testes não confiáveis e recentemente falhados são realçados e se alguns desses testes forem corrigidos em builds posteriores, a página de resultados dos testes será automaticamente atualizada com as informações correspondentes.

Além de poderem ser visualizados na interface de Web, os resultados dos testes também podem ser enviados a você por e-mail, Slack ou outros mensageiros, ou ainda entregues diretamente no seu IDE. Mais uma vez, isso dá a você e à sua equipe um feedback imediato das suas últimas alterações, sem a necessidade de esperar o término da etapa de build.

Principais recursos de automação de testes

Análise de falhas e cobertura de código

O TeamCity vem com uma variedade de executores de build que se integram a ferramentas usadas para realizar o processo de build, teste e implantação de software. Quando uma sequência de testes é executada com a ajuda de um executor de build, o TeamCity é capaz de compreender os eventos que acontecem durante o build, verificar a cobertura do código, fornecer relatórios em tempo real, coletar estatísticas e analisar tendências.

Às vezes, pode não parecer prático converter um script de testes em etapas de build do TeamCity e em vez disso, você pode preferir usar o executor de build genérico em linha de comando. Se você decidir fazer isso, poderá adicionar mensagens de serviço do TeamCity à saída do seu script para informar o TeamCity do andamento e ainda continuar desfrutando de todos os recursos inteligentes do TeamCity. Por exemplo, se o TeamCity obtiver informações sobre nomes de testes e sua duração, poderá calcular como os testes poderão ser paralelizados. Para mais detalhes, veja a seção Mensagens de Serviço da nossa documentação.

Dependendo dos seus requisitos específicos, o TeamCity permite que você defina quando um build deve ser marcado como bem-sucedido ou falhado. Por exemplo, se for importante que a cobertura do seu teste unitário não diminua de um build para o seguinte, você pode fazer com que a métrica de cobertura de código seja uma condição de falha na etapa de build.

Para gerenciar falhas de testes, o TeamCity permite que você atribua investigações aos membros da sua equipe ou suspenda testes que você não precisar corrigir imediatamente. Os testes suspensos serão ignorados nas execuções seguintes do pipeline, permitindo que o seu processo automatizado de teste continue sem interrupções e sem alterações manuais no pipeline.

Desenvolvemos executores de build para todas as ferramentas e linguagens de programação populares, incluindo:

  • Gradle
  • Kotlin
  • Maven
  • .NET
  • Node.js
  • Python
  • E muitas outras

Além dos executores de build suportados pela JetBrains, há mais de 100 plug-ins gratuitos e uma API abrangente que permite integrar o TeamCity com as suas próprias ferramentas e scripts.

Testes em paralelo

A paralelização inteligente de testes é um recurso exclusivo do TeamCity que permite acelerar muito o seu processo de teste. Quando múltiplos agentes de build estão disponíveis, o TeamCity pode dividir os testes automaticamente em lotes iguais com base na duração dos testes e executá-los em paralelo. Se os seus testes usarem scripts personalizados, em vez dos executores de build do TeamCity, você poderá usar mensagens de serviço para informar ao TeamCity do progresso dos scripts, para que ele possa calcular uma maneira otimizada de paralelizar os testes e usar esse cálculo para gerar arquivos especiais de instruções, ajudando assim a configurar a paralelização.

Para mais detalhes, veja a seção Testes em Paralelo da nossa documentação.

Monitoramento de desempenho

Costuma não ser fácil compreender se as instâncias no seu hardware ou na nuvem nas quais você executa os seus testes são as ideais para os seus projetos. O Monitor de Desempenho do TeamCity coleta automaticamente estatísticas de desempenho da CPU, memória e armazenamento, ajudando você a compreender se há algum gargalo prejudicando os seus pipelines.

Para mais detalhes, veja a seção Monitor de Desempenho da nossa documentação.

Testar código sem fazer commit a um VCS

O TeamCity torna possível testar o seu código sem fazer o commit para um sistema de controle de versões. Isso é especialmente útil se o seu desenvolvimento for feito em um único branch principal, pois minimiza a chance de causar falhas no build e bloquear o trabalho de outros membros da equipe.

A maneira mais fácil de testar as suas alterações sem fazer commit delas é usar o recurso de Execução Remota do plug-in do TeamCity para os IDEs baseados no IntelliJ ou para o Visual Studio. Equipes que hospedam seu código em Git têm a opção adicional de criar um patch de Git, enviá-lo ao TeamCity e depois executar um build pessoal através da interface de usuário do TeamCity.

Configuração flexível de pipelines de testes automatizados

O TeamCity oferece uma variedade de gatilhos de build para iniciar testes automaticamente e permite executar testes manualmente a partir da sua própria interface de usuário ou a partir do seu IDE. Dependendo do que tiver acionado o build e do que tiver acontecido antes no pipeline, você poderá adicionar lógica condicional ao seu pipeline de testes, para otimizar o seu processo e controlar quando os testes são executados. Por exemplo, você pode agendar builds noturnos para executar uma sequência completa de testes, executar apenas testes unitários a cada commit, ou especificar o escopo exato dos testes ao executar um pipeline manualmente.

Mais recursos do TeamCity para complementarem o seu workflow de testes

Dimensionamento automático da infraestrutura de CI/CD

Com um sistema grande de CI/CD, com muitos projetos, pode ser um desafio determinar com precisão o número de agentes de build necessários para executar builds e testes. O TeamCity pode ajudar você a implementar uma configuração escalável de CI/CD, iniciando automaticamente novos agentes de build na nuvem e aumentando dinamicamente a capacidade dos seus pipelines. As plataformas de nuvem com suporte incluem o Amazon EC2, o Microsoft Azure, o Google Cloud, o VMWare vSphere, o Kubernetes e outras.

Integração com o Docker

O TeamCity dá suporte e pode acelerar todos os workflows de desenvolvimento de software que usem o Docker. Por exemplo, ele pode executar testes em uma versão específica do ambiente, garantindo resultados consistentes e reproduzíveis, ou pode realizar testes de integração que requerem a organização de vários containers do Docker. Não importa como você usa o Docker nos seus pipelines de CI/CD, o TeamCity pode rastrear todos os eventos que ocorrerem durante o build e fornecer relatórios em tempo real, análises de testes e outros insights.

Mesclagem automática de alterações

Se o build tiver sucesso, o TeamCity poderá mesclar as alterações automaticamente em um branch designado como destino. Também é possível configurar uma série de operações de merge em cascata. Isto, combinado com a capacidade de testar o código antes de fazer o commit para um VCS, permite que você use o padrão gated commit.

FAQ: Testes automatizados com o TeamCity

A paralelização de testes com o TeamCity é um recurso gratuito?

Sim, a paralelização de testes está disponível gratuitamente em todas as edições do TeamCity, incluindo a edição gratuita auto-hospedada. No TeamCity On-Premises, você pode dividir os testes entre tantos agentes de build quantos a sua licença permitir.

Quais sistemas operacionais são suportados pelo TeamCity?

O TeamCity está disponível para Windows, Linux e macOS, e pode ser executado como um container do Docker em qualquer plataforma que tenha suporte a um runtime do Docker. Você também pode usá-lo como um serviço gerenciado, o TeamCity Cloud, que não exige que você instale ou mantenha nada.

O TeamCity pode re-executar testes falhados automaticamente?

Sim, com a ajuda do gatilho de build Retry, o TeamCity pode adicionar o build de novo à fila automaticamente em caso de falha. Isto ajuda você a lidar com situações nas quais o código está correto, mas os testes falham por causa de problemas de rede ou outros fatores externos.

O TeamCity suporta frameworks de testes de interface de usuário?

O TeamCity é uma ferramenta de CI/CD que pode ser usada com uma grande variedade de ferramentas e frameworks de teste, incluindo os usados no teste de interfaces de usuário. Para saber mais sobre o uso do TeamCity no teste de interfaces de usuário, dê uma olhada na nossa postagem de blog Interface de usuário no TeamCity: como testá-la? (em inglês).