Configurando Jenkins para um projeto com GhostDriver e Gradle

Depois de algumas semanas sem postar, hoje trago um post bem interessante. Vamos mostrar um exemplo simples de como configurar um job no Jenkins para rodar um projeto de testes com GhostDriver, Gradle e TestNG. O projeto que vamos utilizar como exemplo está no meu GitHub, clique aqui para acessar a página do projeto.

Um pouco sobre o Gradle

O Gradle é uma ferramenta de build open source, desenvolvida em Groovy. Ultimamente, ele tem tido bastante destaque na comunidade, sendo utilizado, inclusive, como ferramenta de build do Android. O LinkedIn, e projetos como Hibernate, Spring e Grails também usam o Gradle em seus builds. O diferencial do Gradle é que ele combina o que há de melhor no Maven (gerenciamento de dependências e conceito de convenção sobre configuração) e Ant (flexibilidade das tasks), juntamente com uma DSL (Domain Specific Language) que simplifica muito a escrita dos scripts de build.

Para saber mais sobre o Gradle, veja a documentação, no próprio site. Outro ponto positivo do Gradle é que sua documentação é excelente: extremamente completa e fácil de entender. :)

build.gradle

Enquanto no Ant existe o arquivo build.xml e no Maven o pom.xml, no Gradle, o arquivo de build se chama build.gradle. Você pode ver o arquivo completo do projeto de exemplo aqui. Observe os seguintes trechos no arquivo de build:

repositories {  
    mavenCentral()
}

dependencies {  
    testCompile(
        ['org.testng:testng:6.8.8'],
        ['org.uncommons:reportng:1.1.4'],
        ['com.google.inject:guice:3.0'],
        ['org.seleniumhq.selenium:selenium-java:2.42.0'],
        ['org.seleniumhq.selenium:selenium-server:2.42.0'],
        ['com.github.detro.ghostdriver:phantomjsdriver:1.1.0']
    )
}

Na primeira parte do trecho acima, vemos que o Gradle usará o repositório Maven Central para baixar as dependências do nosso projeto. Na segunda parte, observe as dependências que estão sendo declaradas no projeto: TestNG, ReportNG (extensão do TestNG para relatórios mais elegantes), Guice (necessário para o ReportNG), Selenium-Java/Selenium-Server, e o PhantomJSDriver (binding do GhostDriver em Java).

test {  
    useTestNG() {
        suiteXmlBuilder().suite(name: 'exemplo-ghostdriver-gradle') {
            test (name : 'Test Suite') {
              packages {
                'package' (name: 'ghostdriver.tests.*')
              }
            }
        }
    }
}

No trecho acima, perceba que estamos dizendo ao Gradle que vamos usar o TestNG. Além disso, o Gradle permite criar, dentro do arquivo de build, uma suite do TestNG, através do método "suiteXmlBuilder()". Nesse caso, estamos criando uma suite que roda todos os testes dentro do pacote "ghostdriver.tests".

Gradle + Eclipse

Para usar o Gradle no Eclipse, basta instalar o plugin, seguindo as instruções descritas aqui.


Jenkins

O Jenkins é o servidor de Integração Contínua mais popular atualmente. Ele é um fork do Hudson, que hoje pertence à Oracle. Para prosseguir com o nosso exemplo, acesse a página do Jenkins e faça o download da versão mais recente (em arquivo .war). A partir desse arquivo .war, podemos fazer o deploy dele em um servidor de aplicação, como o Tomcat. Entretanto, por motivos didáticos, vamos iniciar o Jenkins localmente para fazer nossos testes. Para isso, abra um Terminal, navegue até o diretório onde foi salvo o arquivo .war e digite:

java -jar jenkins.war

Quando aparecer no console a informação "INFO: Jenkins is fully up and running", é porque o Jenkins já está no ar. Abra, em um browser qualquer, a URL "http://localhost:8080" e veja que a página inicial do Jenkins é exibida.

IMPORTANTE!

Antes de prosseguir com o tutorial, lembre que o PhantomJS deve estar instalado na máquina que irá rodar o Jenkins. Se quiser, veja o post sobre GhostDriver para mais informações, mas o procedimento é bem simples: baixe a última versão do PhantomJS, extraia o .zip em um diretório de sua preferência e adicione o caminho desse diretório no seu PATH.


Plugins

O Jenkins oferece mais de 600 plugins para customizá-lo de acordo com suas necessidades. Existem plugins pra tudo que você precisar: linguagens, ferramentas de controle de versão, de build, de cobertura de código, etc.. Nesse link, você pode ver a lista dos plugins por categoria, assim como uma descrição dos mesmos.

No nosso exemplo, vamos precisar de dois plugins:

  • Git Plugin (para baixarmos o projeto do GitHub)
  • Gradle Plugin (para que o Jenkins rode o arquivo build.gradle, que executa nossos testes)

Para instalar plugins, primeiro clique na opção "Gerenciar Jenkins", no lado esquerdo da tela principal. Em seguida, clique na opção "Gerenciar Plugins", vide imagem abaixo:

gerenciar plugins

Feito isso, selecione a aba "Disponíveis" e busque pelos plugins citados acima digitando na busca, que fica no lado direito da tela:

plugins disponiveis

Após selecionar os plugins, clique no botão "Baixar agora, instalar e depois reiniciar", na parte de baixo da tela. Aguarde o Jenkins terminar o processo e reiniciar, e pronto, seus plugins já estão instalados e podem ser usados. :)


Configurando o sistema

Clique novamente na opção "Gerenciar Jenkins", na tela principal. Depois disso, clique na opção "Configurar o sistema":

config sistema

Nessa tela, precisamos configurar três itens:

  • JDK

Informe o conteúdo da variável de ambiente JAVA_HOME (que é o caminho da sua instalação da JDK) e dê um nome para a instalação.

  • Git

Informe o caminho do executável do git e dê um nome para a instalação. Caso não tenha o git instalado, baixe em http://git-scm.com/downloads

  • Gradle

Nesse item, você tem duas opções: instalar o Gradle e adicionar o diretório da instalação no seu PATH OU selecionar a opção para o Jenkins instalar automaticamente. Particularmente, recomendo ter uma instalação do Gradle na máquina. Para isso, são necessários apenas 4 passos:

  1. Baixar o .zip do Gradle em http://www.gradle.org/downloads
  2. Extrair o .zip para um diretório de sua preferência
  3. Criar uma variável de ambiente GRADLE_HOME, contendo o caminho do diretório do Gradle (ex: C:\gradle)
  4. Colocar o caminho do diretório "bin" (ex: C:\gradle\bin) da instalação do Gradle na variável PATH

Feito isso, podemos criar nosso job para rodar os testes. A imagem abaixo mostra um exemplo de configuração:

configJdkGitGradle


Criando um job

Para criar um novo job, clique na opção "Novo Item", no lado esquerdo da tela principal. Dê um nome ao job, selecione a opção "Construir um projeto de software free-style" e clique em OK:

novo job

Na seção "Gerenciamento de código fonte", selecione "Git" e informe a URL do repositório (vide imagem abaixo). No caso, informei a URL do repositório do projeto de exemplo no meu GitHub: https://github.com/stefanteixeira/exemplo-ghostdriver-gradle.git

git job

Na seção "Build", clique em "Adicionar passo no build" e, em seguida, na opção "Invoke Gradle Script":

invoke gradle

Selecione, em "Gradle Version", a instalação do Gradle que configuramos anteriormente. No campo "Tasks", informe "clean test --debug". O "clean" diz para o Gradle limpar o diretório de build (caso exista), o "test" diz para o Gradle rodar a task "test", que mostramos no início do post. Já o parâmetro "--debug" apenas seta o log level para debug, o que facilita para investigar caso algum erro ocorra. Finalmente, no campo "Root Build script", informe "${workspace}/exemplo-ghostdriver-gradle", para que o Jenkins rode o arquivo build.gradle que se encontra dentro do projeto. Exemplo de configuração:

gradle config

Para terminar, vamos configurar o Jenkins para publicar o relatório de testes do JUnit. Mesmo que estejamos usando TestNG, são gerados relatórios .xml iguais aos do JUnit. :) Na seção "Ações pós-builds", clique em "Add post-build action" e na opção "Publicar relatório de testes do JUnit":

post build

No campo "Relatório XML de teste", informe "**/build/test-results/*.xml", para pegar todos os arquivos XML dentro desse diretório:

publish junit

Finalmente, clique em "Salvar". Pronto! Tudo está configurado e pronto para rodar.


Executando um job

Clique na opção "Construir agora", no lado esquerdo da tela:

construir agora

Aparecerá um build em execução na caixa "Histórico de builds". Clique nele e selecione a opção "Console output" para acompanhar a execução. Se tudo der certo, você verá uma tela parecida com essa, contendo inclusive um link para o resultado dos testes:

link results

Clicando no link de resultado de testes, é exibido um relatório dos testes executados:

test results


Conclusão

O post foi longo, mas, se você olhar bem, verá que os passos são simples. Poder rodar testes pela UI no próprio servidor de Integração Contínua, de forma simples, sem precisar usar Selenium Grid ou Xvfb, é uma grande vantagem e ajuda muito em termos um rápido feedback dos nossos testes. Existem, inclusive, servidores de IC que já suportam PhantomJS por default, como o Travis CI.

Finalizando, recomendo o livro "Jenkins Continuous Integration Cookbook", escrito pelo Alan Berg, para aprender mais sobre o Jenkins. Além disso, recomendo também ler os links que estou colocando abaixo, na seção de Referências. Estou listando links bastante úteis sobre Integração Contínua, Jenkins e Gradle.

Caso tenham dúvidas ou perguntas/sugestões quaisquer, podem postar nos comentários ou entrar em contato comigo. :)

Até o próximo post!


Referências

CI:
http://blog.caelum.com.br/integracao-continua/
http://www.devmedia.com.br/integracao-continua-uma-introducao-ao-assunto/28002

Jenkins:
http://jenkins-ci.org/
https://wiki.jenkins-ci.org/display/JENKINS/Plugins
http://blog.caelum.com.br/integracao-continua-de-projeto-java-com-jenkins/
http://www.amazon.com/Jenkins-Continuous-Integration-Cookbook-Alan/dp/1849517401

Gradle:
http://www.gradle.org/
http://www.infoq.com/br/news/2012/06/gradle-1-automacao
http://www.gradle.org/tooling
https://github.com/spring-projects/eclipse-integration-gradle/
http://www.gradle.org/docs/current/groovydoc/org/gradle/api/tasks/testing/testng/TestNGOptions.html
Tutorial Gradle Command Line


Sobre o autor: Stefan Teixeira trabalha como QA Engineer e, desde o final de 2014, tem se aventurado no mundo DevOps. É Bacharel em Ciência da Computação pela UFRJ e MBA em Garantia de Qualidade de Software pela Escola Politécnica da UFRJ. Entusiasta de Testes Automatizados (e de tudo que possa ser automatizado!), Agile Testing e da cultura DevOps.

Contatos: stefanfk@gmail.com | Twitter | LinkedIn


comments powered by Disqus