Início rápido: desenvolvimento baseado em testes com o Gerenciador de Testes

  • Artigo

Recomendamos que você crie testes de unidade para ajudar a manter seu código funcionando corretamente por meio de várias etapas incrementais de desenvolvimento.Há várias estruturas que você pode usar para escrever testes de unidade, incluindo desenvolvidos por terceiros.Algumas estruturas de teste são especializadas em testar em idiomas ou em plataformas diferentes.O teste Explorer fornece uma única interface para testes de unidade em quaisquer outras estruturas.Os adaptadores estão disponíveis para as estruturas mais comumente usadas, e você pode escrever seus próprios adaptadores para outras estruturas.

O Test Explorar substitui as janelas de teste da unidade nas edições anteriores do Visual Studio.Seus benefícios incluem:

  • Executar .NET, não gerenciado, banco de dados e outros tipos de testes usando uma única interface.

  • Use a estrutura de testes de unidade de sua escolha, como NUnit ou estruturas MSTests.

  • Consulte em uma janela todas as informações que você precisa.

Usando o Gerenciador de Testes

Para executar testes de unidade usando o Gerenciador de Testes

  1. Crie testes de unidade que usam as estruturas de teste de sua escolha.

    Por exemplo, para criar um teste que usa o MSTest Framework:

    1. Crie um projeto de teste.

      Na caixa de diálogo Novo Projeto, expanda o nó Visual Basic, Visual C#, ou Visual C++, e escolha Testar.

      Selecione o Projeto de teste unitário.

    2. Grave cada teste de unidade como um método.Prefixe cada método de teste com o atributo de [TestMethod].

  2. Na barra de menus, escolha Testar, Executar Testes de Unidade, Todos os Testes.

    A solução é compilada e os testes são executados.

    O teste Explorer abre e exibe um resumo dos resultados.

Para ver uma lista completa de testes: Escolha Mostrar Tudo em qualquer categoria.

Para retornar ao resumo, escolha a exibição INÍCIO.

Para ver os detalhes de um resultado de teste: Seleciona o teste no Gerenciador de Testes para exibir detalhes como mensagens de exceção no painel de detalhes.

Para navegar para o código de um teste: Clique duas vezes no teste no Gerenciador de Testes, ou escolha Abrir Teste no menu de atalho.

Para depurar um teste: Abra o menu de atalho para um ou mais testes e escolha Depurar Testes Selecionados.

Observação importanteImportante

Os resultados que são exibidos são para a execução mais recente.A barra colorida de resultados mostra somente os resultados para os testes executados.Por exemplo, se você executar vários teste e alguns deles falharem e, então, executar somente os testes bem-sucedidos, a barra de resultados será mostrada inteira em verde.
ObservaçãoObservação

Se nenhum teste aparecer, certifique-se de ter instalado um adaptador para conectar o gerenciador de testes à estrutura de teste que você está usando.Para obter mais informações, consulte Usando diferentes frameworks de teste com o Gerenciador de Testes.

Passo a passo: usando o teste de unidade para desenvolver um método

Essa explicação passo a passo demonstra como desenvolver um método testado em C# usando a estrutura de testes de unidade da Microsoft.É possível adaptá-lo facilmente a outras linguagens e usar outros frameworks de teste como NUnit.Para obter mais informações, consulte Usando diferentes frameworks de teste.

Criando o teste e o método

  1. Crie um projeto de Biblioteca de Classes do Visual C#.Este projeto conterá o código que queremos entregar.Nesse exemplo, é chamado MyMath.

  2. Crie um projeto de teste.

    • Na caixa de diálogo Novo Projeto, escolha Visual C#, Testar e então escolha Projeto de Teste unitário.

      Novos projetos de código e teste

  3. Grave um método básico de teste.Verifique o resultado obtido para uma entrada específica:

      [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 o método a partir do teste.

    1. Coloque o cursor em Rooter e, em seguida, no menu de atalho, escolha Gerar, Novo Tipo.

    2. Na caixa de diálogo Gerar Novo Tipo , defina Projeto para o projeto de biblioteca de classes.Nesse exemplo, é MyMath.

    3. Coloque o cursor em SquareRoot e, em seguida, no menu de atalho, escolha Gerar, Stub do Método.

  5. Executar o teste de unidade.

    • No menu Teste, escolha Executar Testes de Unidade, Todos os Testes.

      A solução é compilada e executada.

      O Gerenciador de testes é aberto e exibe os resultados.

      O teste aparece em Testes com falha.

  6. Selecione o nome do teste.

    Os detalhes de teste aparecem na parte inferior do Gerenciador de Testes.

  7. Selecione os itens em Rastreamento de pilha para ver onde o teste falhou.

O Gerenciador de testes de unidade mostrando com falha de teste.

Neste ponto, você criou um teste e um stub que você alterará para que o teste passe.

Após cada alteração, faça todos os testes passarem

  1. Em MyMath\Rooter.cs, melhore o código de SquareRoot:

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

  2. No Gerenciador de Testes, escolha Executar Todos.

    As compilações de código e as execuções de teste.

    O método de teste agora passa.

    Unidade Test Explorer mostrando um teste de passagem.

Adicione testes para estender o intervalo de entradas

  1. Para melhorar a confiança com que seu código funciona em todos os casos, adicione testes que tentam um intervalo maior de valores de entrada.

    DicaDica

    Evite alterar os testes existentes que passam.Em vez disso, adicione novos testes.Altere os testes existentes somente quando os requisitos de usuário mudarem.Essa política ajuda a garantir que você não perde funcionalidades existentes enquanto você trabalha para estender o código.

    Em sua 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 expectedResult = 1e-8;
        expectedResult < 1e+8;
        expectedResult = expectedResult * 3.2)
    {
      RooterOneValue(rooter, expectedResult);
    }
  }

  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 Todos.

    O novo teste falha, embora o primeiro teste ainda passe.

    Para encontrar o ponto de falha, selecione o teste falho e na parte inferior do Gerenciador de Testes, selecione o item superior do Rastreamento de Pilha.

  3. Inspecione o método no teste para ver o que pode estar incorreto.Na classe de MyMath.Rooter, reescreva o código:

      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 Todos.

    Ambos os testes agora passam.

Adicione testes para casos excepcionais

  1. Adicione um teste para entradas negativas:

           [TestMethod]
        public void RooterTestNegativeInputx()
        {
            Rooter rooter = new Rooter();
            try
            {
                rooter.SquareRoot(-10);
            }
            catch (ArgumentOutOfRangeException e)
            {
                return;
            }
            Assert.Fail();
        }

  2. No Gerenciador de Testes, escolha Executar Todos.

    Método em loop de teste e deve ser cancelado manualmente.

  3. Escolha Cancelar.

    O teste para depois de 10 segundos.

  4. Corrigir o código de método:

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

  5. No Gerenciador de Testes, escolha Executar Todos.

    Todos os testes passam.

Refatora sem alterar os testes

  1. Simplifica o código, mas não altera os testes.

    DicaDica

    A refatoração é uma alteração destinada a melhorar a execução do código ou facilitar o entendimento do código.Não há intenção de alterar o comportamento do código, portanto, os testes não serão alterados.

    Recomendamos que você execute as etapas de refatoração separadas das etapas que estendem a funcionalidade.Manter os testes inalteradas lhe deixa confiante de que você não introduziu bugs acidentalmente durante a refatoração.

    		 
      public class Rooter
  {
    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.

    Todos os testes ainda passam.

    Gerenciador de testes de unidade mostrando 3 testes aprovados.