Como: Executar testes de unidade do SQL Server no Team Foundation Build

Artigo
09/15/2015

Você pode usar o Team Foundation Build para executar os testes de unidade do SQL Server como parte de um teste de verificação da compilação (BVT).Você pode configurar os testes de unidade para implantar o banco de dados, gerar dados de teste e executar os testes selecionados.Se você não estiver familiarizado com o Team Foundation Build, analise as seguintes informações antes de seguir os procedimentos deste tópico:

Antes de executar esses procedimentos, primeiro você deve configurar o ambiente de trabalho realizando as seguintes tarefas:

Instale o Team Foundation Build e o controle de versão do Team Foundation.Você provavelmente tem que instalar o Team Foundation Build e o controle de versão do Team Foundation em computadores diferentes.
Instale o MicrosoftSQL Server Data Tools Build Utilities no mesmo computador que o Team Foundation Build.Para instalar o SQL Server Data Tools Build Utilities, primeiro realize um ponto de instalação administrativo.Para obter mais informações sobre um ponto de instalação administrativo, consulte Instalar o SQL Server Data Tools.Em seguida, instale o SSDTBuildUtilties.msi no servidor de compilação do local (/location) usado para o ponto de instalação administrativo.
Conecte-se a uma instância do Visual Studio Team Foundation Server.

Após configurar o ambiente de trabalho, você deverá seguir estas etapas:

Crie um projeto de banco de dados.
Importe ou crie o esquema e os objetos do projeto de banco de dados.
Configure as propriedades do projeto de banco de dados para compilação e implantação.
Crie um ou mais testes de unidade.
Adicione a solução que contém o projeto de banco de dados e o projeto de teste de unidade para fazer o controle de versão e o check-in de todos os arquivos.

Os procedimentos deste tópico descrevem como criar uma definição de compilação para executar os testes de unidade como parte de uma execução de teste automatizada:

Definir configurações de teste para executar testes de unidade de banco de dados em um agente de compilação x64
Atribuir testes a uma categoria de teste (opcional)
Modificar o projeto de teste
Fazer check-in da solução
Criar uma definição de compilação
Executar a nova definição de compilação

Executando SQL Server testes de unidade em um computador de compilação

Quando você executar testes de unidade em um computador de compilação, possivelmente eles não serão capazes de localizar os arquivos de projeto de banco de dados (.sqlproj).Esse problema ocorre porque o arquivo app.config faz referência a esses arquivos usando caminhos relativos.Além de isso, os testes da unidade poderão apresentar falhar se não conseguirem encontrar a instância do SQL Server que você deseja usar para executar os testes de unidade.Esse problema poderá ocorrer se as cadeias de conexão armazenadas no arquivo app.config não forem válidas no computador de compilação.

Para resolver esses problemas, determine uma seção de substituição no app.config que substitua o arquivo app.config por um arquivo de configuração específico do ambiente do Team Foundation Build.Para obter mais informações, consulte Modificar o projeto de teste posteriormente neste tópico.

Definir configurações de teste para executar testes de unidade do SQL Server em um agente de compilação x64

Para que você possa executar os testes de unidade em um agente de compilação x64, defina as configurações de teste para alterar a plataforma do processo do host.

Para especificar a plataforma do processo do host

Abra a solução que contém o projeto de teste cujas configurações você deseja definir.
No Gerenciador de Soluções, na pasta Itens de Solução, clique duas vezes no arquivo Local.testsettings.

A caixa de diálogo Configurações de Teste é exibida.
Na lista, clique em Hosts.
No painel de detalhes, em Plataforma do Processo do Host, clique em MSIL para configurar os testes a serem executados em um agente de compilação x64.
Clique em Aplicar.

Atribuir testes a uma categoria de teste (opcional)

Normalmente, ao criar uma definição de compilação para executar testes de unidade, você especifica uma ou mais categorias de teste.Todos os testes nas categorias especificadas são executados quando a compilação é executada.

Para atribuir testes a uma categoria de teste

Abra a janela Modo de Exibição de Teste.
Selecione um teste.
No painel de propriedades, clique em Categorias de Teste e clique nas reticências (…)na coluna da extrema direita.
Na janela Categoria de Teste, na caixa Adicionar Nova Categoria, digite um nome para a nova categoria de teste.
Clique em Adicionar e, em seguida, clique em OK.

A nova categoria de teste será atribuída ao teste e estará disponível para outros testes através de suas propriedades.

Modificar o projeto de teste

Por padrão, o Team Foundation Build cria um arquivo de configuração no arquivo app.config do projeto ao criar o projeto de testes de unidade.O caminho para o projeto de banco de dados é armazenado como um caminho relativo no arquivo app.config.Os caminhos relativos que funcionam no Visual Studio não funcionarão, pois o Team Foundation Build coloca os arquivos compilados em locais diferentes, de acordo com o local em que você executou os testes de unidade.Além de isso, o arquivo app.config contém as cadeias de conexão que especificam o banco de dados a ser testado.Você também precisará de um arquivo app.config separado para o Team Foundation Build se o teste de unidade precisar se conectar a um banco de dados que não seja o que você usou quando o projeto de teste foi criado.Fazendo as modificações no próximo procedimento, você poderá configurar o projeto de teste e o servidor de compilação de modo que o Team Foundation Build use uma configuração diferente.

Importante
Você deve executar esse procedimento para cada projeto de teste (.vbproj ou .vsproj).

Para especificar um arquivo app.config para o Team Foundation Build

No Gerenciador de Soluções, clique com o botão direito do mouse no arquivo app.config e clique em Copiar.
Clique com o botão direito do mouse no projeto de teste e clique em Colar.
Clique com o botão direito do mouse no arquivo Copy of app.config e clique em Renomear.
Digite BuildComputer**.sqlunitttest.config** e pressione ENTER, em que BuildComputer é o nome do computador no qual o agente de compilação é executado.
Clique duas vezes em BuildComputer.sqlunitttest.config.

O arquivo de configuração é aberto no editor.

Altere o caminho relativo do arquivo .sqlproj file adicionando um nível de pasta para a pasta Sources e uma subpasta com o mesmo nome da solução.Por exemplo, se o arquivo de configuração contiver inicialmente a seguinte entrada:

<DatabaseDeployment DatabaseProjectFileName="..\..\..\Database3\Database3.sqlproj"      Configuration="Debug" />

Atualize o arquivo desta maneira:

<DatabaseDeployment DatabaseProjectFileName="..\..\..\Database3\Database3.sqlproj"      Configuration="Debug" />

Quando você terminar, o arquivo BuildComputer.sqlunitttest.config deverá se parecer com o exemplo a seguir para Visual Studio 2010:

<SqlUnitTesting_VS2010>
    <DatabaseDeployment DatabaseProjectFileName="..\..\..\Database4\Database4.sqlproj"
        Configuration="Debug" />
    <DataGeneration ClearDatabase="true" />
    <ExecutionContext Provider="System.Data.SqlClient" ConnectionString="Data Source=(localdb)\Projects;Initial Catalog=Database4;Integrated Security=True;Pooling=False"
        CommandTimeout="30" />
    <PrivilegedContext Provider="System.Data.SqlClient" ConnectionString="Data Source=(localdb)\Projects;Initial Catalog=Database4;Integrated Security=True;Pooling=False"
        CommandTimeout="30" />
</SqlUnitTesting_VS2010>

Ou, se você estiver usando o Visual Studio 2012:

<SqlUnitTesting_VS2012>
        <DatabaseDeployment DatabaseProjectFileName="..\..\..\Database4\Database4.sqlproj"
            Configuration="Debug" />
        <DataGeneration ClearDatabase="true" />
        <ExecutionContext Provider="System.Data.SqlClient" ConnectionString="Data Source=(localdb)\Projects;Initial Catalog=Database4;Integrated Security=True;Pooling=False"
            CommandTimeout="30" />
        <PrivilegedContext Provider="System.Data.SqlClient" ConnectionString="Data Source=(localdb)\Projects;Initial Catalog=Database4;Integrated Security=True;Pooling=False"
            CommandTimeout="30" />
    </SqlUnitTesting_VS2012>

Atualize o atributo ConnectionString de ExecutionContext e PrivilegedContext para especificar conexões com o banco de dados de destino no qual você deseja fazer a implantação.
No menu Arquivo, clique em Salvar Tudo.
No Gerenciador de Soluções, clique duas vezes em app.config.
No editor, para cada nó < SqlUnitTesting_VSVersion>, adicione AllowConfigurationOverride="true".Por exemplo:
```
-- Update SqlUnitTesting_VS2010 node to:
<SqlUnitTesting_VS2010 AllowConfigurationOverride="true"> 

-- Update SqlUnitTesting_VS2012 node to:
<SqlUnitTesting_VS2012 AllowConfigurationOverride="true">
```
Com essa alteração, você permitirá que o Team Foundation Build use o arquivo de configuração substituto criado.
No menu Arquivo, clique em Salvar Tudo.

Em seguida, atualize Local.testsettings para incluir o arquivo de configuração personalizada.

Para personalizar Local.testsettings para implantar o arquivo de configuração personalizada

No Gerenciador de Soluções, clique duas vezes em Local.testsettings.

A caixa de diálogo Configurações de Teste é exibida.
Na lista de categorias, clique em Implantação.
Marque a caixa de seleção Habilitar implantação.
Clique em Adicionar Arquivo.
Na caixa de diálogo Adicionar Arquivos de Implantação, especifique o arquivo BuildComputer.sqlunitttest.config que você criou.
Clique em Aplicar.
Clique em Fechar.
No menu Arquivo, clique em Salvar Tudo.

Em seguida, faça o check-in da solução para controle de versão.

Fazer check-in da solução

Neste procedimento, você faz o check-in de todos os arquivos da solução.Esses arquivos incluem o arquivo de metadados de teste da sua solução, que contém suas associações de categoria de teste e testes.Sempre que você adicionar, excluir, reorganize ou alterar o conteúdo dos teste, o arquivo de metadados de teste será atualizado automaticamente para refletir essas alterações.

Observação
Este procedimento descreverá as etapas se você estiver usando o controle de versão do Team Foundation Build.Se você estiver usando um software de controle de versão diferente, siga as etapas apropriadas para o software.

Para fazer check-in da solução

Conecte-se a um computador que esteja executando o Team Foundation Build.

Para obter mais informações, consulte Usando o Gerenciador de controle de código-fonte.
Se sua solução ainda não estiver no controle do código-fonte, adicione-a a ele.

Para obter mais informações, consulte Adicionar um projeto ou solução ao controle de versão.
Clique em Exibir e clique em Check-ins Pendentes.

Faça check-in de todos os arquivos da solução.

Para obter mais informações, consulte Fazer check-in das alterações pendentes.

Observação
Você poderia ter um processo de equipe específico que determinasse como os testes automatizados são criados e gerenciados.Por exemplo, o processo pode exigir que você verifique a compilação localmente antes de fazer check-in desse código junto com os testes que serão executados nele.

Em Gerenciador de Soluções, um ícone de cadeado aparece ao lado de cada arquivo para indicar que ele foi verificado.Para obter mais informações, consulte Propriedades de pasta e arquivo de controle de versão do modo de exibição.

Os testes estão disponíveis para o Team Foundation Build.Agora você pode criar uma definição de compilação que contenha os testes a serem executados.

Criar uma definição de compilação

Para criar uma definição de compilação

No Team Explorer, clique no projeto de equipe, clique com o botão direito do mouse no nó Compilações e clique em Nova Definição de Compilação.

A janela Nova Definição de Compilação é exibida.
Em Nome da definição de compilação, digite o nome que você deseja usar para a definição de compilação.
Na barra de navegação, clique em Padrões de Compilação.
Em Copiar saída da compilação para a seguinte pasta de descarte (caminho UNC; por exemplo \\servidor\compartilhamento), especifique uma pasta para conter a saída da compilação.

Você pode especificar uma pasta compartilhada no computador local ou em qualquer local de rede no qual o processo de compilação terá permissões.
Na barra de navegação, clique em Processo.
No grupo Obrigatório, em Itens a Serem Compilados, clique no botãoprocurar (...).
Na caixa de diálogo Editor de Lista do Projeto de Compilação, clique em Adicionar.
Especifique o arquivo de solução (.sln) que você adicionou ao controle de versão anterior neste passo a passo e clique em OK.

A solução aparece na lista Arquivos de projeto ou de solução a serem compilados.
Clique em OK.
No grupo Básico, em Testes Automatizados, especifique os testes a serem executados.Por padrão, os testes contidos nos arquivos denominados *test*.dll na solução serão executados.
No menu Arquivo, clique em Salvar ProjectName.

Você criou uma definição de compilação.Em seguida, você modificará o projeto de teste.

Executar a nova definição de compilação

Para executar o novo tipo de compilação

No Team Explorer, expanda o nó do projeto de equipe, expanda o nó Compilações, clique com o botão direito do mouse na definição de compilação que deseja executar e clique em Enfileirar Nova Compilação.

A caixa de diálogo Enfileirar Compilação {TeamProjectName} é exibida com uma lista de todos os tipos de compilação existentes.
Se necessário, em Definição de compilação, clique na nova definição de compilação.
Confirme se os valores nos campos Definição de compilação, Agente de compilação e Pasta de descarte desta compilação são apropriados e clique em Enfileirar.

A guia Enfileirado de Gerenciador de Compilações é exibida.Para obter mais informações, consulte Gerenciar e exibir compilações concluídas (Visual Studio 2010) or Gerenciar suas compilações no Gerenciador de Compilações (Visual Studio 2012).

Consulte também

Executando testes de unidade do SQL Server
Criar uma definição básica de compilação
Enfileirar uma compilação
Monitore o andamento de uma compilação em execução

Compartilhar via