Test unitaire des bibliothèques Visual Basic .NET à l’aide de dotnet test et TUnit

Ce tutoriel vous guide tout au long d’une expérience interactive qui crée un exemple de solution pas à pas pour apprendre les concepts de test unitaire.

Cet article concerne le test d’un projet .NET Core. Si vous testez un projet ASP.NET Core, consultez tests d’intégration dans ASP.NET Core.

Prerequisites

  • .NET 10 SDK ou versions ultérieures.
  • Un éditeur de texte ou un éditeur de code de votre choix.

TUnit est entièrement basé sur Microsoft. Testing.Platform (MTP) et ne prend pas en charge VSTest. Ce tutoriel utilise le mode MTP de dotnet test, qui nécessite le sdk .NET 10.

Création du projet source

Ouvrez une fenêtre shell. Créez un répertoire appelé unit-testing-vb-tunit pour contenir la solution. Dans ce nouveau répertoire, exécutez la commande suivante pour créer un fichier solution pour la bibliothèque de classes et le projet de test :

dotnet new sln

Ensuite, créez un répertoire PrimeService . Le plan suivant montre la structure de fichiers jusqu’à présent :

/unit-testing-vb-tunit
    unit-testing-vb-tunit.slnx
    /PrimeService

Rendez PrimeService le répertoire actif et exécutez la commande suivante pour créer le projet source :

dotnet new classlib -lang VB

Renommez Class1.vb en PrimeService.vb. Vous créez une implémentation défaillante de la classe PrimeService :

Namespace Prime.Services
    Public Class PrimeService
        Public Function IsPrime(candidate As Integer) As Boolean
            Throw New NotImplementedException("Please create a test first.")
        End Function
    End Class
End Namespace

Revenez au répertoire unit-testing-vb-tunit. Exécutez la commande suivante pour ajouter le projet de bibliothèque de classes à la solution :

dotnet sln add ./PrimeService/PrimeService.vbproj

Création du projet de test

Ensuite, créez le répertoire PrimeService.Tests. Le plan suivant montre la structure de répertoires :

/unit-testing-vb-tunit
    unit-testing-vb-tunit.slnx
    /PrimeService
        Source Files
        PrimeService.vbproj
    /PrimeService.Tests

Les modèles de projet TUnit ne sont pas inclus dans le Kit de développement logiciel (SDK) .NET. Installez-les avec la commande suivante :

dotnet new install TUnit.Templates

Faites du répertoire PrimeService.Tests le répertoire actif et créez un projet à l’aide de la commande suivante :

dotnet new TUnit -lang VB

Note

Les noms courts de modèle respectent la casse. Utilisez TUnit, pas tunit.

La commande dotnet new crée un projet de test qui utilise TUnit comme bibliothèque de tests. Le fichier PrimeService.Tests.vbproj généré est un projet exécutable qui fait référence au TUnit package, qui inclut l’infrastructure de test, la bibliothèque d’assertions et l’exécuteur de test MTP, de sorte que le projet n’a pas besoin d’autres packages de test.

Le modèle ajoute également des exemples de tests. Supprimez tous les fichiers .vb et le répertoire Data du répertoire PrimeService.Tests, car ce didacticiel les remplace par ses propres tests.

À présent, ajoutez la bibliothèque de classes PrimeService comme autre dépendance au projet. Utiliser la commande dotnet reference add :

dotnet reference add ../PrimeService/PrimeService.vbproj

Vous disposez de la disposition finale suivante de la solution :

/unit-testing-vb-tunit
    unit-testing-vb-tunit.slnx
    /PrimeService
        Source Files
        PrimeService.vbproj
    /PrimeService.Tests
        Test Source Files
        PrimeService.Tests.vbproj

Exécutez la commande suivante dans le répertoire unit-testing-vb-tunit :

dotnet sln add ./PrimeService.Tests/PrimeService.Tests.vbproj

Configuration du mode MTP de dotnet test

Étant donné que TUnit ne prend pas en charge VSTest, dotnet test doit s’exécuter en mode MTP. Dans le répertoire unit-testing-vb-tunit , créez un fichier global.json avec le contenu suivant :

{
    "test": {
        "runner": "Microsoft.Testing.Platform"
    }
}

Pour plus d’informations, consultez le mode MTP de dotnet test.

Création du premier test

Vous écrivez un test défaillant, faites-le passer, puis répétez le processus. Dans le répertoire PrimeService.Tests , créez un fichier PrimeService_IsPrimeShould.vb avec le code suivant :

Imports TUnit.Assertions
Imports TUnit.Assertions.Extensions
Imports TUnit.Core

Namespace PrimeService.Tests
    Public Class PrimeService_IsPrimeShould
        Private ReadOnly _primeService As Prime.Services.PrimeService = New Prime.Services.PrimeService()

        <Test>
        Public Async Function IsPrime_InputIs1_ReturnFalse() As Task
            Dim result As Boolean = _primeService.IsPrime(1)

            Await Assert.That(result).IsFalse()
        End Function

    End Class
End Namespace

L’attribut <Test> désigne une méthode exécutée par l’exécuteur de test. TUnit n’a pas besoin d’un attribut dans la classe. Les assertions TUnit sont asynchrones. Le test est donc un Async Function test qui retourne un Task et attend Assert.That.

Visual Basic place le code dans chaque projet sous l'espace de noms racine du projet, de sorte que la PrimeService classe se trouve dans l'PrimeService.Prime.Servicesespace de noms. Le test le désigne par Prime.Services.PrimeService car, à l’intérieur des espaces de noms du projet de test, le nom PrimeService fait référence à un espace de noms plutôt qu’à la classe.

À partir du répertoire unit-testing-vb-tunit , exécutez dotnet test pour générer les tests et la bibliothèque de classes, puis exécutez les tests. Le projet de test TUnit contient le point d’entrée du programme pour exécuter vos tests. dotnet test démarre l’application de test à l’aide du projet de test unitaire que vous avez créé.

Votre test échoue. Vous n’avez pas encore créé l’implémentation. Effectuez ce test en écrivant le code le plus simple dans la classe PrimeService qui fonctionne :

Public Function IsPrime(candidate As Integer) As Boolean
    If candidate = 1 Then
        Return False
    End If
    Throw New NotImplementedException("Please create a test first.")
End Function

Dans le répertoire unit-testing-vb-tunit , exécutez dotnet test à nouveau. La commande dotnet test exécute une build pour le projet PrimeService, puis pour le projet PrimeService.Tests. Après avoir généré les deux projets, il exécute ce test unique. Ça passe.

Ajout de fonctionnalités supplémentaires

Maintenant que vous avez passé un test, il est temps d’écrire plus. Il existe quelques autres cas simples pour les nombres premiers : 0, -1. Vous pouvez ajouter ces cas en tant que nouveaux tests avec l’attribut <Test>, mais cela devient rapidement fastidieux. TUnit fournit l’attribut <Arguments> pour créer une suite de tests qui exécutent le même code, mais qui ont des arguments d’entrée différents.

Au lieu de créer de nouveaux tests, appliquez cet attribut pour créer un seul test piloté par les données. Remplacez la fonction IsPrime_InputIs1_ReturnFalse par le code suivant, qui teste plusieurs valeurs inférieures à deux, le nombre premier le plus bas :

<Test>
<Arguments(-1)>
<Arguments(0)>
<Arguments(1)>
Public Async Function IsPrime_ValuesLessThan2_ReturnFalse(value As Integer) As Task
    Dim result As Boolean = _primeService.IsPrime(value)

    Await Assert.That(result).IsFalse()
End Function

Exécutez dotnet test, et deux de ces tests échouent. Pour passer tous les tests, modifiez la If clause au début de la IsPrime méthode dans le fichier PrimeService.vb :

If candidate < 2 Then

Continuez à itérer en ajoutant d’autres tests et plus de code dans la bibliothèque principale.

Vous avez créé une petite bibliothèque et un ensemble de tests unitaires pour cette bibliothèque. Vous avez structuré la solution pour que l’ajout de nouveaux packages et tests fasse partie du flux de travail normal. Vous avez concentré la plupart de votre temps et votre effort sur la résolution des objectifs de l’application.

Voir aussi

  • Dernière mise à jour :