Tutorial NUnit – Parte I: Introdução a Testes Unitários

Testes de Unidade: Uma ferramenta indispensável para o desenvolvimento de software.


Já passou por alguma situação na qual você tinha uma data de entrega prevista para seu sistema mas teve que adiá-la após descobrir que muitas das funcionalidades que você havia desenvolvido e validado meses atrás já não estavam mais funcionando?

Ou por alguma situação na qual você teve que passar várias horas depurando código para tentar descobrir a origem de bugs que você não faz a menor idéia sobre como ou quando eles surgiram?

Ou, ainda, por alguma situação na qual a própria correção de uma parte de seu sistema fez com que outras partes do sistema parassem de funcionar, o que somente foi descoberto alguns dias ou semanas depois pelos analistas de testes (na melhor das hipóteses) ou pelos clientes e usuários do software?

Se você respondeu “sim” para uma ou mais das perguntas feitas nos parágrafos anteriores, e principalmente se essas situações estão acontecendo com frequência, é sinal de que a qualidade do código que você (ou a empresa na qual você trabalha) desenvolve pode (e precisa) ser melhorada. Mas há uma boa notícia: essa melhoria é relativamente barata e fácil de ser implementada tanto pelo programador individual quanto por uma equipe ou empresa de desenvolvimento de software. Trata-se dos testes de unidade, que, como o título dessa seção diz, são uma ferramenta indispensável para o desenvolvimento de qualquer software.

Neste artigo iremos dar início a uma série de tutoriais sobre como você pode se beneficiar de testes de unidade para aumentar a qualidade de seu código, reduzir os riscos de falha de seus projetos e programar de maneira mais rápida, segura e eficaz.

O que são testes de unidade?


Um teste de Unidade é um trecho de código escrito para se testar uma parte do código da implementação de seu sistema; o código de teste unitário irá exercitar uma parte do código de seu programa fazendo-o passar por uma série de casos de testes (definidos por você) a fim de verificar se seu código está realmente funcionando como esperado, como podemos ver no trecho de código a seguir:

    // Algum código de algum programa escrito em C#.
    public class Calculadora
    {
        public int Somar(int a, int b)
        {
            return a + b;
        }
    }
  
// Exemplo de teste de unidade escrito para o código acima.
    [Test]
    public void Teste_Soma()
    {
        // Define os valores a serem usados durante os testes.
        int parcelaA = 10;
        int parcelaB = 20;
        int somaEsperada = (parcelaA + parcelaB);

        // Cria a calculadora.
        Calculadora calculadora = new Calculadora();

        // Exercita a funcionalidade de soma da calculadora.
        int somaObtida = calculadora.Somar(parcelaA, parcelaB);

        // Verifica se a soma foi efetuada corretamente.
        Assert.AreEqual(somaEsperada, somaObtida, "A função de soma da calculadora não retornou o valor esperado.");
    }
  

Por exemplo, você pode criar um método que autentique um usuário no sistema e então criar um teste de unidade que verifique se um usuário cadastrado consegue acessar o sistema através de seus dados de autenticação tais como login e senha. Ou talvez você crie um método que calcule o valor total de uma venda, e então criar um teste de unidade para verificar se o total da venda foi calculado corretamente.

Após criar testes de unidade para verificar se cada uma das unidades isoladas do código de seu software funcionam corretamente as chances são muito maiores de que o sistema completo também irá funcionar corretamente quando todas essas partes forem integradas para trabalharem juntas. Afinal de contas, se as partes isoladas do software não funcionam corretamente é ingênuo esperar que o produto final irá funcionar corretamente.

Testar as unidades do software, portanto, nos dá a base e a confiança necessárias para podermos investir com segurança em outros tipos de testes no software, os quais também são sem dúvida indispensáveis, tais como testes de aceitação, integração ou testes funcionais.

Veremos mais detalhes sobre o que são testes de unidade e como utilizá-los no decorrer desta série de tutoriais, na qual demonstramos como configurar seus projetos de testes unitários, como implementar testes unitários, como executar seus testes de unidade e como utilizar a técnica de Desenvolvimento Dirigido por Testes (TDD – Test Driven Development) em seu processo de desenvolvimento de software.

Antes, porém, precisamos analisar quais são os benefícios que os testes de unidade podem lhe trazer e por que você deveria considerar utilizá-los em seus projetos.

Benefícios da Aplicação dos Testes de Unidade


São muitos os benefícios que os testes de unidade podem trazer para você no desenvolvimento de seus softwares, o que torna essa ferramenta realmente indispensável para o seu sucesso como programador e para o sucesso dos programas que você ou a empresa na qual você trabalha desenvolve.

Apresentamos a seguir alguns desses principais benefícios. Comente no final deste artigo outros benefícios que você conhece relacionados a testes de unidade e diga o que você pensa sobre os benefícios que foram listados aqui.

  • Programar com Confiança: testes de unidade aumentam sua confiança sobre o código que você está desenvolvendo, pois os testes te mostram claramente se as alterações que você fez provocaram a falha de alguma parte de seu código. Desta forma você pode corrigir o código, executar os testes novamente e, caso todos passem, você pode continuar a trabalhar com a confiança de que tudo continua funcionando corretamente.
  • Integração Contínua do Código: os testes de unidade asseguram que as novas funcionalidades desenvolvidas não provocaram efeitos colaterais sobre o código que já estava funcionando, de modo que você tem mais segurança de que as novas funcionalidades desenvolvidas estão funcionando corretamente e também de que elas não prejudicaram as demais partes do software que antes já haviam sido verificadas e talvez até mesmo validadas.
  • Melhor garantia da qualidade do seu código: com testes de unidade você não apenas supõe que seu código está funcionando, mas você tem certeza que ele está funcionando, pois quando todos os seus testes estão passando você sabe que seu sistema está se comportando exatamente da forma que você espera que ele se comporte.
  • Eliminação de Bugs Quando Eles Surgem: com testes de unidade você descobre os bugs de seu código assim que eles aparecem. Desta forma você pode eliminá-os de seu sistema na mesma hora que surgem, evitando efeitos colaterais que poderiam tornar esses bugs muito mais difíceis de serem localizados e muito mais caro para serem corrigidos depois que mais funções e mais bugs já tivessem sido inseridos em seu sistema.
  • Menos Tempo Depurando o Código: com testes de unidade você não precisa mais gastar tanto tempo depurando o código para procurar a origem dos bugs, pois os testes irão indicar o que está ou não falhando em seu sistema. Desta forma o programador tem uma maior produtividade pois irá passar mais tempo programando do que depurando código.
  • Pronta localização dos bugs: os testes de unidade ajudam você a saber exatamente onde os bugs se encontram no código, de forma que você saiba com segurança o que deve corrigir e onde essa correção deve ser realizada em seu código.
  • A fase de testes funcionais fica menos sobrecarregada: quando o sistema é desenvolvido com testes de unidade os analistas de testes irão encontrar menos erros que fazem o programa parar de funcionar inesperadamente ou bugs que fazem o sistema se comportar de forma errônea. Desta forma, os analistas de teste terão mais tempo para identificar as falhas relacionadas às regras de negócio de seu software do que relatando erros de NullReferenceExceptions e StackOverflows que muitas vezes impedem ou dificultam que os analistas de teste realizem testes completos das funcionalidades do sistema.
  • Melhor reputação para o programador: umas das coisas que mais prejudicam a reputação de um programador são os relatórios frequêntes de falhas e erros encontrados nas funcionalidades desenvolvidas ou mantidas por este programador. Com testes de unidade você irá entregar código com mais qualidade e portanto terá uma melhor reputação devido a um número menor de problemas encontrados nas funcionalidades que você desenvolve.

Vejamos agora como você pode aplicar testes de unidade para obter todos esses e outros benefícios em seu processo de desenvolvimento de software.

Como Trabalhar com Testes de Unidade?


A primeira coisa a fazer é decidir como testar o método (função) em questão, se possível antes mesmo de implementar esse método. Com uma visão razoável do que você deseja testar você pode então escrever o código do teste antes do código da implementação, ou de forma concorrente. Se você estiver escrevendo código de teste para métodos já existentes não tem problemas, porém pode ser que você tenha que refatorar boa parte desse código até que você consiga torná-lo testável.

A seguir você executa o teste, juntamente com todos os outros testes existentes para essa parte específica do sistema, ou até mesmo os testes do sistema inteiro caso isso não consuma muito tempo para ser executado. É importante que todos os testes passem, e não apenas o teste que você acabou de criar. Isso ajuda você a evitar qualquer efeito colateral ou que algum novo bug seja inserido no sistema.

Com a execução de seus testes de unidade você será então capaz de determinar quais partes do seu sistema precisam ser corrigidas, ou se você pode continuar seu trabalho sem se preocupar, visto que todos os seus testes estão passando sem falhas, significando portanto que seu sistema está funcionando exatamente da forma como você espera que ele funcione.

Conclusão Parte I


Nesta primeira parte de nosso tutorial sobre testes de unidade nós apresentamos resumidamente o que são, por que são importantes e como se trabalhar com testes de unidade. Esta introdução aos testes de unidade será o fundamento necessário para que você compreenda todo o restante desta série de tutoriais.

Na próxima parte deste tutorial nós iremos demonstrar como você pode configurar suas soluções no Visual Studio para permitir que você implemente testes de unidade para seus próprios projetos utilizando o framework de testes unitários NUnit. (Se desejar, assine nossa Newsletter ou Feeds para ser notificado sobre atualizações deste tutorial e de outros artigos publicados em nosso Blog.)

Se você gostou deste artigo, lembre-se de assinar nossa Newsletter e/ou se inscrever em nosso Feed para ficar atualizado sobre as futuras publicações de C# Programmer.

2 comments

Participe da discussão. Sua contribuição é muito importante para nossa comunidade.