Exemplarische Vorgehensweise: Erstellen und Ausführen eines Datenbankkomponententests

In dieser exemplarischen Vorgehensweise erstellen Sie einen Datenbankkomponententest, mit dem das Verhalten mehrerer gespeicherter Prozeduren überprüft wird. Sie erstellen Datenbankkomponententests, um das Ermitteln von Codefehlern zu erleichtern, die zu fehlerhaftem Anwendungsverhalten führen können. Datenbankkomponententests und Anwendungstests können Sie als Teil einer automatisierten Testsuite ausführen.

Im Verlauf dieser exemplarischen Vorgehensweise führen Sie folgende Aufgaben aus:

Erstellen eines Skripts mit einem Datenbankschema
Erstellen eines Datenbankprojekts und Importieren dieses Schemas
Erstellen des Datenbankprojekts für eine isolierte Entwicklungsumgebung
Erstellen eines Datenbankkomponententests
Definieren der Testlogik
Ausführen von Datenbankkomponententests
Hinzufügen eines negativen Komponententests

Wenn bei einem Komponententest ein Fehler in einer gespeicherten Prozedur ermittelt wurde, korrigieren Sie diesen Fehler, und führen Sie den Test erneut aus.

Vorbereitungsmaßnahmen

Zum Ausführen dieser exemplarischen Vorgehensweise müssen Sie eine Verbindung mit einem Datenbankserver herstellen können, auf dem Sie über Berechtigungen zum Erstellen und Bereitstellen einer Datenbank verfügen. Weitere Informationen finden Sie unter Erforderliche Berechtigungen für Datenbankfunktionen von Visual Studio.

Erstellen eines Skripts mit einem Datenbankschema

So erstellen Sie ein Skript, aus dem Sie ein Schema importieren können

Zeigen Sie im Menü Datei auf Neu, und klicken Sie auf Datei.

Das Dialogfeld Neue Datei wird angezeigt.
Klicken Sie in der Liste Kategorien auf Allgemein, wenn dieser Eintrag nicht bereits hervorgehoben ist.
Klicken Sie in der Liste Vorlagen auf SQL-Datei und dann auf Öffnen.

Der Transact-SQL-Editor wird geöffnet.

Kopieren Sie den folgenden Transact-SQL-Code, und fügen Sie diesen in den Transact-SQL-Editor ein.

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

Klicken Sie im Menü Datei auf SqlQuery_1.sql speichern unter.

Das Dialogfeld Datei speichern unter wird angezeigt.
Geben Sie in Objektname den Dateinamen SampleImportScript.sql ein.

Sie können die Datei an einem beliebigen Speicherort auf dem Computer speichern. Notieren Sie sich den Speicherort, da Sie dieses Skript in der nächsten Prozedur verwenden müssen.
Klicken Sie auf Speichern.
Klicken Sie im Menü Datei auf Projektmappe schließen.

Danach erstellen Sie ein Datenbankprojekt und importieren das Schema aus dem erstellten Skript.

Erstellen eines Datenbankprojekts und Importieren eines Schemas

So erstellen Sie ein Datenbankprojekt

Zeigen Sie im Menü Datei auf Neu, und klicken Sie auf Projekt.

Das Dialogfeld Neues Projekt wird angezeigt.
Erweitern Sie unter Installierte Vorlagen den Knoten Datenbank, und klicken Sie dann auf SQL Server.

Tipp

Navigieren Sie bei Verwendung von Visual Studio Professional stattdessen zu Installierte Vorlagen, erweitern Sie den Knoten Datenbank, erweitern Sie den Knoten SQL Server, und klicken Sie anschließend auf Erweitert.
Klicken Sie in der Liste der Vorlagen auf SQL Server 2008-Datenbankprojekt.

Tipp

Wenn Sie die Datenbank in einer anderen Datenbankversion bereitstellen möchten, wählen Sie stattdessen die dem Zielserver entsprechende Vorlage aus.
Geben Sie unter Name den Namen SimpleUnitTestDB ein.
Aktivieren Sie ggf. das Kontrollkästchen Projektmappenverzeichnis erstellen.
Deaktivieren Sie ggf. das Kontrollkästchen Zur Quellcodeverwaltung hinzufügen, und klicken Sie auf OK.

Das Datenbankprojekt wird erstellt und im Projektmappen-Explorer angezeigt. Importieren Sie anschließend das Datenbankschema aus einem Skript.

So importieren Sie ein Datenbankschema aus einem Skript

Klicken Sie im Menü Projekt auf Skript importieren.
Klicken Sie auf Weiter, nachdem Sie die Willkommensseite gelesen haben.
Klicken Sie auf Durchsuchen, und geben Sie den Pfad an, unter dem Sie die Datei SampleImportScript.sql gespeichert haben.
Doppelklicken Sie auf die Datei SampleImportScript.sql, und klicken Sie auf Fertig stellen.

Das Skript wird importiert, und die in diesem Skript definierten Objekte werden dem Datenbankprojekt hinzugefügt.
Überprüfen Sie die Zusammenfassung, und klicken Sie dann auf Fertig stellen, um den Vorgang abzuschließen.

Tipp

Die Prozedur Sales.uspFillOrder enthält einen absichtlichen Codierungsfehler, den Sie weiter unten ermitteln und korrigieren.

So überprüfen Sie das resultierende Projekt

Erweitern Sie im Projektmappen-Explorer den untergeordneten Knoten Schemaobjekte.
Betrachten Sie die untergeordneten Knoten unter dem Knoten Schemaobjekte in der Hierarchie.

Der Projektmappen-Explorer enthält die Dateien, die die Datenbankobjekte definieren.
Klicken Sie im Menü Ansicht auf Schemaansicht der Datenbank.
Erweitern Sie in der Schemaansicht den Knoten SimpleUnitTestDB.
Betrachten Sie die untergeordneten Knoten unter dem Knoten SimpleUnitTestDB in der Hierarchie.

Die Schemaansicht enthält die Objekte, die in den Dateien definiert sind, die im Projektmappen-Explorer angezeigt werden.

Bereitstellen einer isolierten Entwicklungsumgebung

Stellen Sie anschließend das Projekt bereit, um eine Datenbank mit dem importierten Schema, aber ohne Daten zu erstellen. Diese Datenbank erstellen Sie in einer isolierten Entwicklungsumgebung (oder Sandbox), sodass Sie die Datenbank ohne Einfluss anderer Aufgaben entwickeln und testen können.

So konfigurieren und erstellen Sie das Datenbankprojekt

Klicken Sie im Projektmappen-Explorer auf das Datenbankprojekt SimpleUnitTestDB.
Klicken Sie im Menü Projekt auf Eigenschaften von SimpleUnitTestDB.

Das Eigenschaftendialogfeld für das Projekt wird angezeigt.
Klicken Sie auf die Registerkarte Bereitstellen.
Klicken Sie in der Liste Bereitstellungseinstellungen konfigurieren für auf Meine isolierte Entwicklungsumgebung. Wenn Sie Einstellungen für die isolierte Entwicklungsumgebung konfigurieren, können Sie andere Bereitstellungseinstellungen verwenden als für andere Umgebungen, z. B. den Bereitstellungs- oder Produktionsserver.
Klicken Sie in der Liste Bereitstellungsvorgang auf Bereitstellungsskript erstellen und in Datenbank bereitstellen (.sql).
Klicken Sie unter Einstellungen für die Zieldatenbank auf Bearbeiten.

Das Dialogfeld Verbindungseigenschaften wird angezeigt.
Legen Sie die Verbindungseigenschaften für die zu erstellende Datenbank fest, und klicken Sie dann auf OK.

Im Feld Zielverbindung wird die richtige Verbindungszeichenfolge angezeigt.

Warnung

Sie sollten die neue Datenbank auf einem Testserver, einem Entwicklungsserver oder auf dem lokalen Computer erstellen. Der Produktionsserver sollte nicht angegeben werden.
Geben Sie unter Zieldatenbankname den Namen SimpleUnitTestDB ein.
Klicken Sie neben Name der Bereitstellungskonfiguration auf Bearbeiten.
Deaktivieren Sie das Kontrollkästchen Inkrementelle Bereitstellung blockieren, wenn Datenverlust auftreten könnte.

Tipp

In dieser exemplarischen Vorgehensweise testen Sie die gespeicherten Prozeduren anhand einer leeren Datenbank, die Sie als Teil des Datenbankkomponententests bereitstellen. Sie müssen keine vorhandenen Daten beibehalten, da Sie die gespeicherten Prozeduren in der isolierten Entwicklungsumgebung testen.
Klicken Sie im Menü Datei auf Alle speichern.
Klicken Sie im Menü Erstellen auf Projektmappe erstellen.

Die eben festgelegten Eigenschaften bestimmen, wie das Bereitstellungsskript erstellt wird. Der Status des Builds wird im Fenster Ausgabe angezeigt, und die letzte Zeile sollte Build: 1 erfolgreich oder aktuell lauten.

Tipp

Wird das Ausgabefenster nicht angezeigt, öffnen Sie das Menü Ansicht, und klicken Sie auf Ausgabe.

So stellen Sie das Datenbankprojekt bereit

Klicken Sie im Projektmappen-Explorer auf das Datenbankprojekt SimpleUnitTestDB.
Klicken Sie im Menü Erstellen auf SimpleUnitTestDB bereitstellen.

Warnung

Sie sollten diese Bereitstellung auf einem Testserver, einem Entwicklungsserver oder dem lokalen Computer ausführen. Der Produktionsserver sollte nicht angegeben werden.

Das Datenbankprojekt wird in einer neuen Datenbank bereitgestellt. Der Status der Bereitstellung wird im Ausgabefenster angezeigt, wobei die letzte Zeile Bereitstellung: 1 erfolgreich lauten sollte. Sie können einen Datengenerierungsplan definieren, um Testdaten in der Datenbank zu erstellen. In dieser exemplarischen Vorgehensweise testen Sie eine ganz einfache Datenbank, für die Sie keine Daten generieren müssen.

Erstellen eines Datenbankkomponententests

So erstellen Sie einen Datenbankkomponententest für gespeicherte Prozeduren

Klicken Sie im Menü Ansicht auf Schemaansicht der Datenbank.
Erweitern Sie in der Schemaansicht nacheinander die Knoten Schemas, Sales, Programmierung und Gespeicherte Prozeduren.
Klicken Sie mit der rechten Maustaste auf die gespeicherte Prozedur uspNewCustomer, und klicken Sie auf Komponententests erstellen.

Das Dialogfeld Komponententests erstellen wird angezeigt.
Aktivieren Sie die Kontrollkästchen für alle fünf gespeicherten Prozeduren: Sales.uspCancelOrder, Sales.uspFillOrder, Sales.uspNewCustomer, Sales.uspPlaceNewOrder und Sales.uspShowOrderDetails.
Klicken Sie unter Projekt auf Neues Visual C#-Testprojekt erstellen.
Übernehmen Sie die Standardnamen für das Projekt und die Klasse, und klicken Sie dann auf OK.

Das Dialogfeld Konfiguration des Projekts 'TestProject' wird angezeigt.
Geben Sie unter Komponententests unter Verwendung folgender Datenverbindung ausführen eine Verbindung mit der Datenbank an, die Sie zuvor in dieser exemplarischen Vorgehensweise bereitgestellt haben.

Tipp

Wenn Sie Ansichten oder gespeicherte Prozeduren mit eingeschränkten Berechtigungen testen müssen, geben Sie in diesem Schritt normalerweise diese Verbindung an. Dann geben Sie die sekundäre Verbindung mit weiteren Berechtigungen an, um den Test zu überprüfen. Bei einer sekundären Verbindung sollten Sie dem Datenbankprojekt diesen Benutzer hinzufügen und für diesen im Skript vor der Bereitstellung Anmeldeinformationen erstellen.
Aktivieren Sie unter Bereitstellung das Kontrollkästchen Datenbankprojekt automatisch vor dem Ausführen von Komponententests bereitstellen.
Klicken Sie unter Datenbankprojekt auf SimpleUnitTestDB.dbproj.
Klicken Sie unter Bereitstellungskonfiguration auf Debuggen.

Sie können auch Testdaten als Teil der Datenbankkomponententests generieren. In dieser exemplarischen Vorgehensweise überspringen Sie diesen Schritt, da in den Tests eigene Daten erstellt werden.
Klicken Sie auf OK.

Das Testprojekt wird erstellt, und der Datenbankkomponententest-Designer wird angezeigt. Danach aktualisieren Sie die Testlogik im Transact-SQL-Skript der Komponententests.

Definieren der Testlogik

Diese sehr einfache Datenbank enthält zwei Tabellen, Customer und Order. Sie aktualisieren die Datenbank mit den folgenden gespeicherten Prozeduren:

uspNewCustomer – Diese gespeicherte Prozedur fügt der Tabelle Customer einen Datensatz hinzu, wodurch die Spalten YTDOrders und YTDSales für den Kunden auf 0 (null) festgelegt werden.
uspPlaceNewOrder – Diese gespeicherte Prozedur fügt der Tabelle Orders einen Datensatz für den angegebenen Kunden hinzu und aktualisiert den YTDOrders-Wert im entsprechenden Datensatz der Tabelle Customer.
uspFillOrder – Diese gespeicherte Prozedur aktualisiert einen Datensatz in der Tabelle Orders, indem sie den Status von 'O' in 'F' ändert, und inkrementiert die YTDSales-Menge im entsprechenden Datensatz in der Tabelle Customer.
uspCancelOrder – Diese gespeicherte Prozedur aktualisiert einen Datensatz in der Tabelle Orders, indem sie den Status von 'O' in 'X' ändert, und dekrementiert die YTDOrders-Menge im entsprechenden Datensatz in der Tabelle Customer.
uspShowOrderDetails – Diese gespeicherte Prozedur verknüpft die Tabelle Orders mit der Tabelle Customer und zeigt die Datensätze für einen bestimmten Kunden an.

Tipp

In diesem Beispiel wird veranschaulicht, wie ein einfacher Datenbankkomponententest erstellt wird. In einer realen Datenbank könnten Sie die Gesamtmengen aller Bestellungen mit dem Status 'O' oder 'F' für einen bestimmten Kunden summieren. Die Prozeduren in dieser exemplarischen Vorgehensweise umfassen auch keine Fehlerbehandlung. Sie verhindern z. B. nicht, dass Sie uspFillOrder für eine Bestellung aufrufen, die bereits erfüllt wurde.

Bei den Tests wird davon ausgegangen, dass die Datenbank in einem bereinigten Zustand gestartet wird. Sie erstellen Tests, um die folgenden Bedingungen zu überprüfen:

uspNewCustomer – Überprüfen Sie, ob die Tabelle Customer nach dem Ausführen der gespeicherten Prozedur eine einzelne Zeile enthält.
uspPlaceNewOrder – Geben Sie für den Kunden mit der CustomerID 1 eine Bestellung über 100 $ auf. Überprüfen Sie, ob die YTDOrders-Menge für diesem Kunden 100 beträgt und die YTDSales-Menge 0 (null) ist.
uspFillOrder – Geben Sie für den Kunden mit der CustomerID 1 eine Bestellung über 50 $ auf. Erfüllen Sie die Bestellung. Überprüfen Sie, ob die Mengen für YTDOrders und YTDSales jeweils 50 lauten.
uspShowOrderDetails – Geben Sie für den Kunden mit der CustomerID 1 Bestellungen über 100 $, 50 $ und 5 $ auf. Überprüfen Sie, ob uspShowOrderDetails gibt die richtige Anzahl von Spalten zurückgibt und das Resultset die erwartete Prüfsumme enthält.

Tipp

Bei einem vollständigen Satz von Datenbankkomponententests überprüfen Sie in der Regel, ob die anderen Spalten ordnungsgemäß festgelegt wurden. Um den Umfang dieser exemplarischen Vorgehensweise überschaubar zu halten, wird nicht beschrieben, wie das Verhalten von uspCancelOrder überprüft wird.

So schreiben Sie den Datenbankkomponententest für uspNewCustomer

Klicken Sie auf der Navigationsleiste des Datenbankkomponententest-Designers auf Sales_uspNewCustomerTest, und stellen Sie sicher, dass in der angrenzenden Liste der Eintrag Test ausgewählt ist.

Nachdem Sie den vorherigen Schritt ausgeführt haben, können Sie das Testskript für die Testaktion im Komponententest erstellen.

Aktualisieren Sie die Transact-SQL-Anweisungen im Transact-SQL-Editor, sodass sie mit den folgenden Anweisungen übereinstimmen:

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

Klicken Sie im Bereich Testbedingungen auf die Testbedingung Nicht eindeutig, und klicken Sie auf Testbedingung löschen (x).
Klicken Sie im Bereich Testbedingungen in der Liste auf Zeilenanzahl und dann auf Testbedingung hinzufügen (+).
Legen Sie im Eigenschaftenfenster die Eigenschaft Zeilenanzahl auf 1 fest.
Klicken Sie im Menü Datei auf Alle speichern.

Definieren Sie danach die Komponententestlogik für uspPlaceNewOrder.

So schreiben Sie den Datenbankkomponententest für uspPlaceNewOrder

Klicken Sie auf der Navigationsleiste des Datenbankkomponententest-Designers auf Sales_uspPlaceNewOrderTest, und stellen Sie sicher, dass in der angrenzenden Liste der Eintrag Test ausgewählt ist.

Nachdem Sie diesen Schritt ausgeführt haben, können Sie das Testskript für die Testaktion im Komponententest erstellen.

Aktualisieren Sie die Transact-SQL-Anweisungen im Transact-SQL-Editor, sodass sie mit den folgenden Anweisungen übereinstimmen:

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

Klicken Sie im Bereich Testbedingungen auf die Testbedingung Nicht eindeutig, und klicken Sie auf Testbedingung löschen (x).
Klicken Sie in der Liste Testbedingungen in der Liste auf Skalarwert und dann auf Testbedingung hinzufügen (+).
Legen Sie im Eigenschaftenfenster die Eigenschaft Erwarteter Wert auf 100 fest.
Klicken Sie auf der Navigationsleiste des Datenbankkomponententest-Designers auf Sales_uspPlaceNewOrderTest, und stellen Sie sicher, dass in der angrenzenden Liste der Eintrag Vortest ausgewählt ist.

Nachdem Sie diesen Schritt ausgeführt haben, können Sie Anweisungen angeben, mit denen die Daten in den Zustand versetzt werden, der für die Ausführung des Tests erforderlich ist. Für dieses Beispiel müssen Sie zuerst den Kundendatensatz erstellen, bevor Sie eine Bestellung aufgeben können.
Klicken Sie auf Klicken Sie zum Erstellen hierauf, um vor dem Test ein Skript zu erstellen.

Aktualisieren Sie die Transact-SQL-Anweisungen im Transact-SQL-Editor, sodass sie mit den folgenden Anweisungen übereinstimmen:

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

Klicken Sie im Menü Datei auf Alle speichern.

Erstellen Sie danach den Komponententest für uspFillOrder.

So schreiben Sie den Datenbankkomponententest für uspFillOrder

Klicken Sie auf der Navigationsleiste des Datenbankkomponententest-Designers auf Sales_uspFillOrderTest, und stellen Sie sicher, dass in der angrenzenden Liste der Eintrag Test ausgewählt ist.

Nachdem Sie diesen Schritt ausgeführt haben, können Sie das Testskript für die Testaktion im Komponententest erstellen.

Aktualisieren Sie die Transact-SQL-Anweisungen im Transact-SQL-Editor, sodass sie mit den folgenden Anweisungen übereinstimmen:

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

Klicken Sie im Bereich Testbedingungen auf die Testbedingung Nicht eindeutig, und klicken Sie auf Testbedingung löschen (x).
Klicken Sie in der Liste Testbedingungen in der Liste auf Skalarwert und dann auf Testbedingung hinzufügen (+).
Legen Sie im Eigenschaftenfenster die Eigenschaft Erwarteter Wert auf 100 fest.
Klicken Sie auf der Navigationsleiste des Datenbankkomponententest-Designers auf Sales_uspFillOrderTest, und stellen Sie sicher, dass in der angrenzenden Liste der Eintrag Vortest ausgewählt ist. Nachdem Sie diesen Schritt ausgeführt haben, können Sie Anweisungen angeben, mit denen die Daten in den Zustand versetzt werden, der für die Ausführung des Tests erforderlich ist. Für dieses Beispiel müssen Sie zuerst den Kundendatensatz erstellen, bevor Sie eine Bestellung aufgeben können.
Klicken Sie auf Klicken Sie zum Erstellen hierauf, um vor dem Test ein Skript zu erstellen.

Aktualisieren Sie die Transact-SQL-Anweisungen im Transact-SQL-Editor, sodass sie mit den folgenden Anweisungen übereinstimmen:

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

Klicken Sie im Menü Datei auf Alle speichern.

Zu diesem Zeitpunkt können Sie die Tests ausführen.

So schreiben Sie den Datenbankkomponententest für uspShowOrderDetails

Klicken Sie auf der Navigationsleiste des Datenbankkomponententest-Designers auf Sales_uspShowOrderDetailsTest, und stellen Sie sicher, dass in der angrenzenden Liste der Eintrag Test ausgewählt ist.

Nachdem Sie diesen Schritt ausgeführt haben, können Sie das Testskript für die Testaktion im Komponententest erstellen.

Aktualisieren Sie die Transact-SQL-Anweisungen im Transact-SQL-Editor, sodass sie mit den folgenden Anweisungen übereinstimmen:

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

Klicken Sie im Bereich Testbedingungen auf die Testbedingung Nicht eindeutig, und klicken Sie auf Testbedingung löschen (x).
Klicken Sie in der Liste Testbedingungen in der Liste auf Erwartetes Schema und dann auf Testbedingung hinzufügen (+).
Klicken Sie im Eigenschaftenfenster in der Eigenschaft Konfiguration auf die Schaltfläche zum Durchsuchen ('…').
Geben Sie im Dialogfeld Konfiguration für expectedSchemaCondition1 eine Verbindung mit der Datenbank an.
Klicken Sie auf Abrufen.

Der Transact-SQL-Text des Komponententests wird ausgeführt, und das resultierende Schema wird im Dialogfeld angezeigt. Da der Vortestcode nicht ausgeführt wurde, werden keine Daten zurückgegeben. Sie müssen nur das Schema und nicht unbedingt die Daten überprüfen.
Klicken Sie auf OK.

Das erwartete Schema wird mit der Testbedingung gespeichert.
Klicken Sie auf der Navigationsleiste des Datenbankkomponententest-Designers auf Sales_uspShowOrderDetailsTest, und stellen Sie sicher, dass in der angrenzenden Liste der Eintrag Vortest ausgewählt ist. Nachdem Sie diesen Schritt ausgeführt haben, können Sie Anweisungen angeben, mit denen die Daten in den Zustand versetzt werden, der für die Ausführung des Tests erforderlich ist. Für dieses Beispiel müssen Sie zuerst den Kundendatensatz erstellen, bevor Sie eine Bestellung aufgeben können.
Klicken Sie auf Klicken Sie zum Erstellen hierauf, um vor dem Test ein Skript zu erstellen.

Aktualisieren Sie die Transact-SQL-Anweisungen im Transact-SQL-Editor, sodass sie mit den folgenden Anweisungen übereinstimmen:

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

Klicken Sie auf der Navigationsleiste des Datenbankkomponententest-Designers auf Sales_uspShowOrderDetailsTest, und klicken Sie in der nebenstehenden Liste auf Test.

Dies ist erforderlich, da Sie die Prüfsummenbedingung auf den Test, nicht den Vortest anwenden möchten.
Klicken Sie in der Liste Testbedingungen in der Liste auf Datenprüfsumme und dann auf Testbedingung hinzufügen (+).
Klicken Sie im Eigenschaftenfenster in der Eigenschaft Konfiguration auf die Schaltfläche zum Durchsuchen ('…').
Geben Sie im Dialogfeld Konfiguration für checksumCondition1 eine Verbindung mit der Datenbank an.

Ersetzen Sie Transact-SQL im Dialogfeld durch folgenden Code:

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;

In diesem Code wird der Transact-SQL-Code aus den Vortest mit dem Transact-SQL aus dem Test selbst kombiniert. Sie benötigen beide, wenn dieselben Ergebnisse wie beim Ausführen des Tests zurückgegeben werden sollen.

Klicken Sie auf Abrufen.

Der angegebene Transact-SQL-Code wird ausgeführt, und für die zurückgegebenen Daten wird eine Prüfsumme berechnet.
Klicken Sie auf OK.

Die berechnete Prüfsumme wird mit der Testbedingung gespeichert. Die erwartete Prüfsumme wird in der Spalte Wert der Testbedingung Datenprüfsumme angezeigt.
Klicken Sie im Menü Datei auf Alle speichern.

Zu diesem Zeitpunkt können Sie die Tests ausführen.

Ausführen von Datenbankkomponententests

So führen Sie die Datenbankkomponententests aus

Zeigen Sie im Menü Test auf Fenster, und klicken Sie dann auf Testansicht.
Klicken Sie im Fenster Testansicht auf der Symbolleiste auf Aktualisieren, um die Liste der Tests zu aktualisieren.

Im Fenster Testansicht werden die Tests aufgeführt, die Sie zuvor in dieser exemplarischen Vorgehensweise erstellt haben und denen Sie Transact-SQL-Anweisungen und Testbedingungen hinzugefügt haben. Der Test TestMethod1 ist leer und wird in dieser exemplarischen Vorgehensweise nicht verwendet.
Klicken Sie mit der rechten Maustaste auf Sales_uspNewCustomerTest, und klicken Sie anschließend auf Auswahl ausführen.

Visual Studio verwendet den angegebenen privilegierten Kontext, um eine Verbindung zur Datenbank herzustellen und den Datengenerierungsplan anzuwenden. Visual Studio wechselt dann zum Ausführungskontext, bevor das Skript Transact-SQL im Test ausgeführt wird. Anschließend werden die Ergebnisse des Transact-SQL-Skripts im Hinblick auf die in der Testbedingung angegebenen Ergebnisse von Visual Studio ausgewertet, und im Fenster Testergebnisse wird das Ergebnis Erfolgreich oder Fehler angezeigt.
Überprüfen Sie das Ergebnis im Fenster Testergebnisse.

Der Test ist erfolgreich, von der SELECT-Anweisung wird also eine Zeile zurückgegeben.

Wiederholen Sie Schritt 3 für die Tests "Sales_uspPlaceNewOrderTest", "Sales_uspFillOrderTest" und "Sales_uspShowOrderDetailsTest". Dabei sollten die folgenden Ergebnisse erzielt werden:

Test	Erwartetes Ergebnis
Sales_uspPlaceNewOrderTest	Erfolgreich
Sales_uspShowOrderDetailsTest	Erfolgreich
Sales_uspFillOrderTest	Fehler: "Fehler bei ScalarValueCondition-Bedingung (scalarValueCondition2): ResultSet 1 Zeile 1 Spalte 1: Werte stimmen nicht überein, tatsächlich '-100', erwartet '100'." Dieser Fehler tritt auf, weil die Definition der gespeicherten Prozedur einen geringfügigen Fehler enthält.

Korrigieren Sie dann den Fehler, und führen Sie den Test erneut aus.

So korrigieren Sie den Fehler in Sales.uspFillOrder

Doppelklicken Sie unter Schemaansicht auf die gespeicherte Prozedur uspFillOrder, um deren Definition im Transact-SQL-Editor zu öffnen.

Suchen Sie in der Definition die folgende Transact-SQL-Anweisung:

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

Ändern Sie in der Anweisung die SET-Klausel, sodass sie mit der folgenden Anweisung übereinstimmt:

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

Klicken Sie im Menü Datei auf uspFillOrder.proc.sql speichern.
Klicken Sie im Fenster Testansicht mit der rechten Maustaste auf Sales_uspFillOrderTest, und klicken Sie anschließend auf Auswahl ausführen.

Der Test wurde erfolgreich ausgeführt.

Hinzufügen eines negativen Komponententests

Sie könnten einen negativen Test erstellen, um zu überprüfen, ob ein Test mit Fehler ausgeführt wird, wenn dies erwartet wird. Wenn Sie beispielsweise versuchen, eine bereits erfüllte Bestellung zu stornieren, darf der Test nicht erfolgreich ausgeführt werden. In diesem Teil der exemplarischen Vorgehensweise erstellen Sie einen negativen Komponententest für die gespeicherte Prozedur Sales.uspCancelOrder.

Zum Erstellen und Überprüfen eines negativen Tests müssen Sie die folgenden Aufgaben ausführen:

Aktualisieren der gespeicherten Prozedur, um auf Fehlerbedingungen zu testen
Definieren eines neuen Komponententests
Ändern des Codes für den Komponententest, um anzugeben, dass dieser erwartungsgemäß nicht erfolgreich ausgeführt wird
Ausführen des Komponententests

So aktualisieren Sie die gespeicherte Prozedur

Erweitern Sie in der Schemaansicht nacheinander die Knoten SimpleUnitTestDB, Schemas, Sales, Programmierung und Gespeicherte Prozeduren, und doppelklicken Sie anschließend auf uspCancelOrder.

Aktualisieren Sie im Transact-SQL-Editor die Definition der Prozedur, sodass diese dem folgenden Code entspricht:

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

Klicken Sie im Menü Datei auf uspCancelOrder.proc.sql speichern.
Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf SimpleUnitTestDB, und klicken Sie auf Bereitstellen.

Sie stellen die Aktualisierungen an der gespeicherten Prozedur uspCancelOrder bereit. Sie haben keine weiteren Objekte geändert, daher wird nur diese gespeicherte Prozedur aktualisiert.

Danach definieren Sie den zugeordneten Komponententest für diese Prozedur.

So schreiben Sie den Datenbankkomponententest für uspCancelOrder

Klicken Sie auf der Navigationsleiste des Datenbankkomponententest-Designers auf Sales_uspCancelOrderTest, und stellen Sie sicher, dass in der angrenzenden Liste der Eintrag Test ausgewählt ist.

Nachdem Sie diesen Schritt ausgeführt haben, können Sie das Testskript für die Testaktion im Komponententest erstellen.

Aktualisieren Sie die Transact-SQL-Anweisungen im Transact-SQL-Editor, sodass sie mit den folgenden Anweisungen übereinstimmen:

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

Klicken Sie im Bereich Testbedingungen auf die Testbedingung Nicht eindeutig, und klicken Sie auf Testbedingung löschen (x).
Klicken Sie in der Liste Testbedingungen in der Liste auf Skalarwert und dann auf Testbedingung hinzufügen (+).
Legen Sie im Eigenschaftenfenster die Eigenschaft Erwarteter Wert auf 0 fest.
Klicken Sie auf der Navigationsleiste des Datenbankkomponententest-Designers auf Sales_uspCancelOrderTest, und stellen Sie sicher, dass in der angrenzenden Liste der Eintrag Vortest ausgewählt ist. Nachdem Sie diesen Schritt ausgeführt haben, können Sie Anweisungen angeben, mit denen die Daten in den Zustand versetzt werden, der für die Ausführung des Tests erforderlich ist. Für dieses Beispiel müssen Sie zuerst den Kundendatensatz erstellen, bevor Sie eine Bestellung aufgeben können.
Klicken Sie auf Klicken Sie zum Erstellen hierauf, um vor dem Test ein Skript zu erstellen.

Aktualisieren Sie die Transact-SQL-Anweisungen im Transact-SQL-Editor, sodass sie mit den folgenden Anweisungen übereinstimmen:

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

Klicken Sie im Menü Datei auf Alle speichern.

Zu diesem Zeitpunkt können Sie die Tests ausführen.

So führen Sie die Datenbankkomponententests aus

Klicken Sie in der Testansicht mit der rechten Maustaste auf Sales_uspCancelOrderTest, und klicken Sie auf Auswahl ausführen.
Überprüfen Sie das Ergebnis im Fenster Testergebnisse.

Der Test wird mit dem folgenden Fehler ausgeführt:

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

Ändern Sie dann den Code, um anzugeben, dass die Ausnahme erwartet wird.

So ändern Sie den Code für den Komponententest

Erweitern Sie im Projektmappen-Explorer den Knoten TestProject1, klicken Sie mit der rechten Maustaste auf DatabaseUnitTests1.cs, und klicken Sie dann auf Code anzeigen.
Navigieren Sie im Code-Editor zur Sales_uspCancelOrderTest-Methode. Passen Sie die Attribute der Methoden an den folgenden Code an:
```
        [TestMethod(), ExpectedSqlException(Severity=16, MatchFirstError=false, State=1)]
        public void Sales_uspCancelOrderTest()
```
Sie geben an, dass Sie eine bestimmte SQL-Ausnahme erwarten. Sie können auch eine bestimmte Fehlernummer angeben. Wenn Sie dieses Attribut nicht hinzufügen, wird der Komponententest mit einem Fehler ausgeführt, und im Fenster Testergebnisse wird eine Meldung angezeigt.
Klicken Sie im Menü Datei auf DatabaseUnitTests1.cs speichern.

Danach führen Sie den Komponententest erneut aus, um zu überprüfen, ob dieser wie erwartet mit einem Fehler ausgeführt wird.

So führen Sie die Datenbankkomponententests erneut aus

Klicken Sie in der Testansicht mit der rechten Maustaste auf Sales_uspCancelOrderTest, und klicken Sie auf Auswahl ausführen.
Überprüfen Sie das Ergebnis im Fenster Testergebnisse.

Der Test wird erfolgreich ausgeführt, d. h., dass die Prozedur mit Fehler ausgeführt wurde, als dies erwartet wurde.

Nächste Schritte

In einem typischen Projekt definieren Sie weitere Komponententests, um die ordnungsgemäße Funktion aller kritischen Datenbankobjekte zu überprüfen. Wenn die Reihe von Tests abgeschlossen ist, checken Sie diese Tests in die Versionskontrolle ein, um sie für das Team freizugeben.

Nachdem Sie eine Baseline festgelegt haben, können Sie Datenbankobjekte erstellen und ändern und anschließend entsprechende Tests definieren, mit denen überprüft wird, ob sich eine Änderung auf das erwartete Verhalten auswirkt.

Siehe auch

Aufgaben

Gewusst wie: Erstellen eines leeren Datenbankkomponententests

Gewusst wie: Konfigurieren der Ausführung von Datenbankkomponententests

Konzepte

Erstellen und Definieren von Datenbankkomponententests

Überprüfen von Datenbankcode mithilfe von Komponententests

Generieren von Testdaten für Datenbanken mithilfe von Daten-Generatoren

Last updated on 2011-07-20

Exemplarische Vorgehensweise: Erstellen und Ausführen eines Datenbankkomponententests

Vorbereitungsmaßnahmen

Erstellen eines Skripts mit einem Datenbankschema

So erstellen Sie ein Skript, aus dem Sie ein Schema importieren können

Erstellen eines Datenbankprojekts und Importieren eines Schemas

So erstellen Sie ein Datenbankprojekt

So importieren Sie ein Datenbankschema aus einem Skript

So überprüfen Sie das resultierende Projekt

Bereitstellen einer isolierten Entwicklungsumgebung

So konfigurieren und erstellen Sie das Datenbankprojekt

So stellen Sie das Datenbankprojekt bereit

Erstellen eines Datenbankkomponententests

So erstellen Sie einen Datenbankkomponententest für gespeicherte Prozeduren

Definieren der Testlogik

So schreiben Sie den Datenbankkomponententest für uspNewCustomer

So schreiben Sie den Datenbankkomponententest für uspPlaceNewOrder

So schreiben Sie den Datenbankkomponententest für uspFillOrder

So schreiben Sie den Datenbankkomponententest für uspShowOrderDetails

Ausführen von Datenbankkomponententests

So führen Sie die Datenbankkomponententests aus

So korrigieren Sie den Fehler in Sales.uspFillOrder

Hinzufügen eines negativen Komponententests

So aktualisieren Sie die gespeicherte Prozedur

So schreiben Sie den Datenbankkomponententest für uspCancelOrder

So führen Sie die Datenbankkomponententests aus

So ändern Sie den Code für den Komponententest

So führen Sie die Datenbankkomponententests erneut aus

Nächste Schritte

Siehe auch

Aufgaben

Konzepte

Zusätzliche Ressourcen