Partager via

Procédure pas à pas : création et exécution d'un test unitaire de base de données

  • Article

Dans cette procédure pas à pas, vous allez créé un test unitaire de base de données qui vérifie le comportement de plusieurs procédures stockées. Vous créez des tests unitaires de base de données pour mieux identifier les erreurs de code susceptibles de provoquer un comportement anormal des applications. Vous pouvez exécuter des tests unitaires de base de données et des tests d'application dans le cadre d'une suite automatisée de tests.

Dans cette procédure pas à pas, vous allez effectuer les tâches suivantes :

  • Créer un script qui contient un schéma de la base de données

  • Créer un projet de base de données et importer le schéma

  • Déployer le projet de base de données dans un environnement de développement isolé

  • Créer des tests unitaires de base de données

  • Définir la logique des tests

  • Exécuter des tests unitaires de base de données

  • Ajouter un test unitaire négatif

Si l'un des tests unitaires détecte une erreur dans une procédure stockée, corrigez-la et exécutez le test à nouveau.

Composants requis

Pour effectuer cette procédure pas à pas, vous devez être en mesure de vous connecter à un serveur de base de données pour lequel vous disposer des autorisations de créer et de déployer une base de données. Pour plus d'informations, consultez Autorisations requises pour les fonctionnalités de base de données de Visual Studio.

Créer un script qui contient un schéma de la base de données

Pour créer un script duquel vous pouvez importer un schéma

  1. Dans le menu Fichier, pointez sur Nouveau, puis cliquez sur Fichier.

    La boîte de dialogue Nouveau fichier s'affiche.

  2. Dans la liste Catégories, cliquez sur la catégorie Général si elle n'est pas déjà sélectionnée.

  3. Dans la liste Modèles, cliquez sur Fichier Sql, puis sur Ouvrir.

    L'éditeur Transact-SQL s'ouvre.

  4. Copiez le code Transact-SQL suivant et collez-le dans l'éditeur 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

  5. Dans le menu Fichier, cliquez sur Enregistrer SqlQuery_1.sql sous.

    La boîte de dialogue Enregistrer le fichier sous apparaît.

  6. Dans Nom de l'objet, tapez SampleImportScript.sql.

    Vous pouvez enregistrer le fichier dans un emplacement quelconque sur votre ordinateur. Prenez note de l'emplacement car vous allez utiliser ce script dans la procédure suivante.

  7. Cliquez sur Enregistrer.

  8. Dans le menu Fichier, cliquez sur Fermer la solution.

    Ensuite, créez un projet de base de données et importez le schéma depuis le script que vous avez créé.

Créer un projet de base de données et importer un schéma

Pour créer un projet de base de données

  1. Dans le menu Fichier, pointez sur Nouveau, puis cliquez sur Projet.

    La boîte de dialogue Nouveau projet s'affiche.

  2. Sous Modèles installés, développez le nœud Base de données, puis cliquez sur SQL Server.

    Notes

    Si vous utilisez Visual Studio Professional, regardez plutôt sous Modèles installés, développez le nœud Base de données , développez le nœud SQL Server et cliquez sur Avancé.

  3. Dans la liste des modèles, cliquez sur Projet de base de données SQL Server 2008.

    Notes

    Si vous envisagez de déployer votre base de données vers une version différente de la base de données, choisissez plutôt le modèle qui correspond à votre serveur cible.

  4. Dans Nom, tapez SimpleUnitTestDB.

  5. Activez la case à cocher Créer le répertoire pour la solution si elle ne l'est pas déjà.

  6. Désactivez la case à cocher Ajouter au contrôle de code source si elle ne l'est pas déjà, puis cliquez sur OK.

    Le projet de base de données est créé et s'affiche dans l'Explorateur de solutions. Vous importez ensuite le schéma de base de données à partir d'un script.

Pour importer un schéma de base de données à partir d'un script

  1. Dans le menu Projet, cliquez sur Importer le script.

  2. Cliquez sur Suivante après avoir lu la page d'accueil.

  3. Cliquez sur Parcourir et indiquez le chemin d'accès où vous avez enregistré le fichier SampleImportScript.sql.

  4. Double-cliquez sur le fichier SampleImportScript.sql et cliquez sur Terminer.

    Le script est importé, et les objets définis dedans sont ajoutés à votre projet de base de données.

  5. Examinez le résumé, puis cliquez sur Terminer pour finaliser l'opération.

    Notes

    La procédure Sales.uspFillOrder contient une erreur de codage intentionnelle que vous allez détecter et corriger, plus loin dans cette procédure.

Pour examiner le projet résultant

  1. Dans l'Explorateur de solutions, développez le nœud enfant Objets de schéma.

  2. Accédez aux sous-nœuds du nœud Objets de schéma dans la hiérarchie.

    L'Explorateur de solutions contient les fichiers qui définissent les objets de la base de données.

  3. Dans le menu Affichage, cliquez sur Vue Schéma de base de données.

  4. Dans la vue Schéma, développez le nœud SimpleUnitTestDB.

  5. Accédez aux sous-nœuds du nœud SimpleUnitTestDB dans la hiérarchie.

    La vue Schéma contient les objets définis dans les fichiers qui apparaissent dans l'Explorateur de solutions.

Déploiement dans un environnement de développement isolé

Ensuite, déployez le projet pour créer une base de données contenant le schéma importé, mais aucune donnée. Vous créez cette base de données dans un environnement de développement isolé (ou bac à sable) afin de pouvoir développer et tester la base de données sans avoir à intervenir ailleurs.

Pour configurer et générer le projet de base de données

  1. Dans l'Explorateur de solutions, cliquez sur le projet de base de données SimpleUnitTestDB.

  2. Dans le menu Projet, cliquez sur Propriétés SimpleUnitTestDB.

    La boîte de dialogue des propriétés du projet s'affiche.

  3. Cliquez sur l'onglet Déployer.

  4. Dans la liste Configurer les paramètres de déploiement pour, cliquez sur Mon environnement de développement isolé. En configurant des paramètres pour votre environnement de développement isolé, vous pouvez appliquer d'autres paramètres de déploiement que ceux qui seront utilisés dans vos autres environnements, tels que le serveur de transit ou de production.

  5. Dans la liste Action de déploiement, cliquez sur Créer un script de déploiement (.sql) et le déployer vers la base de données.

  6. Dans Paramètres de la base de données cible, cliquez sur Modifier.

    La boîte de dialogue Propriétés de connexion s'affiche.

  7. Définissez les propriétés de connexion pour la base de données que vous voulez créer, puis cliquez sur OK.

    Dans la zone Connexion cible, la chaîne de connexion correcte s'affiche.

    Avertissement

    Vous devez créer la base de données sur un serveur de test, un serveur de développement ou sur votre ordinateur local. Vous ne devez pas spécifier votre serveur de production.

  8. Dans Nom de la base de données cible, tapez SimpleUnitTestDB.

  9. En regard de Fichier de configuration de déploiement, cliquez sur Modifier.

  10. Désactivez la case à cocher Bloquer le déploiement incrémentiel si une perte de données peut se produire.

    Notes

    Pour cette procédure pas à pas, vous allez tester les procédures stockées en les comparant avec une base de données vide que vous déployez dans le cadre du test unitaire de base de données. Vous n'allez pas conserver de données existantes dans la mesure où vous allez tester les procédures stockées dans votre environnement de développement isolé.

  11. Dans le menu Fichier, cliquez sur Enregistrer tout.

  12. Dans le menu Générer, cliquez sur Générer la solution.

    Les propriétés que vous venez de définir déterminent la façon dont le script de déploiement est généré. L'état de la génération apparaît dans la fenêtre Sortie, et Génération : 1 a réussi ou est à jour doit apparaître sur la dernière ligne.

    Notes

    Si la fenêtre Sortie n'apparaît pas, ouvrez le menu Affichage et cliquez sur Sortie.

Pour déployer le projet de base de données

  1. Dans l'Explorateur de solutions, cliquez sur le projet de base de données SimpleUnitTestDB.

  2. Dans le menu Générer, cliquez sur Déployer SimpleUnitTestDB.

    Avertissement

    Vous devez exécuter ce déploiement sur un serveur de test, un serveur de développement ou votre ordinateur local. Vous ne devez pas spécifier votre serveur de production.

    Le projet de base de données est déployé vers une nouvelle base de données. L'état du déploiement s'affiche dans la fenêtre Sortie et Déploiement : 1 a réussi doit apparaître sur la dernière ligne. Vous pouvez définir un plan de génération de données pour créer les données de test dans votre base de données. Pour cette procédure pas à pas, vous allez tester une base de données simple pour laquelle vous n'avez pas besoin de générer des données.

Créer des tests unitaires de base de données

Pour créer un test unitaire de base de données pour les procédures stockées

  1. Dans le menu Affichage, cliquez sur Vue Schéma de base de données.

  2. Dans la vue Schéma, développez les nœuds Schémas, Sales, Programmabilité et Procédures stockées.

  3. Cliquez avec le bouton droit sur la procédure stockée uspNewCustomer et cliquez sur Créer des tests unitaires.

    La boîte de dialogue Créer des tests unitaires s'affiche.

  4. Activez les cases à cocher des cinq procédures stockées : Sales.uspCancelOrder, Sales.uspFillOrder, Sales.uspNewCustomer, Sales.uspPlaceNewOrder et Sales.uspShowOrderDetails.

  5. Dans Projet, cliquez sur Créer un nouveau projet de test Visual C#.

  6. Acceptez les noms par défaut pour le nom du projet et le nom de la classe, puis cliquez sur OK.

    La boîte de dialogue Configuration du projet 'TestProject1' s'affiche.

  7. Dans Exécuter les tests unitaires en utilisant la connexion de données suivante, spécifiez une connexion à la base de données que vous avez déployée précédemment, dans cette procédure pas à pas.

    Notes

    Si vous devez tester des vues ou des procédures stockées associées à des autorisations limitées, vous indiquez en principe cette connexion à cette étape. Ensuite, vous définissez la connexion secondaire, avec des autorisations plus étendues, afin de valider le test. Si vous avez une connexion secondaire, vous devez ajouter cet utilisateur au projet de base de données et créer un nom de connexion pour cet utilisateur dans le script de prédéploiement.

  8. Dans Déploiement, activez la case à cocher Déployer automatiquement le projet de base de données avant d'exécuter les tests.

  9. Dans Projet de base de données, cliquez sur SimpleUnitTestDB.dbproj.

  10. Dans Configuration de déploiement, cliquez sur Débogage.

    Vous pouvez aussi générer des données de test dans le cadre de vos tests unitaires de base de données. Pour cette procédure pas à pas, vous allez ignorer cette étape car les tests créeront leurs propres données.

  11. Cliquez sur OK.

    Le projet de test est généré et le Concepteur de test unitaire de base de données apparaît. Ensuite, vous allez mettre à jour le test logique dans le script Transact-SQL des tests unitaires.

Définir la logique des tests

Cette base de données très simple comporte deux tables, Customer et Order. Vous mettez à jour la base de données à l'aide des procédures stockées suivantes :

  • uspNewCustomer - Cette procédure stockée ajoute un enregistrement à la table Customer, qui définit les colonnes YTDOrders et YTDSales du client sur zéro.

  • uspPlaceNewOrder - Cette procédure stockée ajoute un enregistrement à la table Orders pour le client spécifié et met à jour la valeur YTDOrders dans l'enregistrement correspondant de la table Customer.

  • uspFillOrder - Cette procédure stockée met à jour un enregistrement de la table Orders en redéfinissant l'état « O » sur « F » et incrémente le montant YTDSales dans l'enregistrement correspondant de la table Customer.

  • uspCancelOrder - Cette procédure stockée met à jour un enregistrement de la table Orders en redéfinissant l'état « O » sur « X » et décrémente le montant YTDOrders dans l'enregistrement correspondant de la table Customer.

  • uspShowOrderDetails - Cette procédure stockée joint la table Orders à la table Customer et affiche les enregistrements pour un client spécifique.

Notes

Cet exemple illustre comment créer un test unitaire de base de données simple. Dans une base de données réelle, vous pourriez additionner les montants totaux de toutes les commandes à l'état « O » ou « F » pour un client particulier. Les étapes de cette procédure pas à pas ne contiennent pas de gestion des erreurs. Par exemple, elles ne vous empêchent pas d'appeler uspFillOrder pour une commande déjà exécutée.

Les tests supposent que la base de données démarre à l'état valide. Vous allez créer des tests qui vérifient les conditions suivantes :

  • uspNewCustomer - Vérifier que la table Customer contient une ligne après avoir exécuté la procédure stockée.

  • uspPlaceNewOrder - Pour le client qui a un CustomerID de 1, passer une commande de $100. Vérifier que le montant YTDOrders de ce client est 100 et que le montant YTDSales est nul.

  • uspFillOrder - Pour le client qui a un CustomerID de 1, passer une commande de $50. Exécuter cette commande. Vérifier que les montants YTDOrders et YTDSales sont tous les deux égaux à 50.

  • uspShowOrderDetails - Pour le client qui a un CustomerID de 1, passer des commandes de $100, $50 et $5. Vérifier que uspShowOrderDetails retourne le nombre correct de colonnes et que le jeu de résultats présente le checksum prévu.

Notes

Pour un jeu complet de tests unitaires de base de données, il convient en principe de vérifier que les autres colonnes ont été correctement définies. Pour que cette procédure pas à pas ne soit pas trop longue, elle n'explique pas comment vérifier le comportement de uspCancelOrder.

Pour écrire le test unitaire de base de données pour uspNewCustomer

  1. Dans la barre de navigation du Concepteur de test unitaire de base de données, cliquez sur Sales_uspNewCustomerTest et assurez-vous que Test est mis en surbrillance dans la liste adjacente.

    Après avoir effectué cette étape, vous pouvez créer le script de test pour l'action de test dans le test unitaire.

  2. Dans l'éditeur Transact-SQL, mettez à jour les instructions Transact-SQL afin qu'elles correspondent aux suivantes :

    -- 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. Dans le volet Conditions de test, cliquez sur la condition de test Non concluant, puis sur Supprimer la condition de test (x).

  4. Dans le volet Conditions de test, cliquez sur Nombre de lignes dans la liste, puis sur Ajouter une condition de test (+).

  5. Dans la fenêtre Propriétés, affectez 1 à la propriété Nombre de lignes.

  6. Dans le menu Fichier, cliquez sur Enregistrer tout.

    Ensuite, définissez le test unitaire logique pour uspPlaceNewOrder.

Pour écrire le test unitaire de base de données pour uspPlaceNewOrder

  1. Dans la barre de navigation du Concepteur de test unitaire de base de données, cliquez sur Sales_uspPlaceNewOrderTest et assurez-vous que ce Test est mis en surbrillance dans la liste adjacente.

    Après avoir effectué cette étape, vous pouvez créer le script de test pour l'action de test dans le test unitaire.

  2. Dans l'éditeur Transact-SQL, mettez à jour les instructions Transact-SQL afin qu'elles correspondent aux suivantes :

    -- 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. Dans le volet Conditions de test, cliquez sur la condition de test Non concluant, puis sur Supprimer la condition de test (x).

  4. Dans le volet Conditions de test, cliquez sur Valeur scalaire dans la liste, puis sur Ajouter une condition de test (+).

  5. Dans la fenêtre Propriétés, affectez à la propriété Valeur attendue la valeur 100.

  6. Dans la barre de navigation du Concepteur de test unitaire de base de données, cliquez sur Sales_uspPlaceNewOrderTest et assurez-vous que ce Pré-test est mis en surbrillance dans la liste adjacente.

    Après avoir effectué cette étape, vous pouvez spécifier les instructions qui font passer vos données à l'état requis pour exécuter votre test. Pour cet exemple, vous devez créer l'enregistrement Customer avant de passer une commande.

  7. Cliquez sur Cliquer ici pour créer pour créer un script de prétest.

  8. Dans l'éditeur Transact-SQL, mettez à jour les instructions Transact-SQL afin qu'elles correspondent aux suivantes :

    /*
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. Dans le menu Fichier, cliquez sur Enregistrer tout.

    Ensuite, vous créez le test unitaire pour uspFillOrder.

Pour écrire le test unitaire de base de données pour uspFillOrder

  1. Dans la barre de navigation du Concepteur de test unitaire de base de données, cliquez sur Sales_uspFillOrderTest et assurez-vous que Test est mis en surbrillance dans la liste adjacente.

    Après avoir effectué cette étape, vous pouvez créer le script de test pour l'action de test dans le test unitaire.

  2. Dans l'éditeur Transact-SQL, mettez à jour les instructions Transact-SQL afin qu'elles correspondent aux suivantes :

    -- 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. Dans le volet Conditions de test, cliquez sur la condition de test Non concluant, puis sur Supprimer la condition de test (x).

  4. Dans le volet Conditions de test, cliquez sur Valeur scalaire dans la liste, puis sur Ajouter une condition de test (+).

  5. Dans la fenêtre Propriétés, affectez à la propriété Valeur attendue la valeur 100.

  6. Dans la barre de navigation du Concepteur de test unitaire de base de données, cliquez sur Sales_uspFillOrderTest et assurez-vous que Pré-test est mis en surbrillance dans la liste adjacente. Après avoir effectué cette étape, vous pouvez spécifier les instructions qui font passer vos données à l'état requis pour exécuter votre test. Pour cet exemple, vous devez créer l'enregistrement Customer avant de passer une commande.

  7. Cliquez sur Cliquer ici pour créer pour créer un script de prétest.

  8. Dans l'éditeur Transact-SQL, mettez à jour les instructions Transact-SQL afin qu'elles correspondent aux suivantes :

    /*
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. Dans le menu Fichier, cliquez sur Enregistrer tout.

    À ce stade, vous êtes prêt à exécuter vos tests.

Pour écrire le test unitaire de base de données pour uspShowOrderDetails

  1. Dans la barre de navigation du Concepteur de test unitaire de base de données, cliquez sur Sales_uspShowOrderDetailsTest et assurez-vous que Test est mis en surbrillance dans la liste adjacente.

    Après avoir effectué cette étape, vous pouvez créer le script de test pour l'action de test dans le test unitaire.

  2. Dans l'éditeur Transact-SQL, mettez à jour les instructions Transact-SQL afin qu'elles correspondent aux suivantes :

    -- 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. Dans le volet Conditions de test, cliquez sur la condition de test Non concluant, puis sur Supprimer la condition de test (x).

  4. Dans le volet Conditions de test, cliquez sur Schéma attendu dans la liste, puis sur Ajouter une condition de test (+).

  5. Dans la fenêtre Propriétés, dans la propriété Configuration, cliquez sur le bouton Parcourir ('...').

  6. Dans la boîte de dialogue Configuration de expectedSchemaCondition1, spécifiez une connexion à votre base de données.

  7. Cliquez sur Récupérer.

    Le corps Transact-SQL de votre test unitaire est exécuté, et le schéma obtenu s'affiche dans la boîte de dialogue. Étant donné que le code de pré-test n'a pas été exécuté, aucune donnée n'est retournée. Puisque vous vérifiez uniquement le schéma mais pas les données, cela ne pose pas de problème.

  8. Cliquez sur OK.

    Le schéma attendu est stocké avec la condition de test.

  9. Dans la barre de navigation du Concepteur de test unitaire de base de données, cliquez sur Sales_uspShowOrderDetailsTest et assurez-vous que Test est mis en surbrillance dans la liste adjacente. Après avoir effectué cette étape, vous pouvez spécifier les instructions qui font passer vos données à l'état requis pour exécuter votre test. Pour cet exemple, vous devez créer l'enregistrement Customer avant de passer une commande.

  10. Cliquez sur Cliquer ici pour créer pour créer un script de prétest.

  11. Dans l'éditeur Transact-SQL, mettez à jour les instructions Transact-SQL afin qu'elles correspondent aux suivantes :

    /*
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. Dans la barre de navigation du Concepteur de test unitaire de base de données, cliquez sur Sales_uspShowOrderDetailsTest, puis sur Test dans la liste adjacente.

    Vous devez effectuer ce test car il convient d'appliquer la condition de checksum au test, et non pas au pré-test.

  13. Dans le volet Conditions de test, cliquez sur Checksum des données dans la liste, puis sur Ajouter une condition de test (+).

  14. Dans la fenêtre Propriétés, dans la propriété Configuration, cliquez sur le bouton Parcourir ('...').

  15. Dans la boîte de dialogue Configuration de checksumCondition1, spécifiez une connexion à votre base de données.

  16. Remplacez le code Transact-SQL dans la boîte de dialogue par le code suivant :

    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;

    Ce code combine le code Transact-SQL du pré-test avec le code Transact-SQL du test lui-même. Vous avez besoin des deux pour retourner les mêmes résultats que le test renverra lorsque vous l'exécuterez.

  17. Cliquez sur Récupérer.

    Le code Transact-SQL que vous avez spécifié est exécuté, et un checksum est calculé pour les données retournées.

  18. Cliquez sur OK.

    Le checksum calculé est stocké avec la condition de test. Le checksum attendu s'affiche dans la colonne Valeur de la condition de test Checksum des données.

  19. Dans le menu Fichier, cliquez sur Enregistrer tout.

    À ce stade, vous êtes prêt à exécuter vos tests.

Exécution de tests unitaires de base de données

Pour exécuter les tests unitaires de base de données

  1. Dans le menu Test, pointez sur Fenêtres, puis cliquez sur Affichage des tests.

  2. Dans la fenêtre Affichage des tests, cliquez sur Actualiser dans la barre d'outils pour mettre à jour la liste de tests.

    La fenêtre Affichage des tests répertorie les tests que vous avez créés dans cette procédure pas à pas et auxquels vous avez ajouté des instructions Transact-SQL et des conditions de test. Le test nommé TestMethod1 est vide et n'est pas utilisé dans cette procédure pas à pas.

  3. Cliquez avec le bouton droit sur Sales_uspNewCustomerTest, puis cliquez sur Exécuter la sélection.

    Visual Studio utilise le contexte privilégié que vous avez spécifié pour se connecter à la base de données et appliquer le plan de génération de données. Visual Studio bascule ensuite vers le contexte d'exécution avant d'exécuter le script Transact-SQL dans le test. Enfin, Visual Studio évalue les résultats du script Transact-SQL par rapport à ceux que vous avez spécifiés dans la condition de test, et un résultat de réussite ou d'échec s'affiche dans la fenêtre Résultats des tests.

  4. Afficher le résultat des tests dans la fenêtre Résultats des tests.

    Le test est réussi, ce qui signifie que l'instruction SELECT retourne une ligne lorsqu'elle est exécutée.

  5. Répétez l'étape 3 pour les tests Sales_uspPlaceNewOrderTest, Sales_uspFillOrderTest et Sales_uspShowOrderDetailsTest. Les résultats doivent être les suivants :

    Test

    Résultat attendu

    Sales_uspPlaceNewOrderTest

    Correct

    Sales_uspShowOrderDetailsTest

    Correct

    Sales_uspFillOrderTest

    Échec avec l'erreur suivante: « La condition ScalarValueCondition (scalarValueCondition2) a échoué : Jeu de résultats 1 ligne 1 colonne 1 : les valeurs ne correspondent pas, réelle '-100' attendue '100'. ». Cette erreur se produit parce que la définition de la procédure stockée contient une erreur mineure.

    Vous allez donc corriger l'erreur et ré-exécuter votre test.

Pour corriger l'erreur du test Sales.uspFillOrder

  1. Dans la vue Schéma, double-cliquez sur la procédure stockée uspFillOrder pour ouvrir sa définition dans l'éditeur Transact-SQL.

  2. Dans la définition, recherchez l'instruction Transact-SQL suivante :

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

  3. Modifiez la clause SET de l'instruction de sorte à la faire correspondre à l'instruction suivante :

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

  4. Dans le menu Fichier, cliquez sur Enregistrer uspFillOrder.proc.sql.

  5. Dans Affichage des tests, cliquez avec le bouton droit sur Sales_uspFillOrderTest, puis cliquez sur Exécuter la sélection.

    Le test est réussi.

Ajouter un test unitaire négatif

Vous pouvez créer un test négatif pour vérifier qu'un test échoue lorsqu'il doit effectivement échouer. Par exemple, si vous essayez d'annuler une commande qui a déjà été exécutée, le test doit en théorie échouer. Dans cette partie de la procédure pas à pas, vous créez un test unitaire négatif pour la procédure stockée Sales.uspCancelOrder.

Pour créer et vérifier un test négatif, vous devez effectuer les tâches suivantes :

  • Mettre à jour la procédure stockée pour tester les conditions d'échec

  • Définir un nouveau test unitaire

  • Modifier le code du test unitaire pour indiquer que son échec est attendu

  • Exécuter le test unitaire

Pour mettre à jour la procédure stockée

  1. Dans la vue Schéma, développez les nœuds SimpleUnitTestDB, Schémas, Sales, Programmabilité, Procédures stockées, puis double-cliquez sur uspCancelOrder.

  2. Dans l'éditeur Transact-SQL, mettez à jour la définition de la procédure en intégrant le code suivant :

    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. Dans le menu Fichier, cliquez sur Enregistrer uspCancelOrder.proc.sql.

  4. Dans l'Explorateur de solutions, cliquez avec le bouton droit sur SimpleUnitTestDB, puis cliquez sur Déployer.

    Vous déployez les mises à jour dans la procédure stockée uspCancelOrder. Vous n'avez pas modifié d'autres objets, par conséquent, seule cette procédure stockée est mise à jour.

    Ensuite, vous allez définir le test unitaire associé à cette procédure.

Pour écrire le test unitaire de base de données pour uspCancelOrder

  1. Dans la barre de navigation du Concepteur de test unitaire de base de données, cliquez sur Sales_uspCancelOrderTest et assurez-vous que Test est mis en surbrillance dans la liste adjacente.

    Après avoir effectué cette étape, vous pouvez créer le script de test pour l'action de test dans le test unitaire.

  2. Dans l'éditeur Transact-SQL, mettez à jour les instructions Transact-SQL afin qu'elles correspondent aux suivantes :

    -- 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. Dans le volet Conditions de test, cliquez sur la condition de test Non concluant, puis sur Supprimer la condition de test (x).

  4. Dans le volet Conditions de test, cliquez sur Valeur scalaire dans la liste, puis sur Ajouter une condition de test (+).

  5. Dans la fenêtre Propriétés, affectez à la propriété Valeur attendue la valeur 0.

  6. Dans la barre de navigation du Concepteur de test unitaire de base de données, cliquez sur Sales_uspCancelOrderTest et assurez-vous que Pré-test est mis en surbrillance dans la liste adjacente. Après avoir effectué cette étape, vous pouvez spécifier les instructions qui font passer vos données à l'état requis pour exécuter votre test. Pour cet exemple, vous devez créer l'enregistrement Customer avant de passer une commande.

  7. Cliquez sur Cliquer ici pour créer pour créer un script de prétest.

  8. Dans l'éditeur Transact-SQL, mettez à jour les instructions Transact-SQL afin qu'elles correspondent aux suivantes :

    /*
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. Dans le menu Fichier, cliquez sur Enregistrer tout.

    À ce stade, vous êtes prêt à exécuter vos tests.

Pour exécuter les tests unitaires de base de données

  1. Dans Affichage des tests, cliquez avec le bouton droit sur Sales_uspCancelOrderTest, puis cliquez sur Exécuter la sélection.

  2. Afficher le résultat des tests dans la fenêtre Résultats des tests.

    Le test échoue, et l'erreur suivante s'affiche :

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

    Ensuite, modifiez le code pour indiquer que l'exception est attendue.

Pour modifier le code du test unitaire

  1. Dans l'Explorateur de solutions, développez TestProject1, cliquez avec le bouton droit sur DatabaseUnitTests1.cset cliquez sur Afficher le code.

  2. Dans l'éditeur de code, naviguez jusqu'à la méthode Sales_uspCancelOrderTest. Modifiez les attributs de la méthode de manière à intégrer le code suivant :

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

    Indiquez qu'une exception SQL spécifique est le résultat attendu. Vous pouvez éventuellement spécifier un numéro d'erreur particulier. Si vous n'ajoutez pas cet attribut, le test unitaire échoue, et un message s'affiche dans la fenêtre Résultats des tests.

  3. Dans le menu Fichier, cliquez sur Enregistrer DatabaseUnitTests1.cs.

    Ensuite, ré-exécutez votre test unitaire pour vérifier qu'il échoue selon le résultat attendu.

Pour ré-exécuter les tests unitaires de base de données

  1. Dans Affichage des tests, cliquez avec le bouton droit sur Sales_uspCancelOrderTest, puis cliquez sur Exécuter la sélection.

  2. Afficher le résultat des tests dans la fenêtre Résultats des tests.

    Le test est réussi, ce qui signifie que la procédure a échoué comme elle était censée le faire.

Étapes suivantes

Dans un projet classique, vous définiriez des tests unitaires supplémentaires afin de vérifier que tous les objets de base de données critiques fonctionnent correctement. Lorsque le jeu de tests est terminé, vous vérifiez ces tests dans le contrôle de version pour les partager avec l'équipe.

Après avoir établi des données de base, vous pouvez créer et modifier des objets de base de données, puis créer des tests associés pour vérifier si une modification est susceptible d'annuler le comportement attendu.

Voir aussi

Tâches

Comment : créer un test unitaire de base de données vide

Comment : configurer l'exécution de tests unitaires de base de données

Concepts

Création et définition de tests unitaires de base de données

Vérification du code de base de données à l'aide de tests unitaires

Génération de données de test pour des bases de données à l'aide de générateurs de données