Exemplarische Vorgehensweise: Erstellen und Ausführen eines SQL Server-Komponententests

In dieser exemplarischen Vorgehensweise erstellen Sie einen SQL Server-Komponententest, mit dem das Verhalten mehrerer gespeicherter Prozeduren überprüft wird. Mithilfe von SQL Server-Komponententests können Codefehler, die u.U. ein fehlerhaftes Anwendungsverhalten verursachen, leichter identifiziert werden. SQL Server-Komponententests und -Anwendungstests können im Rahmen einer automatisierten Testreihe ausgeführt werden.

In dieser exemplarischen Vorgehensweise führen Sie folgende Aufgaben aus:

Erstellen eines Skripts, das ein Datenbankschema enthält
Erstellen eines Datenbankprojekts und Importieren des Schemas
Bereitstellen des Datenbankprojekts in einer isolierten Entwicklungsumgebung
Erstellen von SQL Server-Komponententests
Definieren einer Testlogik
Ausführen von SQL Server-Komponententests
Hinzufügen eines negativen Komponententests

Nachdem einer der Komponententests einen Fehler in einer gespeicherten Prozedur erkannt hat, korrigieren Sie diesen Fehler, und führen Sie den Test erneut aus.

Voraussetzungen

Zum Durchführen dieser exemplarischen Vorgehensweise müssen Sie in der Lage sein, eine Verbindung mit einem Datenbankserver (bzw. LocalDB-Datenbank) herzustellen, auf dem bzw. der 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, das ein Datenbankschema enthält

Zeigen Sie im Menü "Datei" auf "Neu", und wählen Sie dann "Datei" aus.

Das Dialogfeld Neue Datei wird angezeigt.
Wählen Sie in der Liste "Kategorien" die Option "Allgemein " aus, wenn sie noch nicht hervorgehoben ist.
Wählen Sie in der Liste "Vorlagen " die Option "SQL-Datei" und dann " Öffnen" aus.

Der Transact-SQL-Editor wird geöffnet.

Kopieren Sie den Transact-SQL-Code, und fügen Sie ihn im 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/2030'));
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/2030'));
GO

PRINT N'Creating Sales.uspCancelOrder...';
GO

CREATE PROCEDURE [Sales].[uspCancelOrder]
@OrderID INT
AS
BEGIN
    DECLARE @Delta AS INT, @CustomerID AS 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 AS INT, @CustomerID AS 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);
    RETURN 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 AS 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

Speichern Sie die Datei . Notieren Sie sich den Speicherort, da dieses Skript im nächsten Verfahren benötigt wird.
Wählen Sie im Menü "Datei " die Option "Lösung schließen" aus.

Als Nächstes erstellen Sie ein Datenbankprojekt und importieren das Schema aus dem erstellten Skript.

Erstellen eines Datenbankprojekts und Importieren eines Schemas

Erstellen eines Datenbankprojekts

Zeigen Sie im Menü "Datei " auf "Neu", und wählen Sie "Projekt" aus.

Das Dialogfeld Neues Projekt wird angezeigt.
Wählen Sie unter Installierte Vorlagen den Knoten SQL Server und dann SQL Server-Datenbankprojekt aus.
Geben Sie im Feld Name den Wert SimpleUnitTestDB ein.
Aktivieren Sie das Kontrollkästchen "Verzeichnis für Lösung erstellen ", wenn es noch nicht aktiviert ist.
Deaktivieren Sie das Kontrollkästchen "Zur Quellcodeverwaltung hinzufügen ", wenn es noch nicht deaktiviert ist, und wählen Sie "OK" aus.

Das Datenbankprojekt wird erstellt und im Projektmappen-Explorerangezeigt. Als Nächstes importieren Sie das Datenbankschema aus einem Skript.

Importieren eines Datenbankschemas aus einem Skript

Wählen Sie im Menü "Projekt " die Option "Importieren " und dann "Skript(* .sql)" aus.
Wählen Sie "Weiter" aus, nachdem Sie die Willkommensseite gelesen haben.
Wählen Sie "Durchsuchen" aus, und wechseln Sie zu dem Verzeichnis, in dem Sie die .sql Datei gespeichert haben.
Doppelklicken Sie auf die .sql Datei, und wählen Sie "Fertig stellen" aus.

Das Skript wird importiert, und die im Skript definierten Objekte werden dem Datenbankprojekt hinzugefügt.
Überprüfen Sie die Zusammenfassung, und wählen Sie dann "Fertig stellen " aus, um den Vorgang abzuschließen.

Hinweis

Die Sales.uspFillOrder-Prozedur enthält einen beabsichtigten Codierungsfehler, den Sie später in diesem Verfahren ermitteln und korrigieren.

Untersuchen des resultierenden Projekts

Untersuchen Sie im Projektmappen-Explorerdie Skriptdateien, die in das Projekt importiert wurden.
Suchen Sie im SQL Server-Objekt-Explorer die Datenbank unter dem Knoten „Projekte“.

Bereitstellen in LocalDB

Wenn Sie F5 drücken, stellen Sie die Datenbank standardmäßig in einer LocalDB-Datenbank bereit (oder veröffentlichen). Sie können den Datenbankpfad ändern, indem Sie auf der Eigenschaftenseite des Projekts die Registerkarte „Debuggen“ öffnen und die Verbindungszeichenfolge ändern.

Erstellen von SQL Server-Komponententests

Erstellen eines SQL Server-Komponententests für die gespeicherten Prozeduren

Erweitern Sie im SQL Server-Objekt-Explorer den Projektknoten für SimpleUnitTestDB, dann erweitern Sie Programmierbarkeit und anschließend den Knoten Gespeicherte Prozeduren.
Klicken Sie mit der rechten Maustaste auf eine der gespeicherten Prozeduren, und wählen Sie "Komponententests erstellen " aus, um das Dialogfeld " Komponententests erstellen " anzuzeigen.
Aktivieren Sie die Kontrollkästchen für alle fünf gespeicherten Prozeduren: Sales.uspCancelOrder, Sales.uspFillOrder, Sales.uspNewCustomer, Sales.uspPlaceNewOrderund Sales.uspShowOrderDetails.
Wählen Sie in der Dropdownliste "Project " die Option "Neues C#-Testprojekt erstellen" aus.
Übernehmen Sie die Standardnamen für den Projektnamen und den Klassennamen, und wählen Sie "OK" aus.
Geben Sie im Dialogfeld „Testkonfiguration“ unter Komponententests unter Verwendung folgender Datenverbindung ausführeneine Verbindung mit der Datenbank an, die Sie zuvor in dieser exemplarischen Vorgehensweise bereitgestellt haben. Wenn Sie z. B. den Standardbereitstellungsort verwendet haben, bei dem es sich um "LocalDB" handelt, wählen Sie "Neue Verbindung angeben ( LocalDB)\Projects" aus. Wählen Sie anschließend den Namen der Datenbank aus. Wählen Sie dann OK aus, um das Dialogfeld "Verbindungseigenschaften " zu schließen.

Hinweis

Zum Testen von Sichten oder gespeicherte Prozeduren mit eingeschränkten Berechtigungen würden Sie in diesem Schritt normalerweise diese Verbindung angeben. Anschließend würden Sie die sekundäre Verbindung mit ausgedehnteren Berechtigungen angeben, um den Test zu überprüfen. Wenn Sie über eine sekundäre Verbindung verfügen, sollten Sie diesen Benutzer dem Datenbankprojekt hinzufügen und eine Anmeldung für diesen Benutzer im Skript vor der Bereitstellung erstellen.
Aktivieren Sie im Dialogfeld „Testkonfiguration“ im Abschnitt Bereitstellung das Kontrollkästchen Datenbankprojekt automatisch vor dem Ausführen von Komponententests bereitstellen .
Wählen Sie im Datenbankprojekt die Option SimpleUnitTestDB.sqlprojaus.
Wählen Sie in der Bereitstellungskonfiguration"Debuggen" aus.

Sie können im Rahmen der SQL Server-Komponententests auch Testdaten generieren. Für diese exemplarische Vorgehensweise überspringen Sie diesen Schritt, da die Tests eigene Daten erstellen.
Wählen Sie OK aus.

Das Testprojekt wird erstellt, und der SQL Server-Komponententest-Designer wird angezeigt. Als Nächstes aktualisieren Sie die Testlogik im Transact-SQL Skript der Komponententests.

Definieren der Testlogik

Diese Basisdatenbank verfügt über zwei Tabellen Customer und Order. Sie aktualisieren die Datenbank mithilfe der folgenden gespeicherten Prozeduren:

Gespeicherte Prozedur	Description
`uspNewCustomer`	Diese gespeicherte Prozedur fügt der `Customer` Tabelle einen Datensatz hinzu, der die Kunden-Spalten `YTDOrders` und `YTDSales` auf Null festlegt.
`uspPlaceNewOrder`	Diese gespeicherte Prozedur fügt der `Orders` Tabelle für den angegebenen Kunden einen Datensatz hinzu und aktualisiert den `YTDOrders` Wert für den entsprechenden Datensatz in der `Customer` Tabelle.
`uspFillOrder`	Diese gespeicherte Prozedur aktualisiert einen Datensatz in der `Orders` Tabelle, indem der Status von "O" in "F" geändert und der `YTDSales` Betrag auf den entsprechenden Datensatz in der `Customer` Tabelle erhöht wird.
`uspCancelOrder`	Diese gespeicherte Prozedur aktualisiert einen Datensatz in der `Orders` Tabelle, indem der Status von "O" in "X" geändert und der `YTDOrders` Betrag für den entsprechenden Datensatz in der `Customer` Tabelle verringert wird.
`uspShowOrderDetails`	Diese gespeicherte Prozedur verknüpft die `Orders` Tabelle mit der benutzerdefinierten Tabelle und zeigt die Datensätze für einen bestimmten Kunden an.

Hinweis

In diesem Beispiel wird veranschaulicht, wie Sie einen einfachen SQL Server-Komponententest erstellen. In einer realen Datenbank könnten Sie die Gesamtmenge aller Bestellungen mit dem Status "O" oder "F" für einen bestimmten Kunden summieren. Die Prozeduren in dieser exemplarischen Vorgehensweise verzichten auch auf eine Fehlerbehandlung. Sie verhindern beispielsweise nicht, dass Sie eine bereits ausgefüllte Bestellung anrufen uspFillOrder .

Zu Testbeginn wird davon ausgegangen, dass die Datenbank einen fehlerfreien Zustand aufweist. Sie erstellen Tests, die die folgenden Bedingungen überprüfen:

uspNewCustomer: Überprüfen Sie, ob die Customer Tabelle eine Zeile enthält, nachdem Sie die gespeicherte Prozedur ausgeführt haben.
uspPlaceNewOrder: Für den Kunden, der eine CustomerID von 1 hat, geben Sie eine Bestellung für $ 100 ein. Vergewissern Sie sich, dass der Betrag für diesen YTDOrders Kunden 100 ist und der YTDSales Betrag null ist.
uspFillOrder: Für den Kunden, der eine CustomerID von 1 hat, geben Sie eine Bestellung für $ 50 ein. Führen Sie die Bestellung aus. Vergewissern Sie sich, dass YTDOrders und YTDSales Beträge von jeweils 50 haben.
uspShowOrderDetails: Für den Kunden, der eine CustomerID von 1 hat, bitte Bestellungen für $100, $50 und $5 aufgeben. Stellen Sie sicher, dass uspShowOrderDetails die richtige Anzahl von Spalten zurückgegeben wird und dass das Resultset über die erwartete Prüfsumme verfügt.

Hinweis

Bei einer vollständigen Gruppe von SQL Server-Komponententests überprüfen Sie in der Regel, ob die anderen Spalten korrekt festgelegt wurden. Um diese Anleitung in einer verwaltbaren Größe beizubehalten, wird nicht beschrieben, wie das Verhalten von uspCancelOrder überprüft wird.

Schreiben Sie den SQL Server-Komponententest für uspNewCustomer

Wählen Sie in der Navigationsleiste des SQL Server-Komponententest-Designers Sales_uspNewCustomerTest aus, und stellen Sie sicher, dass "Test" in der angrenzenden Liste hervorgehoben 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, damit sie folgenden Anweisungen entsprechen:

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

Wählen Sie im Bereich „Testbedingungen“ die nicht schlüssige Testbedingung aus und dann das „Testbedingung löschen“-Icon (das rote X).
Wählen Sie im Bereich "Testbedingungen " in der Liste " Zeilenanzahl " und dann das Symbol " Testbedingung hinzufügen " (grün +) aus.
Öffnen Sie das Eigenschaftenfenster (wählen Sie die Testbedingung aus, und drücken Sie F4), und legen Sie die Row Count-Eigenschaft auf 1 fest.
Wählen Sie im Menü "Datei " die Option "Alle speichern" aus.

Als Nächstes definieren Sie die Komponententestlogik für uspPlaceNewOrder.

Schreiben des SQL Server-Komponententests für uspPlaceNewOrder

Wählen Sie in der Navigationsleiste des SQL Server-Komponententest-Designers Sales_uspPlaceNewOrderTest aus, und stellen Sie sicher, dass "Test" in der angrenzenden Liste hervorgehoben 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, damit sie folgenden Anweisungen entsprechen:

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

-- NOTE: Assumes that you inserted a Customer record with CustomerName='Fictitious Customer' in the pre-test script.
SELECT @RC = 0,
       @CustomerID = 0,
       @CustomerName = N'Fictitious Customer',
       @Amount = 100,
       @OrderDate = getdate(),
       @Status = 'O';

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;

Wählen Sie im Bereich Testbedingungen die Testbedingung „Unschlüssig“ aus und dann Testbedingung löschen.
Wählen Sie im Bereich "Testbedingungen " in der Liste " Skalarwert " und dann " Testbedingung hinzufügen" aus.
Legen Sie im Eigenschaftenfenster die Eigenschaft Erwarteter Wert auf „100“ fest.
Wählen Sie in der Navigationsleiste des SQL Server-Komponententest-Designers Sales_uspPlaceNewOrderTest aus, und stellen Sie sicher, dass "Pre-Test " in der angrenzenden Liste hervorgehoben ist.

Nach diesem Schritt können Sie die Daten mithilfe der erforderlichen Anweisungen für die Ausführung des Tests vorbereiten. In diesem Beispiel müssen Sie den Customer Datensatz erstellen, bevor Sie eine Bestellung aufgeben können.
Klicken Sie hier, um ein Pre-Test-Skript zu erstellen.

Aktualisieren Sie die Transact-SQL-Anweisungen im Transact-SQL-Editor, damit sie folgenden Anweisungen entsprechen:

/*
                              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 [Sales].[Orders]
WHERE [CustomerID] = @CustomerID;

UPDATE [Sales].[Customer]
    SET YTDOrders = 0,
        YTDSales  = 0
WHERE [CustomerID] = @CustomerID;

Wählen Sie im Menü "Datei " die Option "Alle speichern" aus.

Als Nächstes erstellen Sie den Komponententest für uspFillOrder.

Schreiben des SQL Server-Komponententests für uspFillOrder

Wählen Sie in der Navigationsleiste des SQL Server-Komponententest-Designers Sales_uspFillOrderTest aus, und stellen Sie sicher, dass "Test" in der angrenzenden Liste hervorgehoben 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, damit sie folgenden Anweisungen entsprechen:

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

Wählen Sie im Bereich Testbedingungen die Testbedingung „Unschlüssig“ aus und dann Testbedingung löschen.
Wählen Sie im Bereich "Testbedingungen " in der Liste " Skalarwert " und dann " Testbedingung hinzufügen" aus.
Legen Sie im Eigenschaftenfenster die Eigenschaft Erwarteter Wert auf „100“ fest.
Wählen Sie in der Navigationsleiste des SQL Server-Komponententest-Designers Sales_uspFillOrderTest aus, und stellen Sie sicher, dass "Pre-Test " in der angrenzenden Liste hervorgehoben ist. Nach diesem Schritt können Sie die Daten mithilfe der erforderlichen Anweisungen für die Ausführung des Tests vorbereiten. Zur Verwendung dieses Beispiels müssen Sie den Datensatz „Customer“ erstellen, bevor Sie eine Bestellung aufgeben können.
Klicken Sie hier, um ein Pre-Test-Skript zu erstellen.

Aktualisieren Sie die Transact-SQL-Anweisungen im Transact-SQL-Editor, damit sie folgenden Anweisungen entsprechen:

/*
                              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 [Sales].[Orders]
WHERE [CustomerID] = @CustomerID;

UPDATE [Sales].[Customer]
    SET YTDOrders = 0,
        YTDSales  = 0
WHERE [CustomerID] = @CustomerID;

EXECUTE
    @RC = [Sales].[uspPlaceNewOrder]
    @CustomerID,
    @Amount,
    @OrderDate,
    @Status;

COMMIT TRANSACTION;

-- place an order for that customer

Wählen Sie im Menü "Datei " die Option "Alle speichern" aus.

Schreiben Sie den SQL Server-Komponententest für uspShowOrderDetails

Wählen Sie in der Navigationsleiste des SQL Server-Komponententest-Designers Sales_uspShowOrderDetailsTest aus, und stellen Sie sicher, dass "Test" in der angrenzenden Liste hervorgehoben 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, damit sie folgenden Anweisungen entsprechen:

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

Wählen Sie im Bereich Testbedingungen die Testbedingung „Unschlüssig“ aus und dann Testbedingung löschen.
Wählen Sie im Bereich "Testbedingungen " in der Liste " Erwartetes Schema " und dann " Testbedingung hinzufügen" aus.
Wählen Sie im Eigenschaftenfenster in der Konfigurationseigenschaft die Schaltfläche "Durchsuchen" ('...') aus.
Geben Sie im Dialogfeld Konfiguration für expectedSchemaCondition1 eine Verbindung mit der Datenbank an. Wenn Sie z. B. den Standardbereitstellungsort verwendet haben, bei dem es sich um "LocalDB" handelt, wählen Sie "Neue Verbindung angeben ( LocalDB)\Projects" aus. Wählen Sie anschließend den Namen der Datenbank aus.
Wählen Sie "Abrufen" aus. (Wählen Sie bei Bedarf "Abrufen " aus, bis Daten angezeigt werden.)

Der Transact-SQL-Text des Komponententests wird ausgeführt, und das resultierende Schema wird im Dialogfeld angezeigt. Da der Vorabtestcode nicht ausgeführt wurde, werden keine Daten zurückgegeben. Da Sie nur das Schema und nicht die Daten überprüfen, ist dies in Ordnung.
Wählen Sie OK aus.

Das erwartete Schema wird mit der Testbedingung gespeichert.
Wählen Sie in der Navigationsleiste des SQL Server-Komponententest-Designers Sales_uspShowOrderDetailsTest aus, und stellen Sie sicher, dass "Pre-Test " in der angrenzenden Liste hervorgehoben ist. Nach diesem Schritt können Sie die Daten mithilfe der erforderlichen Anweisungen für die Ausführung des Tests vorbereiten. In diesem Beispiel müssen Sie den Customer Datensatz erstellen, bevor Sie eine Bestellung aufgeben können.
Klicken Sie hier, um ein Pre-Test-Skript zu erstellen.

Aktualisieren Sie die Transact-SQL-Anweisungen im Transact-SQL-Editor, damit sie folgenden Anweisungen entsprechen:

/*
                              Add Transact-SQL statements here 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 [Sales].[Orders]
WHERE [CustomerID] = @CustomerID;

UPDATE [Sales].[Customer]
    SET YTDOrders = 0,
        YTDSales  = 0
WHERE [CustomerID] = @CustomerID;

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;

-- place 3 orders for that customer

Wählen Sie in der Navigationsleiste des SQL Server-Komponententest-Designers Sales_uspShowOrderDetailsTest aus, und wählen Sie " Testen " in der angrenzenden Liste aus.

Dieser Schritt ist erforderlich, weil Sie die Prüfsummenbedingung auf den Test und nicht auf den Vortest anwenden möchten.
Wählen Sie im Bereich "Testbedingungen " in der Liste " Datenüberprüfungen " und dann " Testbedingung hinzufügen" aus.
Wählen Sie im Eigenschaftenfenster in der Konfigurationseigenschaft die Schaltfläche "Durchsuchen" ('...') aus.
Geben Sie im Dialogfeld Konfiguration für checksumCondition1 eine Verbindung mit der Datenbank an.

Ersetzen Sie Transact-SQL im Dialogfeld (unterhalb der Schaltfläche Verbindung bearbeiten) 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 [Sales].[Orders]
WHERE [CustomerID] = @CustomerID;

UPDATE [Sales].[Customer]
    SET YTDOrders = 0,
        YTDSales  = 0
WHERE [CustomerID] = @CustomerID;

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;

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

SELECT @CustomerID = [CustomerID]
FROM [Sales].[Customer]
WHERE [CustomerName] = @CustomerName;

EXECUTE
    @RC = [Sales].[uspShowOrderDetails]
    @CustomerID;

SELECT @RC AS RC;

-- place 3 orders for that customer  -- ssNoVersion unit test for Sales.uspFillOrder  -- NOTE: Assumes that you inserted a Customer record with CustomerName='Fictitious Customer' in the pre-test script.  -- fill an order for that customer

In diesem Code wird der Transact-SQL-Code aus dem Vortest mit dem Transact-SQL-Code aus dem Haupttest kombiniert. Sie müssen beide die gleichen Ergebnisse zurückgeben, die der Test zurückgibt, wenn Sie ihn ausführen.

Wählen Sie "Abrufen" aus. (Wählen Sie bei Bedarf "Abrufen " aus, bis Daten angezeigt werden.)

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

Die berechnete Prüfsumme wird mit der Testbedingung gespeichert. Die erwartete Prüfsumme wird in der Spalte „Wert“ der Testbedingung „Datenprüfsumme“ angezeigt.
Wählen Sie im Menü "Datei " die Option "Alle speichern" aus.

An diesem Punkt können Sie Ihre Tests ausführen.

Ausführen von SQL Server-Komponententests

Ausführen der SQL Server-Komponententests

Zeigen Sie im Menü " Test " auf Windows, und wählen Sie dann " Testansicht " in Visual Studio 2010 oder "Test-Explorer " in Visual Studio 2012 aus.
Wählen Sie im Fenster " Testansicht " (Visual Studio 2010) die Option "Aktualisieren" auf der Symbolleiste aus, um die Liste der Tests zu aktualisieren. Um die Liste der Tests im Test-Explorer (Visual Studio 2012) anzuzeigen, erstellen Sie die Projektmappe.

Im Fenster Testansicht oder Test-Explorer werden die Tests aufgelistet, die Sie zuvor in diesem Tutorial erstellt und denen Sie Transact-SQL-Anweisungen und Testbedingungen hinzugefügt haben. Der Test mit dem Namen TestMethod1 ist leer und wird in dieser exemplarischen Vorgehensweise nicht verwendet.
Klicken Sie mit der rechten Maustaste auf Sales_uspNewCustomerTest, und wählen Sie "Auswahl ausführen" aus.

Visual Studio verwendet den angegebenen privilegierten Kontext, den Sie beim Herstellen einer Verbindung mit der Datenbank und beim Anwenden des Datengenerierungsplans angegeben haben. Visual Studio wechselt anschließend zum Ausführungskontext, bevor das Transact-SQL-Skript im Test ausgeführt wird. Zum Schluss werden die Ergebnisse des Transact-SQL-Skripts in Visual Studio anhand der in der Testbedingung angegebenen Ergebnisse ausgewertet, und im Fenster Testergebnisse wird eine erfolgreiche oder fehlerhafte Testausführung gemeldet.
Überprüfen Sie das Ergebnis im Fenster Testergebnisse .

Der Test besteht, was bedeutet, dass die SELECT Anweisung beim Ausführen eine Zeile zurückgibt.

Wiederholen Sie Schritt 3 für die Sales_uspPlaceNewOrderTest, Sales_uspFillOrderTestund Sales_uspShowOrderDetailsTest Tests. Die Ergebnisse sollten wie folgt lauten:

Test	Erwartetes Ergebnis
`Sales_uspPlaceNewOrderTest`	Pass
`Sales_uspShowOrderDetailsTest`	Pass
`Sales_uspFillOrderTest`	Schlägt mit dem folgenden Fehler fehl: `ScalarValueCondition Condition (scalarValueCondition2) Failed: ResultSet 1 Row 1 Column 1: values do not match, actual '-100' expected '100'.` Dieser Fehler tritt auf, da die Definition der gespeicherten Prozedur einen geringfügigen Fehler enthält.

Als Nächstes korrigieren Sie den Fehler, und führen Sie den Test erneut aus.

Korrigieren des Fehlers in Sales.uspFillOrder

Klicken Sie im Projektknoten SQL Server-Objekt-Explorer der Datenbank doppelt auf die gespeicherte Prozedur uspFillOrder, um deren Definition im Transact-SQL-Editor zu öffnen.

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

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

Ändern Sie die Klausel in der SET Anweisung so, dass sie mit der folgenden Anweisung übereinstimmt:
```
UPDATE [Sales].[Customer]
    SET YTDSales = YTDSales + @Delta
WHERE [CustomerID] = @CustomerID;
```
Wählen Sie im Menü "Datei " die Option "UspFillOrder.sql speichern" aus.
Klicken Sie in der Testansicht mit der rechten Maustaste auf Sales_uspFillOrderTest, und wählen Sie " Auswahl ausführen" aus.

Der Test verläuft erfolgreich.

Hinzufügen eines negativen Komponententests

Sie können einen negativen Komponententest erstellen, um zu überprüfen, ob ein Test fehlschlägt, wenn er fehlschlagen sollte. Beispiel: Wenn Sie versuchen, eine bereits ausgeführte Bestellung zu stornieren, sollte dieser Test fehlschlagen. 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 führen Sie folgende Aufgaben aus:

Aktualisieren der gespeicherten Prozedur, um auf Fehlerbedingungen zu testen
Definieren eines neuen Komponententests
Ändern des Codes für den Komponententest, um anzugeben, dass der Test fehlschlagen soll
Ausführen des Komponententests

Aktualisieren der gespeicherten Prozedur

Erweitern Sie im Knoten "SQL Server-Objekt-Explorer-Projekte " für die SimpleUnitTestDB Datenbank den Knoten "Programmierbarkeit", erweitern Sie den Knoten "Gespeicherte Prozeduren", und doppelklicken Sie auf uspCancelOrder.

Aktualisieren Sie im Transact-SQL-Editor die Prozedurdefinition, damit sie dem folgenden Code entspricht:

CREATE PROCEDURE [Sales].[uspCancelOrder]
@OrderID INT
AS
BEGIN
    DECLARE @Delta AS INT, @CustomerID AS INT, @PriorStatus AS 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 AS NVARCHAR (4000);
        DECLARE @ErrorSeverity AS INT;
        DECLARE @ErrorState AS INT;
        SELECT @ErrorMessage = ERROR_MESSAGE(),
               @ErrorSeverity = ERROR_SEVERITY(),
               @ErrorState = ERROR_STATE();
        ROLLBACK;
        RAISERROR (@ErrorMessage, @ErrorSeverity, @ErrorState);
        RETURN 0;
    END CATCH
END

-- Use RAISERROR inside the CATCH block to return  -- error information about the original error that  -- caused execution to jump to the CATCH block.  -- Message text  -- Severity  -- State  -- indicate failure

Wählen Sie im Menü "Datei " die Option "UspCancelOrder.sql speichern" aus.
Drücken Sie F5, um SimpleUnitTestDB bereitzustellen.

Sie stellen die Updates für die uspCancelOrder gespeicherte Prozedur bereit. Da Sie keine anderen Objekte geändert haben, wird nur diese gespeicherte Prozedur aktualisiert.

Als Nächstes definieren Sie den Komponententest für diese Prozedur.

Schreiben Sie einen SQL Server-Komponententest für uspCancelOrder

Wählen Sie in der Navigationsleiste des SQL Server-Komponententest-Designers Sales_uspCancelOrderTest aus, und stellen Sie sicher, dass "Test" in der angrenzenden Liste hervorgehoben 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, damit sie folgenden Anweisungen entsprechen:

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

Wählen Sie im Bereich Testbedingungen die nicht schlüssige Testbedingung aus und dann das Symbol Testbedingung löschen.
Wählen Sie im Bereich "Testbedingungen " in der Liste " Skalarwert " und dann das Symbol " Testbedingung hinzufügen " aus.
Legen Sie im Eigenschaftenfenster die Eigenschaft Erwarteter Wert auf 0 fest.
Wählen Sie in der Navigationsleiste des SQL Server-Komponententest-Designers Sales_uspCancelOrderTest aus, und stellen Sie sicher, dass "Pre-Test " in der angrenzenden Liste hervorgehoben ist. Nach diesem Schritt können Sie die Daten mithilfe der erforderlichen Anweisungen für die Ausführung des Tests vorbereiten. In diesem Beispiel müssen Sie den Customer Datensatz erstellen, bevor Sie eine Bestellung aufgeben können.
Klicken Sie hier, um ein Pre-Test-Skript zu erstellen.

Aktualisieren Sie die Transact-SQL-Anweisungen im Transact-SQL-Editor, damit sie folgenden Anweisungen entsprechen:

/*
                              Add Transact-SQL statements here 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 [Sales].[Orders]
WHERE [CustomerID] = @CustomerID;

UPDATE [Sales].[Customer]
    SET YTDOrders = 0,
        YTDSales  = 0
WHERE [CustomerID] = @CustomerID;

EXECUTE
    @OrderID = [Sales].[uspPlaceNewOrder]
    @CustomerID,
    @Amount,
    @OrderDate,
    @Status;

EXECUTE
    @RC = [Sales].[uspFillOrder]
    @OrderID,
    @FilledDate;

COMMIT TRANSACTION;

-- place an order for that customer  -- fill the order for that customer

Wählen Sie im Menü "Datei " die Option "Alle speichern" aus.

An diesem Punkt können Sie Ihre Tests ausführen.

Ausführen der SQL Server-Komponententests

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

Der Test schlägt mit folgender Fehlermeldung fehl:
```
Test method TestProject1.SqlServerUnitTests1.Sales_uspCancelOrderTest threw exception: System.Data.SqlClient.SqlException: You can only cancel open orders.
```
Im nächsten Schritt ändern Sie den Code, um anzugeben, dass die Ausnahme erwartet wird.

Ändern des Codes für den Komponententest

Erweitern Sie den Projektmappenexplorer, öffnen Sie TestProject1, klicken Sie mit der rechten Maustaste auf SqlServerUnitTests1.cs, und wählen Sie Code anzeigen aus.
Navigieren Sie im Code-Editor zur Sales_uspCancelOrderTest-Methode. Ändern Sie die Attribute der Methode entsprechend folgendem Code:
```
[TestMethod(), ExpectedSqlException(Severity=16, MatchFirstError=false, State=1)]
public void Sales_uspCancelOrderTest()
```
Sie geben an, dass Sie eine bestimmte Ausnahme erwarten. Optional können Sie eine bestimmte Fehlernummer angeben. Wenn Sie dieses Attribut nicht hinzufügen, schlägt der Komponententest fehl, und im Fenster "Testergebnisse" wird eine Meldung angezeigt.
Wählen Sie im Menü "Datei" die Option "SqlServerUnitTests1.cs speichern" aus.

Als Nächstes führen Sie den Komponententest erneut aus, um zu überprüfen, ob er wie erwartet fehlschlägt.

Erneutes Ausführen der SQL Server-Komponententests

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

Der Test verläuft erfolgreich. Dies bedeutet, dass die Prozedur, von der angenommen wurde, dass sie fehlschlägt, tatsächlich einen Fehler verursacht hat.

Feedback

War diese Seite hilfreich?

Last updated on 2025-09-10

Exemplarische Vorgehensweise: Erstellen und Ausführen eines SQL Server-Komponententests

Voraussetzungen

Erstellen eines Skripts, das ein Datenbankschema enthält

Erstellen eines Datenbankprojekts und Importieren eines Schemas

Erstellen eines Datenbankprojekts

Importieren eines Datenbankschemas aus einem Skript

Untersuchen des resultierenden Projekts

Bereitstellen in LocalDB

Erstellen von SQL Server-Komponententests

Erstellen eines SQL Server-Komponententests für die gespeicherten Prozeduren

Definieren der Testlogik

Schreiben Sie den SQL Server-Komponententest für uspNewCustomer

Schreiben des SQL Server-Komponententests für uspPlaceNewOrder

Schreiben des SQL Server-Komponententests für uspFillOrder

Schreiben Sie den SQL Server-Komponententest für uspShowOrderDetails

Ausführen von SQL Server-Komponententests

Ausführen der SQL Server-Komponententests

Korrigieren des Fehlers in Sales.uspFillOrder

Hinzufügen eines negativen Komponententests

Aktualisieren der gespeicherten Prozedur

Schreiben Sie einen SQL Server-Komponententest für uspCancelOrder

Ausführen der SQL Server-Komponententests

Ändern des Codes für den Komponententest

Erneutes Ausführen der SQL Server-Komponententests

Verwandte Inhalte

Feedback

Zusätzliche Ressourcen