WinUI-apps testen die zijn gebouwd met de Windows App SDK

In dit onderwerp geven we enkele aanbevelingen voor het testen en valideren van functionaliteit in apps die zijn gemaakt met de functies van de Windows App SDK met behulp van WinUI 3 ui-functies (User Interface). Testen is een essentieel onderdeel van het app-ontwikkelingsproces. Het helpt u bij het vroegtijdig opsporen van bugs, het onderhouden van codekwaliteit en het garanderen van een betrouwbare gebruikerservaring naarmate uw app zich ontwikkelt. Door eenheidstests in uw werkstroom op te nemen, kunt u met vertrouwen code herstructureren, nieuwe functies toevoegen en updates verzenden, wetende dat bestaande functionaliteit blijft werken zoals verwacht.

Zelfstudie: Een WinUI 3-eenheidstestproject maken.

De meeste objecttypen onder de naamruimten Microsoft.UI.Xaml moeten worden gebruikt vanuit een UI-thread in een XAML-toepassingsproces. (Zie de volgende sectie Testen van niet-WinUI-functionaliteit voor meer informatie over het testen van apps die zijn gemaakt met Windows App SDK en geen WinUI 3 gebruiken.)

Opmerking

U wordt aangeraden alle code die u wilt testen te herstructureren door deze uit het hoofd-app-project te halen en in een bibliotheekproject te plaatsen. Zowel uw app-project als uw eenheidstestproject kunnen vervolgens verwijzen naar dat bibliotheekproject. In deze sectie wordt beschreven hoe u eenheidstests maakt voor WinUI 3-apps in Visual Studio met behulp van de ingebouwde moduletestprojectsjablonen.

Opmerking

De moduletest-app die hier wordt beschreven, is geschreven in de context van een WinUI 3-toepassing. Dit is vereist voor tests die code uitvoeren waarvoor de XAML-runtime is vereist. Met dit project maakt u een XAML UI-thread en voert u de tests uit.

In deze handleiding leer je hoe je:

• Maak een WinUI Unit Test App in Visual Studio.
• Gebruik de Visual Studio Test Explorer.
• Voeg een WinUI Class Library-project toe om te testen.
• Voer tests uit met de Visual Studio Test Explorer.

Vereiste voorwaarden

U moet Visual Studio geïnstalleerd hebben en opgesteld voor WinUI-ontwikkeling. Zie quickstart: Een WinUI 3-project maken en uitvoeren.

Een WinUI Unit Test App-project maken

Maak een eenheidstestproject om te beginnen. Het projecttype wordt geleverd met alle sjabloonbestanden die u nodig hebt.

1. Open Visual Studio en selecteer Maak een nieuw project in het startvenster.

   

2. Filter in het venster Maak een nieuw project projecten naar C#, Windows en WinUI selecteert u de sjabloon WinUI Unit Test App en selecteert u vervolgens Volgend

   

3. [Optioneel] Wijzig in het venster Uw nieuwe project configureren de projectnaam, oplossingsnaam (schakel De oplossing en het project in dezelfde map plaatsen) en de locatie van uw project uit.

4. Klik op Creëren.

Tests uitvoeren met Test Explorer

Wanneer u het testproject maakt, worden uw tests weergegeven in Test Explorer, die wordt gebruikt om uw eenheidstests uit te voeren. U kunt tests ook groeperen in categorieën, de testlijst filteren, afspeellijsten maken, opslaan en uitvoeren van tests, foutopsporingseenheidtests en (in Visual Studio Enterprise) codedekking analyseren.

Het bestand UnitTests.cs bevat de broncode voor de eenheidstests die door Test Explorer worden gebruikt. Standaard worden de hier weergegeven basisvoorbeeldtests automatisch gemaakt:

namespace WinUITest1
{
   [TestClass]
   public class UnitTest1
   {
      [TestMethod]
      public void TestMethod1()
      {
         Assert.AreEqual(0, 0);
      }

      // Use the UITestMethod attribute for tests that need to run on the UI thread.
      [UITestMethod]
      public void TestMethod2()
      {
         var grid = new Grid();
         Assert.AreEqual(0, grid.MinWidth);
      }
   }
}

1. Als u dit nog niet hebt gedaan, bouwt u uw oplossing. Hierdoor kunnen Visual Studio alle beschikbare tests detecteren.

2. Open Test Explorer. Als dit niet zichtbaar is, opent u het menu Testen en kiest u Test Explorer (of drukt u op Ctrl+E, T).

   

3. Tests weergeven. Vouw in het venster Test Explorer alle knooppunten uit (alleen de voorbeeldtests zijn op dit moment aanwezig).

   

4. Voer tests uit.

   • Klik met de rechtermuisknop op afzonderlijke testknooppunten en selecteer Uitvoeren.
   • Selecteer een test en druk op de knop Afspelen of druk op Ctrl+R, T.
   • Druk op de knop Alle tests uitvoeren in weergave of druk op Ctrl+R, V.

   

5. Bekijk resultaten. Nadat de tests zijn voltooid, worden de resultaten weergegeven in het venster Test Explorer .

   

Een klassebibliotheekproject toevoegen voor testen

6. Voeg een nieuw project toe aan de eenheidstestoplossing. Klik in de Solution Explorer met de rechtermuisknop op de oplossing en selecteer Toevoegen -> Nieuw project... .

   

7. Voeg voor dit voorbeeld een WinUI 3-klassebibliotheekproject toe. Filter in het venster Nieuw project op C#/Windows/WinUI en selecteer WinUI Class Library.

   

8. Selecteer Volgende en voer een naam in voor het project (voor dit voorbeeld dat we gebruiken WinUIClassLibrary1) en druk op Maken.

   

9. Voeg een nieuw UserControl project toe. Klik in de Solution Explorer met de rechtermuisknop op het WinUI 3-klassebibliotheekproject dat u zojuist hebt toegevoegd en selecteer Toevoegen -> Nieuw item in het snelmenu.

   

10. Selecteer in het venster Nieuw item toevoegen het WinUI-knooppunt in de lijst Geïnstalleerde items en kies vervolgens Gebruikersbeheer in de resultaten. Geef het besturingselement UserControl1een naam.

    

11. Open het bestand UserControl1.xaml.cs code-behind. In dit voorbeeld voegen we een nieuwe openbare methode GetSeven toe die eenvoudigweg een geheel getal retourneert.

    namespace WinUIClassLibrary1
    {
      public sealed partial class UserControl1 : UserControl
      {
         public UserControl1()
         {
             this.InitializeComponent();
         }
    
         public int GetSeven()
         {
             return 7;
         }
      }
    }
    

12. Stel het WinUI 3-klassebibliotheekproject in als een afhankelijkheid van het eenheidstestproject om het gebruik van typen uit het WinUI 3-klassebibliotheekproject in te schakelen. Klik in Solution Explorer onder het klassebibliotheekproject met de rechtermuisknop op Afhankelijkheden en selecteer Toevoegen projectreferentie.

    

    Selecteer het WinUIClassLibrary1 item in de lijst Projecten .

    

13. Maak een nieuwe testmethode in UnitTests.cs. Aangezien voor deze testcase een XAML UI-thread moet worden uitgevoerd, markeert u deze met het [UITestMethod] kenmerk in plaats van het standaardkenmerk [TestMethod] .

    [UITestMethod]
    public void TestUserControl1()
    {
       WinUIClassLibrary1.UserControl1 userControl1 = new WinUIClassLibrary1.UserControl1();
       Assert.AreEqual(7, userControl1.GetSeven());
    }
    

    Deze nieuwe testmethode wordt nu weergegeven in Test Explorer als een van uw eenheidstests.

    

14. Voer tests uit.

• Klik met de rechtermuisknop op het nieuwe testknooppunt en selecteer Uitvoeren.
• Selecteer de nieuwe test en druk op de knop Afspelen of druk op Ctrl+R, T.
• Druk op de knop Alle tests uitvoeren in weergave of druk op Ctrl+R, V.

Niet-WinUI-functionaliteit testen

In veel gevallen bevat een app functionaliteit die niet afhankelijk is van Microsoft.UI.Xaml-typen, maar nog steeds tests nodig heeft. Er zijn verschillende hulpprogramma's beschikbaar voor het testen van .NET code, waaronder MSTest, NUnit en xUnit. Zie Testing in .NET voor meer informatie over het testen van .NET-apps.

In Visual Studio kunt u een nieuw project maken voor een van deze testhulpprogramma's door met de rechtermuisknop op uw oplossing in Solution Explorer te klikken. Selecteer Toevoegen -> Nieuw project in het snelmenu en kies C# in de Alle talen selector/Windows in de All languages selector/Test from the All project types selector, en kiest u vervolgens het juiste testprogramma in de lijst (MSTest Test Project, NUnit Test Project of xUnit Test Project).

Wanneer u een nieuw MSTest-, NUnit- of xUnit-project maakt dat verwijst naar een WinUI 3-project, moet u:

1. Werk het TargetFramework bestand .csproj van uw testproject bij. Deze waarde moet overeenkomen met die van TargetFramework in het WinUI 3-project. MsTest-, NUnit- en xUnit-projecten richten zich standaard op het volledige scala aan platformen die worden ondersteund door .NET, maar een WinUI 3-project ondersteunt alleen Windows en heeft een specifieker TargetFramework.

   Als u bijvoorbeeld .NET 8 wilt instellen, werkt u het TargetFramework van het eenheidstestproject bij van <TargetFramework>net8.0</TargetFramework> naar <TargetFramework>net8.0-windows10.0.19041.0</TargetFramework>.

2. Werk de RuntimeIdentifiers in uw testproject bij.

   <RuntimeIdentifiers Condition="$([MSBuild]::GetTargetFrameworkVersion('$(TargetFramework)')) &gt;= 8">win-x86;win-x64;win-arm64</RuntimeIdentifiers>

   <RuntimeIdentifiers Condition="$([MSBuild]::GetTargetFrameworkVersion('$(TargetFramework)')) &lt; 8">win10-x86;win10-x64;win10-arm64</RuntimeIdentifiers>

3. Voeg de volgende eigenschap toe aan de PropertyGroup in het .csproj-bestand van uw testproject om ervoor te zorgen dat de test de Windows App SDK runtime laadt: <WindowsAppSdkBootstrapInitialize>true</WindowsAppSdkBootstrapInitialize>

4. Zorg ervoor dat de Windows App SDK runtime is geïnstalleerd op de computer waarop de test wordt uitgevoerd. Zie Windows App SDK implementatiehandleiding voor frameworkafhankelijke apps die zijn verpakt met externe locatie (of uitgepakt) voor meer informatie over Windows App SDK-implementatie.

Automatisering van ui-test

Voor end-to-end testen van de gebruikersinterface van uw app kunt u geautomatiseerde hulpprogramma's voor ui-tests gebruiken die interactie hebben met uw app, zoals een gebruiker zou doen: klikken op knoppen, tekst invoeren en de visuele status verifiëren.

Appium met WinAppDriver

WinAppDriver was het oorspronkelijke hulpprogramma Microsoft voor het testen van de automatisering van de gebruikersinterface Windows, maar deze is niet langer actief. De aanbevolen opvolger is Appium met de Windows Application Driver-invoegtoepassing (appium-windows-driver). Appium maakt gebruik van hetzelfde WebDriver-protocol en ondersteunt Windows desktop-apps via het Windows UI Automation framework.

Appium instellen voor een WinUI 3-bureaublad-app:

Opmerking

Voor deze stappen is Node.js (LTS aanbevolen) vereist.

1. Appium installeren: npm install -g appium
2. Installeer het Windows-stuurprogramma:appium driver install windows
3. Controleer of het stuurprogramma is geïnstalleerd: appium driver list (moet worden weergegeven windows als geïnstalleerd)
4. Start de Appium-server: appium
5. Schrijf tests met behulp van een WebDriver-clientbibliotheek (beschikbaar voor C#, Python, Java en JavaScript).

Tip

Stel de eigenschap app in op de Application User Model ID (AUMID) van uw app voor verpakte apps, of op het pad naar het uitvoerbare bestand voor niet-verpakte apps.

Toegankelijkheidsinzichten en UI Automation

Met toegankelijkheidsinzichten voor Windows kunt u de UI Automation structuur van uw app controleren en valideren. De elementen die worden weergegeven via UI Automation zijn dezelfde elementen waarmee geautomatiseerde testhulpprogramma's communiceren. Ervoor zorgen dat uw app een goed gestructureerde automatiseringsstructuur heeft, verbetert zowel de toegankelijkheid als de testbaarheid.

Microsoft Playwright (webgebruikersinterface in WebView2)

Als uw app Gebruikmaakt van WebView2 voor webinhoud, kunt u Microsoft Playwright gebruiken om de webgedeelten te testen. Playwright ondersteunt geautomatiseerde browsertests en kan verbinding maken met WebView2-exemplaren voor end-to-end-scenariovalidatie.

Codekwaliteit en statische analyse

Statische analysehulpprogramma's vangen fouten, beveiligingsproblemen en problemen met codekwaliteit op voordat runtime wordt uitgevoerd. Integreer deze in uw ontwikkelwerkstroom en CI-pijplijnen voor consistente kwaliteit.

.NET analyzers (Roslyn)

.NET projecten omvatten ingebouwde Roslyn-analyses die controleren op juistheid, prestaties, betrouwbaarheid en beveiligingsproblemen. Alle aanbevolen regels in uw project inschakelen:

<PropertyGroup>
  <AnalysisLevel>latest-recommended</AnalysisLevel>
  <EnforceCodeStyleInBuild>true</EnforceCodeStyleInBuild>
</PropertyGroup>

U kunt de ernst van regels configureren in een .editorconfig bestand of met behulp van <NoWarn> het projectbestand. Zie Overzicht van .NET-broncodeanalyse voor meer informatie.

Statische C++-analyse (/analyseren)

Voor C++ Windows App SDK- en Win32-projecten schakelt u statische analyse van Microsoft in door in uw projecteigenschappen of MSBuild in te stellen/analyze:

<PropertyGroup>
  <EnableMicrosoftCodeAnalysis>true</EnableMicrosoftCodeAnalysis>
  <CodeAnalysisRuleSet>CppCoreCheckRules.ruleset</CodeAnalysisRuleSet>
</PropertyGroup>

C++ Core Guidelines Checker dwingt moderne aanbevolen procedures voor C++ af. Voor Win32 API-gebruikspatronen, SAL-aantekeningen en de /analyze vlag vangen veelvoorkomende levensduur-, buffer- en gelijktijdigheidsproblemen op.

CI-integratie

Voeg statische analyse toe aan uw CI-werkstroom, zodat codekwaliteitscontroles worden uitgevoerd op elke pull-aanvraag. In een GitHub Actions werkstroom:

    - name: Build with analysis
      run: dotnet build --configuration Release /p:AnalysisLevel=latest-recommended /p:TreatWarningsAsErrors=true

Voor C++-projecten met BEHULP van MSBuild:

    - name: Build with /analyze
      run: msbuild MySolution.sln /p:Configuration=Release /p:EnableMicrosoftCodeAnalysis=true /p:RunCodeAnalysis=true

Telemetrie en crashmeldingen

Door telemetrie- en crashgegevens uit productie te verzamelen, begrijpt u hoe uw app presteert in de echte wereld, identificeert u regressies en geeft u prioriteit aan oplossingen.

Application Insights

Azure-toepassing Insights biedt crashrapportage, prestatiebewaking en gebruiksanalyse voor bureaublad-apps. Ga als volgende te werk om het toe te voegen aan een Windows App SDK project:

Opmerking

U hebt een Azure-abonnement en een Application Insights-resource nodig. Zie Een Application Insights-resource maken om uw verbindingsreeks op te halen.

1. Installeer het NuGet-pakket: Microsoft.ApplicationInsights
2. Initialiseer de TelemetryClient bij het opstarten van uw app met uw verbindingsreeks
3. Uitzonderingen, gebeurtenissen en paginaweergaven bijhouden

Zie Application Insights voor .NET console- en bureaublad-apps voor gedetailleerde installatie-instructies.

OpenTelemetry

OpenTelemetry is een leverancierneutrale standaard voor het verzamelen van logboeken, metrische gegevens en gedistribueerde traceringen. De .NET OpenTelemetry SDK kan worden geïntegreerd met Azure Monitor en andere back-ends.

Installeer de vereiste pakketten:

dotnet add package OpenTelemetry
dotnet add package Azure.Monitor.OpenTelemetry.Exporter

Configureer vervolgens de tracerprovider:

var activitySource = new System.Diagnostics.ActivitySource("MyApp");
// OpenTelemetry SDKs can listen to ActivitySource instances like this one.
using var activity = activitySource.StartActivity("Startup");
activity?.SetTag("app.version", "1.0.0");

OpenTelemetry is de aanbevolen benadering voor nieuwe projecten die ondersteuning voor meerdere back-ends of gedistribueerde tracering nodig hebben. Application Insights blijft een goede keuze als u uitsluitend Azure Monitor gebruikt en kant-en-klare dashboards wilt.

Windows Foutrapportage (WER)

Voor systeemeigen crashverzameling legt Windows foutrapportage automatisch crashdumps vast wanneer uw app onverwacht wordt beëindigd. Verpakte apps (MSIX) krijgen crashgegevens die worden weergegeven via kwaliteitsrapporten van Partnercentrum. Voor organisatorische (LOB-)apps kunt u lokale dumpverzameling van WER configureren om minidumps op te slaan voor lokale analyse.

Aanvullende bronnen

• Basisbeginselen van eenheidstests
• Testing-hulpprogramma's in Visual Studio
• Continue integratie voor WinUI-apps
• Overzicht van .NET-broncodeanalyse
• Analyse van C++-code
• Azure Monitor Application Insights
• OpenTelemetry .NET SDK