Partager via

Tests unitaires des bibliothèques F# dans .NET Core à l’aide de dotnet test et xUnit

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. Si vous préférez suivre le didacticiel à l’aide d’une solution prédéfinie, afficher ou télécharger l’exemple de code avant de commencer. Pour obtenir des instructions de téléchargement, consultez Exemples et didacticiels.

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.

Création du projet source

Ouvrez une fenêtre shell. Créez un répertoire appelé unit-testing-with-fsharp pour contenir la solution. Dans ce nouveau répertoire, exécutez dotnet new sln pour créer une solution. Cela facilite la gestion de la bibliothèque de classes et du projet de test unitaire. Dans le répertoire de solution, créez un répertoire MathService . Le répertoire et la structure de fichiers jusqu’à présent sont indiqués ci-dessous :

/unit-testing-with-fsharp
    unit-testing-with-fsharp.sln
    /MathService

Créez MathService le répertoire actif et exécutez-le dotnet new classlib -lang "F#" pour créer le projet source. Vous allez créer une implémentation défaillante du service mathématique :

module MyMath =
    let squaresOfOdds xs = raise (System.NotImplementedException("You haven't written a test yet!"))

Revenez au répertoire unit-testing-with-fsharp . Exécutez dotnet sln add .\MathService\MathService.fsproj pour ajouter le projet de bibliothèque de classes à la solution.

Création du projet de test

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

/unit-testing-with-fsharp
    unit-testing-with-fsharp.sln
    /MathService
        Source Files
        MathService.fsproj
    /MathService.Tests

Créez le répertoire MathService.Tests dans le répertoire actif et créez un projet à l’aide dotnet new xunit -lang "F#"de . Cela crée un projet de test qui utilise xUnit comme bibliothèque de tests. Le modèle généré configure l’exécuteur de test dans MathServiceTests.fsproj :

<ItemGroup>
  <PackageReference Include="Microsoft.NET.Test.Sdk" Version="15.3.0-preview-20170628-02" />
  <PackageReference Include="xunit" Version="2.2.0" />
  <PackageReference Include="xunit.runner.visualstudio" Version="2.2.0" />
</ItemGroup>

Le projet de test nécessite d’autres packages pour créer et exécuter des tests unitaires. dotnet new a ajouté xUnit et le Test Runner xUnit à l’étape précédente. À présent, ajoutez la bibliothèque de classes MathService comme autre dépendance au projet. Utilisez la commande dotnet reference add :

dotnet reference add ../MathService/MathService.fsproj

Conseil / Astuce

Si vous utilisez le Kit de développement logiciel (SDK) .NET 9 ou une version antérieure, utilisez le formulaire « verbe premier » (dotnet add reference) à la place. Le formulaire « nom premier » a été introduit dans .NET 10.

Vous pouvez voir l’intégralité du fichier dans le référentiel d’exemples sur GitHub.

Vous disposez de la disposition finale suivante de la solution :

/unit-testing-with-fsharp
    unit-testing-with-fsharp.sln
    /MathService
        Source Files
        MathService.fsproj
    /MathService.Tests
        Test Source Files
        MathServiceTests.fsproj

Exécutez dotnet sln add .\MathService.Tests\MathService.Tests.fsproj dans le répertoire unit-testing-with-fsharp .

Création du premier test

Vous écrivez un test défaillant, faites-le passer, puis répétez le processus. Ouvrez Tests.fs et ajoutez le code suivant :

[<Fact>]
let ``My test`` () =
    Assert.True(true)

[<Fact>]
let ``Fail every time`` () = Assert.True(false)

L’attribut [<Fact>] désigne une méthode de test exécutée par l’exécuteur de test. À partir du test unitaire avec-fsharp, exécutez dotnet test pour générer les tests et la bibliothèque de classes, puis exécutez les tests. L’exécuteur de test xUnit contient le point d’entrée du programme pour exécuter vos tests. dotnet test démarre l’exécuteur de test à l’aide du projet de test unitaire que vous avez créé.

Ces deux tests montrent les tests de réussite et d’échec les plus élémentaires. My test passe et Fail every time échoue. À présent, créez un test pour la squaresOfOdds méthode. La squaresOfOdds méthode retourne une séquence des carrés de toutes les valeurs entières impaires qui font partie de la séquence d’entrée. Au lieu d’essayer d’écrire toutes ces fonctions à la fois, vous pouvez créer des tests itératifs qui valident la fonctionnalité. Effectuer chaque passe de test signifie créer les fonctionnalités nécessaires pour la méthode.

Le test le plus simple que nous pouvons écrire consiste à appeler squaresOfOdds avec tous les nombres pairs, où le résultat doit être une séquence vide d’entiers. Voici ce test :

[<Fact>]
let ``Sequence of Evens returns empty collection`` () =
    let expected = Seq.empty<int>
    let actual = MyMath.squaresOfOdds [2; 4; 6; 8; 10]
    Assert.Equal<Collections.Generic.IEnumerable<int>>(expected, actual)

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 MathService qui fonctionne :

let squaresOfOdds xs =
    Seq.empty<int>

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

Remplir les conditions requises

Maintenant que vous avez passé un test, il est temps d’écrire plus. Le cas simple suivant fonctionne avec une séquence dont le seul nombre impair est 1. Le nombre 1 est plus facile, car le carré de 1 est 1. Voici ce prochain test :

[<Fact>]
let ``Sequences of Ones and Evens returns Ones`` () =
    let expected = [1; 1; 1; 1]
    let actual = MyMath.squaresOfOdds [2; 1; 4; 1; 6; 1; 8; 1; 10]
    Assert.Equal<Collections.Generic.IEnumerable<int>>(expected, actual)

Exécuter dotnet test exécute vos tests et vous montre que le nouveau test échoue. À présent, mettez à jour la squaresOfOdds méthode pour gérer ce nouveau test. Vous filtrez tous les nombres pairs hors de la séquence pour passer ce test. Vous pouvez le faire en écrivant une petite fonction de filtre et en utilisant Seq.filter:

let private isOdd x = x % 2 <> 0

let squaresOfOdds xs =
    xs
    |> Seq.filter isOdd

Encore une étape : calculer le carré de chaque nombre impair. Commencez par écrire un nouveau test :

[<Fact>]
let ``SquaresOfOdds works`` () =
    let expected = [1; 9; 25; 49; 81]
    let actual = MyMath.squaresOfOdds [1; 2; 3; 4; 5; 6; 7; 8; 9; 10]
    Assert.Equal(expected, actual)

Vous pouvez corriger le test en redirigeant la séquence filtrée via une opération de mappage pour calculer le carré de chaque nombre impair :

let private square x = x * x
let private isOdd x = x % 2 <> 0

let squaresOfOdds xs =
    xs
    |> Seq.filter isOdd
    |> Seq.map square

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

  • Last updated on