Compartilhar via

Demonstra Passo a passo: Criando e executando um teste de unidade de banco de dados

  • Artigo

Esta explicação passo a passo, você cria um teste de unidade de banco de dados que verifica o comportamento de vários procedimentos armazenados. Você criar testes de unidade de banco de dados para ajudar a identificar defeitos de código que podem causar comportamento incorreto do aplicativo. Você pode executar testes de unidade de banco de dados e os testes de aplicativo como parte de uma automatizado suíte de testes.

Nesta explicação passo a passo, você executa as seguintes tarefas:

  • Criar um script que contém um esquema de banco de dados

  • Crie um projeto de banco de dados e importar o esquema

  • Implantar o projeto de banco de dados para um ambiente de desenvolvimento isolado

  • Criar testes de unidade de banco de dados

  • Definir a lógica de teste

  • Executar testes de unidade de banco de dados

  • Adicionar um teste de unidade negativo

Depois que um dos testes de unidade detecta um erro em um procedimento armazenado, você corrigir esse erro e execute novamente o teste.

Pré-requisitos

Para concluir este passo a passo, você deve ser capaz de se conectar a um servidor de banco de dados no qual você tem permissões para criar e implantar um banco de dados. Para obter mais informações, consulte Permissões necessárias para os recursos de banco de dados de Visual Studio.

Criar um Script que contém um esquema de banco de dados

Para criar um script a partir do qual você pode importar um esquema

  1. Sobre o arquivo , aponte para novae, em seguida, clique em arquivo.

    O Novo arquivo caixa de diálogo aparece.

  2. No categorias , clique em Geral se já não estiver realçado.

  3. No modelos de lista, clique em Arquivo Sqle, em seguida, clique em Abrir.

    O Transact-SQL editor será aberta.

  4. Copie o seguinte Transact-SQL code e colá-lo para o Transact-SQL editor.

    PRINT N'Creating Sales...';
GO
CREATE SCHEMA [Sales]
    AUTHORIZATION [dbo];
GO
PRINT N'Creating Sales.Customer...';
GO
CREATE TABLE [Sales].[Customer] (
    [CustomerID]   INT           IDENTITY (1, 1) NOT NULL,
    [CustomerName] NVARCHAR (40) NOT NULL,
    [YTDOrders]    INT           NOT NULL,
    [YTDSales]     INT           NOT NULL
);
GO
PRINT N'Creating Sales.Orders...';
GO
CREATE TABLE [Sales].[Orders] (
    [CustomerID] INT      NOT NULL,
    [OrderID]    INT      IDENTITY (1, 1) NOT NULL,
    [OrderDate]  DATETIME NOT NULL,
    [FilledDate] DATETIME NULL,
    [Status]     CHAR (1) NOT NULL,
    [Amount]     INT      NOT NULL
);
GO
PRINT N'Creating Sales.Def_Customer_YTDOrders...';
GO
ALTER TABLE [Sales].[Customer]
    ADD CONSTRAINT [Def_Customer_YTDOrders] DEFAULT 0 FOR [YTDOrders];
GO
PRINT N'Creating Sales.Def_Customer_YTDSales...';
GO
ALTER TABLE [Sales].[Customer]
    ADD CONSTRAINT [Def_Customer_YTDSales] DEFAULT 0 FOR [YTDSales];
GO
PRINT N'Creating Sales.Def_Orders_OrderDate...';
GO
ALTER TABLE [Sales].[Orders]
    ADD CONSTRAINT [Def_Orders_OrderDate] DEFAULT GetDate() FOR [OrderDate];
GO
PRINT N'Creating Sales.Def_Orders_Status...';
GO
ALTER TABLE [Sales].[Orders]
    ADD CONSTRAINT [Def_Orders_Status] DEFAULT 'O' FOR [Status];
GO
PRINT N'Creating Sales.PK_Customer_CustID...';
GO
ALTER TABLE [Sales].[Customer]
    ADD CONSTRAINT [PK_Customer_CustID] PRIMARY KEY CLUSTERED ([CustomerID] ASC) WITH (ALLOW_PAGE_LOCKS = ON, ALLOW_ROW_LOCKS = ON, PAD_INDEX = OFF, IGNORE_DUP_KEY = OFF, STATISTICS_NORECOMPUTE = OFF);
GO
PRINT N'Creating Sales.PK_Orders_OrderID...';
GO
ALTER TABLE [Sales].[Orders]
    ADD CONSTRAINT [PK_Orders_OrderID] PRIMARY KEY CLUSTERED ([OrderID] ASC) WITH (ALLOW_PAGE_LOCKS = ON, ALLOW_ROW_LOCKS = ON, PAD_INDEX = OFF, IGNORE_DUP_KEY = OFF, STATISTICS_NORECOMPUTE = OFF);
GO
PRINT N'Creating Sales.FK_Orders_Customer_CustID...';
GO
ALTER TABLE [Sales].[Orders]
    ADD CONSTRAINT [FK_Orders_Customer_CustID] FOREIGN KEY ([CustomerID]) REFERENCES [Sales].[Customer] ([CustomerID]) ON DELETE NO ACTION ON UPDATE NO ACTION;
GO
PRINT N'Creating Sales.CK_Orders_FilledDate...';
GO
ALTER TABLE [Sales].[Orders]
    ADD CONSTRAINT [CK_Orders_FilledDate] CHECK ((FilledDate >= OrderDate) AND (FilledDate < '01/01/2020'));
GO
PRINT N'Creating Sales.CK_Orders_OrderDate...';
GO
ALTER TABLE [Sales].[Orders]
    ADD CONSTRAINT [CK_Orders_OrderDate] CHECK ((OrderDate > '01/01/2005') and (OrderDate < '01/01/2020'));
GO
PRINT N'Creating Sales.uspCancelOrder...';
GO
CREATE PROCEDURE [Sales].[uspCancelOrder]
@OrderID INT
AS
BEGIN
DECLARE @Delta INT, @CustomerID INT
BEGIN TRANSACTION
    SELECT @Delta = [Amount], @CustomerID = [CustomerID]
     FROM [Sales].[Orders] WHERE [OrderID] = @OrderID;

UPDATE [Sales].[Orders]
   SET [Status] = 'X'
WHERE [OrderID] = @OrderID;

UPDATE [Sales].[Customer]
   SET
   YTDOrders = YTDOrders - @Delta
    WHERE [CustomerID] = @CustomerID
COMMIT TRANSACTION
END
GO
PRINT N'Creating Sales.uspFillOrder...';
GO
CREATE PROCEDURE [Sales].[uspFillOrder]
@OrderID INT, @FilledDate DATETIME
AS
BEGIN
DECLARE @Delta INT, @CustomerID INT
BEGIN TRANSACTION
    SELECT @Delta = [Amount], @CustomerID = [CustomerID]
     FROM [Sales].[Orders] WHERE [OrderID] = @OrderID;

UPDATE [Sales].[Orders]
   SET [Status] = 'F',
       [FilledDate] = @FilledDate
WHERE [OrderID] = @OrderID;

UPDATE [Sales].[Customer]
   SET
   YTDSales = YTDSales - @Delta
    WHERE [CustomerID] = @CustomerID
COMMIT TRANSACTION
END
GO
PRINT N'Creating Sales.uspNewCustomer...';
GO
CREATE PROCEDURE [Sales].[uspNewCustomer]
@CustomerName NVARCHAR (40)
AS
BEGIN
INSERT INTO [Sales].[Customer] (CustomerName) VALUES (@CustomerName);
SELECT SCOPE_IDENTITY()
END
GO
PRINT N'Creating Sales.uspPlaceNewOrder...';
GO
CREATE PROCEDURE [Sales].[uspPlaceNewOrder]
@CustomerID INT, @Amount INT, @OrderDate DATETIME, @Status CHAR (1)='O'
AS
BEGIN
DECLARE @RC INT
BEGIN TRANSACTION
INSERT INTO [Sales].[Orders] (CustomerID, OrderDate, FilledDate, Status, Amount) 
     VALUES (@CustomerID, @OrderDate, NULL, @Status, @Amount)
SELECT @RC = SCOPE_IDENTITY();
UPDATE [Sales].[Customer]
   SET
   YTDOrders = YTDOrders + @Amount
    WHERE [CustomerID] = @CustomerID
COMMIT TRANSACTION
RETURN @RC
END
GO
CREATE PROCEDURE [Sales].[uspShowOrderDetails]
@CustomerID INT=0
AS
BEGIN
SELECT [C].[CustomerName], CONVERT(date, [O].[OrderDate]), CONVERT(date, [O].[FilledDate]), [O].[Status], [O].[Amount]
  FROM [Sales].[Customer] AS C
  INNER JOIN [Sales].[Orders] AS O
     ON [O].[CustomerID] = [C].[CustomerID]
  WHERE [C].[CustomerID] = @CustomerID
END
GO

  5. Sobre o arquivo menu, clique em Salvar SqlQuery_1.sql como.

    O Salvar arquivo como caixa de diálogo aparece.

  6. Em nome do objeto, tipo SampleImportScript.sql.

    Você pode salvar o arquivo em qualquer local no computador. Anote a localização porque você deve usar esse script no próximo procedimento.

  7. Clique em Save.

  8. No menu File, clique em Close Solution.

    Em seguida, você cria um projeto de banco de dados e importar o esquema do script que você criou.

Crie um projeto de banco de dados e importar um esquema.

Para criar um projeto de banco de dados

  1. Sobre o arquivo , aponte para novae clique em projeto.

    A caixa de diálogo New Project será exibida.

  2. Em Modelos instalados, expanda o banco de dados nó e depois clique em SQL Server.

    ObservaçãoObservação

    Se você estiver usando Visual Studio Professional, em vez disso, procure Installed Templates, expanda o banco de dados nó, expanda o SQL Server nó e clique Advanced.

  3. Na lista de modelos, clique em Projeto de banco de dados de 2008 do SQL Server.

    ObservaçãoObservação

    Se você planeja implantar o seu banco de dados para uma versão diferente do banco de dados, em vez disso, escolha o modelo que corresponde ao seu servidor de destino.

  4. Em nome, digite SimpleUnitTestDB.

  5. Selecione o Create directory for solution caixa de seleção se não estiver selecionada.

  6. Limpar o Add to Source Control caixa de seleção se ele já não estiver desmarcada e clique em OK.

    O projeto de banco de dados é criado e aparece na Solution Explorer. Em seguida você importar o esquema de banco de dados de um script.

Para importar um esquema de banco de dados de um script

  1. Sobre o projeto menu, clique em Importar Script.

  2. Clique em próximo depois de ler a página de boas-vindas.

  3. Clique em Procurare indicar o caminho onde você salvou o arquivo SampleImportScript.sql.

  4. Clique duas vezes no arquivo SampleImportScript.sql e, em seguida, clique em Concluir.

    O script é importado, e os objetos que são definidos no script são adicionados ao seu projeto de banco de dados.

  5. Revise o resumo e, em seguida, clique em Concluir para concluir a operação.

    ObservaçãoObservação

    O procedimento Sales.uspFillOrder contém um erro intencional de codificação que você irá detectar e corrigir neste procedimento.

Para examinar o projeto resultante

  1. Em Solution Explorer, expanda o Os objetos de esquema nó filho.

  2. Explore os subnós sob o Os objetos de esquema o nó na hierarquia.

    Solution Explorer contém os arquivos que definem os objetos de banco de dados.

  3. Do Exibir menu, clique em o modo de exibição do esquema de banco de dados.

  4. Em Visualização Esquema, expanda o nó de SimpleUnitTestDB.

  5. Explore os subnós sob o nó de SimpleUnitTestDB na hierarquia.

    Modo de exibição do esquema contém os objetos que são definidos nos arquivos que aparecem no Solution Explorer.

Implantando em um ambiente de desenvolvimento isolado

Em seguida você implantar o projeto para criar um banco de dados que tem o esquema importado, mas nenhum dado. Criar o banco de dados em um o ambiente de desenvolvimento isolado (ou seguro) para que você pode desenvolver e testar o banco de dados sem interferência de outros esforços.

Para configurar e construir o projeto de banco de dados

  1. Em Solution Explorer, clique no projeto de banco de dados SimpleUnitTestDB.

  2. Sobre o projeto menu, clique em Propriedades de SimpleUnitTestDB.

    Aparece a caixa de diálogo Propriedades do projeto.

  3. Clique o Deploy guia.

  4. No definir configurações de implantação para , clique em Meu ambiente de desenvolvimento isolado. Definindo configurações de seu ambiente de desenvolvimento isolado, você pode usar as configurações de implantação diferentes daqueles que serão usados em outros ambientes, como, por exemplo, o servidor de teste ou produção.

  5. No A ação implantar , clique em criar um script de implantação (. SQL) e implantar banco de dados.

  6. Em Configurações de banco de dados de destino, clique em Editar.

    O Propriedades de conexão caixa de diálogo aparece.

  7. Defina as propriedades de conexão do banco de dados que você deseja criar e clique em OK.

    No Conexão de destino caixa, a seqüência de caracteres de conexão correta é exibida.

    Aviso

    Você deve criar o banco de dados em um servidor de teste, um servidor de desenvolvimento ou no computador local. Você não deve especificar o servidor de produção.

  8. Em nome do banco de dados de destino, digite SimpleUnitTestDB.

  9. Ao lado de arquivo de configuração de implantação, clique em Editar.

  10. Limpar o implantação incremental do bloco se poderá ocorrer perda de dados caixa de seleção.

    ObservaçãoObservação

    Para esta explicação, você testará os procedimentos armazenados em um banco de dados vazio, o que você implantar como parte do teste de unidade de banco de dados. Não é necessário que preservar os dados existentes, pois você irá testar os procedimentos armazenados no seu ambiente de desenvolvimento isolado.

  11. No menu File, clique em Save All.

  12. Sobre o Build menu, clique em Build Solution.

    As propriedades que você acabou de definir determinam como o script de implantação é criado. O status da compilação aparece no saída janela, e Build: 1 com êxito ou atualizada deve aparecer como a última linha.

    ObservaçãoObservação

    Se o saída janela não for exibida, abra o Exibir menu e clique saída.

Para implantar o projeto de banco de dados

  1. Em Solution Explorer, clique no projeto de banco de dados SimpleUnitTestDB.

  2. Sobre o Build menu, clique em Implantar SimpleUnitTestDB.

    Aviso

    Você deve executar essa implantação contra um servidor de teste, um servidor de desenvolvimento ou computador local. Você não deve especificar o servidor de produção.

    O projeto de banco de dados é implantado para um novo banco de dados. O status da implantação aparece no saída janela, e Deploy: 1 foi bem-sucedida deve aparecer como a última linha. Você pode definir um o plano de geração de dados para criar dados de teste em seu banco de dados. Para esta explicação passo a passo, você está testando um banco de dados muito simple para os quais você precisa gerar dados.

Criar testes de unidade de banco de dados

Para criar um banco de dados teste de unidade para os procedimentos armazenados

  1. Sobre o Exibir menu, clique em Visualização do esquema de banco de dados.

  2. No Visualização Esquema, expandir o esquemas nó, expanda o vendas nó, expanda o programação nó e expanda o Stored Procedures nó.

  3. Com o botão direito do uspNewCustomer procedimento armazenado e clique em Create Unit Tests.

    A caixa de diálogo Create Unit Tests aparece.

  4. Marque as caixas de seleção para todos os procedimentos armazenados de cinco: Sales.uspCancelOrder, Sales.uspFillOrder, Sales.uspNewCustomer, Sales.uspPlaceNewOrder, e Sales.uspShowOrderDetails.

  5. Em projeto, clique em criar um novo projeto teste Visual C#.

  6. Aceitar os nomes padrão para o nome do projeto e o nome da classe e, em seguida, clique em OK.

    O o projeto 'testproject1' Configuração caixa de diálogo aparece.

  7. Em executar testes de unidade usando a seguinte conexão de dados, especifique uma conexão de banco de dados que você tiver implantado anteriormente.

    ObservaçãoObservação

    Se você deve testar os modos de exibição ou procedimentos armazenados que têm permissões restritas, você especificaria normalmente essa conexão nesta etapa. Em seguida, especifique a conexão secundária, com permissões mais amplas, para validar o teste. Se você tiver uma conexão secundária, adicione esse usuário para o projeto de banco de dados e criar um logon desse usuário no script de pré-implantação.

  8. Em implantação, selecione o implantar automaticamente o projeto de banco de dados são executados testes de unidade antes de caixa de seleção.

  9. Em o projeto de banco de dados, clique em SimpleUnitTestDB.dbproj.

  10. Na a configuração de implantação, clique em Debug.

    Você também pode gerar dados de teste como parte dos testes de unidade de banco de dados. Para esta explicação, poderá pular essa etapa porque os testes irá criar seus próprios dados.

  11. Clique em OK.

    O projeto de teste é compilado e o criador de teste de unidade de banco de dados é exibida. Em seguida, você irá atualizar a lógica de teste no Transact-SQL o script de testes de unidade.

Definir a lógica de teste

Este banco de dados muito simple possui duas tabelas, o cliente e pedido. Para atualizar o banco de dados usando os seguintes procedimentos armazenados:

  • uspNewCustomer - isso armazenado procedimento adiciona um registro à tabela Customer, que define as colunas de YTDOrders e YTDSales do cliente como zero.

  • uspPlaceNewOrder - isso armazenado procedimento adiciona um registro na tabela de pedidos do cliente especificado e atualiza o valor de YTDOrders do registro correspondente na tabela de clientes.

  • uspFillOrder - isso armazenado atualizações de procedimento, um registro dos pedidos da tabela, alterando o status de ' o ' a 'F' e os incrementos de YTDSales o valor do registro correspondente na tabela de clientes.

  • uspCancelOrder - isso armazenado atualizações de procedimento, um registro dos pedidos da tabela, alterando o status de ' o ' para 'X' e diminui o YTDOrders o valor do registro correspondente na tabela de clientes.

  • uspShowOrderDetails - isso armazenado uniões procedimento, tabela de pedidos com a tabela de personalizado e mostra os registros para um cliente específico.

ObservaçãoObservação

Este exemplo ilustra como criar um teste de unidade de banco de dados simples. Em um banco de dados do mundo real, você pode somar os valores totais de todos os pedidos com um status de ' o ' ou 'F' para um determinado cliente. Os procedimentos neste passo a passo também não contenham nenhuma manipulação de erros. Por exemplo, eles não impedem você chamar o uspFillOrder para um pedido que já foram preenchido.

Os testes pressupõem que o banco de dados começa em um estado limpo. Você irá criar testes que verifiquem as seguintes condições:

  • uspNewCustomer - Verifique se a tabela Customer contém uma linha depois de executar o procedimento armazenado.

  • uspPlaceNewOrder - para o cliente que tenha um CustomerID 1, coloque um pedido de r $100. Verifique se que a quantidade de YTDOrders para que o cliente é 100 e que a quantidade de YTDSales é zero.

  • uspFillOrder - para o cliente que tenha um CustomerID 1, faça um pedido r $50. Ordem de preenchimento. Verifique se os valores de YTDOrders e YTDSales os 50.

  • uspShowOrderDetails - para o cliente que possui um CustomerID de 1, pedidos de lugar de r $100,00, r $50 e r $5. Verifique se uspShowOrderDetails retorna o número de colunas correto e que o conjunto de resultados tem uma soma de verificação esperada.

ObservaçãoObservação

Para obter um conjunto completo de testes de unidade de banco de dados, você normalmente seria verificar que as outras colunas foram definidas corretamente. Para manter este passo a passo em um tamanho gerenciável, ele não descreve como verificar o comportamento de uspCancelOrder.

Para gravar o teste de unidade de banco de dados para uspNewCustomer

  1. Na barra de navegação do Designer de teste de unidade de banco de dados, clique em Sales_uspNewCustomerTeste certifique-se de que teste é destacada na lista adjacente.

    Depois de executar a etapa anterior, você pode criar o script de teste para a ação de teste no teste de unidade.

  2. Atualização do Transact-SQL as instruções na Transact-SQL editor para coincidir com as instruções a seguir:

    -- database unit test for Sales.uspNewCustomer
DECLARE @RC AS INT, @CustomerName AS NVARCHAR (40);

SELECT @RC = 0,
       @CustomerName = 'Fictitious Customer';

EXECUTE @RC = [Sales].[uspNewCustomer] @CustomerName;

SELECT * FROM [Sales].[Customer];

  3. No Condições de teste painel, clique na condição de teste Inconclusive e clique em Excluir condição de teste (x).

  4. No Condições de teste painel, clique em Contagem de linhas na lista e, em seguida, clique Adicionar condição de teste (+).

  5. No Propriedades janela, defina a Contagem de linhas propriedade como 1.

  6. No menu File, clique em Save All.

    Em seguida, você definir a lógica de teste de unidade para uspPlaceNewOrder.

Para gravar o teste de unidade de banco de dados para uspPlaceNewOrder

  1. Na barra de navegação do Designer de teste de unidade de banco de dados, clique em Sales_uspPlaceNewOrderTeste certifique-se de que teste é destacada na lista adjacente.

    Depois de executar esta etapa, você pode criar o script de teste para a ação de teste no teste de unidade.

  2. Atualização do Transact-SQL as instruções na Transact-SQL editor para coincidir com as instruções a seguir:

    -- database unit test for Sales.uspPlaceNewOrder
DECLARE @RC AS INT, @CustomerID AS INT, @Amount AS INT, @OrderDate AS DATETIME, @Status AS CHAR (1);
DECLARE @CustomerName AS NVARCHAR(40);

SELECT @RC = 0,
       @CustomerID = 0,
       @CustomerName = N'Fictitious Customer',
       @Amount = 100,
       @OrderDate = getdate(),
       @Status = 'O';

-- NOTE: Assumes that you inserted a Customer record with CustomerName='Fictitious Customer' in the pre-test script.
SELECT @CustomerID = [CustomerID] FROM [Sales].[Customer] WHERE [CustomerName] = @CustomerName;

-- place an order for that customer
EXECUTE @RC = [Sales].[uspPlaceNewOrder] @CustomerID, @Amount, @OrderDate, @Status;

-- verify that the YTDOrders value is correct.
SELECT @RC = [YTDOrders] FROM [Sales].[Customer] WHERE [CustomerID] = @CustomerID

SELECT @RC AS RC

  3. No Condições de teste painel, clique na condição de teste Inconclusive e clique em Excluir condição de teste (x).

  4. No Condições de teste painel, clique em O valor de escalar na lista e, em seguida, clique Adicionar condição de teste (+).

  5. No Propriedades janela, defina a valor esperado a propriedade como 100.

  6. Na barra de navegação do Designer de teste de unidade de banco de dados, clique em Sales_uspPlaceNewOrderTeste certifique-se de que pré-teste é destacada na lista adjacente.

    Depois de executar esta etapa, você pode especificar instruções colocar os dados do estado em que é necessário para executar o teste. Neste exemplo, você deve criar o registro do cliente antes de poder colocar um pedido.

  7. Clique em Clique aqui para criar para criar um script pré-teste.

  8. Atualização do Transact-SQL as instruções na Transact-SQL editor para coincidir com as instruções a seguir:

    /*
Add Transact-SQL statements here that you want to run before
the test script is run.
*/
-- Add a customer for this test with the name 'Fictitious Customer'
DECLARE @NewCustomerID AS INT, @CustomerID AS INT, @RC AS INT, @CustomerName AS NVARCHAR (40);

SELECT @RC = 0,
       @NewCustomerID = 0,
   @CustomerID = 0,
       @CustomerName = N'Fictitious Customer';

IF NOT EXISTS(SELECT * FROM [Sales].[Customer] WHERE CustomerName = @CustomerName)
BEGIN
EXECUTE @NewCustomerID = [Sales].[uspNewCustomer] @CustomerName;
END

-- NOTE: Assumes that you inserted a Customer record with CustomerName='Fictitious Customer' in the pre-test script.
SELECT @CustomerID = [CustomerID] FROM [Sales].[Customer] WHERE [CustomerName] = @CustomerName;

-- delete any old records in the Orders table and clear out the YTD Sales/Orders fields
DELETE from [Sales].[Orders] WHERE [CustomerID] = @CustomerID;
UPDATE [Sales].[Customer] SET YTDOrders = 0, YTDSales = 0 WHERE [CustomerID] = @CustomerID;

  9. No menu File, clique em Save All.

    Em seguida, você criar o teste de unidade para uspFillOrder.

Para gravar o teste de unidade de banco de dados para uspFillOrder

  1. Na barra de navegação do Designer de teste de unidade de banco de dados, clique em Sales_uspFillOrderTeste certifique-se de que teste é destacada na lista adjacente.

    Depois de executar esta etapa, você pode criar o script de teste para a ação de teste no teste de unidade.

  2. Atualização do Transact-SQL as instruções na Transact-SQL editor para coincidir com as instruções a seguir:

    -- database unit test for Sales.uspFillOrder
DECLARE @RC AS INT, @CustomerID AS INT, @Amount AS INT, @FilledDate AS DATETIME, @Status AS CHAR (1);
DECLARE @CustomerName AS NVARCHAR(40), @OrderID AS INT;

SELECT @RC = 0,
       @CustomerID = 0,
       @OrderID = 0,
       @CustomerName = N'Fictitious Customer',
       @Amount = 100,
       @FilledDate = getdate(),
       @Status = 'O';

-- NOTE: Assumes that you inserted a Customer record with CustomerName='Fictitious Customer' in the pre-test script.
SELECT @CustomerID = [CustomerID] FROM [Sales].[Customer] WHERE [CustomerName] = @CustomerName;
-- Get the most recently added order.
SELECT @OrderID = MAX([OrderID]) FROM [Sales].[Orders] WHERE [CustomerID] = @CustomerID;

-- fill an order for that customer
EXECUTE @RC = [Sales].[uspFillOrder] @OrderID, @FilledDate;

-- verify that the YTDOrders value is correct.
SELECT @RC = [YTDSales] FROM [Sales].[Customer] WHERE [CustomerID] = @CustomerID

SELECT @RC AS RC;

  3. No Condições de teste painel, clique na condição de teste Inconclusive e clique em Excluir condição de teste (x).

  4. No Condições de teste painel, clique em O valor de escalar na lista e, em seguida, clique Adicionar condição de teste (+).

  5. No Propriedades janela, defina a valor esperado a propriedade como 100.

  6. Na barra de navegação do Designer de teste de unidade de banco de dados, clique em Sales_uspFillOrderTeste certifique-se de que pré-teste é destacada na lista adjacente. Depois de executar esta etapa, você pode especificar instruções colocar os dados do estado em que é necessário para executar o teste. Neste exemplo, você deve criar o registro do cliente antes de poder colocar um pedido.

  7. Clique em Clique aqui para criar para criar um script pré-teste.

  8. Atualização do Transact-SQL as instruções na Transact-SQL editor para coincidir com as instruções a seguir:

    /*
Add Transact-SQL statements here that you want to run before
the test script is run.
*/
BEGIN TRANSACTION

-- Add a customer for this test with the name 'CustomerB'
DECLARE @NewCustomerID AS INT, @RC AS INT, @CustomerName AS NVARCHAR (40);

SELECT @RC = 0,
       @NewCustomerID = 0,
       @CustomerName = N'Fictitious Customer';

IF NOT EXISTS(SELECT * FROM [Sales].[Customer] WHERE CustomerName = @CustomerName)
BEGIN
EXECUTE @NewCustomerID = [Sales].[uspNewCustomer] @CustomerName;
END

DECLARE @CustomerID AS INT, @Amount AS INT, @OrderDate AS DATETIME, @Status AS CHAR (1);

SELECT @RC = 0,
       @CustomerID = 0,
       @CustomerName = N'Fictitious Customer',
       @Amount = 100,
       @OrderDate = getdate(),
       @Status = 'O';

-- NOTE: Assumes that you inserted a Customer record with CustomerName='Fictitious Customer' in the pre-test script.
SELECT @CustomerID = [CustomerID] FROM [Sales].[Customer] WHERE [CustomerName] = @CustomerName;

-- delete any old records in the Orders table and clear out the YTD Sales/Orders fields
DELETE from [Sales].[Orders] WHERE [CustomerID] = @CustomerID;
UPDATE [Sales].[Customer] SET YTDOrders = 0, YTDSales = 0 WHERE [CustomerID] = @CustomerID;

-- place an order for that customer
EXECUTE @RC = [Sales].[uspPlaceNewOrder] @CustomerID, @Amount, @OrderDate, @Status;

COMMIT TRANSACTION

  9. No menu File, clique em Save All.

    Neste ponto, você está pronto para executar os testes.

Para gravar o teste de unidade de banco de dados para uspShowOrderDetails

  1. Na barra de navegação do Designer de teste de unidade de banco de dados, clique em Sales_uspShowOrderDetailsTeste certifique-se de que teste é destacada na lista adjacente.

    Depois de executar esta etapa, você pode criar o script de teste para a ação de teste no teste de unidade.

  2. Atualização do Transact-SQL as instruções na Transact-SQL editor para coincidir com as instruções a seguir:

    -- database unit test for Sales.uspFillOrder
DECLARE @RC AS INT, @CustomerID AS INT, @Amount AS INT, @FilledDate AS DATETIME, @Status AS CHAR (1);
DECLARE @CustomerName AS NVARCHAR(40), @OrderID AS INT;

SELECT @RC = 0,
       @CustomerID = 0,
       @OrderID = 0,
       @CustomerName = N'Fictitious Customer',
       @Amount = 100,
       @FilledDate = getdate(),
       @Status = 'O';

-- NOTE: Assumes that you inserted a Customer record with CustomerName='Fictitious Customer' in the pre-test script.
SELECT @CustomerID = [CustomerID] FROM [Sales].[Customer] WHERE [CustomerName] = @CustomerName;

-- fill an order for that customer
EXECUTE @RC = [Sales].[uspShowOrderDetails] @CustomerID;

SELECT @RC AS RC;

  3. No Condições de teste painel, clique na condição de teste Inconclusive e clique em Excluir condição de teste (x).

  4. No Condições de teste painel, clique em Esquema esperado na lista e, em seguida, clique Adicionar condição de teste (+).

  5. No Propriedades janela, o configuração propriedade, clique no botão Procurar ('…').

  6. No configuração de expectedSchemaCondition1 caixa de diálogo, especifique uma conexão ao banco de dados.

  7. Clique em recuperar.

    O Transact-SQL o corpo do seu teste de unidade é executado, e o esquema resultante aparece na caixa de diálogo. Porque o código de pré-teste não foi executado, nenhum dado é retornado. Você só está verificando o esquema e não os dados, isso é bom.

  8. Clique em OK.

    O esquema previsto é armazenado com a condição de teste.

  9. Na barra de navegação do Designer de teste de unidade de banco de dados, clique em Sales_uspShowOrderDetailsTeste certifique-se de que pré-teste é destacada na lista adjacente. Depois de executar esta etapa, você pode especificar instruções colocar os dados do estado em que é necessário para executar o teste. Neste exemplo, você deve criar o registro do cliente antes de poder colocar um pedido.

  10. Clique em Clique aqui para criar para criar um script pré-teste.

  11. Atualização do Transact-SQL as instruções na Transact-SQL editor para coincidir com as instruções a seguir:

    /*
Add Transact-SQL statements here that you want to run before
the test script is run.
*/
BEGIN TRANSACTION

-- Add a customer for this test with the name 'FictitiousCustomer'
DECLARE @NewCustomerID AS INT, @RC AS INT, @CustomerName AS NVARCHAR (40);

SELECT @RC = 0,
       @NewCustomerID = 0,
       @CustomerName = N'Fictitious Customer';

IF NOT EXISTS(SELECT * FROM [Sales].[Customer] WHERE CustomerName = @CustomerName)
BEGIN
EXECUTE @NewCustomerID = [Sales].[uspNewCustomer] @CustomerName;
END


DECLARE @CustomerID AS INT, @Amount AS INT, @OrderDate AS DATETIME, @Status AS CHAR (1);

SELECT @RC = 0,
       @CustomerID = 0,
       @CustomerName = N'Fictitious Customer',
       @OrderDate = getdate(),
       @Status = 'O';

-- NOTE: Assumes that you inserted a Customer record with CustomerName='Fictitious Customer' in the pre-test script.
SELECT @CustomerID = [CustomerID] FROM [Sales].[Customer] WHERE [CustomerName] = @CustomerName;

-- delete any old records in the Orders table and clear out the YTD Sales/Orders fields
DELETE from [Sales].[Orders] WHERE [CustomerID] = @CustomerID;
UPDATE [Sales].[Customer] SET YTDOrders = 0, YTDSales = 0 WHERE [CustomerID] = @CustomerID;

-- place 3 orders for that customer
EXECUTE @RC = [Sales].[uspPlaceNewOrder] @CustomerID, 100, @OrderDate, @Status;
EXECUTE @RC = [Sales].[uspPlaceNewOrder] @CustomerID, 50, @OrderDate, @Status;
EXECUTE @RC = [Sales].[uspPlaceNewOrder] @CustomerID, 5, @OrderDate, @Status;

COMMIT TRANSACTION

  12. Na barra de navegação do Designer de teste de unidade de banco de dados, clique em Sales_uspShowOrderDetailsTeste clique em teste na lista adjacente.

    Você deve fazer isso porque você deseja aplicar a condição de soma de verificação para o teste, e não no pré-teste.

  13. No Condições de teste painel, clique em a soma de verificação de dados na lista e, em seguida, clique Adicionar condição de teste (+).

  14. No Propriedades janela, o configuração propriedade, clique no botão Procurar ('…').

  15. No configuração de checksumCondition1 caixa de diálogo, especifique uma conexão ao banco de dados.

  16. Substituir o Transact-SQL na caixa de diálogo com o seguinte código:

    BEGIN TRANSACTION

-- Add a customer for this test with the name 'CustomerB'
DECLARE @NewCustomerID AS INT, @RC AS INT, @CustomerName AS NVARCHAR (40);

SELECT @RC = 0,
       @NewCustomerID = 0,
       @CustomerName = N'Fictitious Customer';

IF NOT EXISTS(SELECT * FROM [Sales].[Customer] WHERE CustomerName = @CustomerName)
BEGIN
EXECUTE @NewCustomerID = [Sales].[uspNewCustomer] @CustomerName;
END


DECLARE @CustomerID AS INT, @Amount AS INT, @OrderDate AS DATETIME, @Status AS CHAR (1);

SELECT @RC = 0,
       @CustomerID = 0,
       @CustomerName = N'Fictitious Customer',
       @OrderDate = getdate(),
       @Status = 'O';

-- NOTE: Assumes that you inserted a Customer record with CustomerName='Fictitious Customer' in the pre-test script.
SELECT @CustomerID = [CustomerID] FROM [Sales].[Customer] WHERE [CustomerName] = @CustomerName;

-- delete any old records in the Orders table and clear out the YTD Sales/Orders fields
DELETE from [Sales].[Orders] WHERE [CustomerID] = @CustomerID;
UPDATE [Sales].[Customer] SET YTDOrders = 0, YTDSales = 0 WHERE [CustomerID] = @CustomerID;



-- place 3 orders for that customer
EXECUTE @RC = [Sales].[uspPlaceNewOrder] @CustomerID, 100, @OrderDate, @Status;
EXECUTE @RC = [Sales].[uspPlaceNewOrder] @CustomerID, 50, @OrderDate, @Status;
EXECUTE @RC = [Sales].[uspPlaceNewOrder] @CustomerID, 5, @OrderDate, @Status;


COMMIT TRANSACTION


-- database unit test for Sales.uspFillOrder
DECLARE @FilledDate AS DATETIME;
DECLARE @OrderID AS INT;

SELECT @RC = 0,
       @CustomerID = 0,
       @OrderID = 0,
       @CustomerName = N'Fictitious Customer',
       @Amount = 100,
       @FilledDate = getdate(),
       @Status = 'O';

-- NOTE: Assumes that you inserted a Customer record with CustomerName='Fictitious Customer' in the pre-test script.
SELECT @CustomerID = [CustomerID] FROM [Sales].[Customer] WHERE [CustomerName] = @CustomerName;

-- fill an order for that customer
EXECUTE @RC = [Sales].[uspShowOrderDetails] @CustomerID;

SELECT @RC AS RC;

    Esse código combina a Transact-SQL código no pré-teste com o Transact-SQL a partir do próprio teste. Você precisa de ambos para retornar os mesmos resultados de teste retornará ao executá-lo.

  17. Clique em recuperar.

    O Transact-SQL que você especificou é executada, e uma soma de verificação é calculada para os dados retornados.

  18. Clique em OK.

    A soma de verificação calculada é armazenada com a condição de teste. A soma de verificação esperada aparece na coluna valor da condição de teste de soma de verificação de dados.

  19. No menu File, clique em Save All.

    Neste ponto, você está pronto para executar os testes.

Executar testes de unidade de banco de dados

Para executar os testes de unidade de banco de dados

  1. Sobre o teste , aponte para Windowse em seguida, clique em Test View.

  2. Na janela Test View, clique em Atualizar na barra de ferramentas para atualizar a lista de testes.

    O Test View janela lista de testes que você criou anteriormente e para o qual você adicionou Transact-SQL instruções e condições de teste. O teste chamada TestMethod1 está vazio e não é usado nesta explicação.

  3. Com o botão direito Sales_uspNewCustomerTeste clique em Run Selection.

    Visual Studiousa o contexto privilegiado que você especificou para se conectar ao banco de dados e aplicar o plano de geração de dados. Visual StudioAlterna para o contexto de execução antes de executar o Transact-SQL script de Test. Finalmente, Visual Studio avalia os resultados a Transact-SQL script contra aqueles que você especificou na condição de teste e um resultado de pass ou fail aparece no Test Results janela.

  4. Exibir o resultado na Resultados de teste janela.

    Os passos de teste, o que significa que SELECT instrução retorna uma linha quando ele for executar.

  5. Repita a etapa 3 para os testes de Sales_uspPlaceNewOrderTest, Sales_uspFillOrderTest e Sales_uspShowOrderDetailsTest. Os resultados devem ser da seguinte maneira:

    Teste

    Resultado esperado

    Sales_uspPlaceNewOrderTest

    Passar

    Sales_uspShowOrderDetailsTest

    Passar

    Sales_uspFillOrderTest

    Falha com o seguinte erro: "Falha de condição de ScalarValueCondition (scalarValueCondition2): Coluna de linha 1 do conjunto de resultados 1 1: valores não coincidem, real '-100' esperado '100'." Este erro ocorre porque a definição do procedimento armazenado contém um erro secundário.

    Em seguida, você irá corrigir o erro e execute novamente o teste.

Para corrigir o erro no Sales.uspFillOrder

  1. Em Visualização Esquema, clique duas vezes o uspFillOrder procedimento armazenado para abrir a sua definição de Transact-SQL editor.

  2. Na definição de localizar o seguinte Transact-SQL instrução:

    UPDATE [Sales].[Customer]
   SET
   YTDSales = YTDSales - @Delta
    WHERE [CustomerID] = @CustomerID

  3. Altere a cláusula SET na instrução para coincidir com a instrução a seguir:

    UPDATE [Sales].[Customer]
   SET
   YTDSales = YTDSales + @Delta
    WHERE [CustomerID] = @CustomerID

  4. Sobre o arquivo menu, clique em Salvar uspFillOrder.proc.sql.

  5. No Test View, com o botão direito Sales_uspFillOrderTeste clique em Run Selection.

    O teste passar.

Adicionar um teste de unidade negativo

Você pode criar um teste negativo para verificar que um teste falhar quando ele falhar. Por exemplo, se você tentar cancelar um pedido que já foi preenchido, esse teste deve falhar. Nesta parte da explicação, você pode criar um teste de unidade negativo para o procedimento armazenado de Sales.uspCancelOrder.

Para criar e verificar um teste negativo, você deve executar as seguintes tarefas:

  • O procedimento armazenado para testar condições de falha de atualização

  • Definir um novo teste de unidade

  • Modificar o código para o teste de unidade indicar que é esperado falha

  • Executar o teste de unidade

Para atualizar o procedimento armazenado

  1. Na visualização Esquema, expanda o nó de SimpleUnitTestDB, expanda o nó esquemas, expanda o nó de vendas, expanda o nó de programação, expanda o nó procedimentos armazenados e clique duas vezes em uspCancelOrder.

  2. No Transact-SQL editor, atualizar a definição de procedimento para coincidir com o seguinte código:

    CREATE PROCEDURE [Sales].[uspCancelOrder]
@OrderID INT
AS
BEGIN
    DECLARE @Delta INT, @CustomerID INT, @PriorStatus CHAR(1)
    BEGIN TRANSACTION
        BEGIN TRY
            IF (NOT EXISTS(SELECT [CustomerID] from [Sales].[Orders] WHERE [OrderID] = @OrderID))
            BEGIN
                -- Specify WITH LOG option so that the error is
                -- written to the application log.
                RAISERROR( 'That order does not exist.', -- Message text
                           16, -- severity
                            1 -- state
                        ) WITH LOG;
            END

            SELECT @Delta = [Amount], @CustomerID = [CustomerID], @PriorStatus = [Status]
             FROM [Sales].[Orders] WHERE [OrderID] = @OrderID

            IF @PriorStatus <> 'O' 
            BEGIN
                -- Specify WITH LOG option so that the error is
                -- written to the application log.
                RAISERROR ( 'You can only cancel open orders.', -- Message text
                            16, -- Severity
                            1 -- State
                            ) WITH LOG;
            END
            ELSE
            BEGIN
                -- If we make it to here, then we can cancel the order. Update the status to 'X' first...
                UPDATE [Sales].[Orders]
                   SET [Status] = 'X'
                WHERE [OrderID] = @OrderID
                -- and then remove the amount from the YTDOrders for the customer
                UPDATE [Sales].[Customer]
                       SET
                           YTDOrders = YTDOrders - @Delta
                WHERE [CustomerID] = @CustomerID
                COMMIT TRANSACTION
                RETURN 1; -- indicate success
            END
        END TRY
        BEGIN CATCH
            DECLARE @ErrorMessage NVARCHAR(4000);
            DECLARE @ErrorSeverity INT;
            DECLARE @ErrorState INT;

            SELECT @ErrorMessage = ERROR_MESSAGE(),
                   @ErrorSeverity = ERROR_SEVERITY(),
                   @ErrorState = ERROR_STATE();

            ROLLBACK TRANSACTION
            -- Use RAISERROR inside the CATCH block to return
            -- error information about the original error that
            -- caused execution to jump to the CATCH block.
            RAISERROR (@ErrorMessage, -- Mesasge text
                       @ErrorSeverity, -- Severity
                       @ErrorState -- State
                      );
            RETURN 0; -- indicate failure
        END CATCH;
END

  3. Sobre o arquivo menu, clique em Salvar uspCancelOrder.proc.sql.

  4. Em Solution Explorer, com o botão direito SimpleUnitTestDB e clique em Deploy.

    Para implantar as atualizações para o procedimento armazenado de uspCancelOrder. Você não alterou nenhum outro objeto, portanto, apenas que o procedimento armazenado é atualizado.

    Em seguida, você define o teste de unidade associado para que este procedimento.

Para gravar o teste de unidade de banco de dados para uspCancelOrder

  1. Na barra de navegação do Designer de teste de unidade de banco de dados, clique em Sales_uspCancelOrderTeste certifique-se de que teste é destacada na lista adjacente.

    Depois de executar esta etapa, você pode criar o script de teste para a ação de teste no teste de unidade.

  2. Atualização do Transact-SQL as instruções na Transact-SQL editor para coincidir com as instruções a seguir:

    -- database unit test for Sales.uspFillOrder
DECLARE @RC AS INT, @CustomerID AS INT, @Amount AS INT, @FilledDate AS DATETIME, @Status AS CHAR (1);
DECLARE @CustomerName AS NVARCHAR(40), @OrderID AS INT;

SELECT @RC = 0,
       @CustomerID = 0,
       @OrderID = 0,
       @CustomerName = N'Fictitious Customer',
       @Amount = 100,
       @FilledDate = getdate(),
       @Status = 'O';

-- NOTE: Assumes that you inserted a Customer record with CustomerName='Fictitious Customer' in the pre-test script.
SELECT @CustomerID = [CustomerID] FROM [Sales].[Customer] WHERE [CustomerName] = @CustomerName;
-- Get the most recently added order.
SELECT @OrderID = MAX([OrderID]) FROM [Sales].[Orders] WHERE [CustomerID] = @CustomerID;

-- try to cancel an order for that customer that has already been filled
EXECUTE @RC = [Sales].[uspCancelOrder] @OrderID;

SELECT @RC AS RC;

  3. No Condições de teste painel, clique na condição de teste Inconclusive e clique em Excluir condição de teste (x).

  4. No Condições de teste painel, clique em O valor de escalar na lista e, em seguida, clique Adicionar condição de teste (+).

  5. No Propriedades janela, defina a valor esperado a propriedade como 0.

  6. Na barra de navegação do Designer de teste de unidade de banco de dados, clique em Sales_uspCancelOrderTeste certifique-se de que pré-teste é destacada na lista adjacente. Depois de executar esta etapa, você pode especificar instruções colocar os dados do estado em que é necessário para executar o teste. Neste exemplo, você deve criar o registro do cliente antes de poder colocar um pedido.

  7. Clique em Clique aqui para criar para criar um script pré-teste.

  8. Atualização do Transact-SQL as instruções na Transact-SQL editor para coincidir com as instruções a seguir:

    /*
Add Transact-SQL statements here that you want to run before
the test script is run.
*/
BEGIN TRANSACTION

-- Add a customer for this test with the name 'CustomerB'
DECLARE @NewCustomerID AS INT, @RC AS INT, @CustomerName AS NVARCHAR (40);

SELECT @RC = 0,
       @NewCustomerID = 0,
       @CustomerName = N'Fictitious Customer';

IF NOT EXISTS(SELECT * FROM [Sales].[Customer] WHERE CustomerName = @CustomerName)
BEGIN
EXECUTE @NewCustomerID = [Sales].[uspNewCustomer] @CustomerName;
END

DECLARE @CustomerID AS INT, @Amount AS INT, @OrderDate AS DATETIME, @FilledDate AS DATETIME, @Status AS CHAR (1), @OrderID AS INT;

SELECT @RC = 0,
       @CustomerID = 0,
   @OrderID = 0,
       @CustomerName = N'Fictitious Customer',
       @Amount = 100,
       @OrderDate = getdate(),
   @FilledDate = getdate(),
       @Status = 'O';

-- NOTE: Assumes that you inserted a Customer record with CustomerName='Fictitious Customer' in the pre-test script.
SELECT @CustomerID = [CustomerID] FROM [Sales].[Customer] WHERE [CustomerName] = @CustomerName;

-- delete any old records in the Orders table and clear out the YTD Sales/Orders fields
DELETE from [Sales].[Orders] WHERE [CustomerID] = @CustomerID;
UPDATE [Sales].[Customer] SET YTDOrders = 0, YTDSales = 0 WHERE [CustomerID] = @CustomerID;

-- place an order for that customer
EXECUTE @OrderID = [Sales].[uspPlaceNewOrder] @CustomerID, @Amount, @OrderDate, @Status;

-- fill the order for that customer
EXECUTE @RC = [Sales].[uspFillOrder] @OrderID, @FilledDate;

COMMIT TRANSACTION

  9. No menu File, clique em Save All.

    Neste ponto, você está pronto para executar os testes.

Para executar os testes de unidade de banco de dados

  1. Em Test View, com o botão direito Sales_uspCancelOrderTeste clique em Run Selection.

  2. Exibir o resultado na Resultados de teste janela.

    O teste falhar e aparece o seguinte erro:

    Test method TestProject1.DatabaseUnitTests1.Sales_uspCancelOrderTest threw exception: System.Data.SqlClient.SqlException: You can only cancel open orders.

    Em seguida, você pode modificar o código para indicar que a exceção é o esperado.

Para modificar o código para o teste de unidade

  1. Em Solution Explorer, expanda TestProject1, com o botão direito DatabaseUnitTests1.cse clique em Exibir código.

  2. No editor de código, navegue até o método Sales_uspCancelOrderTest. Modificar os atributos do método para coincidir com o código a seguir:

            [TestMethod(), ExpectedSqlException(Severity=16, MatchFirstError=false, State=1)]
        public void Sales_uspCancelOrderTest()

    Especificar o que você espera ver uma exceção específica do SQL. Opcionalmente, você pode especificar um número de erro específico. Se você não adicionar esse atributo, o teste de unidade falhará e uma mensagem é exibida na janela Test Results

  3. No menu Arquivo, clique em Salvar DatabaseUnitTests1.cs.

    Em seguida, execute novamente o teste de unidade para verificar se ele falha conforme o esperado.

Para executar novamente os testes de unidade de banco de dados

  1. Em Test View, com o botão direito Sales_uspCancelOrderTeste clique em Run Selection.

  2. Exibir o resultado na Resultados de teste janela.

    O teste passar, o que significa que o procedimento falhou quando ele deveria falhar.

Próximas etapas

Um projeto típico, você definiria a testes de unidade adicionais para verificar se a todos os objetos de banco de dados críticos funcionam corretamente. Quando o conjunto de testes estiver concluído, você verificaria esses testes em o controle de versão para compartilhá-los com a equipe.

Depois de estabelecer uma linha de base, você pode criar e modificar objetos de banco de dados e, em seguida, criar testes associados para verificar se uma alteração interromperá o comportamento esperado.

Consulte também

Tarefas

Como: Criar um teste de unidade de banco de dados vazio

Como: Configurar a execução do teste de unidade de banco de dados

Conceitos

Criar e definir os testes de unidade de banco de dados

Verificando o banco de dados código usando testes de unidade

Geração de dados de teste para bancos de dados usando os geradores de dados