Nozioni di base sugli unit test

Verificare che il codice funzioni come previsto creando ed eseguendo unit test. Si tratta di unit test perché si suddivide la funzionalità del programma in comportamenti testabili discreti che è possibile testare come singole unità. Esplora test di Visual Studio offre un modo flessibile ed efficiente per eseguire gli unit test e visualizzare i risultati in Visual Studio. Visual Studio installa i framework di unit test Microsoft per il codice gestito e nativo. Usare un framework di unit test per creare unit test, eseguirli e segnalare i risultati di questi test. Rieseguire 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 al codice e li esegue in background durante la digitazione.

Gli unit test hanno il massimo effetto sulla qualità del codice quando fa parte integrante del flusso di lavoro di sviluppo software. Non appena si scrive una funzione o un altro blocco di codice dell'applicazione, creare unit test che verificano il comportamento del codice in risposta a casi standard, limite e non corretti di dati di input e che controllano eventuali presupposti espliciti o impliciti effettuati dal codice. Con lo sviluppo basato su test, si creano gli unit test prima di scrivere il codice, quindi si usano gli unit test sia come documentazione di progettazione che come specifiche funzionali.

Esplora test può anche eseguire framework di unit test open source e di terze parti che hanno implementato interfacce aggiuntive di Esplora test. È possibile aggiungere molti di questi framework tramite Gestione estensioni di Visual Studio e la raccolta di Visual Studio. Per ulteriori informazioni, consultare i framework di unit test di terze parti Install.

Get started

Per un'introduzione agli unit test che consentono di scrivere codice direttamente, vedere uno di questi articoli:

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

• Procedura dettagliata: Sviluppo basato su test con Esplora test

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

Esempio di soluzione Bank

In questo articolo viene usato lo sviluppo di un'applicazione fittizia denominata MyBank come esempio. Non è necessario il codice effettivo per seguire le spiegazioni in questo articolo. I metodi di test vengono scritti in C# e presentati usando microsoft Unit Testing Framework per codice gestito. Tuttavia, i concetti vengono facilmente trasferiti ad altri linguaggi e framework.

Il primo tentativo di progettazione per l'applicazione MyBank include un componente conti che rappresenta un singolo conto e le relative transazioni con la banca e un componente di database che rappresenta la funzionalità per aggregare e gestire i singoli conti.

Viene creata una Bank soluzione che contiene due progetti:

• Accounts

• BankDB

Il primo tentativo di progettare il Accounts progetto contiene una classe per contenere informazioni di base su un conto, un'interfaccia che specifica la funzionalità comune di qualsiasi tipo di conto, ad esempio il deposito e il ritiro di asset dal conto, e una classe derivata dall'interfaccia che rappresenta un conto corrente. Per iniziare i progetti Accounts, creare i file di origine seguenti:

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

• IAccount.cs definisce un'interfaccia standard IAccount per un conto, inclusi i metodi per depositare e ritirare le attività da un conto e recuperare il saldo del conto.

• CheckingAccount.cs contiene la CheckingAccount classe che implementa l'interfaccia IAccount per un account di controllo.

Sappiamo dall'esperienza che un prelievo da un conto corrente deve assicurarsi che l'importo prelevato sia inferiore al saldo del conto. Viene quindi eseguito l'override del IAccount.Withdraw metodo in CheckingAccount con un metodo che verifica la presenza di questa condizione. Il metodo potrebbe essere simile 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, è il momento di eseguire il test.

Creare il progetto di unit test e gli unit test manualmente

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

Per aggiungere un progetto di 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 articolo viene usato MSTest.

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

4. Nel progetto di unit test aggiungere un riferimento al progetto di codice sottoposto a test, in questo esempio al progetto Accounts.

   Per creare il riferimento al progetto di codice:

   1. Nel progetto di unit test in Esplora soluzioni, cliccare con il tasto destro del mouse sul nodo Riferimenti o Dipendenze, quindi scegliere Aggiungi riferimento progetto o Aggiungi riferimento, a seconda di quello che è 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 di unit test contiene classi che rispecchiano i nomi delle classi nel progetto di codice. In questo esempio il AccountsTests progetto conterrà le classi seguenti:

• AccountInfoTests la classe contiene i metodi di unit test per la AccountInfo classe nel Accounts progetto

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

Scrivete i vostri test

Il framework di unit test che utilizzi e Visual Studio IntelliSense ti guidano nella scrittura del codice per gli unit test per un progetto di sviluppo. 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 forniscono anche un modo, in genere tramite istruzioni assert o attributi del metodo, per indicare se il metodo di test è stato superato o non riuscito. Altri attributi identificano metodi di installazione facoltativi che si trovano all'inizializzazione della classe e prima di ogni metodo di test e metodi di disinstallazione eseguiti dopo ogni metodo di test e prima che la classe venga eliminata definitivamente.

Il modello AAA (Arrange, Act, Assert) è un modo comune per scrivere unit test per un metodo sottoposto a test.

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

• La sezione Act richiama il metodo sottoposto a test con i parametri disposti.

• La sezione Assert verifica che l'azione del metodo sottoposto a test si comporti come previsto. Per .NET, i metodi nella classe Assert vengono spesso usati per la 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.). CheckingAccountTests Nella classe 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 di unit test Microsoft, vedere uno degli articoli seguenti:

• Esegui test unitari del codice

• Scrittura di unit test per C/C++

Impostare i timeout per gli unit test

Se si usa il framework MSTest, è possibile utilizzare TimeoutAttribute per impostare un timeout su un singolo metodo di test.

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

Per impostare il timeout sul valore massimo consentito:

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

Eseguire test in Test Explorer

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.

Durante l'esecuzione , la scrittura e la riesecuzione dei test, Esplora test può visualizzare i risultati in gruppi di test non superati, test superati, test ignorati e test non eseguiti. È possibile scegliere diversi gruppi per opzioni nella barra degli strumenti.

È anche possibile filtrare i test in qualsiasi visualizzazione associando il testo nella casella di ricerca a livello globale o selezionando uno dei filtri predefiniti. È possibile eseguire qualsiasi selezione dei test in qualsiasi momento. I risultati di un'esecuzione di test sono immediatamente evidenti nella barra di superamento/esito negativo nella parte superiore della finestra di esplorazione. I dettagli del risultato di un metodo di test vengono visualizzati quando si seleziona il test.

Eseguire e visualizzare i test

La barra degli strumenti 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 visualizzare i dettagli del test 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 impediscono l'esecuzione in qualsiasi ordine, attivare l'esecuzione di test paralleli nel menu delle impostazioni della barra degli strumenti. Ciò 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 delle impostazioni nella barra degli strumenti esplora test e selezionare Esegui test dopo la compilazione.

Filtrare e raggruppare l'elenco di test

Quando si dispone di un numero elevato di test, è possibile digitare nella casella di ricerca Esplora test per filtrare l'elenco in base alla stringa specificata. È possibile limitare l'evento di filtro scegliendo dall'elenco di filtri.

Button	Description
	Per raggruppare i test per 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?

Una: Usare Esplora Test per avviare una sessione di debug per i test. L'esecuzione del codice con il debugger di Visual Studio consente di spostarsi facilmente tra gli unit test e il progetto sottoposto a test. 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.

   Annotazioni

   Poiché i metodi di test possono essere eseguiti in qualsiasi ordine, impostare i 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 Debug test selezionati dal menu di scelta rapida.

Altre informazioni dettagliate sul debug degli unit test.

Q: Se sto utilizzando TDD, come genero codice dai miei test?

A: Usa 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 è a un costruttore della nuova classe, scegliere Genera tipo dal menu e seguire la procedura guidata per inserire la classe nel progetto di codice. Se la chiamata è a un metodo, scegliere Genera metodo dal menu IntelliSense.

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

R: Sì. I metodi di test basati sui dati consentono di testare un intervallo di valori con un singolo metodo di unit test. Usare un attributo DataRow, DynamicData 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. Esplora test segnala un errore di test per il metodo se una delle iterazioni non riesce. Il riquadro dei dettagli dei risultati del test per il metodo mostra il metodo di stato pass/fail per ogni riga di dati.

Altre informazioni sugli unit test basati sui dati.

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

È possibile eseguire code coverage su test selezionati o su tutti i test in una soluzione. Nella finestra Risultati code coverage viene visualizzata la percentuale di blocchi di codice di prodotto che sono stati testati per riga, funzione, classe, namespace e modulo.

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

I risultati della copertura appaiono nella finestra Risultati della copertura del codice.

Altre informazioni sul code coverage.

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

R: Sì. Se si ha 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 creare classi sostitutive per le dipendenze esterne:

1. Gli stub generano classi sostitutive derivate dall'interfaccia padre della classe di dipendenza di destinazione. I metodi Stub possono essere sostituiti con metodi virtuali pubblici della classe di destinazione.

2. Gli shim usano la strumentazione di runtime per deviare le chiamate a un metodo di destinazione a un metodo shim sostitutivo per metodi non virtuali.

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

Scopri di più sull'isolamento dei metodi di unit test con Microsoft Fakes.

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

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

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

D: Come si esportano i risultati degli unit test?

A: È possibile utilizzare un file .runsettings sia con la riga di comando che con l'IDE di Visual Studio per configurare gli unit test e impostare il file dei risultati del test. Per altre informazioni, vedere Elemento LoggerRunSettings.