Nozioni di base sugli unit test

Per controllare che il codice funzioni come previsto, creare ed eseguire unit test. Si parla di unit test in quanto le funzionalità del programma vengono scomposte in comportamenti discreti testabili come singole unità. Esplora test di Visual Studio offre un modo flessibile ed efficiente per eseguire gli unit test e visualizzarne i risultati in Visual Studio. Visual Studio installa i framework per unit test Microsoft per codice gestito e nativo. Usare un framework di unit test per creare unit test, eseguirli e creare report con i relativi risultati. Eseguire nuovamente gli unit test quando si apportano modifiche per verificare che il codice funzioni ancora correttamente. Visual Studio Enterprise può eseguire questa operazione automaticamente con Live Unit Testing, che rileva i test interessati dalle modifiche del codice e li esegue in background durante la digitazione.

Gli unit test offrono i risultati migliori in relazione alla qualità del codice quando sono parte integrante del flusso di lavoro di sviluppo di software. Non appena si scrive una funzione o un altro blocco di codice dell'applicazione, creare unit test per verificare il comportamento del codice in risposta a casi standard, limite e non corretti di dati di input e quindi controllare eventuali presupposti espliciti o impliciti presenti nel codice. Con lo sviluppo basato su test, gli unit test vengono creati prima di scrivere il codice e quindi vengono usati sia come documentazione di progettazione sia come specifiche funzionali.

Esplora test può eseguire anche framework per unit test di terze parti e open source che hanno implementato le interfacce dei componenti aggiuntivi di Esplora test. È possibile aggiungere molti di questi framework tramite Gestione estensioni di Visual Studio e la Visual Studio Gallery. Per altre informazioni, vedere Installare framework di unit test di terze parti.

È possibile generare rapidamente progetti di test e metodi di test dal codice oppure creare manualmente i test necessari. Quando si usa IntelliTest per esplorare il codice .NET, è possibile generare dati di test e una suite di unit test. Per ogni istruzione nel codice viene generato un input di test che eseguirà l'istruzione. Informazioni su come generare unit test per il codice .NET.

Attività iniziali

Per un'introduzione agli unit test che mostra direttamente la creazione di codice, vedere uno degli argomenti seguenti:

• Procedura dettagliata: Creare ed eseguire unit test per il codice .NET

• Procedura dettagliata: Sviluppo basato su test con Esplora test

• Scrivere unit test per C/C++ in Visual Studio

Esempio di soluzione Bank

In questo articolo si usa come esempio lo sviluppo di un'applicazione fittizia denominata MyBank. Per seguire le spiegazioni disponibili in questo argomento non è necessario il codice effettivo. I metodi di test vengono scritti in C# e vengono presentati tramite il framework di testing unità Microsoft per codice gestito. I concetti sono tuttavia facilmente trasferibili in altri linguaggi e framework.

Il primo tentativo di progettazione per l'applicazione MyBank include un componente conti che rappresenta un singolo conto e le rispettive transazioni con la banca e un componente database che rappresenta la funzionalità per l'aggregazione e la gestione dei singoli conti.

Verrà creata una soluzione Bank che contiene due progetti:

• Accounts

• BankDB

Il primo tentativo di progettazione del progetto Accounts include una classe per le informazioni di base su un account, un'interfaccia che specifica la funzionalità comune di un tipo di conto, ad esempio il deposito e il prelievo di beni dal conto, e una classe derivata dall'interfaccia che rappresenta un conto corrente. Il progetto Accounts inizia con la creazione dei file di origine seguenti:

• AccountInfo.cs definisce le informazioni di base per un conto.

• IAccount.cs definisce un'interfaccia IAccount standard per un conto, inclusi metodi per il deposito e il prelievo di beni da un conto e per il recupero del saldo del conto.

• CheckingAccount.cs contiene la classe CheckingAccount che implementa l'interfaccia IAccount per un conto corrente.

L'esperienza mostra che per un prelievo da un conto corrente è necessario essere sicuri che l'importo prelevato sia inferiore al saldo del conto. Viene quindi eseguito l'override del metodo IAccount.Withdraw in CheckingAccount con un metodo che verifica questa condizione. Il metodo può avere un aspetto analogo al seguente:

public void Withdraw(double amount)
{
    if(m_balance >= amount)
    {
        m_balance -= amount;
    }
    else
    {
        throw new ArgumentException(nameof(amount), "Withdrawal exceeds balance!");
    }
}

Ora che è disponibile codice, è possibile passare al test.

Creare progetti di unit test e metodi di test (C#)

Per C#, spesso è più rapido generare lo stub di unit test e unit test dal codice. In alternativa, è possibile creare il progetto di unit test e i test manualmente, in base alle esigenze. Per creare unit test dal codice con un framework di terze parti, è necessario installare una di queste estensioni: NUnit o xUnit. Se non si usa C#, ignorare questa sezione e passare a Creare manualmente il progetto di unit test e gli unit test.

Generare progetto e stub di unit test

1. Nella finestra dell'editor del codice fare clic con il pulsante destro del mouse e scegliere Crea unit test dal menu di scelta rapida.

   

   Nota

   Il comando di menu Crea unit test è disponibile solo per il codice C#. Per usare questo metodo con .NET Core o .NET Standard, è necessario Visual Studio 2019 o versione successiva.

2. Fare clic su OK per accettare le impostazioni predefinite per creare gli unit test oppure modificare i valori usati per creare e denominare il progetto di unit test e gli unit test. È possibile selezionare il codice aggiunto per impostazione predefinita ai metodi di unit test.

   

3. Gli stub di unit test vengono creati in un nuovo progetto di unit test per tutti i metodi nella classe.

   

4. A questo scopo, è possibile apprendere come scrivere i test per rendere significativo lo unit test e tutti gli unit test aggiuntivi da aggiungere per testare accuratamente il codice.

Creare il progetto di unit test e gli unit test manualmente

Un progetto unit test rispecchia in genere la struttura di un progetto a codice singolo. Nell'esempio MyBank si aggiungono due progetti unit test denominati AccountsTests e BankDbTests alla soluzione Bank . I nomi dei progetti di test sono arbitrari, ma è consigliabile adottare una convenzione di denominazione standard.

Per aggiungere un progetto unit test a una soluzione:

1. In Esplora soluzioni fare clic con il pulsante destro del mouse sulla soluzione e scegliere Aggiungi>NuovoProgetto.

2. Digitare test nella casella di ricerca del modello di progetto per trovare un modello di progetto unit test per il framework di test che si vuole usare. Negli esempi di questo argomento viene usato MSTest.

3. Nella pagina successiva assegnare un nome al progetto. Per testare il progetto Accounts dell'esempio, è possibile assegnare al progetto il nome AccountsTests.

4. Nel progetto unit test aggiungere un riferimento al progetto di codice da testare, che nell'esempio corrisponde al progetto Accounts.

   Per creare il riferimento al progetto di codice:

   1. Nel progetto di unit test in Esplora soluzioni fare clic con il pulsante destro del mouse sul nodo Riferimenti o dipendenze, quindi scegliere Aggiungi riferimento progetto o Aggiungi riferimento, a qualsiasi elemento disponibile.

   2. Nella finestra di dialogo Gestione riferimenti aprire il nodo Soluzione e scegliere Progetti. Selezionare il nome del progetto di codice e chiudere la finestra di dialogo.

Ogni progetto unit test contiene classi che rispecchiano i nomi delle classe del progetto di codice. Nell'esempio il progetto AccountsTests contiene le classi seguenti:

• La classeAccountInfoTests contiene i metodi di unit test per la classe AccountInfo nel progetto Accounts .

• La classeCheckingAccountTests contiene i metodi di unit test per la classe CheckingAccount .

Scrivere i test

Il framework di unit test usato e Visual Studio IntelliSense forniranno indicazioni per la scrittura del codice per gli unit test per un progetto di codice. Per l'esecuzione in Esplora test, la maggior parte dei framework richiede l'aggiunta di attributi specifici per identificare i metodi di unit test. I framework offrono anche un modo, in genere tramite istruzioni Assert o attributi di metodo, per indicare se un metodo di test ha avuto esito positivo o negativo. Altri attributi identificano metodi di configurazione facoltativi che si trovano in corrispondenza dell'inizializzazione delle classi e prima di ogni metodo di test e dei metodi di disinstallazione eseguiti dopo ogni metodo di test e prima dell'eliminazione della classe.

Lo schema AAA (Arrange, Act, Assert) è un modo comune per scrivere unit test per un metodo da testare.

• La sezione Arrange di un metodo di unit test inizializza oggetti e imposta il valore dei dati passati al metodo da testare.

• La sezione Act richiama il metodo da testare con i parametri definiti.

• La sezione Assert verifica che l'azione del metodo da testare si comporti come previsto. Per .NET, i metodi nella classe vengono spesso usati per la Assert verifica.

Per testare il metodo dell'esempio CheckingAccount.Withdraw , è possibile scrivere due test: uno che verifica il comportamento standard del metodo e uno che verifica che un ritiro di più del saldo avrà esito negativo (il codice seguente mostra uno unit test MSTest, supportato in .NET.). Nella classe CheckingAccountTests vengono aggiunti i metodi seguenti:

[TestMethod]
public void Withdraw_ValidAmount_ChangesBalance()
{
    // arrange
    double currentBalance = 10.0;
    double withdrawal = 1.0;
    double expected = 9.0;
    var account = new CheckingAccount("JohnDoe", currentBalance);

    // act
    account.Withdraw(withdrawal);

    // assert
    Assert.AreEqual(expected, account.Balance);
}

[TestMethod]
public void Withdraw_AmountMoreThanBalance_Throws()
{
    // arrange
    var account = new CheckingAccount("John Doe", 10.0);

    // act and assert
    Assert.ThrowsException<System.ArgumentException>(() => account.Withdraw(20.0));
}

Per altre informazioni sui framework per unit test Microsoft, vedere uno degli argomenti seguenti:

• Eseguire unit test del codice

• Scrittura di unit test per C/C++

• Usare il framework MSTest negli unit test

Impostare i timeout per gli unit test

Se si usa il framework MSTest, è possibile usare TimeoutAttribute per impostare un timeout per un singolo metodo di test:

[TestMethod]
[Timeout(2000)]  // Milliseconds
public void My_Test()
{ ...
}

Per impostare il timeout sul valore massimo permesso:

[TestMethod]
[Timeout(TestTimeout.Infinite)]  // Milliseconds
public void My_Test ()
{ ...
}

Eseguire test in Esplora test

Quando si compila il progetto di test, i test vengono visualizzati in Esplora test. Se Esplora test non è visibile, scegliere Test dal menu di Visual Studio, scegliere Windows e quindi Esplora test oppure premere CTRL + E, T.

Quando si eseguono, si scrivono e si rieseguono i test, Esplora test può visualizzare i risultati nei gruppi Test non superati, Test superati, Test ignorati e Test non eseguiti. È possibile scegliere diverse opzioni di raggruppamento nella barra degli strumenti.

È anche possibile filtrare i test in qualsiasi visualizzazione in base alla corrispondenza con il testo nella casella di ricerca a livello globale oppure tramite la selezione di uno dei filtri predefiniti. È possibile eseguire qualsiasi selezione di test in qualsiasi momento. I risultati di un'esecuzione dei test sono visualizzati immediatamente nella barra relativa alle operazioni riuscite/non riuscite nella parte superiore della finestra di Esplora test. I dettagli relativi al risultato di un metodo di test vengono visualizzati quando si seleziona il test.

Eseguire e visualizzare i test

La barra degli strumenti di Esplora test consente di individuare, organizzare ed eseguire i test a cui si è interessati.

È possibile scegliere Esegui tutto per eseguire tutti i test (o premere CTRL + R, V) oppure scegliere Esegui per scegliere un subset di test da eseguire (CTRL + R, T). Selezionare un test per visualizzarne i dettagli nel riquadro dei dettagli del test. Scegliere Apri test dal menu di scelta rapida (tastiera: F12) per visualizzare il codice sorgente per il test selezionato.

Se i singoli test non hanno dipendenze che ne impediscono l'esecuzione in qualsiasi ordine, attivare l'esecuzione parallela dei test nel menu Impostazioni sulla barra degli strumenti. Questo può ridurre notevolmente il tempo impiegato per eseguire tutti i test.

Eseguire test dopo ogni compilazione

Per eseguire gli unit test dopo ogni compilazione locale, aprire l'icona Impostazioni sulla barra degli strumenti di Esplora test e selezionare Esegui test dopo compilazione.

Filtrare e raggruppare l'elenco dei test

Quando è presente un numero elevato di test, è possibile digitare nella casella di ricerca di Esplora test per filtrare l'elenco in base alla stringa specificata. È possibile limitare ulteriormente i risultati scegliendo uno dei filtri disponibili nell'elenco.

Pulsante	Descrizione
	Per raggruppare i test in base alla categoria, scegliere il pulsante Raggruppa per .

Per altre informazioni, vedere Eseguire unit test con Esplora test.

Domande e risposte

D: Come si esegue il debug degli unit test?

R: Usare Esplora test per avviare una sessione di debug per i test. Esaminando con facilità il codice grazie al debugger di Visual Studio è possibile spostarsi in avanti e indietro tra gli unit test e i progetti da testare. Per avviare il debug:

1. Nell'editor di Visual Studio impostare un punto di interruzione in uno o più metodi di test di cui si vuole eseguire il debug.

   Nota

   Poiché i metodi di test possono essere eseguiti in qualsiasi ordine, impostare punti di interruzione in tutti i metodi di test di cui si vuole eseguire il debug.

2. In Esplora test selezionare i metodi di test e quindi scegliere Esegui debug test selezionati dal menu di scelta rapida.

Altre informazioni dettagliate sul debug di unit test.

D: Se si usa lo sviluppo basato su test, come è possibile generare codice dai test?

R: Usare azioni rapide per generare classi e metodi nel codice del progetto. Scrivere un'istruzione in un metodo di test che chiama la classe o il metodo da generare, quindi aprire la lampadina visualizzata sotto l'errore. Se la chiamata è per un costruttore della nuova classe, scegliere Genera tipo dal menu, quindi eseguire la procedura guidata per inserire la classe nel progetto di codice. Se la chiamata è per un metodo, scegliere Genera metodo dal menu di IntelliSense.

D: È possibile creare unit test che accettano più set di dati come input per eseguire il test?

R: Sì. Imetodi di test basati sui dati permettono di testare un intervallo di valori con un singolo metodo di unit test. Usare un DataRowDynamicData attributo o DataSource per il metodo di test che specifica l'origine dati che contiene i valori delle variabili da testare.

Il metodo con attributi viene eseguito una sola volta per ogni riga nell'origine dati. In caso di esito negativo di una delle iterazioni, Esplora test segnala un errore di test per il metodo. Nel riquadro dei dettagli dei risultati del test per il metodo è mostrato il metodo di stato relativo all'esito positivo/negativo per ogni riga di dati.

Altre informazioni sugli unit test basati sui dati.

D: È possibile visualizzare la quantità di codice testata dagli unit test?

R: Sì. È possibile determinare la quantità di codice sottoposta effettivamente a test dagli unit test usando lo strumento per il code coverage di Visual Studio in Visual Studio Enterprise. Sono supportati i linguaggi nativi e gestiti e tutti i framework di unit test che possono essere eseguiti dal framework di unit test.

È possibile eseguire il code coverage su test selezionati oppure su tutti i test in una soluzione. La finestra Risultati code coverage visualizza la percentuale di blocchi di codice del prodotto esaminati in base a riga, funzione, classe, spazio dei nomi e modulo.

Per eseguire il code coverage per i metodi di test in una soluzione, scegliere Analizza>code coverage per tutti i test.

I risultati del code coverage vengono visualizzati nella finestra Risultati code coverage.

Altre informazioni sul code coverage .

D: È possibile testare metodi nel codice con dipendenze esterne?

R: Sì. Se si dispone di Visual Studio Enterprise, è possibile usare Microsoft Fakes con i metodi di test scritti usando framework di unit test per il codice gestito.

Microsoft Fakes usa due approcci per la creazione delle classi sostitutive per le dipendenze esterne:

1. Glistub generano classi sostitutive derivate dall'interfaccia padre della classe di dipendenza di destinazione. I metodi stub possono sostituire metodi pubblici virtuali della classe di destinazione.

2. Glishim usano strumentazione di runtime per deviare chiamate a un metodo di destinazione, indirizzandole a un metodo shim sostitutivo per metodi non virtuali.

In entrambi gli approcci si usano i delegati generati delle chiamate per il metodo di dipendenza per specificare il comportamento desiderato nel metodo di test.

Altre informazioni sull' isolamento di metodi di unit test tramite Microsoft Fakes.

D: È possibile usare altri framework di unit test per creare unit test?

R: Sì, seguire questa procedura per trovare e installare altri framework. Dopo aver riavviato Visual Studio, riaprire la soluzione per creare unit test e quindi selezionare i framework installati:

Gli stub di unit test verranno creati usando il framework selezionato.