Procedura dettagliata: utilizzo di una condizione di test personalizzata per verificare i risultati di una stored procedure

Articolo
08/15/2011

In questa procedura dettagliata di estensione di funzionalità si creerà una condizione di test e se ne verificherà la funzionalità creando uno unit test del database. Il processo include la creazione di un progetto Libreria di classi per la condizione di test, la firma e la registrazione del progetto. Se si dispone già di una condizione di test da aggiornare, vedere Procedura: aggiornare una condizione di test personalizzata da una versione precedente.

Vengono illustrate le attività seguenti:

Creazione di una condizione di test.
Firma dell'assembly con un nome sicuro.
Aggiunta dei riferimenti necessari al progetto.
Compilazione di un'estensione di funzionalità.
Registrazione della nuova estensione di funzionalità.
Test della nuova estensione di funzionalità.

Prerequisiti

Per completare questa procedura dettagliata è necessario disporre di Visual Studio Premium o Visual Studio Ultimate.

Creazione di una condizione di test personalizzata

Per prima cosa si creerà una libreria di classi.

Per creare una libreria di classi

Scegliere Nuovo dal menu File, quindi fare clic su Progetto.
Nella finestra di dialogo Nuovo progetto scegliere Visual C# in Tipi progetto.
Selezionare Libreria di classi in Modelli.
Nella casella di testo Nome digitare ColumnCountCondition e fare clic su OK.

Si firmerà quindi il progetto.

Per firmare il progetto

Nel menu Progetto scegliere Proprietà ColumnCountCondition.
Nella scheda Firma selezionare la casella di controllo Firma assembly.
Nella casella Scegli un file chiave con nome sicuro fare clic su <Nuova>.

Verrà visualizzata la finestra di dialogo Crea chiave con nome sicuro.
Nella casella Nome file di chiave digitare SampleKey.
Digitare e confermare una password, quindi scegliere OK.

Quando si compilerà la soluzione, il file di chiave verrà utilizzato per firmare l'assembly.
Scegliere Salva tutto dal menu File.
Dal menu Compila scegliere Compila soluzione.

Si aggiungeranno quindi i riferimenti necessari al progetto.

Per aggiungere i riferimenti applicabili al progetto

In Esplora soluzioni selezionare il progetto ColumnCountCondition.
Scegliere Aggiungi riferimento dal menu Progetto.

Verrà visualizzata la finestra di dialogo Aggiungi riferimento.
Selezionare la scheda .NET.
Nella colonna Nome componente individuare i seguenti componenti:
- Microsoft.Data.Schema
- Microsoft.Data.Schema.UnitTesting
Suggerimento

Tenere premuto il tasto CTRL e contemporaneamente fare clic per selezionare più componenti.
Scegliere OK dopo aver selezionato tutti i componenti necessari.

I riferimenti selezionati verranno visualizzati nel nodo Riferimenti del progetto in Esplora soluzioni.

Suggerimento
Tenere premuto il tasto CTRL e contemporaneamente fare clic per selezionare più componenti.

Creazione della classe ResultSetColumnCountCondition

Si rinominerà quindi Class1 con ResultSetColumnCountCondition e lo si deriverà da TestCondition. La classe ResultSetColumnCountCondition è una condizione di test semplice che consente di verificare che il numero di colonne restituito in ResultSet sia quello previsto. È possibile utilizzare questa condizione per assicurarsi che il contratto per una stored procedure sia corretto.

Per creare una classe di condizioni di test

In Esplora soluzioni fare clic con il pulsante destro del mouse su Class1.cs, scegliere Rinomina e digitare ResultSetColumnCountCondition.cs.
Fare clic su Sì per confermare la ridenominazione di tutti i riferimenti a Class1.

Aprire il file ResultSetColumnCountCondition.cs e aggiungere le seguenti istruzioni using al file:

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

Derivare la classe da TestCondition:

    public class ResultSetColumnCountCondition : TestCondition

Aggiungere l'attributo DatabaseSchemaProviderCompatibilityAttribute. Per ulteriori informazioni, vedere Generare dati di test specializzati con un generatore di dati personalizzato.
```
[DatabaseSchemaProviderCompatibility(typeof(DatabaseSchemaProvider))]
   [DatabaseSchemaProviderCompatibility(null)]
    [DisplayName("ResultSet Column Count")]
    public class ResultSetColumnCountCondition : TestCondition
```
La condizione di test dispone di entrambi gli attributi di compatibilità così che:
- La condizione viene caricata quando è presente un provider di schema del database che eredita da DatabaseSchemaProvider. In questo modo viene gestita la situazione in cui la finestra di progettazione unit test del database dispone di un contesto del provider di schema del database. Se si desidera che la condizione di test sia specifica per SQL Server, è possibile specificare invece SqlDatabaseSchemaProvider.
- La condizione di test viene caricata quando non esistono provider di schema del database. Questa situazione si verifica quando lo unit test del database carica le estensioni senza un provider di schema del database.

Aggiungere l'attributo DisplayName:

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

Creare le variabili membro:

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

Creare il costruttore:

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

Eseguire l'override del metodo Assert. Il metodo include argomenti per IDbConnection, che rappresenta la connessione al database, e ExecutionResult. Il metodo utilizza DataSchemaException per la gestione degli errori.

        //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));
        }

Aggiungere il metodo seguente, che esegue l'override del metodo ToString.

        //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);
        }

Aggiungere le seguenti proprietà della condizione di test utilizzando gli attributi CategoryAttribute, DisplayNameAttribute e DescriptionAttribute:

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

Il codice finale avrà il seguente aspetto:

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

Si compilerà quindi il progetto.

Per compilare il progetto

Scegliere Compila soluzione dal menu Compila.

Si raccoglieranno quindi le informazioni sull'assembly generate nel progetto, inclusa la versione, le impostazioni cultura e PublicKeyToken.

Per raccogliere le informazioni sull'assembly

Dal menu Visualizza scegliere Altre finestre, quindi fare clic su Finestra di comando per aprire la finestra Comando.
Nella finestra Comando digitare il codice seguente. Sostituire FilePath con il percorso e il nome del file con estensione dll compilato. Racchiudere il percorso e il nome del file tra virgolette.

Nota

Per impostazione predefinita, il percorso del file con estensione dll compilato è PercorsoSoluzione\bin\Debug o PercorsoSoluzione\bin\Release.
```
? System.Reflection.Assembly.LoadFrom(@"FilePath").FullName
```
Premere Invio. La riga dovrebbe assomigliare alla seguente, con il PublicKeyToken specifico:
```
"ColumnCountCondition, Version=1.0.0.0, Culture=neutral, PublicKeyToken=nnnnnnnnnnnnnnnn"
```
Annotare o copiare queste informazioni sull'assembly, che verranno utilizzate nella procedura descritta di seguito.

Si creerà quindi un file XML utilizzando le informazioni sull'assembly raccolte nella procedura precedente.

Per creare il file XML

In Esplora soluzioni selezionare il progetto ColumnCountCondition.
Scegliere Aggiungi nuovo elemento dal menu Progetto.
Nel riquadro Modelli individuare e selezionare l'elemento File XML.
Nella casella di testo Nome digitare ColumnCountCondition.Extensions.xml, quindi fare clic sul pulsante Aggiungi.

Il file ColumnCountCondition.Extensions.xml verrà aggiunto al progetto in Esplora soluzioni.

Aprire il file ColumnCountCondition.Extensions.xml e aggiornarlo in modo tale che corrisponda al codice XML seguente. Sostituire la versione, le impostazioni cultura e il PublicKeyToken recuperati nel corso della procedura precedente.

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

Scegliere Salva dal menu File.

Si copieranno quindi le informazioni sull'assembly e il file XML nella directory Extensions. All'avvio di Visual Studio tutte le estensioni nella directory %Programmi%\Microsoft Visual Studio 10.0\VSTSDB\Extensions e nelle relative sottodirectory saranno identificate e registrate per essere utilizzate nella sessione.

Per copiare le informazioni sull'assembly e il file XML nella directory Extensions

Creare una nuova cartella denominata CustomConditions nella directory %Programmi%\Microsoft Visual Studio 10.0\VSTSDB\Extensions\.
Copiare il file di assembly ColumnCountCondition.dll dalla directory di output (per impostazione predefinita, Documenti\Visual Studio 2010\Progetti\CustomConditions\CustomConditions\bin\Debug\) nella directory %Programmi%\Microsoft Visual Studio 10.0\VSTSDB\Extensions\CustomConditions creata.

Copiare il file di assembly ColumnCountCondition.Extensions.xml (per impostazione predefinita contenuto nella directory Documenti\Visual Studio 2010\Progetti\CustomConditions\CustomConditions) nella directory %Programmi%\Microsoft Visual Studio 10.0\VSTSDB\Extensions\CustomConditions creata.

Suggerimento
Si consiglia di inserire gli assembly di estensioni in una cartella nella directory %Programmi%\Microsoft Visual Studio 10.0\VSTSDB\Extensions. In questo modo sarà più facile identificare quali estensioni erano incluse con il prodotto e quali sono state create personalmente. Si consiglia inoltre l'utilizzo di cartelle per organizzare le estensioni in categorie specifiche.

Si avvierà quindi una nuova sessione di Visual Studio e si creerà un progetto di database.

Per avviare una nuova sessione di Visual Studio e creare un progetto di database

Avviare una seconda sessione di Visual Studio.
Scegliere Nuovo dal menu File, quindi fare clic su Progetto.
Nella finestra di dialogo Nuovo progetto, nell'elenco Modelli installati espandere il nodo Database, quindi fare clic su SQL Server.
Nel riquadro dei dettagli fare clic su Progetto di database di SQL Server 2008.
Nella casella di testo Nome digitare SampleConditionDB e fare clic su OK.

Si creerà quindi uno unit test.

Per creare uno unit test del database all'interno di una nuova classe di test.

Scegliere Nuovo test dal menu File.

Nota

È anche possibile aprire Esplora soluzioni, fare clic con il pulsante destro del mouse sul progetto di test, scegliere Aggiungi, quindi Nuovo test.

Verrà visualizzata la finestra di dialogo Aggiungi nuovo test.
Nell'elenco Modelli fare clic su Unit test di database.
In Nome test digitare SampleUnitTest.
In Aggiungi a progetto di test fare clic su Crea nuovo progetto di test Visual C#.
Fare clic su OK.

Verrà visualizzata la finestra di dialogo Nuovo progetto di test.
Digitare SampleUnitTest per il nome del progetto.
Scegliere Annulla per creare lo unit test senza configurare il progetto di test per l'utilizzo di una connessione di database.

Nota

Per ulteriori informazioni sulla creazione e la configurazione di unit test del database con le connessioni di database, vedere Procedura: creare uno unit test del database vuoto.

Il test vuoto verrà visualizzato nella Finestra di progettazione unit test del database. Un file di codice sorgente di Visual C# verrà aggiunto al progetto di test.
Scegliere Fare clic qui per creare per completare la creazione dello unit test.

Si vedrà infine la nuova condizione visualizzata nel progetto di SQL Server.

Per visualizzare la nuova condizione

Nella Finestra di progettazione unit test del database fare clic sul test inconclusiveCondition1 nella colonna Nome in Condizioni di test.
Fare clic sul pulsante della barra degli strumenti Elimina condizione di test per rimuovere il test inconclusiveCondition1.
Fare clic sull'elenco a discesa Condizioni di test e selezionare ResultSet Column Count.
Fare clic sul pulsante della barra degli strumenti Aggiungi condizione di test per aggiungere la condizione di test personalizzata.
Nella finestra Proprietà configurare le proprietà Count, Enabled e ResultSet.

Per ulteriori informazioni, vedere Procedura: aggiungere condizioni di test a unit test del database.

Vedere anche

Cronologia delle modifiche

Data	Cronologia	Motivo
Dicembre 2010	Apportate rettifiche secondarie (attributi) al codice finale per soddisfare i commenti e suggerimenti dei clienti.	Commenti e suggerimenti dei clienti.

Dicembre 2010

Apportate rettifiche secondarie (attributi) al codice finale per soddisfare i commenti e suggerimenti dei clienti.

Commenti e suggerimenti dei clienti.

Condividi tramite