UNIT TESTING in Asp.Net: Tutorial completo

⚡ Riepilogo intelligente

Il test unitario di un'applicazione ASP.NET in Visual Studio inizia con un progetto di test unitario, crea un riferimento al progetto di destinazione, aggiunge gli attributi MSTest [TestClass] e [TestMethod] e chiama i metodi Assert per dimostrare che le classi si comportano come previsto.

🧪 Progetto di prova: Aggiungi un progetto di test unitario alla soluzione ASP.NET e fai riferimento al progetto di destinazione che desideri verificare.
🏷️ Attributi: Contrassegna la classe con [TestClass] e ogni test con [TestMethod] in modo che MSTest possa individuarli.
✅ Affermazioni: Utilizza Assert.AreEqual, Assert.IsTrue e chiamate simili per dichiarare il risultato atteso di ogni test.
▶ ️ Esegui test: Nel menu Esegui test, seleziona Esegui tutti i test all'interno di Visual Studio e controlla Esplora test per verificare i risultati, sia positivi che negativi.
️ Scelta del framework: MSTest, NUnit e xUnit funzionano tutti con dotnet test; MSTest è incluso di default, mentre xUnit è preferibile per ASP.NET Core.
️ migliori Pratica: Isola l'unità, segui il ciclo Arrange Act Assert e mantieni l'intera suite veloce in modo che venga eseguita a ogni commit.

Scopri di più

Il test è un aspetto essenziale di qualsiasi linguaggio di programmazione. Collaudo Lo sviluppo di applicazioni ASP.NET è possibile grazie a Visual Studio.

Visual Studio viene utilizzato per creare codice di test. Viene anche utilizzato per eseguire il codice di test per un'applicazione ASP.NET. In questo modo, diventa semplice verificare la presenza di eventuali errori in un'applicazione ASP.NET. In Visual Studio, il modulo di test include funzionalità predefinite. È possibile eseguire immediatamente un test per un progetto ASP.NET.

Introduzione ai test per ASP.NET

Il primo livello di test di un progetto ASP.NET è il test unitario. Questo test verifica la funzionalità dell'applicazione. Il test viene condotto per garantire che l'applicazione si comporti come previsto. In ASP.NET, il primo passaggio consiste nel creare un progetto di test in Visual Studio. Il progetto di test conterrà il codice necessario per testare l'applicazione.

Consideriamo la pagina web seguente. Nella pagina, abbiamo il messaggio “Guru99 – ASP.NET” visualizzato. Ora, come possiamo confermare che venga visualizzato il messaggio corretto quando si esegue un progetto ASP.NET? Questo si fa aggiungendo un progetto di test alla soluzione ASP.NET (utilizzata per sviluppare applicazioni web). Questo progetto di test garantirà che il messaggio corretto venga visualizzato all'utente.

Analizziamo ora più nel dettaglio come possiamo procedere con i test in ASP.NET.

Creazione di un progetto di unit test .NET

Prima di creare un progetto di prova, dobbiamo eseguire i passaggi di alto livello riportati di seguito.

Utilizza la nostra 'DemoApplication' utilizzata nelle sezioni precedenti. Questa sarà la nostra applicazione che deve essere testata.
Aggiungeremo una nuova classe a DemoApplication. Questa classe conterrà una stringa chiamata 'Guru99 – ASP.NET.' Questa stringa verrà testata nel nostro progetto di test.
Infine, creeremo un progetto di test. Questo verrà utilizzato per testare l'applicazione ASP.NET.

Seguiamo quindi i passaggi generali sopra descritti e vediamo come implementare i test.

Passo 1) Assicurarsi che DemoApplication sia aperto in Visual Studio.

Passo 2) Aggiungiamo ora una nuova classe a DemoApplication. Questa classe conterrà una stringa chiamata 'Guru99 – ASP.NET.' Questa stringa verrà testata nel nostro progetto di test.

Segui il passaggio seguente per aggiungere una nuova classe.

In Visual Studio, fare clic con il pulsante destro del mouse su "DemoApplication" in Esplora soluzioni.
Scegli l'opzione Aggiungi->Classe dal menu contestuale.

Passo 3) In questa fase,

Assegna un nome "Tutorial.cs" alla nuova classe.
Fare clic sul pulsante "Aggiungi" per aggiungere il file all'applicazione Demo.

Ora, una nuova classe viene aggiunta al file "DemoApplication".

Passo 4) Apri il nuovo file Tutorial.cs da “DemoApplication”. Aggiungi la stringa “Guru99 – ASP.NET.”

Per aprire il file, fare doppio clic sul file Tutorial.cs in Esplora soluzioni.

Il file avrà del codice predefinito già scritto. Non preoccuparti di quel codice, aggiungi semplicemente la riga di codice seguente.

namespace DemoApplication
{
  public class Tutorial
  {
     public String Name;
     public Tutorial()
     {
        Name = "Guru99 - ASP.Net";
     }
  }
}

Code Spiegazione:-

La variabile Nome è di tipo stringa.
Infine, nel costruttore della classe Tutorial, assegnare il valore della variabile Name. Il valore viene assegnato a “Guru99 – ASP.NET”

Passo 5) Ora vai al file demo.aspx e aggiungi le righe di codice per visualizzare il testo "Guru99 – ASP.NET.”

<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml">
<head runat="server">
    <title></title>
</head>
    <body>
    <form id="form1" runat="server">
    <div>
        <% DemoApplication.Tutorial tp=new DemoApplication.Tutorial();%>
        <%=tp.Name%>
    </div>
    </form>
    </body>
</html>

Code Spiegazione:-

La prima riga crea un oggetto della classe 'Tutorial'. Questo è il primo passo quando si lavora con classi e oggetti. Il nome assegnato all'oggetto è 'tp'.
Infine chiamiamo "tutorial.cs" dal file demo.aspx. Visualizza il valore della variabile Nome.

Quando esegui il programma sopra in Visual Studio, otterrai il seguente output.

Produzione:-

Dall'output, si vede il messaggio "Guru99 – ASP.NET” visualizzato.

Passo 6) Ora aggiungiamo il nostro progetto di test all'applicazione demo. Questo viene fatto con l'aiuto di Visual Studio.

Fare clic con il pulsante destro del mouse sulla Soluzione – Applicazione Demo.
Nel menu contestuale, scegli l'opzione 'Nuovo progetto'.

Passo 7) Il passaggio prevede l'aggiunta del progetto Unit Test all'applicazione demo.

Fare clic sul tipo di elemento "Test" nel pannello di sinistra.
Selezionare la voce 'Progetto di test unitario' dall'elenco visualizzato nella parte centrale della finestra di dialogo.
Dai un nome al progetto di prova. Nel nostro caso, il nome indicato è "DemoTest".
Infine, fai clic sul pulsante "OK".

Alla fine vedrai il progetto DemoTest aggiunto a Solution Explorer. Con questo, puoi anche vedere altri file come UnitTest1.cs, proprietà, ecc. generati per impostazione predefinita.

Esecuzione del progetto di prova

Il progetto di test creato nella sezione precedente viene utilizzato per testare la nostra applicazione ASP.NET. Nei passaggi successivi, vedremo come eseguire il progetto di test.

Il primo passo consiste nell'aggiungere un riferimento al progetto ASP.NET. Questo passaggio è necessario affinché il progetto di test possa accedere al progetto ASP.NET.
Quindi scriveremo il nostro codice di test.
Infine, eseguiremo il test utilizzando Visual Studio.

Passo 1) Per testare la nostra applicazione demo, il primo progetto di test deve fare riferimento all'applicazione demo. Aggiungere un riferimento alla soluzione Demo.aspx.

Fare clic con il pulsante destro del mouse sul progetto Test demo
Dal menu scegli l'opzione Aggiungi->Riferimento.

Passo 2) Il passaggio successivo consiste nell'aggiungere un riferimento a DemoApplication.

Selezionare l'opzione Progetti dal lato sinistro della finestra di dialogo
Fare clic sulla casella di controllo accanto a DemoApplication
Fare clic sul pulsante "OK".

Ciò consentirà a un progetto demotest di testare la nostra DemoApplication.

Passo 3) Ora è il momento di aggiungere il codice di test al nostro progetto di test.

Per prima cosa, fare doppio clic sul file UnitTest1 (il file UnitTest1 viene aggiunto automaticamente da Visual Studio quando viene creato il progetto di test) in Esplora soluzioni.
Questo è il file che verrà eseguito per testare il progetto ASP.NET.

Vedrai il codice sottostante aggiunto da Visual Studio nel file UnitTest1.cs. Questo è il codice di base necessario per l'esecuzione del progetto di test.

Passo 4) Il passo successivo è aggiungere il codice che viene utilizzato per testare la stringa "Guru99 – ASP.NET.”

using System;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using DemoApplication;

namespace DemoTest
{
 [TestClass]
 public class UnitTest1
 {
   [TestMethod]
   public void TestMethod1()
   {
      Tutorial tp = new Tutorial();
      Assert.AreEqual(tp.Name,"Guru99 - ASP.Net");
   }
 }
}

Crea un nuovo oggetto chiamato 'tp' del tipo Tutorial
Il metodo Assert.AreEqual viene utilizzato in .NET per verificare se un valore è uguale a qualcos'altro. Quindi, nel nostro caso, stiamo confrontando i valori di tp.Name con Guru99 – ASP.NET.

Passo 5) Ora eseguiamo il nostro progetto di test. Per farlo, dobbiamo andare all'opzione di menu Test->Esegui->Tutti i test.

Produzione:-

Verrà visualizzata una finestra di Esplora test in Visual Studio. Questa mostrerà il risultato sopra e indicherà che è stato eseguito un test riuscito in Visual Studio.

Attributi e asserzioni MSTest che utilizzerai

Migliori MicrosoftLo spazio dei nomi .VisualStudio.TestTools.UnitTesting include un piccolo set di attributi e asserzioni che coprono la maggior parte dei test unitari di ASP.NET. Imparare prima questi renderà ogni test successivo più facile da leggere e da mantenere.

[TestClass] – contrassegna la classe come contenitore di test. MSTest analizza le classi con questo attributo in fase di rilevamento.
[Metodo di prova] – contrassegna un metodo pubblico senza parametri come test individuale. Il metodo restituisce void, Task o ValueTask.
[TestInitialize] / [TestCleanup] – Eseguire prima e dopo ogni metodo di test. Utilizzarli per creare e rilasciare configurazioni condivise, come un repository di mock o un contesto in memoria.
[ClassInitialize] / [ClassCleanup] – Esegui una sola volta per l'intera classe. Sono utili quando la configurazione è complessa, ad esempio per popolare un database di test.
[DataRow] e [DataTestMethod] – fornire input parametrizzati in modo che un singolo metodo di test copra diversi casi.

All'interno di ogni metodo di test, la classe Assert verifica il risultato. Le chiamate più comuni includono Assert.AreEqual per i confronti di valore, Assert.IsTrue e Assert.IsFalse per i valori booleani, Assert.IsNull e Assert.IsNotNull per i riferimenti e Assert.ThrowsException per le eccezioni previste. Struttura ogni test utilizzando il pattern Arrange, Act, Assert in modo che la configurazione, l'invocazione e la verifica rimangano visivamente separate. Questa struttura semplifica il debug dei test falliti, poiché la riga che causa l'errore è quasi sempre l'unica Assert in fondo.

Confronto tra MSTest, NUnit e xUnit per ASP.NET

Nell'ecosistema .NET dominano tre framework di test. Ognuno di essi viene eseguito all'interno di Visual Studio e si integra con dotnet test, quindi la differenza risiede principalmente nello stile, nel supporto della community e nel comportamento predefinito.

MSTest – spedito da Microsoft e viene fornito preinstallato con il modello di progetto di test unitario di Visual Studio utilizzato in precedenza in questo tutorial. È l'impostazione predefinita più sicura quando un team è nuovo ai test unitari su Microsoft pila.
NUnità – il più vecchio dei tre, originariamente portato da JUnitOffre un ricco modello di vincoli, test parametrizzati tramite TestCase e TestCaseSource e un supporto consolidato per ogni versione di .NET.
xUnit.net – Utilizzato internamente dai team ASP.NET Core e Entity Framework Core. Sostituisce il metodo SetUp con il costruttore e IDisposable, incoraggia una classe di test per ogni comportamento e utilizza [Fact] e [Theory] al posto di [TestMethod].

Tutti e tre i framework scoprono i test tramite attributi, li eseguono tramite il comando dotnet test e producono report XML trx o xUnit che le pipeline CI come Azure DevOps, GitHub Actions e Jenkins può essere utilizzato direttamente. Per un primo progetto ASP.NET, rimanere con MSTest semplifica la toolchain. I team che desiderano una parametrizzazione più ricca o che utilizzano già ASP.NET Core spesso scelgono xUnit per coerenza con il framework con cui è stato sviluppato.

Migliori pratiche per il test unitario delle applicazioni ASP.NET

Seguire una serie di abitudini consolidate permette di mantenere una suite di strumenti veloce, affidabile e utile per tutta la durata di un progetto ASP.NET.

Testare un comportamento per ciascun metodo. Un test che verifica diverse cose non correlate fallisce per molteplici ragioni e richiede più tempo per essere corretto.
Nome test dopo l'intento. Un pattern come MethodUnderTest_Scenario_ExpectedResult fa sì che l'output di Test Explorer fornisca una specifica leggibile della classe.
Isolare l'unità dai sistemi esterni. Avvolgi le chiamate a file, rete e database dietro interfacce e sostituiscile con oggetti fittizi o simulati in modo che il test non interagisca con la dipendenza reale.
Mantieni i test veloci. L'obiettivo è che l'intera suite di test termini in pochi secondi. I test lenti vengono saltati e i test saltati nascondono le regressioni.
Segui lo schema Organizza, Agisci, Afferma. Tre brevi blocchi con linee vuote tra di loro indicano l'intento e rendono facile individuare le righe non riuscite.
Eseguire i test su ogni commit. Integrare dotnet test in una pipeline CI in modo che un test non riuscito blocchi l'unione invece di essere distribuitoping alla produzione.
Traccopertura del codice k, ma non inseguirla. La copertura mette in evidenza i percorsi non ancora esplorati, ma un numero elevato da solo non garantisce la qualità. RevScopri la funzione delle righe mancanti.

Applicate congiuntamente, queste pratiche trasformano il progetto DemoTest descritto in precedenza nel punto di partenza di una suite in grado di individuare le regressioni a ogni commit, documentare il comportamento per gli sviluppatori futuri e infondere fiducia durante il refactoring di un'applicazione ASP.NET.

DOMANDE FREQUENTI

Sì. GitHub Copilot può generare automaticamente blocchi [TestClass] e [TestMethod], suggerire layout Arrange Act Assert e generare casi [DataRow] parametrizzati a partire dalla firma di un metodo di destinazione. RevEsamina le asserzioni generate prima di utilizzarle in produzione.

Sì. Gli assistenti basati sull'apprendimento automatico possono segnalare test fragili, suggerire nomi migliori ed evidenziare configurazioni duplicate che dovrebbero trovarsi in [TestInitialize]. Riducono i tempi di revisione, ma la correttezza di ogni Assert rimane comunque responsabilità dello sviluppatore.

Un test unitario isola una singola classe o un singolo metodo e ne simula le dipendenze. Un test di integrazione, invece, verifica l'interazione di diversi componenti, spesso interagendo direttamente con un database o un server web reale. I test unitari vengono eseguiti in millisecondi; i test di integrazione richiedono più tempo, ma consentono di individuare bug di cablaggio.

In Visual Studio Enterprise, usa Test Analizza Code Copertura per tutti i test. Nelle altre edizioni, aggiungere il fascicolo NuGet pacchetto ed esegui dotnet test –collect:"XPlat Code Copertura” per produrre un Cobertura Report XML.

Avvolgi la dipendenza dietro un'interfaccia e iniettala tramite il costruttore. Nel test, passa uno stub o un mock creato con librerie come Moq o NSubstitute, in modo che l'unità da testare non interagisca mai con il database reale o l'endpoint HTTP.

Esegui il comando `dotnet test` nella cartella che contiene il progetto di test. Il comando compila il progetto, individua tutti i [TestMethod], li esegue e stampa un riepilogo. I sistemi di CI come GitHub Actions richiamano lo stesso comando all'interno di una fase del flusso di lavoro.

Contrassegna il metodo con [DataTestMethod] e aggiungi uno o più attributi [DataRow] che forniscono i valori di input e il risultato atteso. MSTest esegue quindi lo stesso corpo una volta per riga, producendo una riga separata in Esplora test per ogni caso.

Scrivi un [TestMethod] fallimentare che descriva il comportamento successivo richiesto, aggiungi il codice di produzione sufficiente a farlo superare, quindi esegui il refactoring. Ripetere questo ciclo di refactoring rosso-verde fa sì che la progettazione sia guidata dai test anziché il contrario.