SVN e Jenkins: Integra��o cont�nua com SVN e Jenkins

Fique por dentro

O artigo apresenta a pr�tica de integraç�o cont�nua, muito utilizada em ambientes que adotam o desenvolvimento �gil, por�m, n�o � muito conhecido em meio a comunidade Delphi.

Sua aplicaç�o objetiva a garantia de uma entrega de software melhor, com qualidade, atrav�s de rotinas automatizadas que v�o desde compilaç�o aos testes. Para demonstrar isso o artigo aborda a criaç�o do ambiente ideal utilizando ferramentas gratuitas, como o Jenkins para a realizaç�o de Builds, o VisualSVN para controle de vers�es e DUnit para testes automatizados, tudo isso com um exemplo pr�tico.

Guia do artigo:

Jenkins
Subversion (SVN)
MSBuild
Instalando o SVN e criando um reposit�rio
Fazendo o primeiro Checkout
Criando o projeto em Delphi
Criando o projeto de testes automatizados
Mais sobre o SVN no Delphi
Integraç�o continua com Jenkins
Configurando o MSBuild
Criando um Job
Executando Testes pelo Jenkins
Automatizando a execuç�o de Jobs
Pensando nos benef�cios

Integraç�o cont�nua � uma pr�tica de metodologia �gil diretamente ligada ao XP (eXtreme Programming). A integraç�o continua visa garantir que, qualquer alteraç�o no c�digo fonte seja rapidamente integrada e validada dentro da soluç�o completa de forma transparente e automatizada. Caso uma alteraç�o que tenha sido integrada acabe por gerar uma falha, o processo de integraç�o continua deve garantir que o feedback seja imediato e preciso.

Para validar o resultado de um processo de integraç�o cont�nua � poss�vel mesclar in�meras etapas. Diferente do que muitos pensam, integraç�o continua n�o se resume somente ao build automatizado, mas sim, em uma s�rie de etapas, com destaque para os testes automatizados.

Resumindo, segundo Martin Fowler: �Integraç�o Cont�nua � uma pr�tica de desenvolvimento de software onde os membros de um time integram seu trabalho frequentemente, geralmente cada pessoa integra pelo menos diariamente � podendo haver m�ltiplas integraç�es por dia.

Cada integraç�o � verificada por um build automatizado (incluindo testes) para detectar erros de integraç�o o mais r�pido poss�vel. Muitos times acham que essa abordagem leva a uma significante reduç�o nos problemas de integraç�o e permite que um time desenvolva software coeso mais rapidamente.�

A Figura 1 ilustra um exemplo de ciclo de integraç�o cont�nua.

Figura 1. Exemplo de ciclo de integraç�o cont�nua (I.C.).

Os benef�cios na adoç�o de um processo de integraç�o cont�nua s�o in�meros, por�m, podemos destacar alguns imediatos:

Agilidade na detecç�o de falhas;
Build automatizado e parametrizado;
Atualizaç�o de ambiente de testes automatizado;
Aumento da confiabilidade dos artefatos produzidos;
Processo de desenvolvimento em equipe mais seguro.

Veremos agora um pouco sobre cada ferramenta que ser� utilizada no artigo e quais s�o os seus prop�sitos.

Jenkins

O Jenkins � uma ferramenta multiplataforma Open Source voltada para a integraç�o cont�nua, baseada (Fork � ver BOX 1) no projeto Hudson. Basicamente o Jenkins funciona como um servidor de integraç�o continua onde � poss�vel programar Jobs para diversos projetos, inclusive sendo poss�vel criar integraç�es entre esses Jobs.

N�o entraremos em muitos detalhes sobre o Jenkins por n�o ser o foco deste artigo, mas � altamente recomendado visitar o site oficial (seç�o Links) e se associar ao grupo brasileiro sobre a ferramenta (jenkinsci-br@googlegroups.com). Uma das vantagens do Jenkins � a sua comunidade extremamente forte.

Neste artigo iremos utilizar a sua distribuiç�o para o ambiente Windows visando uma melhor integraç�o com o Delphi.

BOX 1. Fork

O Fork, recurso do GitHub, consiste em criar uma c�pia independente de um determinado reposit�rio, desta forma, � poss�vel trabalhar em um fork de um projeto, sem que as alteraç�es afetem o projeto original. Esta � a forma utilizada para contribuir em projetos open source.

Ap�s as alteraç�es serem finalizadas no fork, � poss�vel realizar um pull request no reposit�rio original, com isso o dono do projeto pode tomar a decis�o de acoplar ou n�o as alteraç�es do fork ao projeto original.

Subversion (SVN)

O Subversion � um dos sistemas controladores de vers�o mais famosos atualmente. Utilizaremos ele como nosso reposit�rio neste artigo por ser extremamente simples e integrar perfeitamente com o Delphi e com o Jenkins (outra vantagem do Jenkins � sua vasta gama de Plugins que permite a integraç�o com os mais diversos sistemas controladores de vers�o como por exemplo o GIT).

Iremos criar um servidor Subversion Windows e nele iremos criar nosso reposit�rio, para isso, utilizaremos o VisualSVN Server que pode ser obtido no site dispon�vel na seç�o Links.

MSBuild

O MSBuild � a plataforma de compilaç�o da Microsoft que pode ser utilizada em conjunto com o compilador do Delphi. Utilizaremos um Plugin para o Jenkins que se integra com o MSBuild afim de realizar os processos de compilaç�o dos nossos Jobs de projetos Delphi.

O MSBuild j� � disponibilizado no Windows e pode ser encontrado no diret�rio C:\Windows\Microsoft.NET\Framework\[VERSAO]\MSBuild. Neste artigo utilizaremos a vers�o v3.5.

Instalando o SVN e criando um reposit�rio

Finalmente iremos colocar a m�o na massa, começando por nosso reposit�rio no SVN. Para isso, iremos instalar o VisualSVN Server, uma vers�o do SVN para Windows.

Basicamente seu processo de instalaç�o se resume ao padr�o Windows (next, next e finish). A �nica observaç�o se d� na escolha da ediç�o (VisualSVN Server Editions), como pode ser visto na Figura 2. Nesta tela selecione a opç�o Standard Edition que � a vers�o gratuita.

Figura 2. Instalaç�o do VirtualSVN Server.

Ap�s a instalaç�o, ser� apresentada uma tela como a da Figura 3, onde ser� poss�vel criar nossos usu�rios e nossos reposit�rios.

Figura 3. VisualSVN Server.

Criaremos dois usu�rios, um para o desenvolvedor e outro para o Jenkins, para isso, clique com o bot�o direito do mouse em Users e depois clique em Create User. Ap�s preencher o nome de usu�rio e senha, o usu�rio j� est� criado, agora basta criarmos o reposit�rio. Para isso, clique com o bot�o direito do mouse em Repositories e depois clique em Create New Repository

Ap�s preencher seu nome, ser�o apresentadas as opç�es de estrutura inicial do reposit�rio, selecione a opç�o Single-Project Repository para que j� seja criada uma estrutura padr�o (Branches, Trunk e Tags). Ap�s isso, informe que todos os usu�rios t�m acesso completo ao reposit�rio e o processo estar� finalizado (Figura 4).

Figura 4. Reposit�rio Criado.

Fazendo o primeiro Checkout

Para se trabalhar com o SVN, � preciso fazer um checkout do reposit�rio em sua m�quina, ou seja, fazer uma c�pia de trabalho do reposit�rio. Para isso utilizaremos o pr�prio Delphi que j� possui integraç�o nativa com o SVN.

No Delphi, em File->Open From Version Control, coloque a url do reposit�rio e o diret�rio da c�pia de trabalho para realizar o checkout, conforme � demonstrado na Figura 5.

Figura 5. Realizando Checkout.

Pronto, agora basta criar o projeto e salvar no diret�rio da sua c�pia local. Vale uma observaç�o, o SVN trabalha com o conceito de Branches para a c�pia de trabalho, Trunk para a �ltima vers�o est�vel e Tags para as vers�es antigas.

Criando o projeto em Delphi

Iremos criar um projeto em Delphi simples que se resume a uma classe somente que ser� utilizada para validar nossos conceitos.

Esta classe dever� realizar c�lculos relacionados a desconto e posteriormente, iremos criar uma rotina de automatizaç�o de testes para esta.
Crie um projeto do tipo VCL Forms Application ou FireMonkey HD Application e d� o nome de ClubeDelphi. Inclua uma unit chamada untDesconto e nesta codifique a classe TDesconto, conforme a Listagem 1.

Listagem 1. Classe que realiza c�lculos de descontos.


  01 unit untDesconto;
   
  02 interface
   
  03 type
  04   TDesconto = class
  05   strict private
  06     FValorTotal: Real;
  07     FValorFinal: Real;
  08     FDescontoValor: Real;
  09     FDescontoPorcentagem: Real;
  10     procedure SetValorTotal(const Value: Real);
  11   public
  12     function AplicarDescontoPorcentagem(const APorcentagem : Real):Real;
  13     function AplicarDescontoValor(const AValor : Real):Real;
  14     property ValorTotal : Real read FValorTotal write SetValorTotal;
  15     property DescontoPorcentagem : Real read FDescontoPorcentagem;
  16     property DescontoValor : Real read FDescontoValor;
  17     property ValorFinal : Real read FValorFinal;
  18   end;
 
 
  19 implementation
 
 
  20 function TDesconto.AplicarDescontoPorcentagem(
      const APorcentagem: Real): Real;
  21 begin
  22   Self.FDescontoPorcentagem := APorcentagem;
  23   Self.FDescontoValor       := (APorcentagem * Self.FValorTotal) / 100;
  24   Self.FValorFinal          := Self.FValorTotal - Self.FDescontoValor;
   
  25   Result := Self.FValorFinal;
  26 end;
 
 
  27 function TDesconto.AplicarDescontoValor(const AValor: Real): Real;
  28 begin
  29   Self.FDescontoValor       := AValor;
  30   Self.FDescontoPorcentagem := (AValor * 100) / Self.FValorTotal;
  31   Self.FValorFinal          := Self.FValorTotal - Self.FDescontoValor;
   
  32   Result := Self.FValorFinal;
  33 end;
 
 
  34 procedure TDesconto.SetValorTotal(const Value: Real);
  35 begin
  36   FValorTotal := Value;
  37   Self.AplicarDescontoValor(Self.FDescontoValor);
  38 end;
   
  39 end.

Como podemos ver a classe TDesconto, basicamente calcula descontos por porcentagem e por valor. Antes de prosseguirmos com o projeto de testes automatizados, iremos incluir nosso projeto ClubeDelphi em nosso reposit�rio do SVN, para isso, salve o projeto no diret�rio onde foi feito o checkout do nosso reposit�rio do SVN (Figura 5). Ap�s isso, clique com o bot�o direito do mouse no projeto em Project Manager e depois em Add to Version Control, conforme a Figura 6.

Figura 6. Adicionando arquivos ao reposit�rio.

Feito isso, nosso projeto j� faz parte do reposit�rio. Agora iremos criar o projeto de testes.

Criando o projeto de testes automatizados

Um processo de integraç�o cont�nua n�o faz sentido se n�o possuir uma rotina de testes automatizados, pois s� o fato de realizar um Build em um projeto, n�o garante que ele est� livre de falhas. Para Delphi existe o projeto Open Source DUnit que j� vem acoplado a IDE desde algumas vers�es mais antigas. Para mais informaç�es sobre, veja a seç�o Links ao final do artigo.

Criar um projeto de testes � algo muito simples, basta acessar o menu em File>New>Other>Unit Test>Test Project. Ser� apresentada uma tela semelhante � Figura 7.

Figura 7. Criando um projeto de testes automatizados.

Basta informar o projeto principal (Source Project), o nome do projeto de testes automatizados (Project Name) e a localizaç�o dos arquivos do projeto de testes automatizados (Location). Assim, o projeto de testes automatizados est� criado.

Faremos ent�o o nosso primeiro caso de testes, baseado na classe TDesconto Novamente acesse o menu File>New>Other>Unit Test>Test Case. Ser� apresentada uma tela semelhante � Figura 8.

Figura 8. Criaç�o do caso de testes.

Estes Wizards facilitam muito a vida de quem est� começando a lidar com a DUnit, por�m, nada impede que voc� crie seus testse do zero, basta conhecer o framework da DUnit. Ap�s a criaç�o do caso de testes, teremos uma unit com o nome de TestUntDesconto contendo a classe TestTDesconto com o esqueleto de uma rotina de automatizaç�o de testes baseada na classe TDesconto. Ap�s algumas alteraç�es na classe TestTDesconto, esta deve ficar semelhante � Listagem 2.

Listagem 2. Classe que realiza c�lculos de descontos.


  01 unit TestUntDesconto;
 
 
  02 interface
 
 
  03 uses TestFramework, untDesconto;
   
  04 type
   
  05   TestTDesconto = class(TTestCase)
  06   strict private
  07     FDesconto: TDesconto;
  08   public
  09     procedure SetUp; override;
  10     procedure TearDown; override;
  11   published
  12     procedure TestAplicarDescontoPorcentagem;
  13     procedure TestAplicarDescontoValor;
  14     procedure TestAtualizacaoDeTotal;
  15   end;
   
  16 implementation
   
  17 procedure TestTDesconto.SetUp;
  18 begin
  19   FDesconto := TDesconto.Create;
  20   FDesconto.ValorTotal := 250;
  21 end;
 
 
  22 procedure TestTDesconto.TearDown;
  23 begin
  24   FDesconto.Free;
  25   FDesconto := nil;
  26 end;
 
 
  27 procedure TestTDesconto.TestAplicarDescontoPorcentagem;
  28 var
  29   ReturnValue: Real;
  30   APorcentagem: Real;
  31 begin
  32   APorcentagem := 10;
  33   ReturnValue := FDesconto.AplicarDescontoPorcentagem(APorcentagem);
  34   CheckEquals(225,ReturnValue,'Retorno do m�todo');
  35   CheckEquals(225,FDesconto.ValorFinal,'Valor final');
  36   CheckEquals(25,FDesconto.DescontoValor,'Desconto em valor');
  37   CheckEquals(10,FDesconto.DescontoPorcentagem,'Desconto em 
         porcentagem');
  38 end;
   
  39 procedure TestTDesconto.TestAplicarDescontoValor;
  40 var
  41   ReturnValue: Real;
  42   AValor: Real;
  43 begin
  44   AValor      := 25;
  45   ReturnValue := FDesconto.AplicarDescontoValor(AValor);
  46   CheckEquals(225,ReturnValue,'Retorno do m�todo');
  47   CheckEquals(225,FDesconto.ValorFinal,'Valor final');
  48   CheckEquals(25,FDesconto.DescontoValor,'Desconto em valor');
  49   CheckEquals(10,FDesconto.DescontoPorcentagem,'Desconto em  
         porcentagem');
  50 end;
 
 
  51 procedure TestTDesconto.TestAtualizacaoDeTotal;
  52 begin
  53   FDesconto.AplicarDescontoValor(35);
  54   CheckEquals(215,FDesconto.ValorFinal);
  55   FDesconto.ValorTotal := 350;
  56   CheckEquals(35,FDesconto.DescontoValor,'Desconto $ p�s atualizaç�o');
  57   CheckEquals(10,FDesconto.DescontoPorcentagem,'Desconto % p�s 
         atualizaç�o');
  58   CheckEquals(315,FDesconto.ValorFinal,'Valor final p�s atualizaç�o');
  59 end;
 
 
  60 initialization
  61   RegisterTest(TestTDesconto.Suite);
   
  62 end.

O objetivo desse c�digo n�o � abordar em si o que a unit TestDesconto faz, mas sim o uso do DUnit. Para isso, vale conhecermos a respeito de alguns conceitos b�sicos. As classes de caso de teste devem descender da classe TTestCase para que seja poss�vel registrar a su�te de testes da classe.

Os m�todos SetUp (linhas 17 a 21) e TearDown (linhas 22 a 26) podem ser sobrepostos (override) caso sejam necess�rios. Esses s�o executados sempre antes (SetUp) e depois (TearDown) da execuç�o de qualquer m�todo de teste. Metodologias �geis defendem que cada teste deve ser independente, por isso, � poss�vel criar e liberar a instancia de um objeto a cada teste, prevenindo assim qualquer poss�vel interfer�ncia entre os testes, para isso, basta usar o m�todo SetUp e o m�todo TearDown.

Os m�todos de teste devem estar na sess�o published da classe de caso de testes, para que assim, atrav�s da RTTI o framework da DUnit consiga execut�-los.

Voltando a falar da nossa classe TestTDesconto, ela basicamente testa as 3 possibilidades da classe TDesconto, aplicaç�o de desconto por porcentagem (linhas 27 a 38), desconto por valor (linhas 39 a 50) e atualizaç�o do valor total com rec�lculo dos descontos (linhas 51 a 59).

Para ver nossos testes em aç�o, basta executar o aplicativo. Essa aç�o dever� apresentar algo como a Figura 9.

Figura 9. DUnit em aç�o.

Mais sobre o SVN no Delphi

Finalizado o projeto de testes, � chegada a hora de adicion�-lo ao nosso reposit�rio no SVN, para isso, repita o processo de Add to Version Control, como demonstrado na Figura 6.

Feito isso, nosso reposit�rio j� sabe da exist�ncia dos arquivos do nosso projeto, agora precisamos realizar o commit das alteraç�es. O commit � o processo onde as alteraç�es locais s�o efetivadas no reposit�rio principal.

Para realizar o commit a partir do Delphi, basta clicar com o bot�o direito do mouse no projeto em Project Manager e depois clicar em Subversion>Commit>From Project Directory. Ser� apresentada uma tela semelhante � Figura 10.

Figura 10. Arquivos que foram alterados ap�s o �ltimo commit.

Nos casos em que um membro da equipe realizar um Commit no reposit�rio e sua c�pia passar a ficar desatualizada, basta realizar o processo de Update. O Update � o processo oposto ao Commit, se no Commit estamos efetivando nossas alteraç�es locais no reposit�rio principal, no Update estamos atualizando nossa c�pia local se baseando na c�pia do reposit�rio. No Delphi esta opç�o fica em Subversion>Update>From Project Directory, ou ao clicar de direito sobre o projeto no Project Manager.

Integraç�o continua com Jenkins

Vamos agora para o nosso "maestro", que ir� orquestrar toda a nossa obra, o poderoso servidor de integraç�o cont�nua Jenkins.

Lembrando que o Jenkins n�o � a �nica opç�o de servidor de integraç�o continua no mercado, como � o caso do Final Builder, um excelente servidor de integraç�o que j� vem (em uma vers�o um pouco mais limitada) junto a algumas vers�es do Delphi.

A instalaç�o do Jenkins n�o possui relativas dificuldades. Depois de instalado, o Jenkins passa a rodar como um serviço do Windows e responde com um servidor HTTP na porta 8080 (Figura 11).

Figura 11. Tela inicial do Jenkins

Com o Jenkins instalado e funcionando, podemos instalar o Plugin do MSBuild para que seja poss�vel compilar nossas aplicaç�es Delphi. Na lateral esquerda da tela principal (Figura 11) clique sobre o menu Gerenciar Jenkins. Este � o painel de controle do Jenkins. Agora v� em �Gerenciar Plugins>Dispon�veis� e na caixa de filtro, digite MSBuild. Marque para instalar o Plugin e clique em �Baixar agora, instalar e depois reiniciar�.

Feito isso, o MSBuild j� estar� instalado e, caso haja algum problema na instalaç�o autom�tica do plugin, � poss�vel realizar o download manualmente (ver seç�o Links) e realizar a instalaç�o em �Gerenciar Plugins>Avançado>Upload�.

Por�m, se voc� usar proxy na sua rede, pode ser que ocorra algum erro para realizar o download, caso voc� se depare com esse cen�rio, v� em �Gerenciar Plugins> Avançado� e realize a configuraç�o de proxy do Jenkins.

Outro Plugin necess�rio � o EnvInject (seç�o Links) que basicamente injeta vari�veis de ambiente ao processo de build de um projeto. Instale-o da mesma forma como foi instalado o MSBuild.

Configurando o MSBuild

Com nossos Plugins instalados no Jenkins, vamos realizar as configuraç�es do MSBuild na opç�o �Gerenciar Jenkins>Configurar o sistema>MSBuild Instalaç�es�. Nesta sess�o, iremos especificar as informaç�es sobre o MSBuild instalado no servidor que iremos utilizar. Os par�metros que iremos configurar s�o os seguintes:

Name: Um nome de identificaç�o para o Plugin instalado, j� que podem ser configurados mais de um MSBuild.
Path do MSBuild: Caminho completo do bin�rio do MSBuild, geralmente encontrado em �C:\Windows\Microsoft.NET\Framework\[vers�o]\MSBuild.exe�

Criando um Job

Primeiramente iremos criar um Job simples que somente baixe os fontes do SVN e compile o projeto, depois iremos aprimorando. Clique em �Novo Item� na lateral esquerda do Jenkins, informe o nome do Job e selecione a opç�o �Construir um projeto de software free-style�.

Na tela de parametrizaç�o do Job, na opç�o �Gerenciamento de c�digo fonte�, selecione o Subversion. Ao realizar essa seleç�o, ser�o apresentadas as parametrizaç�es do gerenciador. Para o Subversion, iremos configurar somente o diret�rio do nosso reposit�rio, algo como https://[servidor]/svn/clubedelphi/branches/.

Caso o Jenkins n�o consiga estabelecer conex�o com o reposit�rio, ser� solicitado o usu�rio e senha de acesso atrav�s do link �Enter credential�. Especifique o usu�rio criado no SVN para ser usado no Jenkins com o tipo de autenticaç�o �username/password�.

Agora na opç�o �Ambiente de Build�, marque a opç�o �Inject environment variable to the build process� (essa opç�o est� dispon�vel graças ao Plugin EnvInject) e em �Properties Content� copie o conte�do do arquivo rsvars.bat sem os @SET antes do nome das vari�veis.

Esse arquivo j� vem com o Delphi, geralmente no diret�rio �C:\Program Files (x86)\Embarcadero\RAD Studio\[vers�o]\bin�. Essas vari�veis de ambiente s�o necess�rias no momento do Build de aplicaç�es Delphi pelo MSBuild.

Finalmente chega a hora de configurar os processos de Build. Na tela de parametrizaç�o do Job, v� em �Adicionar passo no build>Build a Visual Studio project or solution using MSBuild�. Em �MSBuild Version�, selecione a instalaç�o do MSBuild configurada anteriormente, em �MSBuild Build File�, digite o nome do arquivo dproj do projeto que ser� compilado, no caso ClubeDelphi.dproj e por fim, em �Command Line Arguments�, coloque o seguinte texto: �/v:d /target:Build /p:config=Debug�, com isso estamos especificando que faremos um build do projeto no modo Debug.

Com essas configuraç�es feitas, deveremos ter algo como a Figura 12.

Figura 12. Parametrizaç�o do Job.

Salve as configuraç�es e clique em �Construir agora� na lateral esquerda, para testar o Job. Se tudo ocorrer como esperado, dever� aparecer um c�rculo azul no hist�rico de Builds dentro das opç�es do Job, ou no grid da Dashboard do Jenkins, isso significa que o processo foi bem sucedido, caso algo d� errado, esse c�rculo dever� ser vermelho. Observe o exemplo na Figura 13.

Figura 13. Hist�rico de Builds.

Executando Testes pelo Jenkins

Um processo de integraç�o cont�nua n�o est� completo se n�o existirem testes unit�rios automatizados. Sendo assim, nosso projeto de testes j� est� pronto, por�m, da forma como o Delphi cria o projeto de teste da DUnit atrav�s de seu Wizard, o mesmo n�o est� pronto para a execuç�o por linha de comando.

A Listagem 3 apresenta o c�digo do arquivo .dpr rec�m gerado de um projeto de teste da DUnit.

Listagem 3. Projeto de testes.


  01 program ClubeDelphiTests;
   
  02 {$IFDEF CONSOLE_TESTRUNNER}
  03 {$APPTYPE CONSOLE}
  04 {$ENDIF}
 
 
  05 uses
  06   DUnitTestRunner,
  07   TestUntDesconto in 'TestUntDesconto.pas',
  08   untDesconto in '..\untDesconto.pas';
 
 
  09 {$R *.RES}
 
 
  10 begin
  11   DUnitTestRunner.RunRegisteredTests;
  12 end.

Por�m, precisamos que o aplicativo de testes funcione com interface gr�fica se for executado por uma pessoa, e tamb�m como console, se for executado pelo Jenkins. Assim sendo, faremos algumas alteraç�es neste arquivo para que o mesmo suporte as duas opç�es. O c�digo deve ser feito como descrito na Listagem 4.

Listagem 4. Projeto de testes.


  01 program ClubeDelphiTests;
 
 
  02 {$IFDEF CONSOLE_TESTRUNNER}
  03 {$APPTYPE CONSOLE}
  04 {$ENDIF}
   
  05 uses
  06   TestFrameWork,
  07   TextTestRunner,
  08   GUITestRunner,
  09   TestUntDesconto in 'TestUntDesconto.pas',
  10   untDesconto in '..\untDesconto.pas';
   
  11 {$R *.RES}
   
  12 var
  13   Results: TTestResult;
   
  14 begin
  15   if ParamStr(1) = 'jenkins' then
  16   begin
  17     Results := TextTestRunner.RunRegisteredTests;
  18     try
  19       if Results.FailureCount + Results.ErrorCount = 0 then
  20         ExitCode := 0
  21       else
  22         ExitCode := 1;
  23     finally
  24       Results.Free;
  25     end;
  26   end
  27   else
  28     GUITestRunner.RunRegisteredTests;
  29 end.

Embora esse c�digo seja relativamente grande, � relativamente simples. Devemos atentar principalmente a partir da linha 15. Nota-se que � verificado se foi recebido um par�metro denominado �jenkins�. Caso ele exista, a execuç�o ocorrer� da linha 17 a 25, onde � executado o m�todo RunRegisteredTests de TextTestRunner (linha 17) em modo console, caso contr�rio, o mesmo m�todo � executado, por�m de GUITestRunner (linha 28), utilizando interface gr�fica.

Voltando ao Jenkins, faremos agora com que nosso Job saiba da exist�ncia do projeto de testes e passe a consider�-lo, mas, antes disso, deve-se realizar o commit das alteraç�es do projeto para o SVN.

Nas configuraç�es do Job inclua mais dois passos de Build, o primeiro ser� um �Build a Visual Studio project or solution using MSBuild�, como feito anteriormente, mas dessa vez, apontando para o projeto de testes, ou seja, no campo MSBuild File dever� estar o valor �Test\ClubeDelphiTests.dproj�. Posicione esse Build como sendo o primeiro da lista.

O segundo passo de Build a ser adicionado � do tipo �Executar no comando do Windows�. Esse ser� o passo onde iremos executar nosso teste. No campo para especificar o que ser� executado, informe a instruç�o: �Test\Win32\Debug\ClubeDelphiTests.exe jenkins�. Ou seja, atrav�s de linhas de comando estaremos executando a aplicaç�o de testes passando o par�metro 'jenkins'. Posicione esse passo de build como sendo o segundo.

Agora o build do Job dever� conter os seguintes passos: �Compilaç�o do projeto de testes>Execuç�o dos testes>Compilaç�o do projeto principal�. Quando qualquer um destes passos falharem, o seguinte n�o ser� executado.

Salve as alteraç�es e execute o Job clicando em �Construir agora�. Neste momento, perceba que nada de diferente aconteceu, isso porque todos os testes est�o obtendo sucesso. Para validar o ciclo, na unit TestUntDesconto.pas do projeto de testes, localize o m�todo TestTDesconto.TestAplicarDescontoPorcentageme altere a linha:

APorcentagem := 10;

para

APorcentagem := 11;

Faça o commit das alteraç�es e execute o Job. Sim, agora temos um c�rculo vermelho. Isso significa que algo falhou (mas para n�s significa que o processo est� coerente).

Para saber mais sobre a execuç�o do Build, clique no link da execuç�o do Build (o link que possui o c�rculo com a cor de status, o n�mero de Build, e a data e hora de execuç�o) e depois clique em Sa�da do Console. Para o Job, a sa�da do Build provavelmente ocorrer� na seguinte ordem: execuç�o do Plugin EnvInject, atualizaç�o do reposit�rio do SVN, compilaç�o do projeto de testes e finalmente, a execuç�o dos testes com o texto da Listagem 5.

Listagem 5. Resultado dos testes.


  DUnit / Testing
 ...F..
 Time: 0:00:00.0 
 
 FAILURES!!! 
 Test Results: 
 Run: 3 
 Failures: 1 
 Errors: 0 
 There was 1 failure: 
   1) TestAplicarDescontoPorcentagem: ETestFailure 
     at "Retorno do m�todo, expected: <225> but was: <222,5>" 
 
 C:\Program Files (x86)\Jenkins\jobs\ClubeDelphi\workspace>exit 1 
 Build step 'Executar no comando do Windows' marked build as failure 
 Finished: FAILURE

Com isso comprovamos que nosso ciclo de integraç�o continua est� funcionando por completo. Por�m, h� como aprimorar ainda mais a sa�da de console dos testes, para isso, � poss�vel utilizar o Plugin NUnit para o Jenkins, que � espec�fico para interagir com os resultados de testes no padr�o NUnit.

Instale esse plugin atrav�s da listagem de plugins dispon�veis do jenkins, caso ele n�o esteja dispon�vel nesta listagem, voc� pode baixar a sua �ltima vers�o pelo GitHub (seç�o Links). A DUnit que vem com o Delphi j� est� preparada para exportar os resultados dos testes registrados para um arquivo XML, por�m, esse arquivo n�o est� no padr�o esperado pelo plugin NUnit do Jenkins.

Para resolver este problema foi criada por Mark Pickersgill a unit �XMLTestRunner2pas� que basicamente substitui a unit TextTestRunnerpas em nosso exemplo. Baixe essa unit (seç�o Links) e adicione a biblioteca da DUnit do Delphi (geralmente em C:\Program Files (x86)\Embarcadero\RAD Studio\[vers�o]\source\DUnit\src).

Com todas ferramentas preparadas para interagir com o padr�o NUnit nos resultados dos testes, � necess�rio adaptar a aplicaç�o e o Job para tirar proveito deste recurso. Começaremos pelo projeto de testes. Basicamente a alteraç�o necess�ria ser� substituir a unit TextTestRunner pela XMLTestRunner2 em nosso arquivo DPR e depois especificar o local de sa�da para o arquivo XML gerado. Ap�s a alteraç�o, o c�digo do projeto de testes deve ficar semelhante ao da Listagem 6.

Listagem 6. Projeto de testes atualizado.


  01 program ClubeDelphiTests;
   
  02 {$IFDEF CONSOLE_TESTRUNNER}
  03 {$APPTYPE CONSOLE}
  04 {$ENDIF}
   
  05 uses
  06   TestFrameWork,
  07   XMLTestRunner2,
  08   GUITestRunner,
  09   TestUntDesconto in 'TestUntDesconto.pas',
  10   untDesconto in '..\untDesconto.pas';
  
  11 {$R *.RES}
   
  12 var
  13   Results: TTestResult;
   
  14 begin
  15   if ParamStr(1) = 'jenkins' then
  16   begin
  17     Results := XMLTestRunner2.RunRegisteredTests('DUnitResult.xml');
  18     try
  19       if Results.FailureCount + Results.ErrorCount = 0 then
  20         ExitCode := 0
  21       else
  22         ExitCode := 1;
  23     finally
  24       Results.Free;
  25     end;
  26   end
  27   else
  28     GUITestRunner.RunRegisteredTests;
  29 end.

Note que o c�digo � o mesmo da anterior, diferindo apenas na linha 17, onde � utilizada a unit XMLTestRunner2.

Faça o commit das alteraç�es para o SVN. Por fim, iremos adaptar nosso Job para ter conhecimento do arquivo DUnitResult.xml que ser� gerado a cada execuç�o dos testes. Nas configuraç�es do Job, adicione um passo p�s-build em �Add post-build action�, esse passo ser� do tipo �Publish NUnit test result report� (essa opç�o est� dispon�vel graças � instalaç�o do plugin NUnit).

Note que a �nica configuraç�o do passo � o caminho do arquivo XML. Informe o nome que especificado no projeto de testes, ou seja, �DUnitResult.xml�. Salve as configuraç�es e execute o Job.

Note que agora existe uma s�rie de indicadores de testes, baseados no resultado do �ltimo Build. Na p�gina principal do Job agora � poss�vel ver o �ltimo resultado de teste e tamb�m � exibido um gr�fico de Tend�ncia de resultados de teste conforme a Figura 14.

Figura 14. Plugin NUnit em aç�o.

Automatizando a execuç�o de Jobs

At� agora, toda execuç�o de Jobs que fizemos foi atrav�s de um processo de acionamento manual, com certeza esse n�o � o cen�rio ideal para o dia a dia. Podemos resolver essa quest�o de duas maneiras (e inclusive combin�-las), a primeira � atrav�s de agendamento de execuç�o de Jobs e a segunda � atrav�s de scripts de hook do SVN.

Nas configuraç�es de um Job, existe a opç�o �Trigger the builds>Construir periodicamente�, ao marcar essa opç�o ser� disponibilizado um campo para digitar as configuraç�es de agenda. Para quem est� familiarizado com o Linux, os comandos de agendamento de Jobs do Jenkins seguem o padr�o Cron (com pequenas diferenças), por exemplo, para programar um Job para ser executado de hora em hora, basta utilizar o texto: �1 * * * *� que significa que ser� executado "no minuto 1 de toda hora, todo dia, todo m�s e todo dia da semana".

Para n�o executar um Job de forma desnecess�ria, � poss�vel condicionar sua execuç�o a uma poss�vel alteraç�o no reposit�rio, para que isso seja poss�vel, basta realizar a mesma configuraç�o na opç�o �Consultar periodicamente o SCM� e descartar a opç�o �Construir periodicamente�.

A outra opç�o � utilizar os Hooks do SVN. Os Hooks s�o rotinas a serem executadas entre eventos de um reposit�rio do SVN. Por exemplo, � poss�vel programar uma rotina para ser executada logo ap�s um Commit em um determinado reposit�rio, em termos t�cnicos estar�amos configurando um Hook de Post-Commit. No ambiente Windows os Hooks podem ser tanto um execut�vel como um script .bat, enquanto que no ambiente Unix poderia ser um script python, um script shell, um bin�rio C e etc.

O Jenkins possui uma API REST pr�pria, que entre outras coisas, permite que, via HTTP-GET seja poss�vel realizar a construç�o (Build) de um projeto. A URL desta API segue o seguinte Template: �http://[servidor_jenkins]/job/[nome_do_job]/build�. Faremos proveito deste recurso para que, quando um Commit seja disparado em nosso reposit�rio, seja acionado o Build do Job no Jenkins.

Para nos auxiliar neste processo, usaremos o aplicativo WGET (seç�o Links). Este � um aplicativo Free extremamente simples que dentre outras coisas, executa requisiç�es HTTP por linha de comando.

Com o WGET dispon�vel no servidor, vamos finalmente programar o nosso Hook, no VisualSVN Server (Figura 15), sendo assim, clique de direita no reposit�rio e depois selecione a opç�o �Todas as tarefas -> Manage Hooks�.

Figura 15. Manage Hooks.

Ser� apresentada uma lista com todos os poss�veis Hooks. Utilizaremos o Post-Commit Hooks, hook executado logo ap�s o Commit neste reposit�rio. Marque o Hook e depois clique em editar. Respeitando os caminhos configurados em seu ambiente, configure o comando da Listagem 7 como sendo o comando do Hook.

Listagem 7. Post-Commit Hook.


  C:/Projetos/wget.exe -b http://localhost:8080/job/ClubeDelphi/build

O par�metro �b indica que o WGET ir� realizar a requisiç�o em Background. Sendo assim o processo foi finalizado, agora ao realizar qualquer Commit em seu reposit�rio, automaticamente ser� iniciado o processo de Build do seu Job no Jenkins.

Pensando nos benef�cios

As possibilidades dentro da integraç�o cont�nua s�o diversas, sendo um dos principais pilares no processo de ALM (Application Life Management). Em integraç�es manuais, o dia a dia de uma equipe que trabalha em um projeto relativamente mais sofisticado se torna cada vez mais complicada ao entrarem em processos de geraç�o de Build, testes, montagens e etc.

Imagine realizar a montagem de um pacote resultante de mais de 20 Commits, se ocorrer um erro durante os testes, seria f�cil descobrir o respons�vel? Seria f�cil retomar o racioc�nio de mais de cinco Commits atr�s?

A adoç�o da integraç�o cont�nua colabora para diminuir os riscos de um projeto, a ponto que, ao final de cada dia, � poss�vel se certificar que toda evoluç�o o projeto foi implementada, testada, integrada e possivelmente publicada em um ambiente de testes ou at� mesmo de produç�o, fazendo o que � conhecido como entrega cont�nua.

Confira tamb�m

Curso de Python

Curso

Criando minha primeira aplicaç�o em Delphi