Olá Pessoal, hoje vou falar um pouco sobre Programação Orientada a Teste ou TDD, essa é uma das técnicas que vem sendo muito utilizadas dentro dos ambientes de desenvolvimento e que também está dentro da filosofia agile e XP(Extreme Programming) e sua utilização vem crescendo cada vez mais.
Essa filosofia de desenvolvimento traz muitos benefícios, entre eles estão o desenvolvimento de um produto final melhor, uma boa organização de código, e um dos pontos mais importantes é que quando houver uma grande mudança no sistema você pode rastrear quais são os efeitos destas mudanças por meio dos teste feitos anteriormente.
Para dar uma introdução de como funciona o TD vou dar um exemplo de como desenvolver um Placar de Futebol.
Primeiro Cliclo
O TDD é desenvolvido em ciclos. Em primeiro lugar desenvolvemos o a Interface do placar. Essa interface pode ser vista como o projeto do Placar, onde vão ser definidas as funções e variáveis.
Para isso vamos criar um projeto Class Library no VS2010, com o nome de Placar, vamos criar uma Interface
IPlacar uma classe
Placar que vai implementar a interface criada, o projeto e os códigos devem ficar semelhantes as figuras abaixo:
namespace Placar
{
public interface IPlacar
{
int jogador1 { get; }
int jogador2 { get; }
string getPlacarAtual();
void addJogador1();
void addJogador2();
void clearPlacar();
}
}
namespace Placar
{
class Placar: IPlacar
{
public int jogador1 { get; set; }
public int jogador2 { get; set; }
public string getPlacarAtual()
{
throw new NotImplementedException();
}
public void addJogador1()
{
throw new NotImplementedException();
}
public void addJogador2()
{
throw new NotImplementedException();
}
public void clearPlacar()
{
throw new NotImplementedException();
}
}
}
Após montado o projeto básico, vamos começar a montar nosso primeiro teste, para isso vamos criar um novo projeto Class Library chamado Placar.Test, que é onde vamos testar nosso placar, para realizar os teste eu utilizo o NUnit que pode ser baichado
aqui. para que o Nunit possa achar nossos teste adicione na referência do projeto a DLL do NUnit (nunit.framework) que está na pasta da instalação do NUnit. Criamos a classe de teste, com os primeiros teste:
namespace Placar.Teste
{
[TestFixture]
public class PlacarTest
{
[Test]
public void PlacarZerado()
{
IPlacar placar = new Placar();
Assert.AreEqual("0", placar.jogador1);
Assert.AreEqual("0", placar.jogador2);
Assert.AreEqual("0x0", placar.getPlacarAtual());
}
}
}
Com isso pronto podemos começar a testar. Abra o NUnit na aba file click em Open Project e procure pela DLL do Placar.Test, click em Run e terá o resultado do teste:
O primeiro teste falhou, pois ainda não foi implementada a função getPlacarAtual e as variaveis não estão com o valor "0".
Segundo Cliclo
O segundo ciclo consiste em implementar as falhas do primeiro teste e rodar o teste novamente, após feita a implementação temos o código abaixo:
namespace Placar
{
public class Placar: IPlacar
{
public int jogador1 { get; set; }
public int jogador2 { get; set; }
public Placar()
{
jogador1 = 0;
jogador2 = 0;
}
public string getPlacarAtual()
{
return jogador1.ToString() + "x" + jogador2.ToString();
}
public void addJogador1()
{
throw new NotImplementedException();
}
public void addJogador2()
{
throw new NotImplementedException();
}
public void clearPlacar()
{
throw new NotImplementedException();
}
}
}
Fazendo o teste novamente vemos que occorre tudo como o esperado:
Terceiro Ciclo
Agora montamos o segundo deste, onde adicionamos pontos a jogador1 e ao jogador2 também zeramos o placar:
namespace Placar.Teste
{
[TestFixture]
public class PlacarTest
{
[Test]
public void PlacarZerado()
{
IPlacar placar = new Placar();
Assert.AreEqual(0, placar.jogador1);
Assert.AreEqual(0, placar.jogador2);
Assert.AreEqual("0x0", placar.getPlacarAtual());
}
[Test]
public void PontuaJogadores()
{
IPlacar placar = new Placar();
placar.addJogador1();
placar.addJogador2();
Assert.AreEqual("1x1", placar.getPlacarAtual());
placar.clearPlacar();
Assert.AreEqual("0x0", placar.getPlacarAtual());
}
}
}
Executando o teste temos o resultado:
Da mesma forma fazemos a implementação do Placar e aplicamos o teste novamente:
namespace Placar
{
public class Placar: IPlacar
{
public int jogador1 { get; set; }
public int jogador2 { get; set; }
public Placar()
{
jogador1 = 0;
jogador2 = 0;
}
public string getPlacarAtual()
{
return jogador1.ToString() + "x" + jogador2.ToString();
}
public void addJogador1()
{
jogador1++;
}
public void addJogador2()
{
jogador2++;
}
public void clearPlacar()
{
jogador1 = 0;
jogador2 = 0;
}
}
}
Esse post foi apenas uma introdução, de como fazer um desenvolvimento orientado a testes. No começo pode ser um pouco trabalhoso, mas com o andamento do desenvolvimento esse processo pode até facilitar, pois tudo que foi desenvolvido até um dado ponto foi bem testado, e a cada mudança que você faz no programa os testes anteriores checam se houve alguma alteração no comportamento geral do sistema.
Por hoje é só, no próximo post vou aprofundar um pouco mais no NUnit e suas funções.Abraço.
