Introduzione a Live Unit Testing

Quando si abilita Live Unit Testing in una soluzione di Visual Studio, viene illustrata visivamente la copertura dei test e lo stato dei test. Live Unit Testing esegue anche i test in modo dinamico ogni volta che si modifica il codice e invia immediatamente una notifica quando le modifiche causano l'esito negativo dei test.

Live Unit Testing può essere usato per testare soluzioni destinate a .NET Framework, .NET Core o .NET 5+. In questa esercitazione si apprenderà come usare Live Unit Testing creando una libreria di classi semplice destinata a .NET e si creerà un progetto MSTest destinato a .NET per testarlo.

La soluzione C# completa può essere scaricata dal repository MicrosoftDocs/visualstudio-docs su GitHub.

Questa esercitazione richiede che sia installata l'edizione Enterprise di Visual Studio con il carico di lavoro .NET per lo sviluppo di applicazioni desktop.

Per iniziare, creare una soluzione di Visual Studio denominata UtilityLibraries costituita da un singolo progetto di libreria di classi .NET, StringLibrary.

La soluzione è solo un contenitore per uno o più progetti. Per creare una soluzione vuota, aprire Visual Studio ed eseguire le operazioni seguenti:

1. Selezionare File>Nuovo>Progetto dal menu di primo livello di Visual Studio.

2. Digitare soluzione nella casella di ricerca del modello e quindi selezionare il modello Soluzione Vuota. Denominare il progetto UtilityLibraries.

3. Completare la creazione della soluzione.

Dopo aver creato la soluzione, si creerà una libreria di classi denominata StringLibrary che contiene diversi metodi di estensione per l'uso delle stringhe.

1. In Esplora soluzioni , fare clic con il pulsante destro del mouse sulla soluzione LibrerieDiUtilità e selezionare Aggiungi>Nuovo Progetto.

2. Digitare libreria di classi nella casella di ricerca del modello e selezionare il modello libreria di classi destinato a .NET o .NET Standard. Fare clic su Avanti.

3. Denominare il progetto StringLibrary.

4. Fare clic su Crea per creare il progetto.

5. Sostituire tutto il codice esistente nell'editor di codice con il codice seguente:

   using System;
   
   namespace UtilityLibraries
   {
       public static class StringLibrary
       {
           public static bool StartsWithUpper(this string s)
           {
               if (String.IsNullOrWhiteSpace(s))
                   return false;
   
               return Char.IsUpper(s[0]);
           }
   
           public static bool StartsWithLower(this string s)
           {
               if (String.IsNullOrWhiteSpace(s))
                   return false;
   
               return Char.IsLower(s[0]);
           }
   
           public static bool HasEmbeddedSpaces(this string s)
           {
               foreach (var ch in s.Trim())
               {
                   if (ch == ' ')
                       return true;
               }
               return false;
           }
       }
   }
   

   StringLibrary ha tre metodi statici:

   • StartsWithUpper restituisce true se una stringa inizia con un carattere maiuscolo; in caso contrario, restituisce false.

   • StartsWithLower restituisce true se una stringa inizia con un carattere minuscolo; in caso contrario, restituisce false.

   • HasEmbeddedSpaces restituisce true se una stringa contiene un carattere di spazio vuoto incorporato; in caso contrario, restituisce false.

6. Selezionare Compila>Compila soluzione dal menu principale di Visual Studio. La compilazione dovrebbe avere esito positivo.

Il passaggio successivo consiste nel creare il progetto di unit test per testare la libreria StringLibrary. Creare gli unit test eseguendo la procedura seguente:

1. Nell'Esplora soluzioni , fare clic con il pulsante destro del mouse sulla soluzione UtilityLibraries e selezionare Aggiungi>Nuovo progetto.

2. Digitare "unit test " nella casella di ricerca del modello, selezionare "C# " come linguaggio e quindi selezionare il modello "MSTest Unit Test Project per .NET". Fare clic su Avanti.

   Nota

   In Visual Studio 2019 versione 16.9, il nome del modello di progetto MSTest è Progetto di test unitario.

3. Denominare il progetto StringLibraryTests e fare clic su Avanti.

4. Seleziona il framework di destinazione consigliato o .NET 8 e quindi scegli Crea.

   Nota

   Questa esercitazione introduttiva usa Live Unit Testing con il framework di test MSTest. È anche possibile usare i framework di test xUnit e NUnit.

5. Il progetto di unit test non può accedere automaticamente alla libreria di classi di cui è in corso il test. Concedi l'accesso alla libreria di test aggiungendo un riferimento al progetto della libreria di classi. Per fare ciò, fare clic con il pulsante destro del mouse sul progetto StringLibraryTests e selezionare Aggiungi Riferimento al Progetto>. Nella finestra di dialogo Gestione Riferimenti, verificare che sia selezionata la scheda Soluzione e selezionare il progetto StringLibrary, come mostrato nella figura seguente.

   

   

6. Sostituire il codice di unit test boilerplate fornito dal modello con il codice seguente:

   using System;
   using Microsoft.VisualStudio.TestTools.UnitTesting;
   using UtilityLibraries;
   
   namespace StringLibraryTest
   {
       [TestClass]
       public class UnitTest1
       {
           [TestMethod]
           public void TestStartsWithUpper()
           {
               // Tests that we expect to return true.
               string[] words = { "Alphabet", "Zebra", "ABC", "Αθήνα", "Москва" };
               foreach (var word in words)
               {
                   bool result = word.StartsWithUpper();
                   Assert.IsTrue(result,
                                 $"Expected for '{word}': true; Actual: {result}");
               }
           }
   
           [TestMethod]
           public void TestDoesNotStartWithUpper()
           {
               // Tests that we expect to return false.
               string[] words = { "alphabet", "zebra", "abc", "αυτοκινητοβιομηχανία", "государство",
                                  "1234", ".", ";", " " };
               foreach (var word in words)
               {
                   bool result = word.StartsWithUpper();
                   Assert.IsFalse(result,
                                  $"Expected for '{word}': false; Actual: {result}");
               }
           }
   
           [TestMethod]
           public void DirectCallWithNullOrEmpty()
           {
               // Tests that we expect to return false.
               string[] words = { String.Empty, null };
               foreach (var word in words)
               {
                   bool result = StringLibrary.StartsWithUpper(word);
                   Assert.IsFalse(result,
                                  $"Expected for '{(word == null ? "<null>" : word)}': " +
                                  $"false; Actual: {result}");
               }
           }
       }
   }
   

7. Salvare il progetto selezionando l'icona Salva sulla barra degli strumenti.

   Poiché il codice di unit test include alcuni caratteri non ASCII, verrà visualizzata la finestra di dialogo seguente per avvisare che alcuni caratteri andranno persi se si salva il file nel formato ASCII predefinito.

8. Scegliere il pulsante Salva con altra codifica.

   

   

9. Nell'elenco a discesa Codifica della finestra di dialogo Opzioni di salvataggio avanzate, scegliere Unicode (UTF-8 senza firma) - Tabella codici 65001, come mostrato nell'illustrazione seguente.

   

10. Compila il progetto di test unitario selezionando Compila>Ricompila Soluzione dal menu superiore di Visual Studio.

Hai creato una libreria di classi e alcuni test unitari. Sono stati completati i preliminari necessari per usare Live Unit Testing.

Finora, anche se hai scritto i test per la libreria di classi StringLibrary, non li hai ancora eseguiti. Live Unit Testing li esegue automaticamente dopo averlo abilitato. A tale scopo, eseguire le operazioni seguenti:

1. Facoltativamente, selezionare la finestra dell'editor di codice contenente il codice per StringLibrary. Si tratta di Class1.cs per un progetto C# o Class1.vb per un progetto Visual Basic. Questo passaggio consente di esaminare visivamente il risultato dei test e l'estensione del code coverage dopo aver abilitato Live Unit Testing.

2. Selezionare Test>Live Unit Testing>Start dal menu di primo livello di Visual Studio.

3. Verificare la configurazione per Live Unit Testing assicurandosi che la radice del repository includa il percorso dei file di origine sia per il progetto di utilità che per il progetto di test. Selezionare Avanti e quindi Fine.

Al termine dell'esecuzione dei test, Live Unit Testing visualizza sia i risultati complessivi che il risultato dei singoli test. Inoltre, la finestra dell'editor di codice visualizza graficamente sia la copertura del codice del test che il risultato dei tuoi test. Come illustrato nella figura seguente, tutti e tre i test sono stati eseguiti correttamente. Mostra anche che i test hanno trattato tutti i percorsi di codice nel metodo StartsWithUpper e che tutti i test sono stati eseguiti correttamente (che è indicato dal segno di spunta verde "✓"). Infine, mostra che nessuno degli altri metodi in StringLibrary ha la copertura del codice (code coverage), indicata da una riga blu, "➖".

È anche possibile ottenere informazioni più dettagliate sulla copertura dei test e sui risultati dei test selezionando un'icona di code coverage specifica nella finestra dell'editor di codice. Per esaminare questo dettaglio, eseguire le operazioni seguenti:

1. Fare clic sul segno di spunta verde sulla riga che legge if (String.IsNullOrWhiteSpace(s)) nel metodo StartsWithUpper. Come illustrato nella figura seguente, Live Unit Testing indica che tre test riguardano tale riga di codice e che tutti sono stati eseguiti correttamente.

   

   

2. Fare clic sul segno di spunta verde sulla riga che legge return Char.IsUpper(s[0]) nel metodo StartsWithUpper. Come illustrato nella figura seguente, Live Unit Testing indica che solo due test riguardano tale riga di codice e che tutti sono stati eseguiti correttamente.

   

   

Il problema principale identificato da Live Unit Testing è il code coverage incompleto. Verrà affrontato nella sezione successiva.

In questa sezione si estenderanno gli unit test al metodo StartsWithLower. Anche se si esegue questa operazione, Live Unit Testing continuerà dinamicamente a testare il codice.

Per estendere il code coverage al metodo StartsWithLower, eseguire le operazioni seguenti:

1. Aggiungere i metodi di TestStartsWithLower e TestDoesNotStartWithLower seguenti al file di codice sorgente di test del progetto:

   // Code to add to UnitTest1.cs
   [TestMethod]
   public void TestStartsWithLower()
   {
       // Tests that we expect to return true.
       string[] words = { "alphabet", "zebra", "abc", "αυτοκινητοβιομηχανία", "государство" };
       foreach (var word in words)
       {
           bool result = word.StartsWithLower();
           Assert.IsTrue(result,
                         $"Expected for '{word}': true; Actual: {result}");
       }
   }
   
   [TestMethod]
   public void TestDoesNotStartWithLower()
   {
       // Tests that we expect to return false.
       string[] words = { "Alphabet", "Zebra", "ABC", "Αθήνα", "Москва",
                          "1234", ".", ";", " "};
       foreach (var word in words)
       {
           bool result = word.StartsWithLower();
           Assert.IsFalse(result,
                          $"Expected for '{word}': false; Actual: {result}");
       }
   }
   

2. Modificare il metodo DirectCallWithNullOrEmpty aggiungendo il codice seguente immediatamente dopo la chiamata al metodo Microsoft.VisualStudio.TestTools.UnitTesting.Assert.IsFalse.

   // Code to add to UnitTest1.cs
   result = StringLibrary.StartsWithLower(word);
   Assert.IsFalse(result,
                  $"Expected for '{(word == null ? "<null>" : word)}': " +
                  $"false; Actual: {result}");
   

3. Live Unit Testing esegue automaticamente test nuovi e modificati quando si modifica il codice sorgente. Come illustrato nella figura seguente, tutti i test, inclusi i due aggiunti e quello modificato, hanno avuto esito positivo.

   

   

4. Passare alla finestra contenente il codice sorgente per la classe StringLibrary. Live Unit Testing mostra ora che la copertura del codice è stata estesa al metodo StartsWithLower.

   

   

In alcuni casi, i test riusciti in Esplora test potrebbero essere disattivati. Ciò indica che un test è attualmente in esecuzione o che il test non è stato eseguito di nuovo perché non sono state apportate modifiche al codice che potrebbero influire sul test dall'ultima esecuzione.

Finora, tutti i nostri test sono riusciti. Nella sezione successiva verrà illustrato come gestire l'errore di test.

In questa sezione verrà illustrato come usare Live Unit Testing per identificare, risolvere i problemi e risolvere gli errori di test. Puoi fare questo espandendo la copertura dei test al metodo HasEmbeddedSpaces.

1. Aggiungere il metodo seguente al file di test:

   [TestMethod]
   public void TestHasEmbeddedSpaces()
   {
       // Tests that we expect to return true.
       string[] phrases = { "one car", "Name\u0009Description",
                            "Line1\nLine2", "Line3\u000ALine4",
                            "Line5\u000BLine6", "Line7\u000CLine8",
                            "Line0009\u000DLine10", "word1\u00A0word2" };
       foreach (var phrase in phrases)
       {
           bool result = phrase.HasEmbeddedSpaces();
           Assert.IsTrue(result,
                         $"Expected for '{phrase}': true; Actual: {result}");
       }
   }
   

2. Quando il test viene eseguito, Live Unit Testing indica che il metodo TestHasEmbeddedSpaces non è riuscito, come illustrato nella figura seguente:

   non riuscito

   

3. Selezionare la finestra che visualizza il codice della libreria. Live Unit Testing ha ampliato la copertura del codice al metodo HasEmbeddedSpaces. Segnala anche l'errore di test aggiungendo un rosso "🞩" alle righe coperte da test non superati.

4. Posiziona il puntatore del mouse sulla riga con la firma del metodo HasEmbeddedSpaces. Live Unit Testing visualizza un tooltip che segnala che il metodo è soggetto a un test, come illustrato nella figura seguente.

   

   non riuscito

5. Selezionare il test TestHasEmbeddedSpaces non riuscito. Live Unit Testing offre alcune opzioni, ad esempio l'esecuzione di tutti i test e il debug di tutti i test, come illustrato nella figura seguente:

   

   

6. Selezionare Debug tutto per eseguire il debug del test non riuscito.

7. Visual Studio esegue il test in modalità di debug.

   Il test assegna ogni stringa in una matrice a una variabile denominata phrase e la passa al metodo HasEmbeddedSpaces. L'esecuzione del programma sospende e richiama il debugger la prima volta che l'espressione assert è false. Nella figura seguente viene illustrata la finestra di dialogo eccezione risultante dal valore imprevisto nella chiamata al metodo Microsoft.VisualStudio.TestTools.UnitTesting.Assert.IsTrue.

   

   

   Inoltre, tutti gli strumenti di debug forniti da Visual Studio sono disponibili per risolvere i problemi relativi al test non riuscito, come illustrato nella figura seguente:

   

   

   Si noti nella finestra auto che il valore della variabile phrase è "Name\tDescription", che è il secondo elemento della matrice. Il metodo di test prevede che HasEmbeddedSpaces restituisca true quando viene superata questa stringa; restituisce invece false. Evidentemente, non riconosce "\t", il carattere di tabulazione, come spazio incorporato.

8. Selezionare Debug>Continua, premere F5oppure fare clic sul pulsante Continua sulla barra degli strumenti per continuare l'esecuzione del programma di test. Poiché si è verificata un'eccezione non gestita, il test termina. In questo modo vengono fornite informazioni sufficienti per un'analisi preliminare del bug. TestHasEmbeddedSpaces (routine di test) ha fatto un presupposto non corretto oppure HasEmbeddedSpaces non riconosce correttamente tutti gli spazi incorporati.

9. Per diagnosticare e correggere il problema, iniziare con il metodo StringLibrary.HasEmbeddedSpaces. Guarda il confronto nel metodo HasEmbeddedSpaces. Considera U+0020 uno spazio incorporato. Tuttavia, lo standard Unicode include un certo numero di altri caratteri di spazio. Ciò suggerisce che il codice della libreria non è stato testato correttamente per un carattere di spazio vuoto.

10. Sostituire il confronto di uguaglianza con una chiamata al metodo System.Char.IsWhiteSpace:

    if (Char.IsWhiteSpace(ch))
    

11. Live Unit Testing esegue automaticamente il metodo di test non riuscito.

    Live Unit Testing mostra che vengono visualizzati i risultati aggiornati, che vengono visualizzati anche nella finestra dell'editor di codice.

• Test di Unità Live in Visual Studio
• Domande frequenti su Live Unit Testing