Utilizando Testes Unitários no Visual Studio 2012

Prévia do material em texto

Utilizando Testes Unitários no Visual Studio 2012
A solução que está sendo apresentada neste artigo foi criada no .NET framework 4.5, através da utilização do Microsoft Visual Studio 2012 Professional. Basicamente, será implementada uma biblioteca para o cálculo de tributos federais como PIS, COFINS, ISS e IRPJ; estes impostos estão geralmente associados a operação fiscais que envolvam a prestação de seguros.
O primeiro passo para a implementação do exemplo baseado em testes unitários consiste na criação de uma Solution chamada “TesteNF”, conforme demonstrado na Figura 1.
Figura 1: Criando a Solution TesteNF
A solução TesteNF será formada pelos seguintes projetos:
TesteNF.Utils: conterá a classe estática TributacaoHelper, a qual disponibiliza operações para o cálculo de impostos como PIS, COFINS, IRPJ e CSLL;
TesteNF.Utils.UnitTesting: aplicação onde estarão os diversos testes unitários responsáveis por verificar as funcionalidades da classe TributacaoHelper.
Uma vez gerado o arquivo correspondente à Solution TesteNF, deve-se prosseguir com a criação de um projeto do tipo Class Library e que terá por nome “TesteNF.Utils” (Figura 2).
Figura 2: Criando a Class Library TesteNF.Utils
Neste primeiro momento, será implementada no projeto TesteNF.Utils uma versão extremamente simples da classe TributacaoHelper, com todos os métodos para cálculo de impostos retornando zero como resultado de sua execução. O objetivo deste procedimento é justamente assegurar que a primeira bateria de testes unitários falhe, de maneira que apenas num segundo momento sejam codificados os cálculos necessários.
Na Tabela 1 estão indicados as alíquotas para cada um dos impostos calculados por meio do tipo TributacaoHelper.
	Imposto
	Alíquota
	PIS (Programa de Integração Social)
	0,0065
	COFINS (Contribuição para o Financiamento da Seguridade Social)
	0,03
	IRPJ (Imposto sobre Renda de Pessoa Jurídica)
	0,015
	CSLL (Contribuição Social sobre Lucro Líquido)
	0,02
Tabela 1: Alíquotas de impostos que serão utilizadas pelo tipo TributacaoHelper
Já na Listagem 1 está a definição inicial para a classe TributacaoHelper. Estão declarados neste tipo os métodos estáticos CalcularPIS, CalcularCOFINS, CalcularIRPJ e CalcularCSLL, com cada uma destas operações devolvendo como resultado de sua execução o imposto a ser pago a partir de um valor de serviço prestado.
Listagem 1: Classe TributacaoHelper
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace TesteNF.Utils
{
 public static class TributacaoHelper
 {
 public static double CalcularPIS(double valorBase)
 {
 return 0;
 }
 public static double CalcularCOFINS(double valorBase)
 {
 return 0;
 }
 public static double CalcularIRPJ(double valorBase)
 {
 return 0;
 }
 public static double CalcularCSLL(double valorBase)
 {
 return 0;
 }
 }
}
Na sequência, é a vez de criar o projeto de testes chamado “TesteNF.Utils.UnitTesting” (Figura 3). Assim como acontece com outros templates, esse tipo de projeto é nativo do Visual Studio e não exige qualquer configuração adicional para sua inclusão em uma Solution.
Figura 3: Criando o projeto TesteNF.Utils.UnitTesting
Com o projeto TesteNF.Utils.UnitTesting gerado, é possível observar a existência de um arquivo chamado UnitTest1.cs, o qual também foi criado automaticamente. Remover este arquivo, já que outras classes de testes serão criadas seguindo uma nomenclatura própria para este projeto.
OBSERVAÇÃO: devido ao fato do projeto TesteNF.Utils.UnitTesting executar o teste de funcionalidades da classe TributacaoHelper, será necessário então adicionar ao mesmo uma referência que aponte para a Class Library TesteNF.Utils.
A primeira classe de testes a ser criada terá por nome “TributacaoHelperTeste01”. O Visual Studio também oferece um template (“Basic Unit Test”) para este tipo de construção, sendo possível selecionar tal item a partir da opção que adiciona novos tipos de arquivos a um projeto (conforme indicado na Figura 4).
Figura 4: Criando uma nova classe de teste unitário
Os diferentes testes a serem executados através da classe TributacaoHelperTeste01 estarão tomando R$ 8.400,00 como valor-base para serviços prestados. Considerando isto, na Tabela 2 estão listados os valores esperados para cada cálculo de imposto a ser verificado.
	Imposto
	Operação a ser Verificada em TributacaoHelper
	Valor Esperado
	PIS
	CalcularPIS
	54,6
	COFINS
	CalcularCOFINS
	252
	IRPJ
	CalcularIRPJ
	126
	CSLL
	CalcularCSLL
	84
Tabela 2: Valores esperados para os testes da classe TributacaoHelperTeste01
Na Listagem 2 está o código corresponde à classe TributacaoHelperTeste01. É possível notar na definição deste tipo as seguintes características:
A classe TributacaoHelperTeste01 foi marcada com o atributo TestClassAttribute. Isto se faz necessário pois, diferente de uma Console Application ou executável Windows Forms, projetos de testes não contam com um método Main para iniciar a sua execução; logo, o Visual Studio irá buscar sempre classes marcadas com o atributo citado, a fim de com isto acionar os diferentes testes presentes nas mesmas;
Os diferentes métodos que representam testes (TestarCalculoPIS, TestarCalculoCOFINS, TestarCalculoIR e TestarCalculoCSLL) também estão marcados com um atributo, sendo que neste último caso foi utilizado o elemento TestMethodAttribute. Mais uma vez, será por meio deste vínculo que o mecanismo de execução de testes do Visual Studio identificará quais métodos precisarão ser executados;
As verificações de cada funcionalidade presente na classe TributacaoHelper são feitas através do uso do método AreEqual, o qual pertence ao tipo Assert. Esta operação recebe como parâmetros o resultado da execução do método a ser testado, além do valor esperado para esta ação. Caso tais valores não coincidam, o teste falhará e um alerta será gerado dentro do Visual Studio.
OBSERVAÇÃO: As classes TestClassAttribute, TestMethodAttribute e Assert estão situadas no namespace Microsoft.VisualStudio.TestTools.UnitTesting.
Listagem 2: Classe TributacaoHelperTeste01
using System;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using TesteNF.Utils;
namespace TesteNF.Utils.UnitTesting
{
 [TestClass]
 public class TributacaoHelperTeste01
 {
 [TestMethod]
 public void TestarCalculoPIS()
 {
 Assert.AreEqual(TributacaoHelper
 .CalcularPIS(8400.00), 54.60);
 }
 [TestMethod]
 public void TestarCalculoCOFINS()
 {
 Assert.AreEqual(TributacaoHelper
 .CalcularCOFINS(8400.00), 252.00);
 }
 [TestMethod]
 public void TestarCalculoIRPJ()
 {
 Assert.AreEqual(TributacaoHelper
 .CalcularIRPJ(8400.00), 126.00);
 }
 [TestMethod]
 public void TestarCalculoCSLL()
 {
 Assert.AreEqual(TributacaoHelper
 .CalcularCSLL(8400.00), 84.00);
 }
 }
}
Durante a construção de testes unitários, o uso de uma nomenclatura padronizada representa uma boa prática de desenvolvimento. Nos exemplos apresentados ao longo deste artigo, o nome de todos os métodos é iniciado pelo prefixo “Testar”. Já a identificação das classes de testes é formada pelo nome do tipo a ser analisado (no caso “TributacaoHelper”), seguidos pela palavra “Teste”, além de números identificadores (“01”, “02”).
Além de AreEqual, a classe estática Assert (namespace Microsoft.VisualStudio.TestTools.UnitTesting) também disponibiliza para validações outros métodos, constituindo exemplos disto as operações:
AreNotEqual: verifica que os valores fornecidos como parâmetros são diferentes;
IsFalse: checa se o retorno de uma condição é falso;
IsTrue: verifica se o retorno de uma expressãoé verdadeiro;
IsNull: checa se o valor associado a um objeto é nulo;
IsNotNull: verifica se o conteúdo de um objeto não é nulo.
Uma segunda classe de testes chamada TributacaoHelperTeste02 precisará ser criada. Na Tabela 3 estão os valores que servirão de base para os testes, considerando para isto R$ 7.728,00 como total de prestação de serviços.
	Imposto
	Operação a ser Verificada em TributacaoHelper
	Valor Esperado
	PIS
	CalcularPIS
	50,23
	COFINS
	CalcularCOFINS
	231,84
	IRPJ
	CalcularIRPJ
	115,92
	CSLL
	CalcularCSLL
	77,28
Tabela 3: Valores esperados para os testes da classe TributacaoHelperTeste02
Na Listagem 3 é apresentado o código que define a classe TributacaoHelperTeste02; este tipo conta com uma estrutura idêntica à da classe TributacaoHelperTeste01, diferindo desta última apenas pelos valores que estarão sendo analisados.
Listagem 3: Classe TributacaoHelperTeste02
using System;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using TesteNF.Utils;
namespace TesteNF.Utils.UnitTesting
{
 [TestClass]
 public class TributacaoHelperTeste02
 {
 [TestMethod]
 public void TestarCalculoPIS()
 {
 Assert.AreEqual(TributacaoHelper
 .CalcularPIS(7728.00), 50.23);
 }
 [TestMethod]
 public void TestarCalculoCOFINS()
 {
 Assert.AreEqual(TributacaoHelper
 .CalcularCOFINS(7728.00), 231.84);
 }
 [TestMethod]
 public void TestarCalculoIRPJ()
 {
 Assert.AreEqual(TributacaoHelper
 .CalcularIRPJ(7728.00), 115.92);
 }
 [TestMethod]
 public void TestarCalculoCSLL()
 {
 Assert.AreEqual(TributacaoHelper
 .CalcularCSLL(7728.00), 77.28);
 }
 }
}
Formulados os testes unitários destinados à validação da classe TributacaoHelper, chega agora momento de se efetuar o processamento dos mesmos. As diferentes opções que permitem acionar a execução de testes unitários encontram-se no menu Test (Figura 5).
Figura 5: Menu Test no Visual Studio 2012
Acionando a opção “All Tests”, será ativada a janela “Test Explorer” (Figura 6) com o resultado da execução das duas classes de testes unitários. Conforme pode ser observado, todos os testes falharam.
Figura 6: Listagem dos testes que falharam
Selecionando um dos testes que falharam, serão exibidos detalhes a respeito do mesmo como, por exemplo, em que arquivo/classe está situado o método que produziu a falha (conforme indicado na Figura 7).
Figura 7: Detalhamento de um teste que falhou
A Listagem 4 apresenta o código referente à classe TributacaoHelper, já considerando agora as instruções necessárias para o cálculo dos diversos impostos previstos por este tipo.
OBSERVAÇÃO: para a aplicação de exemplo aqui apresentada foram utilizados valores fixos nas alíquotas de impostos. Numa situação real, o ideal seria que tais alíquotas fossem parametrizáveis, ou seja, definidas em um arquivo de configuração ou, até mesmo, numa tabela pertencente dentro de uma base de dados.
Listagem 4: Classe TributacaoHelper após a implementação dos cálculos de impostos
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace TesteNF.Utils
{
 public static class TributacaoHelper
 {
 public static double CalcularPIS(double valorBase)
 {
 return Math.Round(valorBase * 0.65 / 100, 2);
 }
 public static double CalcularCOFINS(double valorBase)
 {
 return Math.Round(valorBase * 3 / 100, 2);
 }
 public static double CalcularIRPJ(double valorBase)
 {
 return Math.Round(valorBase * 1.5 / 100, 2);
 }
 public static double CalcularCSLL(double valorBase)
 {
 return Math.Round(valorBase * 1 / 100, 2);
 }
 }
}
Uma nova execução dos testes unitários resultará em sucesso desta vez, como pode ser visualizado na Figura 8.
Figura 8: Execução com sucesso de todos os testes
Observando o código que implementa a classe TributacaoHelper, nota-se que em todos os métodos repete-se o uso da operação Round, a qual se encontra definida na classe estática Math (namespace System). Além disso, em todas as situações a alíquota é dividida por 100, de forma a se obter o valor decimal correspondente a uma porcentagem. Este é um bom exemplo no qual técnicas de refatoração podem ser empregadas: um método chamado CalcularImposto é implementado de forma a agrupar as instruções comuns, com o mesmo sendo acionado pelas demais operações de TributacaoHelper (Listagem 5).
Listagem 5: Classe TributacaoHelper refatorada
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace TesteNF.Utils
{
 public static class TributacaoHelper
 {
 private static double CalcularImposto(
 double valorBase, double aliquota)
 {
 return Math.Round(valorBase * aliquota / 100, 2);
 }
 public static double CalcularPIS(double valorBase)
 {
 return CalcularImposto(valorBase, 0.65);
 }
 public static double CalcularCOFINS(double valorBase)
 {
 return CalcularImposto(valorBase , 3);
 }
 public static double CalcularIRPJ(double valorBase)
 {
 return CalcularImposto(valorBase, 1.5);
 }
 public static double CalcularCSLL(double valorBase)
 {
 return CalcularImposto(valorBase, 1);
 }
 }
}
Reprocessando os testes após essa etapa de refatoração, nota-se que os mesmos ainda são válidos, o que significa que não foram introduzidos erros no código-fonte (Figura 9).
Figura 9: Testes executados com sucesso após refatoração da classe TributacaoHelper
Conclusão
Procurei com este artigo demonstrar como testes unitários podem ser utilizados a partir do Visual Studio 2012. O desenvolvimento guiado por testes pode resultar não apenas na obtenção de aplicações com menor sujeição a erros, como também contribuir para uma melhor estruturação do sistema ao estimular o uso de boas práticas de arquitetura.
Contudo, é altamente recomendável não se depender apenas de testes unitários para a validação de uma aplicação. As outras modalidades de testes são importantíssimas e devem ser aplicadas ao longo das diferentes fases de um projeto, garantindo assim um produto estável, sem falhas que impeçam sua operação normal no dia-a-dia.
Espero que o conteúdo aqui abordado possa ser útil em algum momento. Até uma próxima oportunidade!
Leia mais em: Testes Unitários no Visual Studio 2012 http://www.devmedia.com.br/testes-unitarios-no-visual-studio-2012/27215#ixzz3aDK2jDh9