Freigeben über

Exemplarische Vorgehensweise: Verwenden einer benutzerdefinierten Testbedingung zum Überprüfen der Ergebnisse einer gespeicherten Prozedur

  • Artikel

In dieser exemplarischen Vorgehensweise zu Funktionserweiterungen erstellen Sie eine Testbedingung, und Sie überprüfen deren Funktionsfähigkeit, indem Sie einen Datenbankkomponententest erstellen. Der Vorgang umfasst das Erstellen eines Klassenbibliotheksprojekts für die Testbedingung sowie deren Signierung und Registrierung. Wenn Sie bereits über eine Testbedingung verfügen, die Sie aktualisieren möchten, finden Sie entsprechende Informationen unter Gewusst wie: Aktualisieren einer benutzerdefinierten Testbedingung aus einer älteren Version.

In dieser exemplarischen Vorgehensweise werden die folgenden Aufgaben veranschaulicht:

  1. Erstellen einer Testbedingung

  2. Signieren der Assembly mit einem starken Namen

  3. Hinzufügen der erforderlichen Verweise auf das Projekt

  4. Erstellen einer Funktionserweiterung

  5. Registrieren einer neuen Funktionserweiterung

  6. Testen der neuen Funktionserweiterung

Vorbereitungsmaßnahmen

Sie können diese exemplarische Vorgehensweise nur ausführen, wenn Visual Studio Premium oder Visual Studio Ultimate installiert ist.

Erstellen einer benutzerdefinierten Testbedingung

Zuerst erstellen Sie eine Klassenbibliothek.

So erstellen Sie eine Klassenbibliothek

  1. Klicken Sie im Menü Datei auf Neu und anschließend auf Projekt.

  2. Klicken Sie im Dialogfeld Neues Projekt unter Projekttypen auf Visual C#.

  3. Wählen Sie unter Vorlagen die Option Klassenbibliothek aus.

  4. Geben Sie im Textfeld Name den Namen "ColumnCountCondition" ein, und klicken Sie anschließend auf OK.

Anschließend signieren Sie das Projekt.

So signieren Sie das Projekt

  1. Klicken Sie im Menü Projekt auf Eigenschaften von ColumnCountCondition.

  2. Aktivieren Sie auf der Registerkarte Signierung das Kontrollkästchen Assembly signieren.

  3. Klicken Sie im Feld Schlüsseldatei mit starkem Namen auswählen auf Neu.

    Das Dialogfeld Schlüssel für einen starken Namen erstellen wird geöffnet.

  4. Geben Sie im Feld Schlüsseldateiname den Namen "SampleKey" ein.

  5. Geben Sie ein Kennwort ein, bestätigen Sie das Kennwort, und klicken Sie dann auf OK.

    Wenn Sie die Projektmappe erstellen, wird die Assembly mit der Schlüsseldatei signiert.

  6. Klicken Sie im Menü Datei auf Alle speichern.

  7. Klicken Sie im Menü Erstellen auf Projektmappe erstellen.

Als Nächstes fügen Sie dem Projekt die erforderlichen Verweise hinzu.

So fügen Sie dem Projekt die zutreffenden Verweise hinzu

  1. Wählen Sie im Projektmappen-Explorer das Projekt ColumnCountCondition aus.

  2. Klicken Sie im Menü Projekt auf Verweis hinzufügen.

    Das Dialogfeld Verweis hinzufügen wird geöffnet.

  3. Wählen Sie die Registerkarte .NET aus.

  4. Suchen Sie in der Spalte Komponentenname die folgenden Komponenten:

    Tipp

    Halten Sie STRG gedrückt, während Sie nacheinander auf mehrere Komponenten klicken, um sie auszuwählen.

  5. Klicken Sie auf OK, nachdem Sie alle erforderlichen Komponenten ausgewählt haben.

    Die ausgewählten Verweise werden im Projektmappen-Explorer unter dem Knoten Verweise des Projekts angezeigt.

Erstellen der ResultSetColumnCountCondition-Klasse

Danach benennen Sie Class1 in ResultSetColumnCountCondition um und leiten diese von TestCondition ab. Die ResultSetColumnCountCondition-Klasse stellt eine einfache Testbedingung dar, mit der überprüft wird, ob die Anzahl der im Resultset zurückgegebenen Spalten dem erwarteten Wert entspricht. Mit dieser Bedingung können Sie sicherstellen, dass der Vertrag für eine gespeicherte Prozedur richtig ist.

So erstellen Sie eine Testbedingungsklasse

  1. Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf "Class1.cs", klicken Sie auf Umbenennen, und geben Sie "ResultSetColumnCountCondition.cs" ein.

  2. Klicken Sie auf Ja, um das Umbenennen aller Verweise auf Class1 zu bestätigen.

  3. Öffnen Sie die Datei ResultSetColumnCountCondition.cs, und fügen Sie der Datei die folgenden using-Anweisungen hinzu:

    using System;
using System.Collections.Generic;
using Microsoft.Data.Schema.UnitTesting;
using Microsoft.Data.Schema.UnitTesting.Conditions;
using Microsoft.Data.Schema.Extensibility;
using System.ComponentModel;
using System.Data;
using System.Data.Common;
using Microsoft.Data.Schema;

 
namespace ColumnCountCondition
{
    public class ResultSetColumnCountCondition

  4. Leiten Sie die Klasse von TestCondition ab:

        public class ResultSetColumnCountCondition : TestCondition

  5. Fügen Sie das DatabaseSchemaProviderCompatibilityAttribute-Attribut hinzu. Weitere Informationen finden Sie unter Generieren spezialisierter Testdaten mit einem benutzerdefinierten Daten-Generator.

    [DatabaseSchemaProviderCompatibility(typeof(DatabaseSchemaProvider))]
   [DatabaseSchemaProviderCompatibility(null)]
    [DisplayName("ResultSet Column Count")]
    public class ResultSetColumnCountCondition : TestCondition

    Die Testbedingung verfügt über beide Kompatibilitätsattribute, sodass Folgendes gilt:

    • Die Bedingung wird geladen, wenn ein von DatabaseSchemaProvider erbender Datenbankschema-Anbieter vorhanden ist. Dadurch wird die Situation behandelt, in der der Datenbankkomponententest-Designer einen Datenbankschema-Anbieter-Kontext besitzt. Wenn die Testbedingung für SQL Server spezifisch sein soll, können Sie stattdessen "SqlDatabaseSchemaProvider" angeben.

    • Die Testbedingung wird geladen, wenn kein Datenbankschema-Anbieter vorhanden ist. Dies tritt auf, wenn beim Datenbankkomponententest Erweiterungen ohne Datenbankschema-Anbieter geladen werden.

  6. Fügen Sie das DisplayName-Attribut hinzu:

        [DatabaseSchemaProviderCompatibility(typeof(DatabaseSchemaProvider))]
        [DatabaseSchemaProviderCompatibility(null)]
    [DisplayName("ResultSet Column Count")]
    public class ResultSetColumnCountCondition : TestCondition

  7. Erstellen Sie die Membervariablen:

        {
        private int _resultSet;
        private int _count;
        private int _batch;
 

  8. Erstellen Sie den Konstruktor:

            public ResultSetColumnCountCondition()
        {
            _resultSet = 1;
            _count = 0;
            _batch = 1;
        }
 

  9. Setzen Sie die Assert-Methode außer Kraft. Die Methode umfasst Argumente für IDbConnection, die die Verbindung mit der Datenbank darstellt, und ExecutionResult. Die Methode verwendet DataSchemaException für die Fehlerbehandlung.

            //method you need to override
        //to perform the condition verification
        public override void Assert(DbConnection validationConnection, ExecutionResult[] results)
        {
            //call base for parameter validation
            base.Assert(validationConnection, results);
 
            //verify batch exists
            if (results.Length < _batch)
                throw new DataSchemaException(String.Format("Batch {0} does not exist", _batch));
 
            ExecutionResult result = results[_batch - 1];
 
            //verify resultset exists
            if (result.DataSet.Tables.Count < ResultSet)
                throw new DataSchemaException(String.Format("ResultSet {0} does not exist", ResultSet));
 
            DataTable table = result.DataSet.Tables[ResultSet - 1];
 
            //actual condition verification
            //verify resultset column count matches expected
            if (table.Columns.Count != Count)
                throw new DataSchemaException(String.Format(
                    "ResultSet {0}: {1} columns did not match the {2} columns expected",
                    ResultSet, table.Columns.Count, Count));
        }
 

  10. Fügen Sie die folgende Methode hinzu, durch die die ToString-Methode außer Kraft gesetzt wird:

            //this method is called to provide the string shown in the
        //test conditions panel grid describing what the condition tests
        public override string ToString()
        {
            return String.Format(
                "Condition fails if ResultSet {0} does not contain {1} columns",
                ResultSet, Count);
        }
 

  11. Fügen Sie mit den Attributen CategoryAttribute, DisplayNameAttribute und DescriptionAttribute die folgenden Testbedingungseigenschaften hinzu:

            //below are the test condition properties
        //that are exposed to the user in the property browser
        #region Properties
 
        //property specifying the resultset for which
        //you want to check the column count
        [Category("Test Condition")]
        [DisplayName("ResultSet")]
        [Description("ResultSet Number")]
        public int ResultSet
        {
            get { return _resultSet; }
 
            set
            {
                //basic validation
                if (value < 1)
                    throw new ArgumentException("ResultSet cannot be less than 1");
 
                _resultSet = value;
            }
        }
 
        //property specifying
        //expected column count
        [Category("Test Condition")]
        [DisplayName("Count")]
        [Description("Column Count")]
        public int Count
        {
            get { return _count; }
 
            set
            {
                //basic validation
                if (value < 0)
                    throw new ArgumentException("Count cannot be less than 0");
 
                _count = value;
            }
        }
 
        #endregion
    }
}

Der endgültige Code sollte wie folgt aussehen:

using System;
using System.Collections.Generic;
using Microsoft.Data.Schema.UnitTesting;
using Microsoft.Data.Schema.UnitTesting.Conditions;
using Microsoft.Data.Schema.Extensibility;
using System.ComponentModel;
using System.Data;
using System.Data.Common;
using Microsoft.Data.Schema;

namespace ColumnCountCondition
{
DatabaseSchemaProviderCompatibility(typeof(DatabaseSchemaProvider))]
        [DatabaseSchemaProviderCompatibility(null)]

    [DisplayName("ResultSet Column Count")]
    public class ResultSetColumnCountCondition : TestCondition
    {
        private int _resultSet; 
        private int _count; 
        private int _batch; 

        public ResultSetColumnCountCondition()
        {
            _resultSet = 1; 
            _count = 0; 
            _batch = 1; 
        }

        //method you need to override
        //to perform the condition verification
        public override void Assert(DbConnection validationConnection, ExecutionResult[] results) 
        {
            //call base for parameter validation
            base.Assert(validationConnection, results); 

            //verify batch exists
            if (results.Length < _batch) 
                throw new DataException(String.Format("Batch {0} does not exist", _batch)); 

            ExecutionResult result = results[_batch - 1]; 

            //verify resultset exists
            if (result.DataSet.Tables.Count < ResultSet) 
                throw new DataException(String.Format("ResultSet {0} does not exist", ResultSet)); 

            DataTable table = result.DataSet.Tables[ResultSet - 1]; 

            //actual condition verification
            //verify resultset column count matches expected
            if (table.Columns.Count != Count) 
                throw new DataException(String.Format(
                    "ResultSet {0}: {1} columns did not match the {2} columns expected",
                    ResultSet, table.Columns.Count, Count)); 
        }
        //this method is called to provide the string shown in the
        //test conditions panel grid describing what the condition tests
        public override string ToString()
        {
            return String.Format(
                "Condition fails if ResultSet {0} does not contain {1} columns",
                ResultSet, Count); 
        }
         //below are the test condition properties
        //that are exposed to the user in the property browser
        #region Properties

        //property specifying the resultset for which
        //you want to check the column count
        [Category("Test Condition")]
        [DisplayName("ResultSet")]
        [Description("ResultSet Number")]
        public int ResultSet
        {
            get { return _resultSet; }
 
            set
            {
                //basic validation
                if (value < 1) 
                    throw new ArgumentException("ResultSet cannot be less than 1");
 
                _resultSet = value; 
            }
        }
 
        //property specifying
        //expected column count
        [Category("Test Condition")]
        [DisplayName("Count")]
        [Description("Column Count")]
        public int Count
        {
            get { return _count; }
 
            set
            {
                //basic validation
                if (value < 0) 
                    throw new ArgumentException("Count cannot be less than 0");
 
                _count = value; 
            }
        }
 
        #endregion
    }
}

Anschließend erstellen Sie das Projekt.

So erstellen Sie das Projekt

  • Klicken Sie im Menü Erstellen auf Projektmappe erstellen.

Anschließend erfassen Sie im Projekt generierte Assemblyinformationen, u. a. Version, Kultur und PublicKeyToken.

So erfassen Sie Assemblyinformationen

  1. Klicken Sie im Menü Ansicht auf Weitere Fenster, und klicken Sie dann auf Befehlsfenster, um das Befehlsfenster zu öffnen.

  2. Geben Sie im Befehlsfenster folgenden Code ein. Ersetzen Sie FilePath durch den Pfad und Dateinamen der kompilierten DLL-Datei. Schließen Sie Pfad und Dateiname in Anführungszeichen ein.

    Tipp

    Der Pfad der kompilierten DLL-Datei lautet standardmäßig Projektmappenpfad\bin\Debug oder Projektmappenpfad\bin\Release.

    ? System.Reflection.Assembly.LoadFrom(@"FilePath").FullName

  3. Drücken Sie die EINGABETASTE. Die Zeile sollte mit Ihrem entsprechenden PublicKeyToken etwa folgendermaßen aussehen:

    "ColumnCountCondition, Version=1.0.0.0, Culture=neutral, PublicKeyToken=nnnnnnnnnnnnnnnn"

    Notieren oder kopieren Sie diese Assemblyinformationen, da Sie sie für das nächste Verfahren benötigen.

Danach erstellen Sie eine XML-Datei mit den Assemblyinformationen, die Sie im vorhergehenden Verfahren erfasst haben.

So erstellen Sie die XML-Datei

  1. Wählen Sie im Projektmappen-Explorer das Projekt ColumnCountCondition aus.

  2. Klicken Sie im Menü Projekt auf Neues Element hinzufügen.

  3. Suchen Sie im Bereich Vorlagen das Element XML-Datei, und wählen Sie es aus.

  4. Geben Sie im Textfeld Name den Namen "ColumnCountCondition.Extensions.xml" ein, und klicken Sie auf die Schaltfläche Hinzufügen.

    Dem Projekt wird im Projektmappen-Explorer die Datei ColumnCountCondition.Extensions.xml hinzugefügt.

  5. Öffnen Sie die Datei ColumnCountCondition.Extensions.xml, und aktualisieren Sie diese so, dass sie mit dem folgenden XML übereinstimmt. Ersetzen Sie die Version, die Kultur und das PublicKeyToken, die Sie im vorherigen Verfahren abgerufen haben.

    <?xml version="1.0" encoding="utf-8"?>
<extensions assembly=""
            version="1" xmlns="urn:Microsoft.Data.Schema.Extensions"
            xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
            xsi:schemaLocation="urn:Microsoft.Data.Schema.Extensions Microsoft.Data.Schema.Extensions.xsd">

  <extension type="ColumnCountCondition.ResultSetColumnCountCondition" assembly="ColumnCountCondition, Version=1.0.0.0, Culture=neutral, PublicKeyToken=nnnnnnnnnnnnnnnn" enabled="true"/>
</extensions>

  6. Klicken Sie im Menü Datei auf Speichern.

Danach kopieren Sie die Assemblyinformationen und die XML-Datei in das Erweiterungsverzeichnis. Beim Start von Visual Studio werden sämtliche Erweiterungen im Verzeichnis "%Programme%\Microsoft Visual Studio 10.0\VSTSDB\Extensions" und in den Unterverzeichnissen identifiziert und für die Verwendung in der Sitzung registriert.

So kopieren Sie die Assemblyinformationen und die XML-Datei in das Erweiterungsverzeichnis

  1. Erstellen Sie im Verzeichnis "%Programme%\Microsoft Visual Studio 10.0\VSTSDB\Extensions\" den neuen Ordner "CustomConditions".

  2. Kopieren Sie die Assemblydatei "ColumnCountCondition.dll" aus dem Ausgabeverzeichnis (standardmäßig "Eigene Dateien\Visual Studio 2010\Projects\CustomConditions\CustomConditions\bin\Debug\") in das von Ihnen erstellte Verzeichnis "%Programme%\Microsoft Visual Studio 10.0\VSTSDB\Extensions\CustomConditions".

  3. Kopieren Sie die Assemblydatei "ColumnCountCondition.Extensions.xml", die sich standardmäßig im Verzeichnis "Eigene Dateien\Visual Studio 2010\Projects\CustomConditions\CustomConditions\" befindet, in das von Ihnen erstellte Verzeichnis "%Programme%\Microsoft Visual Studio 10.0\VSTSDB\Extensions\CustomConditions".

    Tipp

    Als Vorgehensweise wird empfohlen, die Erweiterungsassemblys in einem Ordner im Verzeichnis %Programme%\Microsoft Visual Studio 10.0\VSTSDB\Extensions einzufügen. So können Sie leichter ermitteln, welche Erweiterungen im Produkt enthalten waren und welche Sie benutzerdefiniert erstellt haben. Ordner werden auch zum Einordnen der Erweiterungen in bestimmte Kategorien empfohlen.

Im nächsten Schritt wird eine neue Visual Studio-Sitzung gestartet und ein Datenbankprojekt erstellt.

So starten Sie eine neue Visual Studio-Sitzung und erstellen ein Datenbankprojekt

  1. Starten Sie eine zweite Sitzung von Visual Studio.

  2. Klicken Sie im Menü Datei auf Neu und anschließend auf Projekt.

  3. Erweitern Sie im Dialogfeld Neues Projekt in der Liste Installierte Vorlagen den Knoten Datenbank, und klicken Sie anschließend auf SQL Server.

  4. Klicken Sie im Detailbereich auf SQL Server 2008-Datenbankprojekt.

  5. Geben Sie im Textfeld Name den Namen "SampleConditionDB" ein, und klicken Sie auf OK.

Als Nächstes erstellen Sie einen Komponententest.

So erstellen Sie einen neuen Datenbankkomponententest in einer neuen Testklasse

  1. Klicken Sie im Menü Test auf Neuer Test.

    Tipp

    Sie können auch den Projektmappen-Explorer öffnen, mit der rechten Maustaste auf ein Testprojekt klicken, auf Hinzufügen zeigen und anschließend auf Neuer Test klicken.

    Das Dialogfeld Neuen Test hinzufügen wird angezeigt.

  2. Klicken Sie in der Liste Vorlagen auf Datenbankkomponententest.

  3. Geben Sie unter Testname den Namen "SampleUnitTest" ein.

  4. Klicken Sie unter Zu Testprojekt hinzufügen auf Neues Visual C#-Testprojekt erstellen.

  5. Klicken Sie auf OK.

    Das Dialogfeld Neues Testprojekt wird angezeigt.

  6. Geben Sie als Projektnamen SampleUnitTest ein.

  7. Klicken Sie auf Abbrechen, um den Komponententest zu erstellen, ohne das Testprojekt für die Verwendung einer Datenbankverbindung zu konfigurieren.

    Tipp

    Weitere Informationen zum Erstellen und Konfigurieren von Datenbankkomponententests mit Datenbankverbindungen finden Sie unter Gewusst wie: Erstellen eines leeren Datenbankkomponententests.

    Der leere Test wird im Datenbankkomponententest-Designer angezeigt. Dem Testprojekt wird eine Visual C#-Quellcodedatei hinzugefügt.

  8. Klicken Sie auf Klicken Sie zum Erstellen hierauf, um das Erstellen des Komponententests abzuschließen.

Letztlich wird die neue Bedingung im SQL Server-Projekt angezeigt.

So zeigen Sie die neue Bedingung an

  1. Klicken Sie auf im Datenbankkomponententest-Designer unter Testbedingungen in der Spalte Name auf den Test inconclusiveCondition1.

  2. Klicken Sie auf die Symbolleistenschaltfläche Testbedingung löschen, um den Test inconclusiveCondition1 zu entfernen.

  3. Klicken Sie auf das Dropdownelement Testbedingungen, und wählen Sie ResultSet Column Count aus.

  4. Klicken Sie auf die Symbolleistenschaltfläche Testbedingung hinzufügen, um die benutzerdefinierte Testbedingung hinzuzufügen.

  5. Konfigurieren Sie im Eigenschaftenfenster die Eigenschaften Count, Enabled und ResultSet.

    Weitere Informationen finden Sie unter Gewusst wie: Hinzufügen von Testbedingungen zu Datenbankkomponententests.

Siehe auch

Aufgaben

Gewusst wie: Erstellen von Testbedingungen für den Datenbankkomponententest-Designer

Gewusst wie: Registrieren und Verwalten von Funktionserweiterungen

Konzepte

Erstellen und Definieren von Datenbankkomponententests

Weitere Ressourcen

Verwalten der Signierung von Assemblys und Manifesten

Änderungsprotokoll

Datum

Versionsgeschichte

Grund

Dezember 2010

Kleinere Korrekturen (Attribute) am endgültigen Code vorgenommen, um Kundenfeedback zu entsprechen.

Kundenfeedback.