Procedura dettagliata: creazione ed esecuzione di unit test

Articolo
08/11/2011

In questa procedura dettagliata vengono illustrate le operazioni di creazione, esecuzione e personalizzazione di una serie di test tramite Microsoft Visual Studio 2010. Sarà innanzitutto illustrato il progetto C# in fase di sviluppo, quindi saranno creati i test in cui sarà utilizzato il codice e saranno esaminati i risultati. Sarà infine possibile modificare il codice del progetto ed eseguire nuovamente i test.

Nota

Per informazioni sulle modalità di esecuzione dei test dalla riga di comando, vedere Procedura dettagliata: utilizzo dell'utilità di test della riga di comando.

In questa procedura dettagliata, si completeranno le seguenti attività:

Preparazione di un progetto "Bank Account" da utilizzare nella procedura dettagliata.
Apertura di un progetto esistente.
Creazione di unit test per metodi pubblici e privati.
Esecuzione dei test nel codice.
Individuazione e correzione degli errori nei test.
Individuazione e correzione degli errori nel codice.

Prerequisiti

Progetto Woodgrove Bank. Vedere Progetto di esempio per la creazione di unit test.

Preparazione per la procedura dettagliata

Per preparare la procedura dettagliata

Aprire Visual Studio 2010 Premium.
Scegliere Nuovo dal menu File, quindi scegliere Progetto.

Viene visualizzata la finestra di dialogo Nuovo progetto.
In Modelli installati fare clic su Visual C#.
Nell'elenco di tipi di applicazione fare clic su Libreria di classi.
Digitare Bank nella casella Nome, quindi scegliere OK.

Nota

Se il nome "Bank" è stato già utilizzato, scegliere un altro nome per il progetto.

Viene creato nuovo progetto Bank, visualizzato in Esplora soluzioni con il file Class1.cs aperto nell'Editor di codice.

Nota

Per aprire il file Class1.cs nell'Editor di codice, nel caso non fosse aperto, fare doppio clic sul file stesso in Esplora soluzioni.
Copiare il codice sorgente da Progetto di esempio per la creazione di unit test.
Sostituire il contenuto originale di Class1.cs con il codice di Progetto di esempio per la creazione di unit test.
Scegliere Compila soluzione dal menu Compila.

A questo punto si dispone di un progetto denominato Bank che contiene il codice sorgente da testare e gli strumenti da utilizzare a questo scopo. Nello spazio dei nomi per Bank, BankAccountNS, è presente la classe pubblica BankAccount, i cui metodi saranno testati nelle procedure seguenti.

Creazione di unit test

Prerequisito: attenersi alla procedura Preparazione per la procedura dettagliata.

Per creare uno unit test

Fare doppio clic sul file Class1.cs nel progetto Bank, in Esplora soluzioni, se non è aperto nell'Editor di codice.
Nella classe BankAccount nel file Class1.cs, scorrere fino al metodo Debit().
Fare clic con il pulsante destro del mouse sul metodo Debit() e selezionare Crea unit test.

Viene visualizzata la finestra di dialogo Crea unit test.

In Selezione corrente, in una struttura ad albero viene visualizzata la classe e la gerarchia di membri dell'assembly in cui si trova la classe BankAccount. In questa pagina è possibile generare unit test per qualsiasi selezione di membri e scegliere un progetto di test in cui si desidera inserire gli unit test generati.

Nella struttura ad albero, è selezionato solo il metodo Debit(). Lasciare tale metodo selezionato e selezionare anche il metodo Credit().
Per Progetto di output, selezionare Crea un nuovo Progetto di test Visual C#.
Fare clic su Impostazioni.

Verrà visualizzata la finestra di dialogo Impostazioni di generazione test. In Impostazioni di denominazione, è possibile modificare il metodo di generazione dei nomi dei file, delle classi e dei metodi del test. In Generale, è possibile cambiare altri aspetti della generazione del test. Non alterare i valori predefiniti per queste impostazioni e fare clic su OK.
Nella finestra di dialogo Genera unit test scegliere OK.

Viene visualizzata la finestra di dialogo Nuovo progetto di test.
Accettare il nome predefinito e fare clic su Crea.

Viene creato un progetto denominato TestProject1, visualizzato in Esplora soluzioni.

Al progetto TestProject1 viene aggiunto un file denominato BankAccountTest.cs, contenente una classe di test. La classe viene popolata con una proprietà TestContext e con i metodi per testare i metodi Debit() e Credit().

Nota

A ogni metodo di test viene automaticamente assegnato l'attributo TestMethod(). Ogni test corrisponde a un singolo metodo nel codice sotto test che si desidera testare. I metodi di test sono contenuti in una classe di test a cui è assegnato l'attributo TestClass().
In BankAccountTest.cs specificare i valori per le variabili da testare. Scorrere fino al metodo DebitTest dove sono visualizzate le righe // TODO che indicano le variabili da impostare.
Per apprendere quali valori utilizzare per il metodo DebitTest, aprire il file Class1.cs e passare al metodo Main. Il nome del cliente inizia con Mr. Bryan Walton, il saldo del conto inizia con 11.99, il metodo Credit viene richiamato con il parametro 5.77 e il metodo Debit viene richiamato con il parametro 11.22. Quindi, se questo conto inizia con un valore di Balance di 11.99, chiamando il metodo Debit quando si invia 11.22 viene restituito il nuovo valore di Balance di 0.77.

Nota

Più avanti in questa procedura si utilizzerà questo valore previsto di Balance (0.77).
Nel file BankAccountTest.cs e scorrere fino al metodo DebitTest.

Impostare i seguenti valori:

BankAccount target = new BankAccount("Mr. Bryan Walton", 11.99);
double amount = 11.22;

Nel metodo CreditTest aggiungere "Mr. Bryan Walton", 11.99) al nuovo BankAccount.
Salvare il file BankAccountTest.cs.

È stato creato un file del codice sorgente contenente i test per il progetto Bank. Adesso è possibile eseguire i test nella classe BankAccountTest nel codice del progetto Bank.

Esecuzione e personalizzazione di unit test

Prerequisito: seguire la procedura Creazione di unit test.

Per eseguire e personalizzare uno unit test

Nel menu Test fare clic su Finestre e selezionare Visualizzazione test.

Verrà visualizzata la finestra Visualizzazione test.
Fare clic con il pulsante destro del mouse su DebitTest e scegliere Esegui selezione.

Verrà aperta la finestra Risultati test, se non è giù visualizzata. Viene eseguito il test DebitTest.

Nella colonna Risultato della finestra Risultati test viene visualizzato lo stato del test In esecuzione durante l'esecuzione del test. Al termine dell'esecuzione del test, il risultato del test cambia in Senza risultato.
Nella finestra Risultati test fare clic con il pulsante destro del mouse sulla riga che rappresenta il test e scegliere Visualizza dettagli risultati test.
Nella pagina Dettagli risultati test viene visualizzato il messaggio di errore "Impossibile eseguire Assert.Inconclusive. Impossibile verificare un metodo che non restituisce valori". Per creare correttamente un test, è necessario innanzitutto trovare e valutare questa istruzione Assert.
Per individuare il metodo di test contenente l'istruzione Assert, aprire il file BankAccountTest.cs e scorrere fino al metodo DebitTest().
L'istruzione Assert è l'ultima riga del metodo DebitTest. Contiene quanto segue:
```
Assert.Inconclusive("A method that does not return a value cannot be verified.");
```
Impostare l'istruzione Assert come commento.
Se il test viene eseguito a questo stadio, il risultato sarà Superato ma solo perché l'oggetto del test è inesistente. È necessario aggiungere il codice per l'esecuzione del test che fornisca i risultati previsti. Aggiungere la seguente istruzione alla fine del metodo DebitTest:
```
Assert.AreEqual((System.Convert.ToDouble(0.77)), target.Balance, 0.05);
```
Questa istruzione confronta il risultato previsto (0.77) con il risultato effettivo dalla chiamata del metodo Balance della classe BankAccount. Se i due valori non sono uguali, Assert restituisce False e il test viene interrotto.

Nota

Nell'istruzione Assert è presente un terzo parametro, delta, con un valore di 0.05. Il parametro delta è obbligatorio in questo overload del metodo Assert.AreEqual; consente di compensare l'errore di arrotondamento intrinseco nei tipi a virgola mobile come Doubles.

È stato eseguito il metodo DebitTest generato della classe di test BankAccountTest; se necessario, sono state apportate modifiche. Adesso è possibile testare la correttezza del metodo Debit nell'applicazione.

Esecuzione di unit test e correzione del codice

Prerequisito: seguire la procedura Esecuzione e personalizzazione di unit test.

Per eseguire uno unit test e una correzione del codice

Eseguire nuovamente il test Debit. Nel file BankAccountTest.cs, fare clic con il pulsante destro del mouse sul metodo DebitTest (), quindi fare clic su Esegui test.

Nella colonna Risultato nella finestra Risultati test, viene visualizzato lo stato del test come In esecuzione durante l'esecuzione del test. Al termine dell'esecuzione del test, il risultato del test cambia in Test non superato.
Nella finestra Risultati test fare clic con il pulsante destro del mouse sulla riga che rappresenta il test e scegliere Visualizza dettagli risultati test.

Verrà aperta la pagina Dettagli risultati, con il messaggio di errore "Impossibile eseguire Assert.AreEqual. Prevista una differenza non maggiore di < 0.05 > tra il valore previsto < 0.77 > e il valore effettivo < 23.21 >." Questi numeri sembrano indicare un'operazione matematica non corretta. Poiché il metodo DebitTest della classe BankAccountTest testa il metodo Debit della classe BankAccount, è necessario innanzitutto verificare il metodo Debit.
Aprire il file Class1.cs e scorrere fino al metodo Debit.
Notare la seguente assegnazione:
```
m_balance += amount;
```
Con questa assegnazione viene aggiunto un importo al saldo mentre nel metodo Debit deve essere sottratto. Modificare questa riga in modo che contenga quanto segue:
```
m_balance -= amount;
```
Eseguire di nuovo il test Debit.

Nella colonna Risultato della finestra Risultati test viene visualizzato Superato per DebitTest.

Nota

Non è stato necessario ricompilare il progetto di test dopo la modifica del codice sorgente perché l'esecuzione di un test determina la compilazione del progetto senza avvisi.

È stato creato uno unit test che funziona e, attraverso tale test, è stato individuato e corretto un errore del codice.

Creazione ed esecuzione di uno unit test per un metodo privato

Prerequisito: seguire la procedura Esecuzione di unit test e correzione del codice.

Per creare ed eseguire uno unit test per un metodo privato

Aprire il file Class1.cs nel progetto Bank.
Fare clic con il pulsante destro del mouse sul metodo FreezeAccount() e scegliere Crea unit test.

Verrà visualizzata la finestra di dialogo Crea unit test.

Nella struttura ad albero che viene visualizzata, è selezionato solo il metodo FreezeAccount().
(Facoltativo) Fare clic su Filtro, quindi deselezionare Visualizza elementi non pubblici. Il metodo FreezeAccount() viene rimosso dall'elenco dei metodi figlio della classe BankAccount. Fare clic nuovamente su Filtro, quindi selezionare Visualizza elementi non pubblici per visualizzare nuovamente il metodo FreezeAccount().
Assicurarsi che il metodo FreezeAccount() sia selezionato, quindi scegliere OK.

Verrà creato un file della funzione di accesso privata nuovo denominato Bank.accessor. Tale file contiene specifici metodi della funzione di accesso utilizzati nel test per chiamare indirettamente metodi privati nella classe BankAccount. Il nuovo file viene visualizzato in Esplora soluzioni nella cartella Riferimenti test.
Aprire il file BankAccountTest.cs e scorrere fino al metodo FreezeAccountTest().

Modificare il codice del metodo FreezeAccountTest () come indicato di seguito. Le aree nuove o modificate vengono indicate:

public void FreezeAccountTest()
{
    BankAccount_Accessor target = new BankAccount_Accessor("Mr. Bryan Walton", 11.99); // TODO: Initialize to an appropriate value
target.FreezeAccount(); 
    // Assert.Inconclusive("A method that does not return a value cannot be verified.");
    
    bool creditAccount = false; // False means account could be credited: Fail test. 
    // Try to credit account
    try
    {
        target.Credit(1.00); 
    }
    catch (System.Exception)
    {
        // Threw exception. FreezeAccount worked correctly: Pass test. 
        creditAccount = true;
    }
    
    // Assert fails if 'creditAccount' condition is false. Fail test.
    Assert.IsTrue(creditAccount, "Was able to credit account.");
}

Eseguire il test FreezeAccountTest.

Nella colonna Risultato della finestra Risultati test lo stato del test finale viene visualizzato come Superato. È il risultato previsto perché il test ha chiamato il metodo Credit() dopo avere bloccato l'account chiamando il metodo FreezeAccount().

È stato aggiunto un metodo privato, creato un nuovo unit test per tale metodo ed eseguito il test. È possibile eseguire il test più volte, utilizzando per la variabile balance altri valori limite, ad esempio 15.00.

Passaggi successivi

Quando si eseguono test su codice in un assembly, è possibile verificare la percentuale del codice del progetto che si sta testando raccogliendo dati di code coverage. Per ulteriori informazioni, vedere Procedura dettagliata: eseguire test e visualizzare il code coverage.

È possibile eseguire test da una riga di comando anziché in Visual Studio. Per ulteriori informazioni, vedere Procedura dettagliata: utilizzo dell'utilità di test della riga di comando.

Se si utilizza Visual Studio 2010 Ultimate, è possibile creare test di carico per isolare problemi di stress e prestazioni tramite gli unit test.

Procedura dettagliata: creazione ed esecuzione di un test di carico contenente unit test

Vedere anche

Attività

Progetto di esempio per la creazione di unit test

Condividi tramite