Programming On Groove: julho 2010

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.