Por que eu devo ler este artigo:Ao utilizarmos testes unitários, podemos detectar muito mais rapidamente os bugs que não foram detectados no início do projeto e evitar que estas falhas cheguem ao cliente final.

Este artigo é útil pois demonstrará o desenvolvimento de uma aplicação ASP.NET MVC 5 utilizando duas ferramentas poderosas no mercado para a realização dos testes unitários, que são a NUnit e o NCrunch, das quais apresentaremos algumas características principais.

Com o alto crescimento do mercado com relação ao desenvolvimento de aplicações, sejam estas mobile, desktop ou web, a utilização de técnicas e ferramentas para que o software seja entregue dentro dos padrões é essencial. Dito isso, nada melhor do que trabalharmos com testes unitários que são extremamente importantes para a detecção de falhas não percebidas durante o desenvolvimento da aplicação.

Neste artigo estaremos interessados em entender os testes de unidades através de uma aplicação ASP.NET MVC 5 simples, onde iremos aprender a configurar os testes, como desassociar uma base de dados da aplicação no momento dos testes, além de adquirirmos uma noção com relação a uma ferramenta de testes contínuos que é o NCrunch.

Quando tratamos com relação à utilização de testes em softwares, isso muitas vezes gera divergência de opiniões que vão da aceitação total a negação por completo sobre o uso das técnicas de testes.

Acreditamos, no entanto, que a utilização de testes em nossas aplicações é uma prática importante, pois ela nos ajuda a identificar um erro antes que o produto chegue ao cliente final e nesse caso, termos retrabalho com a correção dessas falhas em pontos mais avançados do desenvolvimento, o que acarreta em maiores custos.

De uma maneira geral, podemos definir que os testes unitários referem-se a práticas de testar determinadas funções pertencentes ao nosso código, dessa forma podemos ter certeza com relação ao funcionamento dessas funções.

Nesse sentido, podemos dizer que para as funções que desejamos testar será dado um conjunto de dados de entrada para verificarmos se as funções estão retornando falhas durante o ciclo de execução, o que invalida os dados fornecidos.

Dessa forma, somos capazes de identificar falhas existentes em nossos algoritmos, ou mesmo em nossa lógica, e com isso podemos melhorar a qualidade de nosso código, além disso, podemos evitar futuras alterações de código.

O que são Testes Unitários?

De uma maneira simples, podemos dizer que o teste unitário é na realidade um processo de desenvolvimento de software onde as menores partes testáveis (unidades) de uma aplicação são testadas com base em operações adequadas individualmente e independentemente. Estes testes, na maioria das vezes, são realizados de forma automatizada, mas podendo ser realizados também de forma manual.

A utilização de testes unitários é uma das metodologias adotadas pelo XP (Extreme Programming) para o desenvolvimento de softwares a partir da construção de produtos por meio de testes contínuos.

Os testes unitários envolvem características que são importantes para o desempenho da unidade que está sendo testada. Essa é uma característica favorável, pois ela nos incentiva a modificarmos nosso código-fonte sem a necessidade de nos preocuparmos com as mudanças que podem afetar as demais partes do software.

Com a obtenção das pequenas unidades funcionando perfeitamente, podemos usar de igual forma os seus componentes para que possamos testar unidades maiores das nossas aplicações.

Normalmente, os testes unitários podem ser demorados e devido a isso exigem muita paciência dos desenvolvedores, mas esse é o ponto chave para um software bem desenvolvido e “livre” de falhas, além de manter uma documentação mais próxima possível da realidade do software.

De maneira geral, os testes unitários são a nossa maneira de nos certificarmos de que o código escrito é totalmente funcional e retrata as reais necessidades do software.

Um dos princípios fundamentais dos testes unitários é que devemos escrever os testes inicialmente e em seguida escrevermos o código mais simples que será utilizado para fazer o teste passar.

Mas ao invés disso, o que podemos fazer é criar um exemplo simples e em seguida podemos criar os testes unitários com base nas possíveis situações. Mas esse é um ponto a ser levado em consideração por cada desenvolvedor.

Quando trabalhamos com testes unitários, estes devem ser executados inteiramente em memória e não devem ter acesso a bases de dados, nem mesmo a arquivos ou serviços externos. Como bem sabemos, uma unidade é vista como um pequeno trecho de código, o que podemos considerar como sendo um método.

Este método deve ser mantido pequeno e deve realizar uma única operação. Com isso, não temos apenas um código de fácil leitura, como também se torna mais fácil mantê-lo.

Hoje em dia possuímos frameworks para a realização de testes unitários que facilitam a nossa vida, como é o caso do NUnit, que será um dos itens que estaremos usando em nossos exemplos e em seguida, utilizaremos o NCrunch, que possui alguns diferenciais em relação a outras ferramentas de testes.

Vejamos então um pouco sobre cada um dos itens que serão abordados no decorrer do nosso artigo. Mas antes, vejamos alguns dos benefícios gerados com a utilização de testes unitários.

· O teste unitário aumenta a confiança na mudança/manutenção de código: Se os bons testes unitários são escritos e se eles são executados a cada vez que algum código é alterado, seremos capazes de capturar rapidamente quaisquer defeitos introduzidos devido à mudança.

Além disso, os códigos são criados de forma menos interdependente para fazer os testes unitários, o que acarreta em um impacto menor com relação a mudanças que venham a ser feitas.

· Os códigos são mais reutilizáveis: A fim de tornar o teste de unidade possível, os códigos precisam ser modulares, o que significa que os códigos são mais fáceis de reutilizarmos.

· O desenvolvimento é mais rápido: Quando temos um teste unitário, podemos escrever o teste, em seguida escrevermos o código e por último executarmos o teste.

O tempo que levamos para desenvolver nossos testes é alto, mas o tempo é compensado pela menor quantidade de tempo que levaremos para executar os testes; E, claro, testes unitários são mais confiáveis do que os "testes feitos por desenvolvedores".

O desenvolvimento é mais rápido a longo prazo também. Como já teremos a funcionalidade em teste, isso tornará mais fácil a detecção e correção de possíveis defeitos encontrados durante os testes do sistema ou o teste de aceitação (pelo cliente).

· O custo para correção de defeitos detectados durante o teste de unidade é menor em comparação com a de defeitos detectados em níveis mais elevados.

A depuração é fácil - Quando um teste falhar, apenas as últimas mudanças precisam ser depuradas. Com testes em níveis mais elevados, as alterações feitas sobre a extensão de vários dias/semanas/meses precisam ser verificadas.

O que é o NUnit?

O NUnit é um framework utilizado para a realização de testes unitários com base na plataforma .NET. É uma ferramenta amplamente utilizada para o teste de unidade e é preferido por muitos d ...

Quer ler esse conteúdo completo? Seja um assinante e descubra as vantagens.
  • 473 Cursos
  • 10K Artigos
  • 100 DevCasts
  • 30 Projetos
  • 80 Guias
Tenha acesso completo