Tester les applications WinUI créées avec le SDK d'application Windows

Dans cette rubrique, nous fournissons des recommandations pour tester et valider des fonctionnalités dans les applications créées avec les fonctionnalités SDK d'application Windows à l’aide de WinUI 3 fonctionnalités d’interface utilisateur (IU). Le test est un élément essentiel du processus de développement d’applications : il vous aide à intercepter les bogues tôt, à maintenir la qualité du code et à garantir une expérience utilisateur fiable à mesure que votre application évolue. En incorporant des tests unitaires dans votre flux de travail, vous pouvez refactoriser en toute confiance du code, ajouter de nouvelles fonctionnalités et expédier des mises à jour sachant que les fonctionnalités existantes continuent de fonctionner comme prévu.

Tutoriel : Créer un projet de test unitaire WinUI 3.

La plupart des types d’objets sous les espaces de noms Microsoft.UI.Xaml doivent être utilisés à partir d’un thread d’interface utilisateur dans un processus d’application XAML. (Pour en savoir plus sur le test des applications créées avec SDK d'application Windows sans utilisation de WinUI 3, voir la section suivante, Tester les fonctionnalités non-WinUI.)

Dans ce tutoriel, vous allez apprendre à :

Prerequisites

Vous devez avoir Visual Studio installé et configuré pour le développement WinUI. Consultez démarrage rapide : Configurer votre environnement et créer un projet WinUI 3.

Créer un projet d’application de test unitaire WinUI

Pour commencer, créez un projet de test unitaire. Le type de projet est fourni avec tous les fichiers de modèle dont vous avez besoin.

1. Ouvrez Visual Studio et sélectionnez Créer un nouveau projet dans la fenêtre Démarrer.

   

2. Dans la fenêtre Créer un nouveau projet, filtrez les projets sur C#, Windows et WinUI, sélectionnez le modèle , puis sélectionnez Next

   

3. [Facultatif] Dans la fenêtre Configurer votre nouveau projet, modifiez le Nom du projet, le Nom de la solution (décochez Placer la solution et le projet dans le même répertoire) et l’Emplacement de votre projet.

4. Cliquez sur Créer.

Exécuter des tests avec l’Explorateur de tests

Lorsque vous créez le projet de test, vos tests apparaissent dans l’Explorateur de tests, qui permet d'exécuter vos tests unitaires. Vous pouvez également regrouper des tests en catégories, filtrer la liste de tests, créer, enregistrer et exécuter des playlists de tests, déboguer des tests unitaires et (dans Visual Studio Entreprise) analyser la couverture du code.

Le fichier UnitTests.cs contient le code source des tests unitaires utilisés par l’Explorateur de tests. Par défaut, les exemples de tests de base présentés ici sont créés automatiquement :

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. Si vous ne l’avez pas déjà fait, générez votre solution. Cela permet Visual Studio de « découvrir » tous les tests disponibles.

2. Ouvrez l’Explorateur de tests. S’il n’est pas visible, ouvrez le menu Test, puis choisissez Explorateur de tests (ou appuyez sur Ctrl + E, T).

   

3. Consultez les tests. Dans la fenêtre Explorateur de tests, développez tous les nœuds (seuls les exemples de tests seront présents à ce stade).

   

4. Exécutez les tests.

   • Cliquez avec le bouton droit sur les nœuds de tests individuels, puis sélectionnez Exécuter.
   • Sélectionnez un test, puis appuyez sur le bouton Lecture ou sur Ctrl + R, T.
   • Appuyez sur le bouton Exécuter tous les tests dans l’affichage ou appuyez sur Ctrl + R, V.

   

5. Examinez les résultats. Une fois les tests terminés, les résultats sont affichés dans la fenêtre Explorateur de tests.

   

Ajouter un projet de bibliothèque de classes à des fins de test

6. Ajoutez un projet à la solution de test unitaire. Dans le Explorateur de solutions, cliquez avec le bouton droit sur la solution, puis sélectionnez Add -> Nouveau projet... .

   

7. Pour cet exemple, ajoutez un projet de bibliothèque de classes WinUI 3. Dans la fenêtre Nouveau projet, filtrez sur C#/Windows/WinUI, puis sélectionnez Bibliothèque de classesWinUI.

   

8. Sélectionnez Suivant et entrez un nom pour le projet (pour cet exemple, nous utilisons WinUIClassLibrary1) et appuyez sur Créer.

   

9. Ajoutez un nouveau UserControl au projet. Dans le Explorateur de solutions, cliquez avec le bouton droit sur le projet de bibliothèque de classes WinUI 3 que vous venez d’ajouter et sélectionnez Add -> Nouvel élément dans le menu contextuel.

   

10. Dans la fenêtre Ajouter un nouvel élément , sélectionnez le nœud WinUI dans la liste des éléments installés , puis choisissez Contrôle utilisateur dans les résultats. Nommez le contrôle UserControl1.

    

11. Ouvrez le fichier de code sous-jacent UserControl1.xaml.cs. Pour cet exemple, nous ajoutons une nouvelle méthode publique appelée GetSeven qui retourne simplement un entier.

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

12. Définissez le projet bibliothèque de classes WinUI 3 comme dépendance du projet de test unitaire pour permettre l’utilisation de types à partir du projet de bibliothèque de classes WinUI 3. Dans Explorateur de solutions, sous le projet de bibliothèque de classes, cliquez avec le bouton droit sur Dependencies et sélectionnez Add Project Reference.

    

    Sélectionnez l’élément WinUIClassLibrary1 dans la liste Projets .

    

13. Créez une méthode de test dans UnitTests.cs. Comme ce cas de test nécessite qu’un thread d’interface utilisateur XAML s’exécute, marquez-le avec l’attribut [UITestMethod] au lieu de l’attribut standard [TestMethod] .

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

    Cette nouvelle méthode de test apparaît désormais dans l’Explorateur de tests comme l’un de vos tests unitaires.

    

14. Exécutez les tests.

• Cliquez avec le bouton droit sur le nouveau nœud de test et sélectionnez Exécuter.
• Sélectionnez le nouveau test, puis appuyez sur le bouton Lecture ou appuyez sur Ctrl + R, T.
• Appuyez sur le bouton Exécuter tous les tests dans l’affichage ou appuyez sur Ctrl + R, V.

Test de fonctionnalités non WinUI

Dans de nombreux cas, une application inclut des fonctionnalités qui ne dépendent pas des types Microsoft.UI.Xaml, mais qui ont quand même besoin de tests. Différents outils sont disponibles pour tester le code .NET, notamment MSTest, NUnit et xUnit. Pour plus d’informations sur le test des applications .NET, consultez Testing dans .NET.

Dans Visual Studio, vous pouvez créer un nouveau projet pour l’un de ces outils de test en cliquant avec le bouton droit sur votre solution dans l’Explorateur de solutions, en sélectionnant Add -> Nouveau projet dans le menu contextuel, en choisissant C# à partir du sélecteur Toutes les langues/Windows et Test à partir du sélecteur Tous les types de projets, puis en sélectionnant l’outil de test approprié dans la liste (Projet de test MSTest, Projet de test NUnit ou Projet de test xUnit).

Lors de la création d’un projet MSTest, NUnit ou xUnit qui fait référence à un projet WinUI 3, vous devez :

1. Mettre à jour le TargetFramework dans le fichier .csproj de votre projet de test. Cette valeur doit correspondre au TargetFramework du projet WinUI 3. Par défaut, msTest, les projets NUnit et xUnit ciblent la gamme complète de plateformes prises en charge par .NET, mais un projet WinUI 3 prend uniquement en charge Windows et a un TargetFramework plus spécifique.

   Par exemple, si vous ciblez .NET 8, mettez à jour targetFramework du projet de test unitaire de <TargetFramework>net8.0</TargetFramework> vers <TargetFramework>net8.0-windows10.0.19041.0</TargetFramework>.

2. Mettre à jour les RuntimeIdentifiers dans votre projet de test.

   <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. Ajoutez la propriété suivante au PropertyGroup dans le fichier .csproj de votre projet de test pour vous assurer que le test charge le runtime SDK d'application Windows : <WindowsAppSdkBootstrapInitialize>true</WindowsAppSdkBootstrapInitialize>

4. Vérifiez que le runtime SDK d'application Windows est installé sur la machine exécutant le test. Pour plus d’informations sur le déploiement SDK d'application Windows, consultez SDK d'application Windows guide de déploiement pour les applications dépendantes de l’infrastructure empaquetées avec un emplacement externe (ou non empaqueté).

Automatisation des tests d’interface utilisateur

Pour les tests de bout en bout de l’interface utilisateur de votre application, vous pouvez utiliser des outils de test automatisés de l’interface utilisateur qui interagissent avec votre application de la façon dont un utilisateur peut cliquer sur des boutons, entrer du texte et vérifier l’état visuel.

Appium avec WinAppDriver

WinAppDriver était l’outil Microsoft d’origine pour Windows test d’automatisation de l’interface utilisateur, mais il n’est plus en cours de développement actif. Le successeur recommandé est Appium avec le plug-in Windows Application Driver (appium-windows-driver). Appium utilise le même protocole WebDriver et prend en charge Windows applications de bureau via l’infrastructure Windows UI Automation.

Pour configurer Appium pour une application de bureau WinUI 3 :

1. Installez Appium : npm install -g appium
2. Installez le pilote Windows :appium driver install windows
3. Vérifiez que le pilote est installé : appium driver list (doit s’afficher windows comme installé)
4. Démarrez le serveur Appium : appium
5. Écrire des tests à l’aide d’une bibliothèque de client WebDriver (disponible pour C#, Python, Java et JavaScript).

Accessibility Insights et Automatisation de l’interface utilisateur

Accessibility Insights for Windows vous aide à inspecter et valider l’arborescence UI Automation de votre application. Les éléments exposés via UI Automation sont les mêmes éléments que ceux avec lesquels les outils de test automatisé interagissent. S’assurer que votre application dispose d’une arborescence d’automatisation bien structurée améliore à la fois l’accessibilité et la testabilité.

Microsoft Playwright (interface utilisateur web dans WebView2)

Si votre application utilise WebView2 pour le contenu web, vous pouvez utiliser Microsoft Playwright pour tester les parties web. Playwright prend en charge les tests de navigateur automatisés et peut se connecter à des instances WebView2 pour la validation du scénario de bout en bout.

Qualité du code et analyse statique

Les outils d’analyse statique interceptent les bogues, les problèmes de sécurité et les problèmes de qualité du code avant l’exécution. Intégrez-les à votre flux de travail de développement et pipelines CI pour une qualité cohérente.

analyseurs .NET (Roslyn)

.NET projets incluent des analyseurs Roslyn intégrés qui vérifient l’exactitude, les performances, la fiabilité et les problèmes de sécurité. Pour activer toutes les règles recommandées dans votre projet :

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

Vous pouvez configurer les niveaux de gravité des règles dans un fichier .editorconfig ou en utilisant <NoWarn> dans votre fichier de projet. Pour plus d’informations, consultez Vue d’ensemble de l’analyse du code source .NET.

Analyse statique C++ (/analyser)

Pour les projets C++ SDK d'application Windows et Win32, activez l’analyse statique de Microsoft en définissant /analyze dans les propriétés de votre projet ou dans MSBuild :

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

C++ Core Guidelines Checker applique les meilleures pratiques C++ modernes. Pour les modèles d’utilisation de l’API Win32, les annotations SAL et l’indicateur interceptent les /analyze problèmes courants de durée de vie, de mémoire tampon et d’accès concurrentiel.

Intégration continue

Ajoutez une analyse statique à votre workflow CI afin que les contrôles de qualité du code s’exécutent à chaque pull request. Dans un flux de travail GitHub Actions :

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

Pour les projets C++ à l’aide de MSBuild :

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

Télémétrie et rapports d’incident

La collecte des données de télémétrie et d’incident à partir de la production vous permet de comprendre comment votre application s’exécute dans le monde réel, d’identifier les régressions et de hiérarchiser les correctifs.

Application Insights

Azure Application Insights fournit des rapports d’incident, une surveillance des performances et une analytique de l’utilisation pour les applications de bureau. Pour l’ajouter à un projet SDK d'application Windows :

1. Installez le package NuGet : Microsoft.ApplicationInsights
2. Initialisez TelemetryClient au démarrage de votre application avec votre chaîne de connexion
3. Suivre les exceptions, les événements et les affichages de page

Pour obtenir des instructions d’installation détaillées, consultez Application Insights pour .NET applications de console et de bureau.

OpenTelemetry

OpenTelemetry est une norme indépendante des fournisseurs destinée à la collecte de journaux, de métriques et de traces distribuées. Le kit de développement logiciel (SDK) OpenTelemetry .NET s’intègre à Azure Monitor et à d’autres back-ends.

Installez les packages nécessaires :

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

Configurez ensuite le fournisseur de suivi :

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 est l’approche recommandée pour les nouveaux projets nécessitant une prise en charge multi-back-end ou un suivi distribué. Application Insights reste un bon choix si vous utilisez Azure Monitor exclusivement et souhaitez des tableaux de bord clés en main.

Rapport d'erreurs Windows (WER)

Pour la collecte d’incidents native, Windows Rapport d’erreurs capture automatiquement les vidages sur incident lorsque votre application se termine de façon inattendue. Les applications empaquetées (MSIX) voient leurs données de plantage apparaître dans les rapports de qualité de l’Espace partenaires. Pour les applications métier, vous pouvez configurer la collecte de vidage locale WER pour enregistrer des minidumps pour l’analyse locale.

Ressources supplémentaires

• Principes de base des tests unitaires
• Outils de test dans Visual Studio
• Intégration continue pour les applications WinUI
• Vue d’ensemble de l’analyse du code source .NET
• Analyse du code C++
• Azure Monitor Application Insights
• Kit de développement logiciel (SDK) OpenTelemetry .NET