Procedura dettagliata: creazione ed esecuzione di uno unit test del database

Articolo
08/11/2011

In questa procedura dettagliata verrà illustrato la creazione di uno unit test del database in grado di verificare il comportamento di diverse stored procedure. Verranno creati unit test del database per semplificare l'identificazione di difetti del codice che potrebbero causare il funzionamento non corretto dell'applicazione. È possibile eseguire unit test del database e test dell'applicazione nell'ambito di un gruppo di test automatizzato.

Questa procedura dettagliata prevede l'esecuzione delle attività seguenti:

Creare uno script contenente uno schema del database
Creare un progetto di database e importare lo schema
Distribuire il progetto di database in un ambiente di sviluppo isolato
Creare unit test del database
Definire la logica del test
Eseguire unit test del database
Aggiungere uno unit test negativo

In seguito al rilevamento di un errore in una stored procedure mediante uno degli unit test, l'utente provvede a correggere l'errore e quindi esegue nuovamente il test.

Prerequisiti

Per completare questa procedura dettagliata, è necessario essere in grado di connettersi a un server database per il quale si dispone delle autorizzazioni per la creazione e la distribuzione di un database. Per ulteriori informazioni, vedere Autorizzazioni necessarie per le funzionalità di database di Visual Studio.

Creare uno script contenente uno schema del database

Per creare uno script da cui sia possibile importare uno schema

Scegliere Nuovo dal menu File, quindi fare clic su File.

Viene visualizzata la finestra di dialogo Nuovo file.
Se non è già evidenziato, selezionare Generale nell'elenco Categorie.
Nell'elenco Modelli selezionare File SQL, quindi fare clic su Apri.

Verrà aperto l'editor Transact-SQL.

Copiare il codice Transact-SQL seguente e incollarlo nell'editor Transact-SQL.

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

Scegliere Salva SqlQuery_1.sql con nome dal menu File.

Viene visualizzata la finestra di dialogo Salva file con nome.
Digitare SampleImportScript.sql in Nome oggetto.

È possibile salvare il file in qualsiasi percorso sul computer. Prendere nota del percorso poiché sarà necessario utilizzare questo script nella procedura successiva.
Scegliere Salva.
Scegliere Chiudi soluzione dal menu File.

A questo punto è possibile creare un progetto di database e importare lo schema dallo script creato.

Creare un progetto di database e importare uno schema

Per creare un progetto di database

Scegliere Nuovo dal menu File, quindi fare clic su Progetto.

Viene visualizzata la finestra di dialogo Nuovo progetto.
In Modelli installati espandere il nodo Database, quindi fare clic su SQL Server.

Nota

Se si utilizza Visual Studio Professional, in Modelli installati espandere invece il nodo Database e il nodo SQL Server, quindi fare clic su Avanzate.
Nell'elenco dei modelli fare clic su Progetto di database di SQL Server 2008.

Nota

Se si prevede di distribuire il database a una versione di database diversa, scegliere il modello corrispondente al server di destinazione.
In Nome digitare SimpleUnitTestDB.
Selezionare la casella di controllo Crea directory per soluzione, se non è già selezionata.
Deselezionare la casella di controllo Aggiungi al controllo del codice sorgente, se non è già deselezionata, e scegliere OK.

Il progetto di database verrà creato e visualizzato in Esplora soluzioni. A questo punto, è possibile procedere all'importazione dello schema del database da uno script.

Per importare uno schema di database da uno script

Scegliere Importa script dal menu Progetto.
Scegliere Avanti dopo avere letto la schermata iniziale.
Fare clic su Sfoglia e indicare il percorso in cui è stato salvato il file SampleImportScript.sql.
Fare doppio clic sul file SampleImportScript.sql e scegliere Fine.

Lo script verrà importato e gli oggetti che vi sono definiti verranno aggiunti al progetto di database.
Esaminare il riepilogo, quindi fare clic su Fine per completare l'operazione.

Nota

La stored procedure Sales.uspFillOrder contiene un errore di codifica intenzionale che verrà individuato e corretto più avanti in questa procedura.

Per esaminare il progetto risultante

In Esplora soluzioni espandere il nodo figlio Oggetti dello schema.
Esplorare i sottonodi del nodo Oggetti dello schema nella gerarchia.

Esplora soluzioni contiene i file che definiscono gli oggetti di database.
Scegliere Visualizzazione schema di database dal menu Visualizza.
In Visualizzazione schema espandere il nodo SimpleUnitTestDB.
Esplorare i sottonodi del nodo SimpleUnitTestDB nella gerarchia.

Nella finestra Visualizzazione schema sono contenuti gli oggetti definiti nei file visualizzati in Esplora soluzioni.

Distribuzione in un ambiente di sviluppo isolato

A questo punto, è possibile procedere alla distribuzione del progetto per creare un database con lo schema importato ma privo di dati. Tale database viene creato in un ambiente di sviluppo isolato (o sandbox) in modo che sia possibile svilupparlo e testarlo senza interferenze causate da altre attività.

Per configurare e compilare il progetto di database

In Esplora soluzioni fare clic sul progetto di database SimpleUnitTestDB.
Scegliere Proprietà di SimpleUnitTestDB dal menuProgetto.

Verrà visualizzata la finestra di dialogo delle proprietà del progetto.
Fare clic sulla scheda Distribuisci.
Nell'elenco Configura impostazioni di distribuzione per fare clic su Ambiente di sviluppo isolato. Configurando le impostazioni per l'ambiente di sviluppo isolato, è possibile utilizzare impostazioni di distribuzione diverse rispetto a quelle utilizzate in altri ambienti, ad esempio il server di produzione o quello di gestione temporanea.
Nell'elenco Azione di distribuzione fare clic su Crea uno script di distribuzione (.sql) e distribuisci nel database.
Da Impostazioni database di destinazione scegliere Modifica.

Verrà visualizzata la finestra di dialogo Proprietà connessione.
Impostare le proprietà di connessione per il database che si desidera creare, quindi scegliere OK.

Nella casella Connessione di destinazione viene visualizzata la stringa di connessione corretta.

Attenzione

È consigliabile creare il database in un server di test, in un server di sviluppo o nel computer locale. Non è consigliabile specificare il server di produzione.
In Nome database di destinazione digitare SimpleUnitTestDB.
Accanto a File di configurazione distribuzione, fare clic su Modifica.
Selezionare la casella di controllo Blocca distribuzione incrementale se dovesse verificarsi una perdita di dati.

Nota

Ai fini di questa procedura dettagliata, le stored procedure verranno testate su un database vuoto distribuito nell'ambito di uno unit test del database. Non è necessario mantenere eventuali dati esistenti poiché le stored procedure verranno testate nell'ambiente di sviluppo isolato.
Scegliere Salva tutto dal menu File.
Scegliere Compila soluzione dal menu Compila.

La modalità di compilazione dello script di distribuzione dipende dalle proprietà appena impostate. Lo stato della compilazione viene visualizzato nella finestra Risultato e nell'ultima riga dovrebbe apparire il messaggio Compilazione: 1 completate o aggiornate.

Nota

Se la finestra Output non è visualizzata, scegliere Output dal menu Visualizza.

Attenzione
È consigliabile creare il database in un server di test, in un server di sviluppo o nel computer locale. Non è consigliabile specificare il server di produzione.

Per distribuire il progetto di database

In Esplora soluzioni fare clic sul progetto di database SimpleUnitTestDB.
Scegliere Distribuisci SimpleUnitTestDB dal menu Compila.

Attenzione

È consigliabile eseguire questa distribuzione in un server di test, in un server di sviluppo o nel computer locale. Non è consigliabile specificare il server di produzione.

Il progetto di database viene distribuito in un nuovo database. Lo stato della distribuzione viene visualizzato nella finestra Output e nell'ultima riga dovrebbe essere visualizzato il messaggio Distribuzione: 1 completata. È possibile definire un piano di generazione dati per creare dati di test nel database. Ai fini di questa procedura dettagliata, verrà testato un database estremamente semplice per il quale non è necessario generare dati.

Attenzione
È consigliabile eseguire questa distribuzione in un server di test, in un server di sviluppo o nel computer locale. Non è consigliabile specificare il server di produzione.

Creare unit test del database

Per creare uno unit test del database per le stored procedure

Scegliere Visualizzazione schema database dal menu Visualizza.
In Visualizzazione schema espandere il nodo Schemi, il nodo Sales, il nodo Programmazione e infine il nodo Stored procedure.
Fare clic con il pulsante destro del mouse sulla stored procedure uspNewCustomer e scegliere Crea unit test.

Verrà visualizzata la finestra di dialogo Crea unit test.
Selezionare le caselle di controllo delle cinque stored procedure: Sales.uspCancelOrder, Sales.uspFillOrder, Sales.uspNewCustomer, Sales.uspPlaceNewOrder e Sales.uspShowOrderDetails.
In Progetto fare clic su Crea nuovo progetto di test Visual C#.
Accettare i nomi predefiniti per il progetto e la classe e fare clic su OK.

Verrà visualizzata la finestra di dialogo Configurazione del progetto 'TestProject1'.
In Esegui unit test utilizzando la connessione dati seguente specificare una connessione al database distribuito in precedenza nell'ambito di questa procedura dettagliata.

Nota

Se è necessario testare viste o stored procedure con autorizzazioni limitate, la connessione appropriata viene in genere specificata in questo passaggio. Per la convalida del test occorre quindi specificare la connessione secondaria con autorizzazioni più ampie. Se si dispone di una connessione secondaria, è necessario aggiungere il relativo utente al progetto di database e creare un account di accesso per tale utente nello script pre-distribuzione.
In Distribuzione selezionare la casella di controllo Distribuisci automaticamente il progetto di database prima dell'esecuzione degli unit test.
In Progetto di database selezionare SimpleUnitTestDB.dbproj.
In Configurazione distribuzione fare clic su Debug.

È inoltre possibile generare dati di test nell'ambito degli unit test del database. A fini di questa procedura dettagliata, tuttavia, tale passaggio verrà ignorato poiché i test creeranno dati propri.
Scegliere OK.

Il progetto di test verrà compilato e verrà visualizzata la finestra di progettazione unit test del database. A questo punto, è possibile procedere all'aggiornamento della logica del test nello script Transact-SQL degli unit test.

Definire la logica del test

Questo database molto semplice contiene due tabelle, Customer e Orders. Il database verrà aggiornato mediante le stored procedure seguenti:

uspNewCustomer: questa stored procedure aggiunge un record alla tabella Customer, il che determina l'impostazione delle colonne YTDOrders e YTDSales del cliente su zero.
uspPlaceNewOrder: questa stored procedure aggiunge un record alla tabella Orders relativamente al cliente specificato e aggiorna il valore di YTDOrders nel record corrispondente della tabella Customer.
uspFillOrder: questa stored procedure aggiorna un record nella tabella Orders modificando lo stato da 'O' a 'F' e aumenta l'importo indicato nella colonna YTDSales nel record corrispondente della tabella Customer.
uspCancelOrder: questa stored procedure aggiorna un record nella tabella Orders modificando lo stato da 'O' a 'X' e riducendo l'importo di YTDOrders nel record corrispondente della tabella Customer.
uspShowOrderDetails: questa stored procedure unisce la tabella Orders alla tabella Customer e visualizza i record relativi a un cliente specifico.

Nota

In questo esempio viene illustrato come creare un semplice unit test del database. In database di produzione, è possibile sommare gli importi totali di tutti gli ordini con stato 'O' o 'F' relativi a un determinato cliente. Le stored procedure in questa procedura dettagliata non contengono inoltre funzioni di gestione degli errori. Non impediscono, ad esempio, la chiamata a uspFillOrder per un ordine già effettuato.

Ai fini dei test si presuppone che il database venga avviato in uno stato pulito. I test che verranno creati consentono di verificare le condizioni seguenti:

uspNewCustomer: verifica che la tabella Customer contenga una riga dopo l'esecuzione della stored procedure.
uspPlaceNewOrder: per il cliente con ID 1, effettua un ordine di $ 100. Verifica che l'importo in YTDOrders per il cliente sia 100 e che l'importo di YTDSales sia zero.
uspFillOrder: per il cliente con ID 1, effettua un ordine di $ 50. Compila l'ordine in questione. Verifica che gli importi in YTDOrders e YTDSales siano entrambi pari a 50.
uspShowOrderDetails: per il cliente con ID 1, effettua ordini di $ 100, $ 50 e $ 5. Verifica che uspShowOrderDetails restituisca il numero corretto di colonne e che il set di risultati disponga del checksum previsto.

Nota

Un set completo di unit test del database prevede in genere la verifica della corretta impostazione delle altre colonne. Per evitare di rendere eccessivamente complessa questa procedura dettagliata, non viene descritto come verificare il comportamento di uspCancelOrder.

Per scrivere lo unit test del database per uspNewCustomer

Nella barra di navigazione della finestra di progettazione unit test del database, fare clic su Sales_uspNewCustomerTest e verificare che Test sia evidenziato nell'elenco adiacente.

Dopo avere eseguito il passaggio precedente, è possibile creare lo script di test per l'azione di test nello unit test.

Aggiornare le istruzioni Transact-SQL nell'editor Transact-SQL affinché corrispondano a quelle seguenti:

-- 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];

Nel riquadro Condizioni di test selezionare la condizione di test Senza risultati e fare clic su Elimina condizione di test (x).
Nel riquadro Condizioni di test selezionare Conteggio righe nell'elenco, quindi fare clic su Aggiungi condizione di test (+).
Nella finestra Proprietà impostare la proprietà Conteggio righe su 1.
Scegliere Salva tutto dal menu File.

A questo punto, è possibile procedere alla definizione della logica dello unit test per uspPlaceNewOrder.

Per scrivere lo unit test del database per uspPlaceNewOrder

Nella barra di navigazione della finestra di progettazione unit test del database, fare clic su Sales_uspPlaceNewOrderTest e verificare che Test sia evidenziato nell'elenco adiacente.

Dopo avere eseguito questo passaggio, è possibile creare lo script di test per l'azione di test nello unit test.

Aggiornare le istruzioni Transact-SQL nell'editor Transact-SQL affinché corrispondano a quelle seguenti:

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

Nel riquadro Condizioni di test selezionare la condizione di test Senza risultati e fare clic su Elimina condizione di test (x).
Nel riquadro Condizioni di test selezionare Valore scalare nell'elenco, quindi fare clic su Aggiungi condizione di test (+).
Nella finestra Proprietà impostare la proprietà Valore previsto su 100.
Nella barra di navigazione della finestra di progettazione unit test del database, fare clic su Sales_uspPlaceNewOrderTest e verificare che Pre-test sia evidenziato nell'elenco adiacente.

Dopo avere eseguito questo passaggio, è possibile specificare istruzioni che assegnano ai dati lo stato necessario per eseguire il test. Ai fini di questo esempio, è necessario creare il record del cliente prima di poter effettuare un ordine.
Scegliere Fare clic qui per creare per creare uno script pre-test.

Aggiornare le istruzioni Transact-SQL nell'editor Transact-SQL affinché corrispondano a quelle seguenti:

/*
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;

Scegliere Salva tutto dal menu File.

A questo punto, è possibile procedere alla creazione dello unit test per uspFillOrder.

Per scrivere lo unit test del database per uspFillOrder

Nella barra di navigazione della finestra di progettazione unit test del database, fare clic su Sales_uspFillOrderTest e verificare che Test sia evidenziato nell'elenco adiacente.

Dopo avere eseguito questo passaggio, è possibile creare lo script di test per l'azione di test nello unit test.

Aggiornare le istruzioni Transact-SQL nell'editor Transact-SQL affinché corrispondano a quelle seguenti:

-- 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;

Nel riquadro Condizioni di test selezionare la condizione di test Senza risultati e fare clic su Elimina condizione di test (x).
Nel riquadro Condizioni di test selezionare Valore scalare nell'elenco, quindi fare clic su Aggiungi condizione di test (+).
Nella finestra Proprietà impostare la proprietà Valore previsto su 100.
Nella barra di navigazione della finestra di progettazione unit test del database, fare clic su Sales_uspFillOrderTest e verificare che Pre-test sia evidenziato nell'elenco adiacente. Dopo avere eseguito questo passaggio, è possibile specificare istruzioni che assegnano ai dati lo stato necessario per eseguire il test. Ai fini di questo esempio, è necessario creare il record del cliente prima di poter effettuare un ordine.
Scegliere Fare clic qui per creare per creare uno script pre-test.

Aggiornare le istruzioni Transact-SQL nell'editor Transact-SQL affinché corrispondano a quelle seguenti:

/*
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

Scegliere Salva tutto dal menu File.

A questo punto, è possibile procedere all'esecuzione dei test.

Per scrivere lo unit test del database per uspShowOrderDetails

Nella barra di navigazione della finestra di progettazione unit test del database, fare clic su Sales_uspShowOrderDetailsTest e verificare che Test sia evidenziato nell'elenco adiacente.

Dopo avere eseguito questo passaggio, è possibile creare lo script di test per l'azione di test nello unit test.

Aggiornare le istruzioni Transact-SQL nell'editor Transact-SQL affinché corrispondano a quelle seguenti:

-- 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;

Nel riquadro Condizioni di test selezionare la condizione di test Senza risultati e fare clic su Elimina condizione di test (x).
Nel riquadro Condizioni di test selezionare Valore previsto nell'elenco, quindi fare clic su Aggiungi condizione di test (+).
Nella finestra Proprietà fare clic sul pulsante sfoglia (...) nella proprietà Configurazione.
Nella finestra di dialogo Configurazione per expectedSchemaCondition1 specificare una connessione al database.
Fare clic su Recupera.

Il corpo Transact-SQL dello unit test verrà eseguito e lo schema risultante verrà visualizzato nella finestra di dialogo. Poiché il codice di pre-test non è stato eseguito, non vengono restituiti dati. Dal momento che si sta eseguendo solo la verifica dello schema e non dei dati, questo comportamento è corretto.
Scegliere OK.

Lo schema previsto viene archiviato con la condizione di test.
Nella barra di navigazione della finestra di progettazione unit test del database, fare clic su Sales_uspShowOrderDetailsTest e verificare che Pre-test sia evidenziato nell'elenco adiacente. Dopo avere eseguito questo passaggio, è possibile specificare istruzioni che assegnano ai dati lo stato necessario per eseguire il test. Ai fini di questo esempio, è necessario creare il record del cliente prima di poter effettuare un ordine.
Scegliere Fare clic qui per creare per creare uno script pre-test.

Aggiornare le istruzioni Transact-SQL nell'editor Transact-SQL affinché corrispondano a quelle seguenti:

/*
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

Nella barra di navigazione della finestra di progettazione unit test del database, fare clic su Sales_uspShowOrderDetailsTest e fare clic su Test nell'elenco adiacente.

Questa operazione è necessaria perché si desidera applicare la condizione di checksum al test, non al pre-test.
Nel riquadro Condizioni di test selezionare Checksum nell'elenco, quindi fare clic su Aggiungi condizione di test (+).
Nella finestra Proprietà fare clic sul pulsante sfoglia (...) nella proprietà Configurazione.
Nella finestra di dialogo Configurazione per checksumCondition1 specificare una connessione al database.

Sostituire il codice Transact-SQL nella finestra di dialogo con quello seguente:

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;

Questo codice combina il codice Transact-SQL di pre-test con il codice Transact-SQL del test stesso. È necessario il codice di entrambi affinché vengano restituiti gli stessi risultati che si otterranno al momento dell'esecuzione del test.

Fare clic su Recupera.

Il codice Transact-SQL specificato verrà eseguito e verrà calcolato un checksum per i dati restituiti.
Scegliere OK.

Il checksum calcolato viene archiviato con la condizione di test. Il checksum previsto viene visualizzato nella colonna Valore della condizione di test Checksum dei dati.
Scegliere Salva tutto dal menu File.

A questo punto, è possibile procedere all'esecuzione dei test.

Eseguire unit test del database

Per eseguire gli unit test del database

Scegliere Finestre dal menu Test e quindi Visualizzazione test.
Nella finestra Visualizzazione test, fare clic su Aggiorna nella barra degli strumenti per aggiornare l'elenco dei test.

Nella finestra Visualizzazione test sono elencati i test creati nelle fasi precedenti di questa procedura dettagliata e ai quali sono state aggiunte condizioni di test e istruzioni Transact-SQL. Il test denominato TestMethod1 è vuoto e non è utilizzato in questa procedura dettagliata.
Fare clic con il pulsante destro del mouse su Sales_uspNewCustomerTest e scegliere Esegui selezione.

Visual Studio utilizza il contesto autorizzato specificato dall'utente per connettersi al database e applicare il piano di generazione dati. Visual Studio passa quindi al contesto di esecuzione prima di eseguire lo script Transact-SQL nel test. Infine, Visual Studio valuta i risultati dello script Transact-SQL rispetto a quelli specificati nella condizione di test. L'esito della valutazione, positivo o negativo, viene visualizzato nella finestra Risultati test.
I risultati vengono visualizzati nella finestra Risultati test.

Il test ha esito positivo, ovvero in seguito all'esecuzione dell'istruzione SELECT viene restituita una riga.

Ripetere il passaggio 3 per i test Sales_uspPlaceNewOrderTest, Sales_uspFillOrderTest e Sales_uspShowOrderDetailsTest. I risultati saranno simili ai seguenti:

Test	ExpectedResult
Sales_uspPlaceNewOrderTest	Superato
Sales_uspShowOrderDetailsTest	Superato
Sales_uspFillOrderTest	Non riesce con l'errore seguente: "Condizione ScalarValueCondition (scalarValueCondition2) Non superato: Set di risultati 1 Riga 1 Colonna 1: valori non corrispondenti, '-100' effettivi, '100' previsti". Questo errore si verifica perché la definizione della stored procedure contiene un lieve errore.

A questo punto, è possibile procedere alla correzione dell'errore e alla nuova esecuzione del test.

Per correggere l'errore in Sales.uspFillOrder

In Visualizzazione schema fare doppio clic sulla stored procedure uspFillOrder per aprire la relativa definizione nell'editor Transact-SQL.

Individuare l'istruzione Transact-SQL indicata di seguito nella definizione:

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

Modificare la clausola SET nell'istruzione affinché corrisponda all'istruzione seguente:

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

Scegliere Salva uspFillOrder.proc.sql dal menu File.
In Visualizzazione test fare clic con il pulsante destro del mouse su Sales_uspFillOrderTest e scegliere Esegui selezione.

Il test ha esito positivo.

Aggiungere uno unit test negativo

È possibile creare un test negativo per verificare che un test effettivamente non riesca quando è previsto che abbia esito negativo. Se ad esempio si tenta di annullare un ordine già compilato, il test deve avere esito negativo. In questa parte della procedura dettagliata, verrà creato uno unit test negativo per la stored procedure Sales.uspCancelOrder.

Per creare e verificare un test negativo, è necessario eseguire le attività seguenti:

Aggiornare la stored procedure per testare le condizioni di errore
Definire un nuovo unit test
Modificare il codice affinché lo unit test indichi che è previsto l'esito negativo
Eseguire lo unit test

Per aggiornare la stored procedure

In Visualizzazione schema espandere il nodo SimpleUnitTestDB, il nodo Schemi, il nodo Sales, il nodo Programmazione, il nodo Stored procedure e quindi fare doppio clic su uspCancelOrder.

Nell'editor Transact-SQL aggiornare la definizione della stored procedure affinché corrisponda al codice seguente:

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

Scegliere Salva uspCancelOrder.proc.sql dal menu File.
In Esplora soluzioni fare clic con il pulsante destro del mouse su SimpleUnitTestDB e scegliere Distribuisci.

Verranno distribuiti gli aggiornamenti nella stored procedure uspCancelOrder. Non sono stati modificati altri oggetti, pertanto viene aggiornata solo la stored procedure in questione.

A questo punto, è possibile procedere alla definizione dello unit test associato alla stored procedure.

Per scrivere lo unit test del database per uspCancelOrder

Nella barra di navigazione della finestra di progettazione unit test del database, fare clic su Sales_uspCancelOrderTest e verificare che Test sia evidenziato nell'elenco adiacente.

Dopo avere eseguito questo passaggio, è possibile creare lo script di test per l'azione di test nello unit test.

Aggiornare le istruzioni Transact-SQL nell'editor Transact-SQL affinché corrispondano a quelle seguenti:

-- 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;

Nel riquadro Condizioni di test selezionare la condizione di test Senza risultati e fare clic su Elimina condizione di test (x).
Nel riquadro Condizioni di test selezionare Valore scalare nell'elenco, quindi fare clic su Aggiungi condizione di test (+).
Nella finestra Proprietà impostare la proprietà Valore previsto su 0.
Nella barra di navigazione della finestra di progettazione unit test del database, fare clic su Sales_uspCancelOrderTest e verificare che Pre-test sia evidenziato nell'elenco adiacente. Dopo avere eseguito questo passaggio, è possibile specificare istruzioni che assegnano ai dati lo stato necessario per eseguire il test. Ai fini di questo esempio, è necessario creare il record del cliente prima di poter effettuare un ordine.
Scegliere Fare clic qui per creare per creare uno script pre-test.

Aggiornare le istruzioni Transact-SQL nell'editor Transact-SQL affinché corrispondano a quelle seguenti:

/*
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

Scegliere Salva tutto dal menu File.

A questo punto, è possibile procedere all'esecuzione dei test.

Per eseguire gli unit test del database

In Visualizzazione test fare clic con il pulsante destro del mouse su Sales_uspCancelOrderTest e scegliere Esegui selezione.
I risultati vengono visualizzati nella finestra Risultati test.

Il test ha esito negativo e viene visualizzato l'errore seguente:

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

A questo punto, è possibile procedere alla modifica del codice per indicare che l'eccezione è prevista.

Per modificare il codice per lo unit test

In Esplora soluzioni espandere TestProject1, fare clic con il pulsante destro del mouse su DatabaseUnitTests1.cs, quindi scegliere Visualizza codice.
Nell'editor del codice, passare al metodo Sales_uspCancelOrderTest. Modificare gli attributi del metodo affinché corrispondano al codice seguente:
```
        [TestMethod(), ExpectedSqlException(Severity=16, MatchFirstError=false, State=1)]
        public void Sales_uspCancelOrderTest()
```
Si specifica che è prevista un'eccezione SQL specifica. È eventualmente possibile specificare un numero di errore. Se non si aggiunge questo attributo, lo unit test avrà esito negativo è nella finestra Risultati test verrà visualizzato un messaggio
Scegliere Salva DatabaseUnitTests1.cs dal menu File.

A questo punto, è possibile eseguire nuovamente lo unit test per verificare che abbia esito negativo come previsto.

Per eseguire nuovamente gli unit test del database

In Visualizzazione test fare clic con il pulsante destro del mouse su Sales_uspCancelOrderTest e scegliere Esegui selezione.
I risultati vengono visualizzati nella finestra Risultati test.

Il test ha esito positivo, il che significa che la stored procedure non è riuscita come previsto.

Passaggi successivi

In un progetto tipico, verrebbero definiti ulteriori unit test per verificare che tutti gli oggetti di database critici funzionino correttamente. Una volta completato il set di test, questi ultimi verrebbero archiviati nel controllo della versione affinché possano essere condivisi con il team.

Dopo avere stabilito una linea di base, è possibile creare e modificare oggetti di database e quindi creare test associati per verificare se una modifica può compromettere il comportamento previsto.

Vedere anche

Attività

Procedura: creare uno unit test del database vuoto

Procedura: configurare l'esecuzione di unit test del database

Concetti

Creazione e definizione di unit test del database

Verifica del codice del database tramite unit test

Generazione di dati di test per i database tramite generatori di dati

Condividi tramite

Procedura dettagliata: creazione ed esecuzione di uno unit test del database

Prerequisiti

Creare uno script contenente uno schema del database

Per creare uno script da cui sia possibile importare uno schema

Creare un progetto di database e importare uno schema

Per creare un progetto di database

Per importare uno schema di database da uno script

Per esaminare il progetto risultante

Distribuzione in un ambiente di sviluppo isolato

Per configurare e compilare il progetto di database

Per distribuire il progetto di database

Creare unit test del database

Per creare uno unit test del database per le stored procedure

Definire la logica del test

Per scrivere lo unit test del database per uspNewCustomer

Per scrivere lo unit test del database per uspPlaceNewOrder

Per scrivere lo unit test del database per uspFillOrder

Per scrivere lo unit test del database per uspShowOrderDetails

Eseguire unit test del database

Per eseguire gli unit test del database

Per correggere l'errore in Sales.uspFillOrder

Aggiungere uno unit test negativo

Per aggiornare la stored procedure

Per scrivere lo unit test del database per uspCancelOrder

Per eseguire gli unit test del database

Per modificare il codice per lo unit test

Per eseguire nuovamente gli unit test del database

Passaggi successivi

Vedere anche

Attività

Concetti

Risorse aggiuntive