ENHETSTEST i Asp.Net: Komplett handledning

⚡ Smart sammanfattning

Enhetstestning av en ASP.NET-applikation i Visual Studio börjar med ett enhetstestprojekt, kopplar en referens till målprojektet, lägger till attributen MSTest [TestClass] och [TestMethod] och anropar Assert-metoder för att bevisa att klasser beter sig som avsett.

🧪 Testprojekt: Lägg till ett enhetstestprojekt i ASP.NET-lösningen och referera till det målprojekt du vill verifiera.
🏷️ Attribut: Markera klassen med [TestClass] och varje test med [TestMethod] så att MSTest kan upptäcka dem.
✅ Påståenden: Använd Assert.AreEqual, Assert.IsTrue och liknande anrop för att deklarera det förväntade resultatet av varje test.
▶ ️ Kör tester: Menyn Kör test Kör alla tester i Visual Studio och kontrollera Test Explorer för resultat om de godkändes eller misslyckades.
⚖️ Ramval: MSTest, NUnit och xUnit fungerar alla med dotnet-test; MSTest levereras som standard, xUnit är att föredra för ASP.NET Core.
🛠️ Bästa praxis: Isolera enheten, följ Arrange Act Assert och håll hela sviten snabb så att den körs vid varje commit.

Läs mer

Testning är en viktig aspekt av alla programmeringsspråk. Testning för ASP.NET-applikationer är möjligt med hjälp av Visual Studio.

Visual Studio används för att skapa testkod. Det används också för att köra testkod för en ASP.NET-applikation. På så sätt blir det enkelt att kontrollera eventuella fel i en ASP.NET-applikation. I Visual Studio har testmodulen en färdig funktionalitet. Man kan direkt utföra ett test för ett ASP.NET-projekt.

Introduktion till testning för ASP.NET

Den första nivån för att testa ett ASP.NET-projekt är enhetsnivåtestning. Detta test avser funktionaliteten hos en applikation. Testningen utförs för att säkerställa att applikationen beter sig som förväntat. I ASP.NET är den första uppgiften att skapa ett testprojekt i Visual Studio. Testprojektet kommer att innehålla den nödvändiga koden för att testa applikationen.

Låt oss titta på webbsidan nedan. På sidan har vi meddelandet "Guru99 – ASP.NET” visas. Hur kan vi nu bekräfta att rätt meddelande visas när ett ASP.NET-projekt körs? Detta görs genom att lägga till ett testprojekt i ASP.NET-lösningen (som används för att utveckla webbaserade applikationer). Detta testprojekt säkerställer att rätt meddelande visas för användaren.

Låt oss titta mer i detalj nu och se hur vi kan arbeta med testning i ASP.NET.

Skapa ett .NET-enhetstestningsprojekt

Innan vi skapar ett testprojekt måste vi utföra stegen nedan på hög nivå.

Använd vår "DemoApplication" som användes i de tidigare avsnitten. Detta kommer att vara vår applikation som måste testas.
Vi kommer att lägga till en ny klass i DemoApplication. Klassen kommer att innehålla en sträng som heter 'Guru99 – ASP.NET.' Denna sträng kommer att testas i vårt testprojekt.
Slutligen kommer vi att skapa ett testprojekt. Detta används för att testa ASP.NET-applikationen.

Så låt oss följa ovanstående steg på övergripande nivå och se hur man implementerar testning.

Steg 1) Se till att DemoApplication är öppen i Visual Studio.

Steg 2) Låt oss nu lägga till en ny klass i DemoApplication. Klassen kommer att innehålla en sträng som heter 'Guru99 – ASP.NET.' Denna sträng kommer att testas i vårt testprojekt.

Följ stegen nedan för att lägga till en ny klass.

I Visual Studio högerklickar du på "DemoApplication" i Solution Explorer.
Välj alternativet Lägg till->Klass från snabbmenyn.

Steg 3) I detta steg

Ge ett namn "Tutorial.cs" för den nya klassen.
Klicka på knappen "Lägg till" för att lägga till filen i DemoApplication.

Nu läggs en ny klass till filen "DemoApplication."

Steg 4) Öppna den nya Tutorial.cs-filen från ”DemoApplication”. Lägg till strängen ”Guru99 – ASP.NET.”

Du öppnar filen genom att dubbelklicka på filen Tutorial.cs i Solution Explorer.

Filen kommer att ha en viss standardkod redan skriven. Bry dig inte om den koden, lägg bara till kodraden nedan.

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

Code Förklaring:-

Namnvariabeln är av typen string.
Slutligen, i konstruktorn för Tutorial-klassen, tilldela värdet för variabeln Name. Värdet tilldelas "Guru99 – ASP.NET”

Steg 5) Gå nu till demo.aspx-filen och lägg till kodraderna för att visa texten "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 Förklaring:-

Den första raden skapar ett objekt av klassen 'Handledning'. Detta är det första steget när man arbetar med klasser och objekt. Namnet som ges till objektet är 'tp'.
Slutligen kallar vi 'tutorial.cs' från filen demo.aspx. Den visar värdet på variabeln Name.

När du kör programmet ovan i Visual Studio får du följande utdata.

Produktion:-

Från utdata ser du meddelandet "Guru99 – ASP.NET” visas.

Steg 6) Nu ska vi lägga till vårt testprojekt i demoapplikationen. Detta görs med hjälp av Visual Studio.

Högerklicka på Solution – DemoApplication.
I snabbmenyn väljer du alternativet "Nytt projekt".

Steg 7) Steget inbegriper tillägget av Unit Test-projektet till demoapplikationen.

Klicka på objekttyp som "Test" från den vänstra panelen.
Välj objektet som 'Unit Test Project' från listan, som visas i mitten av dialogrutan.
Ge ett namn för testprojektet. I vårt fall är namnet 'DemoTest'.
Klicka slutligen på knappen 'OK'.

Du kommer så småningom att se DemoTest-projektet läggas till i lösningsutforskaren. Med detta kan du också se andra filer som UnitTest1.cs, egenskaper, etc. genereras som standard.

Kör testprojektet

Testprojektet som skapades i föregående avsnitt används för att testa vår ASP.NET-applikation. I följande steg ska vi se hur man kör testprojektet.

Det första steget skulle vara att lägga till en referens till ASP.NET-projektet. Detta steg utförs så att testprojektet har åtkomst till ASP.NET-projektet.
Sedan kommer vi att skriva vår testkod.
Slutligen kommer vi att köra testet med Visual Studio.

Steg 1) För att testa vår demoapplikation måste det första testprojektet referera till demoapplikationen. Lägg till en referens till Demo.aspx-lösningen.

Högerklicka på projektet Demo Test
Från menyn väljer du alternativet Lägg till->Referens.

Steg 2) Nästa steg är att lägga till en referens till DemoApplication.

Välj alternativet Projekt på vänster sida av dialogrutan
Klicka på kryssrutan bredvid DemoApplication
Klicka på knappen 'OK'.

Detta gör det möjligt för ett demotest-projekt att testa vår DemoApplication.

Steg 3) Nu är det dags att lägga till testkoden i vårt testprojekt.

För detta första dubbelklicka på filen UnitTest1 (UnitTest1-filen läggs till automatiskt av Visual Studio när testprojektet skapas) i Solution Explorer.
Det här är filen som kommer att köras för att testa ASP.NET-projektet.

Du kommer att se koden nedan som lagts till av Visual Studio i filen UnitTest1.cs. Detta är den grundläggande koden som behövs för att testprojektet ska köras.

Steg 4) Nästa steg är att lägga till koden som används för att testa strängen "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");
   }
 }
}

Skapa ett nytt objekt som heter 'tp' av typen Tutorial
Metoden Assert.AreEqual används i .NET för att testa om ett värde är lika med något. Så i vårt fall jämför vi värdena för tp.Name med Guru99 – ASP.NET.

Steg 5) Nu kör vi vårt testprojekt. För detta behöver vi gå till menyalternativet Test->Kör->Alla tester.

Produktion:-

Ett testutforskarfönster visas i Visual Studio. Detta kommer att visa ovanstående resultat och visa att ett framgångsrikt test kördes i Visual Studio.

MSTest-attribut och påståenden du kommer att använda

Ocuco-landskapet MicrosoftNamnrymden .VisualStudio.TestTools.UnitTesting levererar en liten uppsättning attribut och assertioner som täcker de flesta ASP.NET-enhetstester. Att lära sig dessa först gör varje senare test lättare att läsa och underhålla.

[Testklass] – markerar klassen som en behållare för tester. MSTest skannar klasser med detta attribut vid upptäcktstillfället.
[Testmetod] – markerar en publik, parameterlös metod som ett individuellt test. Metoden returnerar void, Task eller ValueTask.
[TestInitialisera] / [Testrensning] – kör före och efter varje testmetod. Använd dem för att skapa och avyttra delade inställningar, till exempel ett simulerat arkiv eller en kontext i minnet.
[Klassinitialisera] / [Klassrensning] – kör en gång för hela klassen. De är användbara när installationen är dyr, till exempel att skapa en testdatabas.
[DataRow] och [DataTestMethod] – tillhandahålla parametriserade ingångar så att en enda testmetod täcker flera fall.

Inuti varje testmetod kontrollerar Assert-klassen resultatet. Vanliga anrop inkluderar Assert.AreEqual för värdejämförelser, Assert.IsTrue och Assert.IsFalse för booleska värden, Assert.IsNull och Assert.IsNotNull för referenser och Assert.ThrowsException för förväntade undantag. Strukturera varje test med hjälp av mönstret Arrange, Act och Assert så att konfiguration, anrop och verifiering förblir visuellt separerade. Denna layout gör det enkelt att felsöka misslyckade tester eftersom den misslyckade raden nästan alltid är den enda Assert längst ner.

MSTest, NUnit och xUnit jämförda för ASP.NET

Tre testramverk dominerar .NET-ekosystemet. Var och en körs inuti Visual Studio och integreras med dotnet-test, så skillnaden ligger främst i stil, community-stöd och standardbeteende.

MSTest – skickas av Microsoft och levereras förinstallerad med Visual Studio Unit Test Project-mallen som användes tidigare i den här handledningen. Det är den säkraste standardinställningen när ett team är nytt inom enhetstestning på Microsoft stack.
NUnit – den äldsta av de tre, ursprungligen porterad från JUnitDen erbjuder en omfattande begränsningsmodell, parametriserade tester genom TestCase och TestCaseSource, och moget stöd för alla .NET-versioner.
xUnit.net – används internt av ASP.NET Core- och Entity Framework Core-teamen. Den ersätter SetUp-metoden med konstruktorn och IDisposable, uppmuntrar en testklass per beteende och använder [Fact] och [Theory] istället för [TestMethod].

Alla tre ramverken upptäcker tester genom attribut, körs via dotnet test-kommandot och producerar trx- eller xUnit XML-rapporter som CI-pipelines som Azure DevOps, GitHub-åtgärder och Jenkins kan konsumera direkt. För ett första ASP.NET-projekt förenklar MSTest verktygskedjan. Team som vill ha mer omfattande parametrisering eller redan använder ASP.NET Core väljer ofta xUnit för konsekvens med det ramverk det byggdes med.

Bästa praxis för enhetstestning av ASP.NET-applikationer

Att följa en liten uppsättning vanor håller en sviten snabb, pålitlig och användbar under hela ASP.NET-projektets livslängd.

Testa ett beteende per metod. Ett test som påstår flera orelaterade saker misslyckas av många anledningar och tar längre tid att åtgärda.
Namnge tester efter avsikt. Ett mönster som MethodUnderTest_Scenario_ExpectedResult gör Test Explorer-utdata till en läsbar specifikation av klassen.
Isolera enheten från externa system. Slå in fil-, nätverks- och databasanrop bakom gränssnitt och byt ut mot förfalskningar eller simuleringar så att testet inte träffar det verkliga beroendet.
Håll testerna snabba. Sikta på att hela enhetssviten ska vara klar på några sekunder. Långsamma tester hoppas över, och hoppade tester döljer regressioner.
Följ layouten "Organisera, agera, hävda". Tre korta block med tomma rader mellan dem signalerar avsikt och gör det lätt att upptäcka felaktiga linjer.
Kör tester på varje commit. Koppla dotnet-test till en CI-pipeline så att ett trasigt test blockerar sammanslagningen istället för leveransenping till produktion.
Track-kodtäckning, men jaga den inte. Täckningen belyser oprövade vägar men ett högt antal ensamt garanterar inte kvalitet. RevSe vad de saknade raderna faktiskt gör.

Tillsammans förvandlar dessa metoder DemoTest-projektet som byggts ovan till fröet till en svit som fångar regressioner vid varje push, dokumenterar beteende för framtida utvecklare och ger trygghet vid omstrukturering av en ASP.NET-applikation.

Vanliga frågor

Ja. GitHub Copilot kan skapa [TestClass]- och [TestMethod]-block, föreslå layouter för Arrange Act Assert och generera parametriserade [DataRow]-fall från en målmetodsignatur. RevVisa de genererade påståendena innan du litar på dem i produktion.

Ja. Maskininlärningsbaserade assistenter kan flagga bräckliga tester, föreslå bättre namn och markera duplicerade inställningar som hör hemma i [TestInitialize]. De förkortar granskningstiden men utvecklaren äger fortfarande korrektheten i varje Assert.

Ett enhetstest isolerar en klass eller metod och simulerar dess beroenden. Ett integrationstest utför flera komponenter tillsammans, ofta på en riktig databas eller webbserver. Enhetstester körs på millisekunder; integrationstester tar längre tid men upptäcker fel i kopplingssystemet.

I Visual Studio Enterprise, använd Test Analyze Code Täckning för alla tester. På andra utgåvor, lägg till Coverlet NuGet paketera och kör dotnet test –collect:”XPlat Code "Täckning" för att producera en Cobertura XML-rapport.

Linda beroendet bakom ett gränssnitt och injicera det genom konstruktorn. I testet, skicka en stub eller en mock byggd med bibliotek som Moq eller NSubstitute så att enheten som testas aldrig vidrör den verkliga databasen eller HTTP-slutpunkten.

Kör dotnet test i mappen som innehåller testprojektet. Kommandot bygger projektet, upptäcker varje [TestMethod], kör dem och skriver ut en sammanfattning. CI-system som GitHub Actions anropar samma kommando i ett arbetsflödessteg.

Markera metoden med [DataTestMethod] och lägg till ett eller flera [DataRow]-attribut som anger indatavärdena och förväntat resultat. MSTest kör sedan samma brödtext en gång per rad, vilket skapar en separat rad i Test Explorer för varje fall.

Skriv en felaktig [TestMethod] som beskriver nästa obligatoriska beteende, lägg till precis tillräckligt med produktionskod för att det ska godkännas och refaktorera sedan. Genom att upprepa denna rödgröna refaktoreringsloop håller du designen vägledd av tester istället för tvärtom.