Como criar uma pipeline de testes end-to-end com Cypress e Jenkins

Como criar uma pipeline de testes end-to-end com Cypress e Jenkins

A automação de testes é um pilar fundamental no desenvolvimento de software moderno. Testes end-to-end (E2E) garantem que o fluxo completo de uma aplicação funciona como esperado, simulando a experiência do usuário real. Integrar esses testes em uma pipeline de CI/CD (Integração Contínua/Entrega Contínua) é o próximo passo para garantir qualidade e agilidade. Neste artigo, vamos explorar como criar uma pipeline de testes end-to-end com Cypress e Jenkins, duas ferramentas poderosas para essa tarefa.

Por que Cypress e Jenkins?

Cypress se destaca como um framework de testes E2E de última geração, construído em JavaScript, que roda diretamente no navegador. Ele oferece uma experiência de desenvolvimento interativa, debug fácil e uma sintaxe clara e concisa. Jenkins, por outro lado, é um servidor de automação de código aberto amplamente utilizado, que permite orquestrar pipelines complexas de CI/CD, desde o build até o deploy, passando pela execução de testes.

A combinação dos dois permite que seus testes Cypress sejam executados automaticamente a cada novo commit, fornecendo feedback rápido para a equipe de desenvolvimento e prevenindo que bugs cheguem à produção.

Pré-requisitos

Antes de começar, certifique-se de que você possui:

• Um servidor Jenkins instalado e acessível.
• Node.js e npm instalados na máquina do Jenkins (ou a capacidade de instalá-los através de plugins).
• Um projeto com testes Cypress já configurado e versionado em um repositório Git (como GitHub ou GitLab).

Passo a Passo: Como criar uma pipeline de testes end-to-end com Cypress e Jenkins

Vamos dividir o processo em etapas simples e diretas para configurar sua pipeline.

1. Preparando o Projeto Cypress

Para que o Jenkins possa executar seus testes, é uma boa prática adicionar scripts específicos no seu arquivo package.json. Isso simplifica os comandos que a pipeline precisará executar.

{
  "name": "meu-projeto-cypress",
  "version": "1.0.0",
  "scripts": {
    "cy:open": "cypress open",
    "cy:run": "cypress run"
  },
  "devDependencies": {
    "cypress": "^9.5.0"
  }
}

O script cy:run será o comando que o Jenkins usará para rodar os testes em modo headless, ideal para ambientes de automação.

2. Configurando o Ambiente no Jenkins

Para que o Jenkins possa executar comandos npm, ele precisa do Node.js. A forma mais fácil de gerenciar isso é através do plugin NodeJS.

1. No painel do Jenkins, vá para Manage Jenkins > Manage Plugins.
2. Na aba “Available”, procure por “NodeJS Plugin” e instale-o.
3. Após a instalação, vá para Manage Jenkins > Global Tool Configuration.
4. Na seção “NodeJS”, clique em “Add NodeJS” e escolha uma versão do Node.js para instalar automaticamente. Dê um nome a ela, por exemplo, “NodeJS-16”.

Isso permite que sua pipeline especifique qual versão do Node.js deve ser usada durante a execução.

3. Criando o Job da Pipeline no Jenkins

Agora, vamos criar o job que irá orquestrar todo o processo.

1. No painel do Jenkins, clique em New Item.
2. Dê um nome ao seu job (ex: “Cypress-E2E-Tests”), selecione Pipeline e clique em “OK”.
3. Na página de configuração do job, role para baixo até a seção Pipeline.
4. Selecione “Pipeline script from SCM” na definição. Essa é a melhor prática, pois permite versionar sua pipeline junto com o código.
5. Selecione Git no SCM e insira a URL do seu repositório.
6. Certifique-se de que o “Script Path” está definido como Jenkinsfile (este é o nome padrão).

4. Escrevendo o Jenkinsfile

O Jenkinsfile é um arquivo de texto que define sua pipeline como código. Crie este arquivo na raiz do seu repositório Git. Ele descreve os estágios (stages) do seu processo de teste.

Aqui está um exemplo básico de Jenkinsfile para executar os testes Cypress:

pipeline {
    agent any

    tools {
        // O nome deve ser o mesmo configurado em 'Global Tool Configuration'
        nodejs 'NodeJS-16'
    }

    stages {
        stage('Checkout') {
            steps {
                // Clona o código do repositório
                git 'https://github.com/seu-usuario/seu-projeto.git'
            }
        }

        stage('Install Dependencies') {
            steps {
                // Instala as dependências do projeto, incluindo o Cypress
                sh 'npm install'
            }
        }

        stage('Run Cypress Tests') {
            steps {
                // Executa os testes Cypress em modo headless
                sh 'npm run cy:run'
            }
        }
    }

    post {
        always {
            // Arquiva os resultados (vídeos e screenshots de falhas)
            archiveArtifacts artifacts: 'cypress/videos/**, cypress/screenshots/**', allowEmptyArchive: true
        }
    }
}

Este script define três estágios principais: clonar o repositório, instalar as dependências e, finalmente, rodar os testes. A seção post garante que, independentemente do resultado, os artefatos gerados pelo Cypress (vídeos das execuções e screenshots de falhas) sejam salvos no Jenkins. Isso é extremamente útil para depuração.

5. Executando e Analisando os Resultados

Com o Jenkinsfile no seu repositório e o job configurado, faça um commit para o seu repositório Git. Se você configurou webhooks, o Jenkins iniciará o build automaticamente. Caso contrário, você pode clicar em Build Now no painel do job.

Você poderá acompanhar a execução de cada estágio. Se tudo correr bem, o build será marcado como “SUCCESS”. Se um teste falhar, o estágio “Run Cypress Tests” falhará, e o build será marcado como “FAILURE”. Nos detalhes do build, você encontrará os artefatos arquivados para análise.

Conclusão

Parabéns! Você acabou de aprender como criar uma pipeline de testes end-to-end com Cypress e Jenkins. Essa automação não só economiza tempo, mas também aumenta a confiança da equipe na qualidade do código entregue. A partir daqui, você pode evoluir sua pipeline, adicionando notificações, execuções paralelas e integração com outras ferramentas.

Comece a automatizar seus testes hoje e eleve a qualidade dos seus projetos a um novo patamar. O que você vai automatizar a seguir?