TESTES DE UNIDADE em Asp.Net: Tutorial Completo

O teste é um aspecto essencial de qualquer linguagem de programação. Testes Para aplicações ASP.NET, é possível com a ajuda do Visual Studio.

O Visual Studio é usado para criar código de teste. Ele também é usado para executar o código de teste de uma aplicação ASP.NET. Dessa forma, fica simples verificar erros em uma aplicação ASP.NET. No Visual Studio, o módulo de testes já vem com funcionalidades prontas para uso. É possível executar testes em um projeto ASP.NET diretamente.

Introdução aos testes para ASP.NET

O primeiro nível de teste de um projeto ASP.NET é o teste de unidade. Este teste avalia a funcionalidade da aplicação. O objetivo do teste é garantir que a aplicação se comporte conforme o esperado. Em ASP.NET, a primeira tarefa é criar um projeto de teste no Visual Studio. O projeto de teste conterá o código necessário para testar a aplicação.

Vamos analisar a página web abaixo. Nela, temos a mensagem “Guru99 – ASP.NET” exibido. Agora, como podemos confirmar se a mensagem correta é exibida quando um projeto ASP.NET é executado? Isso é feito adicionando um projeto de teste à solução ASP.NET (usada para desenvolver aplicativos baseados na web). Esse projeto de teste garantirá que a mensagem correta seja exibida ao usuário.

Vamos analisar agora com mais detalhes e ver como podemos trabalhar com testes em ASP.NET.

Criando um projeto de teste de unidade .NET

Antes de criarmos um projeto de teste, precisamos executar as etapas de alto nível abaixo.

1. Use nosso 'DemoApplication' usado nas seções anteriores. Esta será a nossa aplicação que precisa ser testada.
2. Vamos adicionar uma nova classe ao DemoApplication. Essa classe conterá uma string chamada 'Guru99 – ASP.NET.' Esta string será testada em nosso projeto de testes.
3. Por fim, criaremos um projeto de teste. Este projeto será usado para testar a aplicação ASP.NET.

Vamos então seguir os passos gerais acima e ver como implementar os testes.

Passo 1) Certifique-se de que DemoApplication esteja aberto no Visual Studio.

Passo 2) Vamos agora adicionar uma nova classe ao DemoApplication. Esta classe conterá uma string chamada 'Guru99 – ASP.NET.' Esta string será testada em nosso projeto de testes.

Siga a etapa abaixo para adicionar uma nova classe.

1. No Visual Studio, clique com o botão direito em 'DemoApplication' no Solution Explorer.
2. Escolha a opção Adicionar->Classe no menu de contexto.

Passo 3) Nesta etapa,

1. Dê um nome 'Tutorial.cs' para a nova classe.
2. Clique no botão 'Adicionar' para adicionar o arquivo ao DemoApplication.

Agora, uma nova classe é adicionada ao arquivo “DemoApplication”.

Passo 4) Abra o novo arquivo Tutorial.cs do “DemoApplication”. Adicione a string “Guru99 – ASP.NET.”

Para abrir o arquivo, clique duas vezes no arquivo Tutorial.cs no Solution Explorer.

O arquivo terá algum código padrão já escrito. Não se preocupe com esse código, apenas adicione a linha de código abaixo.

namespace DemoApplication
{
  public class Tutorial
  {
     public String Name;
     public Tutorial()
     {
        Name = "Guru99 - ASP.Net";
     }
  }
}

Code Explicação:-

1. A variável Name é do tipo string.
2. Finalmente, no construtor da classe Tutorial, atribua o valor da variável Name. O valor é atribuído a “Guru99 – ASP.NET”

Passo 5) Agora, acesse o arquivo demo.aspx e adicione as linhas de código para exibir o texto “Guru99 – ASP.NET.”

<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml">
<head runat="server">
    <title></title>
</head>
    <body>
    <form id="form1" runat="server">
    <div>
        <% DemoApplication.Tutorial tp=new DemoApplication.Tutorial();%>
        <%=tp.Name%>
    </div>
    </form>
    </body>
</html>

Code Explicação:-

1. A primeira linha cria um objeto da classe 'Tutorial'. Este é o primeiro passo ao trabalhar com classes e objetos. O nome dado ao objeto é 'tp'.
2. Finalmente chamamos 'tutorial.cs' do arquivo demo.aspx. Ele exibe o valor da variável Name.

Ao executar o programa acima no Visual Studio, você obterá a seguinte saída.

Resultado:-

Na saída, você vê a mensagem “Guru99 – ASP.NET” exibido.

Passo 6) Agora, vamos adicionar nosso projeto de teste ao aplicativo de demonstração. Isso é feito com a ajuda do Visual Studio.

1. Clique com o botão direito na Solução – DemoApplication.
2. No menu de contexto, escolha a opção ‘Novo Projeto’.

Passo 7) A etapa envolve a adição do projeto de teste unitário ao aplicativo de demonstração.

1. Clique no tipo de item como ‘Teste’ no painel esquerdo.
2. Escolha o item como 'Projeto de teste de unidade' na lista, que aparece na parte central da caixa de diálogo.
3. Dê um nome para o projeto de teste. No nosso caso, o nome dado é ‘DemoTest’.
4. Por fim, clique no botão ‘OK’.

Eventualmente, você verá o projeto DemoTest adicionado ao gerenciador de soluções. Com isso, você também pode ver que outros arquivos como UnitTest1.cs, propriedades, etc. são gerados por padrão.

Executando o projeto de teste

O projeto de teste criado na seção anterior é usado para testar nossa aplicação ASP.NET. Nos próximos passos, veremos como executar o projeto de teste.

• O primeiro passo seria adicionar uma referência ao projeto ASP.NET. Este passo é realizado para que o projeto de teste tenha acesso ao projeto ASP.NET.
• Então escreveremos nosso código de teste.
• Por fim, executaremos o teste usando Visual Studio.

Passo 1) Para testar nosso aplicativo de demonstração, primeiro o projeto de teste precisa fazer referência ao aplicativo de demonstração. Adicione uma referência à solução Demo.aspx.

1. Clique com o botão direito no projeto Demo Test
2. No menu escolha a opção Adicionar->Referência.

Passo 2) A próxima etapa é adicionar uma referência ao DemoApplication.

1. Selecione a opção Projetos no lado esquerdo da caixa de diálogo
2. Clique na caixa de seleção ao lado de DemoApplication
3. Clique no botão 'OK'.

Isso permitirá que um projeto demotest teste nosso DemoApplication.

Passo 3) Agora é hora de adicionar o código de teste ao nosso projeto de teste.

• Para isso, primeiro clique duas vezes no arquivo UnitTest1 (o arquivo UnitTest1 é adicionado automaticamente pelo Visual Studio quando o projeto de teste é criado) no Solution Explorer.
• Este é o arquivo que será executado para testar o projeto ASP.NET.

Você verá o código abaixo adicionado pelo Visual Studio no arquivo UnitTest1.cs. Este é o código básico necessário para a execução do projeto de teste.

Passo 4) O próximo passo é adicionar o código que é usado para testar a string “Guru99 – ASP.NET.”

using System;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using DemoApplication;

namespace DemoTest
{
 [TestClass]
 public class UnitTest1
 {
   [TestMethod]
   public void TestMethod1()
   {
      Tutorial tp = new Tutorial();
      Assert.AreEqual(tp.Name,"Guru99 - ASP.Net");
   }
 }
}

1. Crie um novo objeto chamado 'tp' do tipo Tutorial
2. O método Assert.AreEqual é usado no .NET para testar se um valor é igual a algo. Portanto, em nosso caso, estamos comparando os valores de tp.Name com Guru99 – ASP.NET.

Passo 5) Agora vamos executar nosso projeto de teste. Para isso, precisamos acessar a opção de menu Teste->Executar->Todos os Testes.

Resultado:-

Uma janela do Explorer de teste aparecerá no Visual Studio. Isso mostrará o resultado acima e mostrará que um teste bem-sucedido foi executado no Visual Studio.

Atributos e asserções do MSTest que você usará

O MicrosoftO namespace .VisualStudio.TestTools.UnitTesting fornece um pequeno conjunto de atributos e asserções que abrangem a maioria dos testes de unidade do ASP.NET. Aprender esses atributos primeiro facilita a leitura e a manutenção de todos os testes posteriores.

• [TestClass] – Marca a classe como um contêiner de testes. O MSTest examina as classes com esse atributo no momento da descoberta.
• [Método de teste] – marca um método público e sem parâmetros como um teste individual. O método retorna void, Task ou ValueTask.
• [InicializarTeste] / [Limpeza de Teste] – Execute antes e depois de cada método de teste. Use-os para criar e descartar configurações compartilhadas, como um repositório simulado ou um contexto em memória.
• [InicializarClasse] / [Limpeza deClasse] – Executar uma vez para toda a turma. São úteis quando a configuração é dispendiosa, por exemplo, ao popular um banco de dados de teste.
• [DataRow] e [DataTestMethod] – fornecer entradas parametrizadas para que um único método de teste cubra vários casos.

Dentro de cada método de teste, a classe `Assert` verifica o resultado. Chamadas comuns incluem `Assert.AreEqual` para comparações de valores, `Assert.IsTrue` e `Assert.IsFalse` para booleanos, `Assert.IsNull` e `Assert.IsNotNull` para referências e `Assert.ThrowsException` para exceções esperadas. Estruture cada teste usando o padrão Arrange, Act, Assert (Arranjar, Agir, Verificar) para que a configuração, a invocação e a verificação permaneçam visualmente separadas. Esse layout facilita a depuração de testes com falha, pois a linha com falha é quase sempre a única chamada `Assert` na parte inferior.

Comparação entre MSTest, NUnit e xUnit para ASP.NET

Três frameworks de teste dominam o ecossistema .NET. Cada um deles é executado dentro do Visual Studio e se integra ao dotnet test, portanto, a diferença reside principalmente no estilo, no suporte da comunidade e no comportamento padrão.

• Teste MS – enviado por Microsoft e vem pré-instalado com o modelo de Projeto de Teste de Unidade do Visual Studio usado anteriormente neste tutorial. É a opção padrão mais segura quando uma equipe é iniciante em testes de unidade no Microsoft pilha.
• NUunidade – o mais antigo dos três, originalmente adaptado de JUnitOferece um modelo de restrições robusto, testes parametrizados por meio de TestCase e TestCaseSource, e suporte consolidado em todas as versões do .NET.
• xUnit.net – usado internamente pelas equipes do ASP.NET Core e do Entity Framework Core. Ele substitui o método SetUp por um construtor e IDisposable, incentiva uma classe de teste por comportamento e usa [Fact] e [Theory] em vez de [TestMethod].

Todas as três estruturas descobrem testes por meio de atributos, executam o comando dotnet test e produzem relatórios XML trx ou xUnit que pipelines de CI como Azure DevOps, GitHub Actions e Jenkins pode consumir diretamente. Para um primeiro projeto ASP.NET, usar o MSTest mantém o conjunto de ferramentas simples. Equipes que desejam uma parametrização mais rica ou que já usam o ASP.NET Core geralmente optam pelo xUnit para manter a consistência com a estrutura com a qual foi desenvolvido.

Melhores práticas para testes unitários de aplicações ASP.NET

Seguir um pequeno conjunto de hábitos mantém um conjunto de ferramentas rápido, confiável e útil durante toda a vida útil de um projeto ASP.NET.

1. Teste um comportamento por método. Um teste que afirma várias coisas não relacionadas falha por diversos motivos e leva mais tempo para ser corrigido.
2. Nomeie os testes de acordo com a intenção. Um padrão como MethodUnderTest_Scenario_ExpectedResult faz com que o Test Explorer gere uma especificação legível da classe.
3. Isole a unidade dos sistemas externos. Encapsule chamadas de arquivos, rede e banco de dados por trás de interfaces e substitua-as por instâncias falsas ou simulações para que o teste não atinja a dependência real.
4. Mantenha os testes rápidos. O objetivo é que o conjunto completo de testes unitários seja concluído em segundos. Testes lentos são ignorados, e testes ignorados ocultam regressões.
5. Siga o esquema Organizar, Agir, Afirmar. Três pequenos blocos com linhas em branco entre eles sinalizam a intenção e facilitam a identificação de linhas com falhas.
6. Execute testes a cada commit. Integre os testes do .NET a um pipeline de CI para que um teste com falha bloqueie a mesclagem em vez de enviar as alterações.ping para a produção.
7. Traccobertura de código k, mas não se preocupe muito com isso. A cobertura destaca caminhos não testados, mas um número elevado por si só não garante qualidade. RevVeja o que as linhas que faltam realmente fazem.

Aplicadas em conjunto, essas práticas transformam o projeto DemoTest, criado anteriormente, na base de um conjunto de testes que detecta regressões a cada atualização, documenta o comportamento para futuros desenvolvedores e oferece confiança na refatoração de uma aplicação ASP.NET.

Perguntas Frequentes