Teste de execução em seu processo de compilação

Você pode usar Team Foundation Build para realizar testes automatizados e analisar o impacto das alterações de código em seus testes como parte do processo de compilação.Por exemplo, você pode definir um processo de compilação para ser o Teste de Verificação de Compilação (BVT, em inglês) regularmente agendado de sua equipe.Você também pode executar testes automatizados e executar tarefas relacionadas a testes a partir de seus processos personalizados de compilação.

Observação

Se você desejar implementar seu aplicativo como parte do processo de compilação, você deve usar uma sequencia de trabalho compilar-implementar-testar e um ambiente de laboratório.Você poderá então executar testes automatizados como parte da sequencia de trabalho, ou então executar testes separadamente após a conclusão da sequencia de trabalho.Para obter mais informações, consulte Configuração de fluxos de trabalho de compilação-implantar-teste automatizado.

Neste tópico

• Preparar para Executar Testes em seu Processo de Compilação

• Permissões Necessárias

• Usar uma Execução de Teste para Rodar Testes Automatizados

• Escolha e Configurar um Executor de Testes

  • Usar o Executor de Testes do Visual Studio para Executar um Teste

  • Usar MSTest para Executar um Teste

• Desativar Temporariamente Testes

• Ativar Análise de Impacto de Teste

• Configurar um Framework de Testes Unitários de Terceiros

• Executar Testes em um Processo de Compilação Personalizada

• Para obter mais informações

Preparar para Executar Testes em seu Processo de Compilação

Antes de executar testes no processo de compilação, pode ser necessário preparar seus testes e o sistema de compilação.

Prepare seus testes: verifique se sua solução e seus arquivos de teste são marcados como controle de versão.Consulte Usando o Controle de Versão.

Categorizar e Priorizar Testes (Opcional): Você pode atribuir categorias e prioridades para seus testes, e filtrá-los em seguida com base nesses atributos ao executá-los na sua compilação.Por exemplo, você pode criar uma categoria de teste chamada CI e então especificar esta categoria em suas compilações de integração contínua.Você pode criar outra categoria para seus teste de verificação de compilação chamada bvt e então especificar esta categoria em compilações agendadas, como por exemplo uma compilação noturna.Para obter mais informações, consulte Definindo categorias de teste para agrupar os testes, TestCategoryAttribute, e PriorityAttribute.

Prepare seu servidor de compilação: Alguns tipos de testes podem ser executados somente por um agente de compilação em um servidor de compilação que é configurado especialmente.Por exemplo, se você estiver executando teste codificados de interface do usuário, você deve configurar o agente de compilação para executar interativamente.Antes de tentar usar o processo de compilação para executar testes, certifique-se que podem ser executados no servidor de compilação que você pretende usar.Para obter mais informações, consulte Habilitar o agente de compilação para executar um teste.

Microsoft Visual Studio é necessário ser instalado no servidor de compilação para os seguintes situações:

• Para compilar todo o projeto de teste de CPP, você deve instalar Visual Studio Professional ou posterior.

• Para executar testes de unidade, ou teste codificados de interface do usuário, você deve instalar Visual Studio Professional ou posterior.

• Para usar dados e adaptadores de dados diagnóstico:

  1. Tinta de código a seguir: Visual Studio Premium ou posterior.

  2. Impacto de teste: Visual Studio Ultimate.

  3. IntelliTrace: Visual Studio Ultimate.

• Para criar alguns aplicativos mais modernos de estilo em um computador de compilação: Visual Studio Ultimate ou Visual Studio Express for Windows 8 (o sistema operacional no servidor de compilação deve ser Windows 8).

• Para compilar e teste de execução para um projeto com um assembly falsificado: Visual Studio Ultimate.

Permissões exigidas

Para executar estes procedimentos a permissão Editar definição de compilação deve estar definida como Permitir.Para obter mais informações, consulte Team Foundation Permissões do servidor.

Executar testes automatizados

Você pode executar um ou mais ensaios na sua compilação que é baseado em o modelo padrão.Para cada execução, você pode especificar as seguintes configurações:

• Quais testes são executados

• Quais configurações são usadas para realizar testes

• Se a compilação deve falhar se um teste falhar

Para executar testes automatizados em um processo de compilação que é baseado no modelo padrão

1. Na barra de menu, escolha Visualizar, Team Explorer.

2. Em Team Explorer, escolha Página Inicial e então escolha Compilações.

3. Na página Compilações, escolha Nova Definição de Compilação ou abra o atalho no menu para a compilação ou definição de compilação que você selecionou, e escolha Editar Definição de Compilação.

   A janela de definição de compilação aparece.

4. Na aba Processo de sua definição de compilação, expanda o nó Básico.

5. Selecione a caixa de seleção Testes automatizados , escolha o botão de reticências (...).

   A caixa de diálogo Testes automatizados é exibida.

6. Execute uma das seguintes etapas:

   • Para adicionar um conjunto de testes, escolha Adicionar.

   • Para alterar um conjunto de testes, escolha-o e a seguir escolha Editar.

   A caixa de diálogo Adicionar/Editar teste é exibida.

7. (Opcional) Especifique o Nome do teste.Este nome aparece na janela de resultados de compilação.Se você não especificar um nome, o sistema gera um automaticamente.

8. Se você desejar que a compilação falhe se qualquer um dos testes em execução falhar, então escolha Falha de compilação em caso de falha de teste.Se você deixar essa caixa de seleção desmarcada e qualquer teste falhar, a compilação concluída será classificada como Com sucesso parcial.

9. Escolha um executor de teste.Especifique como o executor de teste irá operar usando as opções que aparecem.Para obter mais informações consulte Escolher e configurar um executor de teste.

Escolha e configure um Test Runner

Quando você definir o processo de compilação, escolha um corredor de teste que forneça a funcionalidade de precisa.

Recurso	Test Runner do Visual Studio	MSTest
Executar testes unitários no framework Microsoft.VisualStudio.TestTools.UnitTesting.	Sim	Sim
Executar testes de IU codificados, testes genéricos, e testes ordenados	Sim	Sim
Coletar dados de cobertura de código	Sim	Sim
Executar testes unitários gravados em vários frameworks, tais como NUnit, xUnit, e outros.	Sim	Não
Executar testes unitários em binários nativos (por exemplo, C++).	Sim	Não
Executar testes unitários em um aplicativo Windows Store.	Sim	Não
Execute testes de 64 bits Observação MSTest pode executar testes de 64 bits em binários criados com Qualquer CPU especificada como Plataforma.	Sim	Não
Executar testes que dependem de objetos de framework de falsificação. Para obter mais informações sobre como usar o framework de falsificação de testes para criar stubs e correções baseados em delegado em aplicativos do Framework .NET, consulte Isolando os métodos de teste de unidade com as falsificações da Microsoft.	Sim	Não
Gerar dados para testes de banco de dados e executar testes unitários de banco de dados	Não	Sim
Coletar dados de análise de impacto de teste	Não	Sim
Executar testes de carga e da Web	Não	Sim

Observação
Alguns desses recursos funcionam somente em um agente de compilação em um servidor de compilação que é configurado especialmente.Para obter mais informações, consulte Habilitar o agente de compilação para executar um teste.

Depois que você compreender os recursos que seu ensaio requer, escolha um executor de teste:

• Test Runner do Visual Studio

• MSTest com arquivo de configurações de teste

• MSTest com arquivo de metadados

Usar o Test Runner do Visual Studio para Executar um Teste

Para usar o corredor de teste do Visual Studio para executar testes de uma compilação processar que é baseado no modelo padrão

1. No Team Explorer abra Construtores e então adicione ou edite uma definição de compilação.

   Na página Processo, expanda Básico, e selecione Testes Automatizados.Escolha o botão de reticências (...) no final da linha e então escolha a Adicionar ou a Editar uma fonte de teste.

2. Na caixa de diálogo Adicionar/Editar Execução de Teste, em Testar Executor selecione Test Runner do Visual Studio.

3. Testar especificação de arquivo de assembly

   Especifique os arquivos binários que contêm os testes que você deseja executar.Deixe o valor padrão (**\*test*.dll) se você desejar que o agente de compilação procure recursivamente por quaisquer arquivos .dll que corresponderem a *test*.dll no subdiretório binaries da pasta de trabalho do agente de compilação.Como alternativa, modifique a especificação de arquivo para atender às suas necessidades.

4. Se você desejar que o ensaio colete e publique dados de cobertura de código, defina Opções como Ativar a cobertura de código.

   Como alternativa, você pode usar a opção Personalizar especificar um arquivo .runsettings.Para obter mais informações, consulte Personalizando análise de cobertura de código.

5. No menu de Selecionar a plataforma de destino para a execução de teste, escolha x86 para testar binários de 32 bits, ou x64 para testar binários de 64 bits.

6. Você pode especificar os critérios para os testes executados.

Especifique os critérios para a execução de testes pelo Test Runner do Visual Studio

Você pode especificar pares nome/valor para filtrar os testes que são executados.Se você usar a categoria de teste e atributos de prioridade para organizar e priorizar seus testes, poderá filtrar os testes que estiver realizando ao usar os nomes TestCategory e Priority.

Você pode especificar categorias de teste em uma das seguintes maneiras:

• Especificar um único par nome/valor a incluir. Por exemplo, você poderia ter uma categoria de teste chamada bvt.Defina Filtro de teste de situação como TestCategory=bvt para realizar testes somente nessa categoria.

• Especificar várias categorias de teste utilizando || (operador “ou”). Por exemplo, você pode especificar TestCategory=quick||TestCategory=gui para realizar testes na categoria rápida e testes na categoria de GUI.

Use MSTest para realizar testes

Para executar testes usando MSTest em um processo de compilação que é baseado no modelo padrão

1. Use um teste para realizar testes automatizados e outras tarefas de teste. Em seguida, na caixa de diálogo Adicionar/editar realização de teste, em Testar realizador, escolha:

   • Realizador MSTest.exe

     Especifique os arquivos binários que contêm os testes que você deseja executar.Deixe o valor padrão (**\*test*.dll) se você desejar que o agente de compilação procure recursivamente por quaisquer arquivos .dll que corresponderem a *test*.dll no subdiretório binaries da pasta de trabalho do agente de compilação.Como alternativa, modifique a especificação de arquivo para atender às suas necessidades.

     (Opcional) especifique Arquivo de Configurações de Teste para configurar como os testes são executados.Para obter mais informações, consulte Especificando configurações de teste do Visual Studio.

   • Arquivo de Metadados de Teste MsTest (obsoleto)

     Se você escolher essa opção, escolha Procurar para localizar e especificar o arquivo de metadados de teste que deseja usar.Então, você poderá deixar a caixa de seleção Realizar todos os testes neste arquivo VSMDI marcada ou limpá-la e selecionar um ou mais testes na lista de Listas de testes a serem realizados.

     Observação
     As listas de testes estão obsoletas.Para obter mais informações, consulte Definindo categorias de teste para agrupar os testes.

2. Escolha a aba Critérios/Argumentos.

3. Você pode filtrar os testes para executá-los por categoria.

   Você pode especificar categorias de teste em uma das seguintes maneiras:

   • Especificar uma única categoria de teste a incluir ou excluir. Por exemplo, você poderia ter uma categoria de teste chamada bvt.Defina esse parâmetro como bvt para realizar testes somente nessa categoria ou !bvt para realizar todos os testes, exceto os testes dessa categoria.

   • Especificar várias categorias de teste utilizando "&" (operador “e”) e "!" (operador "not"). Por exemplo, você pode especificar o quick&gui&!deep para realizar somente os testes nas categorias rápida e de GUI, mas não na categoria profunda.

   • Especificar várias categorias de teste utilizando "|" (operador “e”) e "!" (operador "not"). Por exemplo, você pode especificar quick|gui|!deep para realizar testes na categoria rápida, testes na categoria de GUI e quaisquer testes que não estejam na categoria profunda.

4. (Opcional) Filtrar os testes para executar por prioridade.

   Dica
   Se você atribuir prioridades a seus testes, poderá usar esse parâmetro para equilibrar melhor testes completos com compilações mais rápidas.

   Defina Prioridade Mínima de Teste ou como um inteiro positivo menor ou igual a Prioridade Máxima de Teste ou como -1 para indicar nenhum valor mínimo.

   Defina Prioridade Máxima de Teste ou como um inteiro positivo maior ou igual a Prioridade Mínima de Teste ou como -1 para indicar nenhum valor máximo.

5. Escolha OK.

Desativar Temporariamente Testes

Se você precisar desativar temporariamente testes sem excluir os conjuntos de testes que os contêm, expanda o nó Avançado, e defina Desativar Testes como Verdadeiro.Defina o valor novamente como Falso quando você desejar ativar testes novamente.

Ativar Análise de Impacto de Teste

Seus testadores e desenvolvedores podem precisar saber como as alterações de código que englobadas por uma compilação concluída afetaram os testes.Ao habilitar a análise de impacto de teste em uma compilação, o sistema analisa e relata como as alterações de código afetaram seus testes no relatório de compilação da compilação concluída.

Para ativar análise de impacto de teste em uma compilação processar que é baseado no modelo padrão

1. Configurar a análise de impacto de teste em um arquivo de configurações de teste.

   Para obter mais informações, consulte Como: coletar dados para verificar quais testes devem ser executados após alterações de código.

2. Criar um conjunto de testes configurado para usar o arquivo de configurações de teste.

   Para obter mais informações consulte Executar Testes Automatizados, abordado anteriormente neste tópico.

3. Expanda o nó Avançado, e certifique-se de que Analisar Impacto do Teste esteja definido como Verdadeiro e que Desativar Testes esteja definido como Falso.

Definir Múltiplas Execuções de Testes

Você pode definir tantas execuções de testes quanto você precisar para atender aos requisitos de compilação de sua equipe e do processo de teste.Por exemplo, talvez você precise definir várias realizações de testes em uma única compilação nas seguintes situações:

• Você deseja usar o Teste Runner do Visual Studio para testar uma solução que produz binários de 32 e de 64 bits.

• Você possui alguns testes que podem ser executados pelo Test Runner do Visual Studio, e outros testes que só podem ser executados pelo MSTest.

• Você possui dois conjuntos de teste:

  • Um núcleo de testes de prioridade máxima que devem ser bem-sucedidos.Você define um conjunto de teste que inclui uma Prioridade Mínima de Teste e uma Prioridade Máxima de Teste de 1.Você marcar a caixa de seleção Falhar com falha do teste.

  • Um conjunto de testes menos importantes que você deseja executar mas que não precisam ser bem-sucedidos para que a compilação seja utilizável.Você define um conjunto de teste que inclui uma Prioridade Mínima de Teste de 2 e uma Prioridade Máxima de Teste de 3.Você deixa a caixa de seleção Falha na falha da compilação de teste desmarcada.

• Você deseja executar o mesmo conjunto de testes com configurações de teste diferentes.

• Você deseja que o conjunto principal de assemblies que você criou para esteja sujeito a cobertura de código.No entanto, você possui outro conjunto de assemblies de uma fonte externa que não requerem a cobertura de código.Para ativar este tipo de processo, você pode usar dois conjuntos de teste que são configurados para usar dois grupos de arquivos de configurações de teste.

Ativar um teste de terceiros Framework de unidade em um controlador de compilação

O processo de compilação pode executar testes de unidade com base em estruturas de terceiros de testes de unidade somente se você forneceu seu controlador de compilação acesso aos conjuntos de terceiros estrutura.

1. Localize, ou se necessário, especifique o caminho do controlador de compilação para assemblies personalizados.

2. Localize, ou se necessário, crie um mapeamento de pasta de assembly personalizado no servidor para uma pasta local no seu espaço de trabalho.

3. Obtenha um plug-in de terceiros de testes de unidade.Você pode localizar os links para alguns de eles aqui: Lista de plug-ins de testes de unidade.

4. Renomear o arquivo do plug-in .vsix em um arquivo .zip.Por exemplo, use o prompt de comando como isso:

   C:\Downloads>ren NUnitTestAdapter.vsix NUnitTestAdapter.zip
   

5. Abra o zíper conteúdo do arquivo .zip na pasta local que o espaço de trabalho você mapeou na etapa 2.

6. Fazer check-in de arquivos.

   Dica
   Para que as estratégias para trabalhar com arquivos binários de terceiros em controle de versão, consulte Aproveitar os binários de terceiros que seu código não compila.

O [Visual Studio 2012.1] inclui um aperfeiçoamento para que as estruturas de terceiros de testes de unidade automatizem a inclusão em definições de compilação de equipe.

Cuidado
Você talvez precise instalar a versão mais recente de pacotes de NuGet para que a estrutura de testes de unidade 3rd-party certifique-se de que a estrutura inclui o aperfeiçoamento de definição de compilação.

Ativar um teste de terceiros Framework de unidade em um controlador de compilação - 2012,1 [Visual Studio]

1. No solution Explorer, abra o menu de atalho no projeto de teste e escolha Gerenciar pacotes de NuGet.

2. Na caixa de diálogo de pacotes de NuGet gerenciar, na coluna esquerda, escolha Online.

3. Selecione o conjunto de NuGet para a estrutura de terceiros de testes de unidade e escolha Instalar.

4. Depois que o conjunto de NuGet é instalar concluído, escolha Fechar.

5. No solution Explorer, abra o menu de atalho na solução e escolha Adicionar Solução ao Código Fonte.

6. Agora você pode colocar a compilação e seus testes com a estrutura de terceiros de testes de unidade executarão automaticamente.

Trabalhar com Testes em um Processo de Compilação Personalizada

Se sua equipe requerer um processo de compilação com recursos mais personalizados, você pode executar um teste e realizar outras tarefas relacionadas com um processo de compilação personalizada.Para obter mais informações, consulte

• Executar testes usando a atividade RunTests

• Executar testes usando a atividade MSTest

• Obter uma lista de testes que a compilação afeta (GetImpactedTests Activity)

Para obter mais informações

Definir um processo de compilação é baseado no modelo padrão fornece informações sobre como criar uma definição de compilação que é baseado no modelo padrão.Este tópico inclui informações sobre configurações de número de bits para Plataforma que você pode usar para criar seu código.

Orientações para fluxos de trabalho de teste implantar compilação fornece informações sobre como implementar um aplicativo e executar testes em um ambiente de laboratório usando o processo de compilação.

Executando testes no Microsoft Test Manager fornece mais informações sobre como executar testes.

Consulte também

Conceitos

Definir o processo de compilação

Criando e gerenciando testes no Microsoft Test Manager