Principes de base des tests unitaires

Vérifiez que votre code fonctionne comme prévu en créant et en exécutant des tests unitaires. Il s’agit de tests unitaires, car vous décomposez les fonctionnalités de votre programme en comportements testables discrets que vous pouvez tester en tant qu’unités individuelles. L’Explorateur de tests Visual Studio offre un moyen flexible et efficace d’exécuter vos tests unitaires et d’afficher leurs résultats dans Visual Studio. Visual Studio installe les frameworks de test unitaire Microsoft pour le code managé et natif. Utilisez une infrastructure de test unitaire pour créer des tests unitaires, les exécuter et signaler les résultats de ces tests. Réexécutez des tests unitaires lorsque vous apportez des modifications pour tester que votre code fonctionne toujours correctement. Visual Studio Enterprise peut effectuer cette opération automatiquement avec Live Unit Testing, qui détecte les tests affectés par vos modifications de code et les exécute en arrière-plan au fur et à mesure que vous tapez.

Les tests unitaires ont le plus grand effet sur la qualité de votre code lorsqu’il fait partie intégrante de votre workflow de développement logiciel. Dès que vous écrivez une fonction ou un autre bloc de code d’application, créez des tests unitaires qui vérifient le comportement du code en réponse aux cas standard, limites et cas incorrects de données d’entrée, et qui vérifient les hypothèses explicites ou implicites effectuées par le code. Avec le développement piloté par les tests, vous créez les tests unitaires avant d’écrire le code. Vous utilisez donc les tests unitaires comme documentation de conception et spécifications fonctionnelles.

L'Explorateur de tests peut également exécuter des frameworks de test unitaire tiers et open source ayant implémenté des interfaces de module complémentaire de l'Explorateur de tests. Vous pouvez ajouter un grand nombre de ces frameworks via le Gestionnaire d’extensions Visual Studio et la galerie Visual Studio. Pour plus d’informations, consultez Installer des frameworks de test unitaire tiers.

Get started

Pour une introduction aux tests unitaires qui vous amène directement dans le codage, consultez l’un des articles suivants :

• Test GitHub Copilot pour .NET

• Procédure pas à pas : créer et exécuter des tests unitaires pour le code .NET

• Procédure pas à pas : développement piloté par les tests avec l’Explorateur de tests

• Écrire des tests unitaires pour C/C++ dans Visual Studio

Exemple de solution banque

Dans cet article, nous utilisons le développement d’une application fictive appelée MyBank comme exemple. Vous n’avez pas besoin du code réel pour suivre les explications de cet article. Les méthodes de test sont écrites en C# et présentées à l’aide de Microsoft Unit Testing Framework for Managed Code. Toutefois, les concepts sont facilement transférés vers d’autres langages et infrastructures.

Notre première tentative de conception pour l’application MyBank comprend un composant de comptes qui représente un compte individuel et ses transactions avec la banque, et un composant de base de données qui représente la fonctionnalité d’agrégation et de gestion des comptes individuels.

Nous créons une Bank solution qui contient deux projets :

• Accounts

• BankDB

Notre première tentative de conception du Accounts projet contient une classe pour contenir des informations de base sur un compte, une interface qui spécifie les fonctionnalités courantes de n’importe quel type de compte, comme le dépôt et le retrait des ressources du compte, et une classe dérivée de l’interface qui représente un compte de vérification. Nous commençons les projets Comptes en créant les fichiers sources suivants :

• AccountInfo.cs définit les informations de base d’un compte.

• IAccount.cs définit une interface standard IAccount pour un compte, y compris les méthodes de dépôt et de retrait d’actifs d’un compte et de récupération du solde du compte.

• CheckingAccount.cs contient la CheckingAccount classe qui implémente l’interface IAccount d’un compte de vérification.

Par expérience, nous savons qu'une chose qu'un retrait d'un compte courant doit faire est de s'assurer que le montant retiré est inférieur au solde du compte. Nous substituons donc la IAccount.Withdraw méthode dans CheckingAccount une méthode qui vérifie cette condition. La méthode peut ressembler à ceci :

public void Withdraw(double amount)
{
    if(m_balance >= amount)
    {
        m_balance -= amount;
    }
    else
    {
        throw new ArgumentException(nameof(amount), "Withdrawal exceeds balance!");
    }
}

Maintenant que nous avons du code, il est temps de tester.

Créer des tests unitaires avec Copilot

À compter de la build Insiders de Visual Studio 2026, vous pouvez utiliser les tests GitHub Copilot pour .NET pour générer automatiquement des tests unitaires. Le test GitHub Copilot pour .NET génère non seulement les tests, mais débogue les tests et les exécute dans l’Explorateur de tests. Pour plus d’informations, consultez Vue d’ensemble des tests GitHub Copilot pour .NET. Il s’agit de la méthode recommandée pour générer des tests.

Vous pouvez également utiliser la « slash command » Copilot /tests pour générer des tests unitaires à partir du code. Par exemple, vous pouvez taper /tests using NUnit Framework pour générer des tests NUnit. Pour plus d’informations, consultez Utiliser les commandes slash dans Copilot Chat.

Générer et exécuter des tests unitaires

À l’aide de la build Insiders de Visual Studio 2026, vous pouvez utiliser les tests GitHub Copilot pour .NET afin de générer automatiquement des tests unitaires.

La plupart des procédures décrites dans cet article s’appliquent aux tests générés manuellement. Si vous souhaitez en savoir plus sur les tests unitaires, vous pouvez lire le reste de cet article ou passer à la section Exécuter des tests dans l’Explorateur de tests.

Créer manuellement le projet de test unitaire et les tests unitaires

Un projet de test unitaire reflète généralement la structure d’un projet de code unique. Dans l’exemple MyBank, vous ajoutez deux projets de test unitaire nommés AccountsTests et BankDbTests à la Bank solution. Les noms de projet de test sont arbitraires, mais l’adoption d’une convention d’affectation de noms standard est une bonne idée.

Pour ajouter un projet de test unitaire à une solution :

1. Dans l’Explorateur de solutions, cliquez avec le bouton droit sur la solution et choisissez Ajouter>un nouveauprojet.

2. Tapez le test dans la zone de recherche du modèle de projet pour rechercher un modèle de projet de test unitaire pour l’infrastructure de test que vous souhaitez utiliser. (Dans les exemples de cet article, nous utilisons MSTest.)

3. Dans la page suivante, nommez le projet. Pour tester le Accounts projet de notre exemple, vous pouvez nommer le projet AccountsTests.

4. Dans votre projet de test unitaire, ajoutez une référence au projet de code sous test, dans notre exemple au projet Comptes.

   Pour créer la référence au projet de code :

   1. Dans le projet de test unitaire dans l’Explorateur de solutions, cliquez avec le bouton droit sur le nœud Références ou Dépendances, puis choisissez Ajouter une référence de projet ou Ajouter une référence, selon la disponibilité.

   2. Dans la boîte de dialogue Gestionnaire de références , ouvrez le nœud Solution et choisissez Projets. Sélectionnez le nom du projet de code et fermez la boîte de dialogue.

Chaque projet de test unitaire contient des classes qui reflètent les noms des classes dans le projet de code. Dans notre exemple, le AccountsTests projet contient les classes suivantes :

• AccountInfoTests la classe contient les méthodes de test unitaire pour la AccountInfo classe dans le Accounts projet

• CheckingAccountTests la classe contient les méthodes de test unitaire pour CheckingAccount la classe.

Écrire vos tests

L’infrastructure de test unitaire que vous utilisez et Visual Studio IntelliSense vous guide tout au long de l’écriture du code pour vos tests unitaires pour un projet de code. Pour s’exécuter dans l’Explorateur de tests, la plupart des frameworks nécessitent l’ajout d’attributs spécifiques pour identifier les méthodes de test unitaire. Les frameworks fournissent également un moyen, généralement par le biais d’instructions d’assertion ou d’attributs de méthode, pour indiquer si la méthode de test a réussi ou échoué. D’autres attributs identifient les méthodes de configuration facultatives qui sont au niveau de l’initialisation de la classe et avant chaque méthode de test et les méthodes de déchirure exécutées après chaque méthode de test et avant la destruction de la classe.

Le modèle AAA (Arrange, Act, Assert) est un moyen courant d’écrire des tests unitaires pour une méthode en cours de test.

• La section Arrange d’une méthode de test unitaire initialise les objets et définit la valeur des données passées à la méthode sous test.

• La section Act appelle la méthode testée avec les paramètres organisés.

• La section Assert vérifie que l’action de la méthode en cours de test se comporte comme prévu. Pour .NET, les méthodes de la Assert classe sont souvent utilisées pour la vérification.

Pour tester la CheckingAccount.Withdraw méthode de notre exemple, nous pouvons écrire deux tests : un qui vérifie le comportement standard de la méthode et un qui vérifie qu’un retrait de plus que l’équilibre échouera (le code suivant montre un test unitaire MSTest, pris en charge dans .NET.). Dans la CheckingAccountTests classe, nous ajoutons les méthodes suivantes :

[TestMethod]
public void Withdraw_ValidAmount_ChangesBalance()
{
    // arrange
    double currentBalance = 10.0;
    double withdrawal = 1.0;
    double expected = 9.0;
    var account = new CheckingAccount("JohnDoe", currentBalance);

    // act
    account.Withdraw(withdrawal);

    // assert
    Assert.AreEqual(expected, account.Balance);
}

[TestMethod]
public void Withdraw_AmountMoreThanBalance_Throws()
{
    // arrange
    var account = new CheckingAccount("John Doe", 10.0);

    // act and assert
    Assert.ThrowsException<System.ArgumentException>(() => account.Withdraw(20.0));
}

Pour plus d’informations sur les frameworks de test unitaire Microsoft, consultez l’un des articles suivants :

• Test unitaire de votre code

• Écriture de tests unitaires pour C/C++

Définir des délais d’expiration pour les tests unitaires

Si vous utilisez l’infrastructure MSTest, vous pouvez utiliser l’attribut TimeoutAttribute pour définir un délai d’expiration sur une méthode de test individuelle.

[TestMethod]
[Timeout(2000)]  // Milliseconds
public void My_Test()
{ ...
}

Pour définir le délai d’expiration au maximum autorisé :

[TestMethod]
[Timeout(TestTimeout.Infinite)]  // Milliseconds
public void My_Test ()
{ ...
}

Exécuter des tests dans l’Explorateur de tests

Lorsque vous générez le projet de test, les tests apparaissent dans l’Explorateur de tests. Si l’Explorateur de tests n’est pas visible, choisissez Test dans le menu Visual Studio, choisissez Windows, puis choisissez Explorateur de tests (ou appuyez sur Ctrl + E, T).

Lorsque vous exécutez, écrivez et réexécutez vos tests, l’Explorateur de tests peut afficher les résultats dans des groupes de tests ayant échoué, de tests réussis, de tests ignorés et non d’exécution de tests. Vous pouvez choisir différents groupes par options dans la barre d’outils.

Vous pouvez également filtrer les tests dans n’importe quelle vue en faisant correspondre le texte dans la zone de recherche au niveau global ou en sélectionnant l’un des filtres prédéfinis. Vous pouvez exécuter n’importe quelle sélection des tests à tout moment. Les résultats d’une exécution de test sont immédiatement apparents dans la barre de réussite/échec en haut de la fenêtre de l’explorateur. Les détails d’un résultat de méthode de test s’affichent lorsque vous sélectionnez le test.

Exécuter et afficher des tests

La barre d’outils de l’Explorateur de tests vous permet de découvrir, d’organiser et d’exécuter les tests qui vous intéressent.

Vous pouvez choisir Exécuter tout pour exécuter tous vos tests (ou appuyez sur Ctrl + R, V), ou choisissez Exécuter pour choisir un sous-ensemble de tests à exécuter (Ctrl + R, T). Sélectionnez un test pour afficher les détails de ce test dans le volet détails du test. Choisissez Ouvrir le test dans le menu contextuel (Clavier : F12) pour afficher le code source du test sélectionné.

Si des tests individuels n’ont aucune dépendance qui les empêche d’être exécutés dans un ordre quelconque, activez l’exécution de tests parallèles dans le menu paramètres de la barre d’outils. Cela peut réduire sensiblement le temps nécessaire à l’exécution de tous les tests.

Exécuter des tests après chaque build

Pour exécuter vos tests unitaires après chaque build locale, ouvrez l’icône des paramètres dans la barre d’outils de l’Explorateur de tests et sélectionnez Exécuter les tests après la génération.

Filtrer et regrouper la liste de tests

Lorsque vous avez un grand nombre de tests, vous pouvez taper dans la zone de recherche de l’Explorateur de tests pour filtrer la liste par la chaîne spécifiée. Vous pouvez restreindre davantage votre événement de filtre en choisissant dans la liste de filtres.

Bouton	Descriptif
	Pour regrouper vos tests par catégorie, choisissez le bouton Regrouper par .

Pour plus d’informations, consultez Exécuter des tests unitaires avec l’Explorateur de tests.

Questions et réponses

Q : Comment déboguer des tests unitaires ?

A: Utilisez Test Explorer pour démarrer une session de débogage de vos tests. L’exécution pas à pas de votre code avec le débogueur Visual Studio vous permet de naviguer de manière transparente entre les tests unitaires et le projet à tester. Pour démarrer le débogage :

1. Dans l’éditeur Visual Studio, définissez un point d’arrêt dans une ou plusieurs méthodes de test que vous souhaitez déboguer.

   Note

   Étant donné que les méthodes de test peuvent s’exécuter dans n’importe quel ordre, définissez des points d’arrêt dans toutes les méthodes de test que vous souhaitez déboguer.

2. Dans l’Explorateur de tests, sélectionnez les méthodes de test, puis choisissez Déboguer les tests sélectionnés dans le menu contextuel.

En savoir plus sur le débogage des tests unitaires.

Q : Si j’utilise TDD, comment générer du code à partir de mes tests ?

Un: Utilisez Les actions rapides pour générer des classes et des méthodes dans le code de votre projet. Écrivez une instruction dans une méthode de test qui appelle la classe ou la méthode que vous souhaitez générer, puis ouvrez l’ampoule qui apparaît sous l’erreur. Si l’appel est à un constructeur de la nouvelle classe, choisissez Générer le type dans le menu et suivez l’Assistant pour insérer la classe dans votre projet de code. Si l’appel est à une méthode, choisissez Générer une méthode dans le menu IntelliSense.

Q : Puis-je créer des tests unitaires qui prennent plusieurs jeux de données comme entrée pour exécuter le test ?

R : Oui. Les méthodes de test pilotées par les données vous permettent de tester une plage de valeurs avec une seule méthode de test unitaire. Utilisez un attribut DataRow ou DynamicData un DataSourceattribut pour la méthode de test qui spécifie la source de données qui contient les valeurs de variable que vous souhaitez tester.

La méthode attribuée s’exécute une fois pour chaque ligne de la source de données. L’Explorateur de tests signale un échec de test pour la méthode si l’une des itérations échoue. Le volet de détails des résultats de test pour la méthode affiche la méthode d’état de réussite/échec pour chaque ligne de données.

En savoir plus sur les tests unitaires pilotés par les données.

Q : Puis-je voir la quantité de mon code testée par mes tests unitaires ?

R : Oui. Vous pouvez déterminer la quantité de votre code en cours de test par vos tests unitaires à l’aide de l’outil de couverture Visual Studio Code dans Visual Studio. Les langages natifs et managés et tous les frameworks de test unitaire qui peuvent être exécutés par l’infrastructure de test unitaire sont pris en charge.

Vous pouvez exécuter la couverture du code sur les tests sélectionnés ou sur tous les tests d’une solution. La fenêtre Résultats de la couverture du code affiche le pourcentage des blocs de code produit qui ont été exercés par ligne, fonction, classe, espace de noms et module.

Pour exécuter la couverture du code pour les méthodes de test dans une solution, choisissez Test>Analyze Code Coverage for All Tests.

Les résultats de couverture s'affichent dans la fenêtre Résultats de couverture de code.

En savoir plus sur la couverture du code.

Q : Puis-je tester des méthodes dans mon code qui ont des dépendances externes ?

R : Oui. Si vous avez Visual Studio Enterprise, Microsoft Fakes peut être utilisé avec des méthodes de test que vous écrivez à l’aide de frameworks de test unitaire pour le code managé.

Microsoft Fakes utilise deux approches pour créer des classes de substitution pour les dépendances externes :

1. Les stubs génèrent des classes de substitution dérivées de l’interface parente de la classe de dépendance cible. Les méthodes stub peuvent être remplacées par des méthodes virtuelles publiques de la classe cible.

2. Shims utilise l’instrumentation du runtime pour rediriger les appels vers une méthode cible vers une méthode shim de remplacement pour les méthodes non virtuelles.

Dans les deux approches, vous utilisez les délégués générés des appels à la méthode de dépendance pour spécifier le comportement souhaité dans la méthode de test.

En savoir plus sur l’isolation des méthodes de test unitaire avec Microsoft Fakes.

Q : Puis-je utiliser d’autres frameworks de test unitaire pour créer des tests unitaires ?

Un: Oui, suivez ces étapes pour rechercher et installer d’autres frameworks. Après avoir redémarré Visual Studio, rouvrez votre solution pour créer vos tests unitaires, puis sélectionnez vos infrastructures installées ici :

Vos stubs de test unitaire seront créés à l’aide du cadre sélectionné.

Q : Comment exporter mes résultats de test unitaire ?

Un: Vous pouvez utiliser un fichier .runsettings avec la ligne de commande ou l’IDE Visual Studio pour configurer des tests unitaires et définir le fichier de résultats des tests. Pour plus d’informations, consultez l’élément LoggerRunSettings.