Introdução ao desenvolvimento orientado a testes usando o Test Explorer

Crie testes de unidade para ajudar a manter seu código funcionando corretamente por meio de alterações incrementais de código. Existem várias estruturas que você pode usar para escrever testes de unidade, incluindo alguns desenvolvidos por terceiros. Algumas estruturas de teste são especializadas para testes em diferentes linguagens ou plataformas. O Test Explorer fornece uma interface única para testes de unidade em qualquer uma dessas estruturas. Para obter mais informações sobre o Gerenciador de Testes, consulte Executar testes de unidade com o Gerenciador de Testes e Perguntas frequentes sobre o Gerenciador de Testes.

Este artigo demonstra como desenvolver um método testado em C# usando o Microsoft Test Framework (MSTest). Você pode adaptá-lo facilmente para outras linguagens ou outras estruturas de teste, como o NUnit. Para obter mais informações, consulte Instalar estruturas de teste de unidade de terceiros.

Criar um teste e gerar código

1. Crie um projeto de biblioteca de classes C# para .NET ou .NET Standard. Este projeto conterá o código que queremos testar. Nomeie o projeto MyMath.

2. Na mesma solução, adicione um novo projeto de teste MSTest para .NET.

   No Visual Studio 2019 versão 16.9, o nome do modelo de projeto MSTest é Projeto de Teste de Unidade.

   Nomeie o projeto de teste MathTests.

   

3. No projeto de teste, escreva um método de teste simples que verifique o resultado obtido para uma entrada específica. Adicione o seguinte código à Test1 classe ou UnitTest1 :

   [TestMethod]
   public void BasicRooterTest()
   {
     // Create an instance to test:
     Rooter rooter = new Rooter();
     // Define a test input and output value:
     double expectedResult = 2.0;
     double input = expectedResult * expectedResult;
     // Run the method under test:
     double actualResult = rooter.SquareRoot(input);
     // Verify the result:
     Assert.AreEqual(expectedResult, actualResult, delta: expectedResult / 100);
   }
   

4. Gere um tipo a partir do código de teste.

   1. Coloque o cursor em Rooter, e depois abra o menu da lâmpada.

      Escolha Gerar novo tipo.

      

   2. Na caixa de diálogo Gerar tipo, defina Project como MyMath, o projeto da biblioteca de classes e escolha OK.

      

5. Gere um método a partir do código de teste. Coloque o cursor sobre SquareRoot, e, em seguida, no menu da lâmpada, escolha Gerar método 'SquareRoot' ou Gerar método 'Rooter.SquareRoot'.

6. Execute o teste de unidade.

   1. Abra o Gerenciador de Testes.

      Para abrir o Gerenciador de Testes no menu Teste , escolha Gerenciador de Testes.

   2. No Gerenciador de Testes, escolha o botão Executar Tudo para executar o teste.

   A solução é compilada e o teste é executado e falha.

7. Selecione o nome do teste.

   Os detalhes do teste aparecem no painel Resumo de Detalhes do Teste .

   

8. Selecione o primeiro link em Stack Trace para ir para o local onde o teste falhou.

Neste ponto, você criou um teste e um esboço que podem ser modificados para que o teste seja aprovado.

Verificar uma alteração de código

1. No arquivo Class1.cs , melhore o código de SquareRoot:

   public double SquareRoot(double input)
   {
       return input / 2;
   }
   

2. No Gerenciador de Testes, escolha Executar Tudo.

   A solução é construída, e o teste é executado e aprovado.

   

Amplie a gama de entradas

Para melhorar nossa confiança de que o código funciona em todos os casos, adicione testes que tentem uma gama mais ampla de valores de entrada.

1. Na classe de teste, adicione o seguinte teste, que tenta um intervalo de valores de entrada:

   [TestMethod]
   public void RooterValueRange()
   {
       // Create an instance to test.
       Rooter rooter = new Rooter();
   
       // Try a range of values.
       for (double expected = 1e-8; expected < 1e+8; expected *= 3.2)
       {
           RooterOneValue(rooter, expected);
       }
   }
   
   private void RooterOneValue(Rooter rooter, double expectedResult)
   {
       double input = expectedResult * expectedResult;
       double actualResult = rooter.SquareRoot(input);
       Assert.AreEqual(expectedResult, actualResult, delta: expectedResult / 1000);
   }
   

2. No Gerenciador de Testes, escolha Executar Tudo.

   O novo teste falha (embora o primeiro teste ainda seja aprovado). Para localizar o ponto de falha, selecione o teste com falha e, em seguida, examine os detalhes no painel Resumo de Detalhes do Teste .

3. Inspecione o método em teste para ver o que pode estar errado. Altere o SquareRoot código da seguinte forma:

   public double SquareRoot(double input)
   {
     double result = input;
     double previousResult = -input;
     while (Math.Abs(previousResult - result) > result / 1000)
     {
       previousResult = result;
       result = result - (result * result - input) / (2 * result);
     }
     return result;
   }
   

4. No Gerenciador de Testes, escolha Executar Tudo.

   Ambos os testes passaram agora.

Adicionar testes para casos excecionais

1. Adicione um novo teste para entradas negativas:

   [TestMethod]
   public void RooterTestNegativeInput()
   {
       Rooter rooter = new Rooter();
       Assert.ThrowsException<ArgumentOutOfRangeException>(() => rooter.SquareRoot(-1));
   }
   

2. No Gerenciador de Testes, escolha Executar Tudo.

   O novo teste falha.

   Se o método estiver em loop durante o teste, escolha Cancelar na barra de ferramentas do Test Explorer. O teste para de ser executado e falha.

3. Corrija o SquareRoot código adicionando a seguinte if instrução no início do método:

   public double SquareRoot(double input)
   {
       if (input <= 0.0)
       {
           throw new ArgumentOutOfRangeException();
       }
       ...
   

4. No Gerenciador de Testes, escolha Executar Tudo.

   Todos os testes são aprovados.

Refatore o código em teste

Refatore o código, mas não altere os testes.

1. Altere a linha que calcula result no método SquareRoot da seguinte maneira:

   public double SquareRoot(double input)
   {
       if (input <= 0.0)
       {
           throw new ArgumentOutOfRangeException();
       }
   
       double result = input;
       double previousResult = -input;
       while (Math.Abs(previousResult - result) > result / 1000)
       {
           previousResult = result;
           result = (result + input / result) / 2;
           //was: result = result - (result * result - input) / (2*result);
       }
       return result;
   }
   

2. Escolha Executar todos e verifique se todos os testes ainda passam.