Noções básicas de teste de unidade

Este tópico descreve os conceitos básicos de gravação e de testes de unidade em execução no teste Explorer Visual Studio.Ele contém as seguintes seções:

Unit testing overview

• Quick starts

The MyBank Solution example

Creating the unit test projects

Writing your tests

Running tests in Test Explorer

• Running and viewing tests from the Test Explorer toolbar

• Running tests after every build

• Filtering and grouping the test list

Debugging unit tests

Additional tools for unit tests

• Generating application code from tests

• Generating multiple tests by using data driven test methods

• Analyzing unit test code coverage

• Isolating unit test methods with Microsoft Fakes

Visão geral sobre testes de unidade

Teste o Gerenciador do Visual Studio é projetado para oferecer suporte aos desenvolvedores e as equipes que incorporam testes de unidade nas práticas de programação de software.Ajuda a testes de unidade você garante a exatidão do seu programa verificando que o código do aplicativo faça o que você espera fazer o.Em testes de unidade, você analisa a funcionalidade do seu programa para descobrir os comportamentos testaveis discretos que você pode testar como unidadesindividuais.Você usa uma estrutura de testes de unidade para criar teste de esses comportamentos e para relatar os resultados de esses testes.

Os testes de unidade grande tem o efeito quando é uma parte integral do fluxo de trabalho de programação de software.Assim que você escrever uma função ou outro bloco de código do aplicativo, você cria os testes de unidade que realizam o comportamento do código em resposta ao padrão, o limite, e os casos incorretos de dados de entrada, e que realizam todas as suposições explícitas ou implícitas feitas pelo código.Em a prática de programação de software conhecida como o desenvolvimento orientado teste, você cria os testes de unidade antes que você escreva o código, para que você use que testa a unidade como a documentação de design e especificações funcionais de funcionalidade.

O teste Explorer fornece um flexível e uma maneira eficiente para executar seus testes de unidade e exibir seus resultados no Visual Studio.O Visual Studio instala estruturas de testes de unidade da Microsoft para código gerenciado e nativo.O teste Explorer também pode executar as estruturas de terceiros e de open source de unidade de teste que implementa interfaces diferentes de teste de Explorer.Você pode adicionar muitas de essas estruturas através do gerenciador de extensão do Visual Studio e de galeria do Visual Studio.Consulte Como: instalar estruturas de teste de unidade de terceiros.

As exibições do gerenciador de teste podem exibir todos os testes, ou apenas os testes que passaram, falhados, não foram executados, ainda não foram pulados.Você pode filtrar os testes em qualquer texto de exibição por correspondência na caixa de pesquisa no nível global ou selecionando um dos filtros predefinidos.Você pode executar qualquer seleção de teste a qualquer momento.Quando você usa Visual Studio Ultimate, você pode executar testes automaticamente após cada compilação.Os resultados de um ensaio são aparentes imediatamente na barra de passagem/falha na parte superior da janela do explorer.Os detalhes de um resultado de teste são exibidos quando você seleciona o teste.

Cabeçotes rápidos

Para obter uma introdução a testes de unidade o que levam diretamente na codificação, consulte um de esses tópicos:

• Instruções passo a passo: criando e executando testes de unidade para código gerenciado

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

• Teste de código nativo com Explorer de teste de unidade

O exemplo de solução de MyBank

Em este tópico, usamos o desenvolvimento de um aplicativo imaginário chamado MyBank como um exemplo.Você não precisa o código real de seguir as explicações em este tópico.Os métodos de teste são gravados em C# e apresentado usando a estrutura de testes de unidade da Microsoft para código gerenciado, no entanto, os conceitos são transferidos facilmente a outros idiomas e estruturas.

A primeira tentativa em um projeto para o aplicativo de MyBank inclui um componente de contas que representa uma conta individual e as transações com o banco, e um componente de banco de dados que representa a funcionalidade para agregar e gerenciar contas individuais.

Criamos uma solução de MyBank que contém dois projetos:

• Accounts

• BankDb

A primeira tentativa de criar o projeto de Accounts contém uma classe para manter informações básicas sobre uma conta, uma interface que especifica a funcionalidade comum de qualquer tipo de conta, como o depósito e a retirada de recursos de conta, e uma classe derivada de interface que representa uma conta corrente.Começamos projetos de contas criar os seguintes arquivos de origem:

• AccountInfo.cs define informações básicas para uma conta.

• IAccount.cs define uma interface padrão de IAccountpara uma conta, incluindo métodos para depositar e retirar recursos de uma conta e recuperar o saldo de contas.

• CheckingAccount.cs contém a classe de CheckingAccount que implementa a interface de IAccounts para uma conta corrente.

Nós sabemos por experiência que uma coisa que uma retirada de uma conta corrente deve fazer é se certificar de que a quantidade retirada é menor que o saldo de contas.Isso substituímos o método de IAccount.Withdaw em CheckingAccount com um método que verifica esta condição.O método pode parecer como este:

public void Withdraw(double amount)
{
    if(m_balance >= amount)
    {
        m_balance -= amount;
    }
    else
    {
        throw new ArgumentException(amount, "Withdrawal exceeds balance!")
    }
}

Agora que temos qualquer código, é hora para teste.

Criando projetos de testes de unidade

Um projeto de teste de unidade espelha geralmente a estrutura de um projeto único de código.Em o exemplo de MyBank, você adiciona dois projetos de testes de unidade AccountsTests nomeados e BankDbTests à solução de MyBanks .Os nomes de projeto de teste são arbitrários, mas adotar uma convenção de nomeclatura padrão é uma boa idéia.

Para adicionar um teste de unidade projeto a uma solução:

1. Em o menu de ArquivoNovo , escolha e então escolha Projeto (teclado CTRL + SHIFT + N).

2. Em a caixa de diálogo new project, expanda o nó de Instalado , escolha a linguagem que você deseja usar para o seu projeto de teste, e escolha Testar.

3. Para usar uma das estruturas de testes de unidade da Microsoft, escolha Projeto de teste de unidade na lista de modelos de projeto.Caso contrário, escolha o modelo de projeto da estrutura de testes de unidade que você deseja usar.Para testar o projeto de Accounts do nosso exemplo, você nomearia o projeto AccountsTests.

   Cuidado
   Nem todas as estruturas de terceiros e de open source de unidade de teste fornecem um modelo de projeto do Visual Studio.Consulte o documento da estrutura para obter informações sobre como criar um projeto.

4. Em seu projeto de teste de unidade, adicione uma referência ao projeto de código no teste, em nosso exemplo para contas projeto.

   Para criar a referência ao projeto código:

   1. Selecione o projeto no solution Explorer.

   2. Em o menu de Projeto , escolha Adicionar Referência.

   3. Em a caixa de diálogo do gerenciador de referência, abra o nó de Solução e escolha Projetos.Selecione o nome do projeto de código e feche a caixa de diálogo.

Cada projeto de teste de unidade contém classes que espelham os nomes das classes no projeto de código.Em nosso exemplo, o projeto de AccountsTests contém as seguintes classes:

• a classe deAccountInfoTests contém os métodos de testes de unidade para a classe de AccountInfo no projeto de BankAccount

• a classe deCheckingAccountTests contém os métodos de testes de unidade para a classe de CheckingAccount .

Escrevendo seus testes

A estrutura de testes de unidade que você use o Visual Studio e o IntelliSense guiá-lo-ão através da criação da unidade testam para um projeto de código.Para executar no teste Explorer, a maioria das estruturas exigem que você adicionar atributos específicos para identificar métodos de testes de unidade.Estruturas também fornecem uma maneira usual assert - completamente instruções ou o método atributos a indica se o método de teste passou ou falhou.Outros atributos identificam os métodos opcionais de configuração que estão na classe de inicialização e antes de cada método de teste e métodos de teardown que são executadas após cada método de teste e antes da classe seja destruída.

O padrão de AAA (organizar, atua, afirmar) é uma maneira comum de testes de unidade de escrita para um método no teste.

• A seção de Organizar de um método de testes de unidade inicializa objetos e defina o valor dos dados que são passados ao método no teste.

• A seção de ato chama o método no teste com os parâmetros organizados.

• A seção de Declarar verifica que a ação de método no teste se comporta como esperado.

Para testar o método de CheckingAccount.Withdraw do nosso exemplo, podemos escrever dois teste: verifique se que o comportamento padrão de método, e se que verifica que uma retirada de mais do que o saldo falhará.Em a classe de CheckingAccountTests , adicionaremos os seguintes métodos:

[TestMethod]
public void Withdraw_ValidAmount_ChangesBalance()
{
    // arrange
    double currentBalance = 10.0;
    double withdrawal = 1.0;
    double expected = 9.0;
    var account = new CheckingAccount("JohnDoe", currentBalance);
    // act
    account.Withdraw(withdrawal);
    double actual = account.Balance;
    // assert
    Assert.AreEqual(expected, actual);
}

[TestMethod]
[ExpectedException(typeof(ArgumentException))]
public void Withdraw_AmountMoreThanBalance_Throws()
{
    // arrange
    var account = new CheckingAccount("John Doe", 10.0);
    // act
    account.Withdraw(1.0);
    // assert is handled by the ExcpectedException
}

Observe que Withdraw_ValidAmount_ChangesBalance usa uma declaração explícita de Assert para determinar se o método passa de teste ou falha, quando Withdraw_AmountMoreThanBalance_Throws usar o atributo de ExpectedException para determinar o sucesso de teste.Sob cobra, métodos de um teste de quebra automática da estrutura de testes de unidade em instruções try/catch.Em a maioria dos casos, se uma exceção é detectada, o método de teste falha e a exceção será ignorada.O atributo de ExpectedException faz com que o método de teste passe se a exceção especificada é lançada.

Para obter mais informações sobre as estruturas de testes de unidade da Microsoft, consulte um dos seguintes tópicos:

• Escrever testes de unidade para o.NET Framework com a estrutura de teste de unidade da Microsoft para código gerenciado

• Escrever testes de unidade para C/C++ com o Microsoft Unit Testing Framework para C++

Executar testes no teste Explorer

Quando você compila o projeto de teste, os testes aparecem no teste Explorer.Se o teste Explorer não estiver visível, escolha Testar no menu do Visual Studio Janelas, escolha, e escolha teste Explorer.

Como você executa, gravar, e execute novamente seus testes, a exibição padrão do gerenciador de teste exibe os resultados em grupos de Testes com falha, Testando passados, Testando ignorados e Não teste de execução.Você pode escolher um título de grupo para abrir a exibição que ele exibe todos os testes no grupo.

Executando e exibindo testes da barra de ferramentas do gerenciador de teste

A barra de ferramentas do gerenciador de teste ajuda para descobrir, organiza-a, e executá-lo os testes que você está interessado.

Você pode escolher Executar todas para executar todos os testes, ou escolha Executar para escolher um subconjunto de teste para executar.Depois de executar um conjunto de teste, um resumo de ensaio aparece na parte inferior da janela do gerenciador de teste.Selecione um teste para exibir os detalhes do teste no painel inferior.Escolha Abra o teste do menu de contexto (teclado: F12) para exibir o código-fonte para teste selecionado.

Executar testes após cada compilação

Cuidado
Os testes de unidade em execução após cada compilação são suportados apenas no Visual Studio final.

Filtragem e agrupamento a lista de teste

Quando você tiver um grande número de teste, você pode digitar na caixa de pesquisa do gerenciador de teste para filtrar a lista pela cadeia de caracteres especificada.Você pode restringir o evento de filtro mais escolhendo a partir da lista de filtro.

Para mais informações, consulte Executando testes de unidade com Test Explorer.

Testes de unidade de depuração

Você pode usar o teste Explorer para iniciar uma sessão de depuração para os testes.Depurar seu código com o depurador do Visual Studio leva você perfeitamente para frente e para trás entre os testes de unidade e o projeto no teste.Para iniciar depuração:

1. Em o editor do Visual Studio, definir um ponto de interrupção em um ou mais métodos de teste que você deseja depurar.

   Observação
   Como os métodos de teste podem executar em qualquer ordem, definir pontos de interrupção em todos os métodos de teste que você deseja depurar.

2. Em o teste Explorer, selecione os métodos de teste e escolha depurar testes selecionados do menu de atalho.

Para obter mais informações sobre o depurador, consulte Depuração no Visual Studio.

Ferramentas adicionais para testes de unidade

Gerando o código do aplicativo de teste

Se você estiver escrevendo seus testes antes que você escrever seu código de projeto, você pode usar o IntelliSense para gerar classes e métodos no seu código de projeto.Escreva uma declaração em um método de teste que chama a classe ou método que você deseja gerar, então abra o menu do IntelliSense na chamada.Se o é chamada para um construtor de classe, escolha Gerar novo tipo de menu e siga o assistente para inserir a classe no projeto de código.Se a chamada é a um método, escolha gere o novo método do menu do IntelliSense.

Gerando mais testes usando os dados e testar métodos

Observação
Estes procedimentos se aplicam somente para testar os métodos que você escreve usando a estrutura de testes de unidade da Microsoft para código gerenciado.Se você estiver usando uma estrutura diferente, consulte a documentação da estrutura para a funcionalidade equivalente.

os métodos orientados a dados dinâmicos de teste permitem verificar um intervalo de valores em um método de testes de unidade.Para criar um método orientado de testes de unidade, adornar o método com um atributo de DataSource que especifica a fonte de dados e a tabela que contém os valores de variáveis que você deseja testar.O corpo do método, você atribui valores a variáveis de linha usando o indicador de TestContext.DataRow[ColumnName] .

Por exemplo, assumir-nos adicione um método à classe desnecessário de CheckingAccount que é chamada AddIntegerHelper.AddIntegerHelper adiciona dois inteiros.

Para criar um teste orientado a dados para o método de AddIntegerHelper primeiro, nós criaremos um banco de dados Access chamado AccountsTest.accdb e uma tabela denominada AddIntegerHelperData.A tabela de AddIntegerHelperData define colunas para especificar os primeiros e segundos operandos de adição e uma coluna para especificar o resultado esperado.Nós preenchemos um número de linhas com valores apropriados.

    [DataSource(
        @"Provider=Microsoft.ACE.OLEDB.12.0;Data Source=C:\Projects\MyBank\TestData\AccountsTest.accdb", 
        "AddIntegerHelperData"
    )]
    [TestMethod()]
    public void AddIntegerHelper_DataDrivenValues_AllShouldPass()
    {
        var target = new CheckingAccount();
        int x = Convert.ToInt32(TestContext.DataRow["FirstNumber"]);
        int y = Convert.ToInt32(TestContext.DataRow["SecondNumber"]); 
        int expected = Convert.ToInt32(TestContext.DataRow["Sum"]);
        int actual = target.AddIntegerHelper(x, y);
        Assert.AreEqual(expected, actual);
    }

O método atribuído executa uma vez para cada linha na tabela.Teste o gerenciador de relatórios uma falha de teste para o método se quaisquer de iterações falhará.O painel de detalhes de resultados de teste para o método mostra o método de status de passagem/falha para cada linha de dados.

Para mais informações, consulte Como criar um teste de unidade orientado a dados.

Para analisar a tinta de código de teste de unidade

Observação
A tinta de código de teste do drive está disponível para nativo e linguagens gerenciadas e todas as estruturas de testes de unidade que podem ser executadas pela estrutura de testes de unidade.

Você pode determinar a quantidade de seu código do produto que está sendo testado realmente por seus testes de unidade usando a ferramenta de tinta de código Visual Studio.Você pode executar a tinta em código de teste ou selecionados em todos os testes em uma solução.A janela de resultados de tinta de código exibe a porcentagem dos blocos de código do produto que foram exercitados linha por linha, funcionam namespace, classe, módulo e.

Para executar a tinta de código para métodos de teste em uma solução,

1. Testes escolha no menu do Visual Studio e escolha Analisar a tinta de código.

2. Escolha um de esses comandos:

   1. Testando selecionados executa os métodos de teste que você selecionou no teste Explorer.

   2. Todos os testes executa todos os métodos de teste na solução.

Os resultados de tinta aparecem na janela de resultados de tinta de código.

Para mais informações, consulte Usando a cobertura de código para determinar como muito código está sendo testado.

Isolando métodos de testes de unidade com falsificação da Microsoft

Observação
As falsificação Microsoft estão disponíveis somente no Visual Studio final.As falsificação Microsoft podem ser usadas somente com métodos de teste que você escreve usando estruturas de testes de unidade para código gerenciado.

o problema

Os métodos de testes de unidade que se centram sobre verificar o código interno em uma função pode ser difícil escrever quando o método nas funções de chamadas de teste que apresentam dependências externas.Por exemplo, os métodos da classe do exemplo de CheckingAccount provavelmente devem fazer chamadas para o componente de BankDb para atualizar o banco de dados principal.Nós podemos refactor a classe de CheckingAccount parecer com o seguinte:

class CheckingAccount : IAccount
{
    public CheckingAccount(customerName, double startingBalance, IBankDb bankDb)
    {
        m_bankDb = bankDb;
        // set up account
    }

    public void Withdraw(double amount)
    {
        if(m_balance >= amount)
        {
            m_balance = m_MyBankDb.Withdraw(m_accountInfo.ID, amount);
        }
        else
        {
            throw new ArgumentException(amount, "Withdrawal exceeds balance!")
        }
    }

    private IBankDb m_bankDb = null;
    // ...

Os testes de unidade de esse método de CheckingAccount.Withdraw agora podem falhar devido a problemas causados pela chamada a m_bankDb.Withdraw.O banco de dados ou conexão de rede podem ser perdido ou as permissões no banco de dados podem ser erradas.Uma falha na chamada de m_bankDB.Withdraw causaria o teste a falha por razões que não estão relacionadas ao seu código interno.

A solução de falsificação da Microsoft

As falsificação Microsoft criar um assembly que contém as classes e métodos que você pode substituir para classes em métodos de testes de unidade que causa dependências.Uma classe substituta no módulo gerado de falsificação declara um método e um representante para cada método público no componente de destino.Em um método de teste, você implementa o representante para criar o comportamento exato da chamada de dependência no método que você deseja testar.

Em nosso exemplo, podemos criar um assembly de falsificação para o projeto de BankDb , e usamos na classe de StubIBankDb que são geradas por falsificação e que deriva de interface de IBankDb para remover a incerteza causada por interações com o banco de dados.Uma versão modifed de teste de Withdraw_ValidAmount_ChangesBalance em teria esta aparência:

[TestMethod]
public void Withdraw_ValidAmount_ChangesBalance()
{
    // arrange
    double currentBalance = 10.0;
    double withdrawal = 1.0;
    double expected = 9.0;

    // set up the Fakes object and delegate
    var stubBankDb = new MyBank.Stubs.StubIBankDb();
    stubBankDb.WithdrawDoubleDouble = (id, amount) => { return 9.0; }
    var account = new CheckingAccount("JohnDoe", currentBalance, stubBankDb);

    // act
    account.Withdraw(withdrawal);
    double actual = account.Balance;

    // assert
    Assert.AreEqual(expected, actual);
}

Esta linha no método de teste:

stubBankDb.WithdrawDoubleDouble = (id, amount) => { return 9.0; }

implementa o representante de falsificação para o método de Withdraw usando uma expressão lamba de.O método de stubBankDb.Withdraw chama o representante e tão sempre retorna a quantidade especificada, que permite o método de teste para verificar confiavelmente o comportamento do método de Accounts .

Mais sobre falsificação da Microsoft

Microsoft falsifica usa duas abordagens para criar classes substituta:

1. Os modelos geram as classes derivadas substituta de interface pai da classe de dependência alvo.Os métodos de stub podem ser substituídos por métodos virtuais públicos de classes de destino.

2. A instrumentação em tempo de execução do uso dascorreções para desviar chamadas para um método de destino para um calça substituir o método para métodos virtuais não.

Em ambas as abordagens, você usa os representantes gerados de chamadas para o método de dependência para especificar o comportamento que você deseja no método de teste.

Para mais informações, consulte Isolando código em teste com falsificação da Microsoft.