Partager via

Organisation et test de projets avec l’interface CLI .NET

Ce tutoriel suit : Créer une application console avec .NET à l’aide de Visual Studio Code, ce qui vous permet de développer des applications avancées et bien organisées au-delà de la création d’une application console simple. Après avoir montré comment utiliser des dossiers pour organiser votre code, le tutoriel vous montre comment étendre une application console avec l’infrastructure de test xUnit .

Note

Ce tutoriel vous recommande de placer le projet d’application et de tester le projet dans des dossiers distincts. Certains développeurs préfèrent conserver ces projets dans le même dossier. Pour plus d’informations, consultez le problème GitHub dotnet/docs #26395.

Utilisation de dossiers pour organiser le code

Si vous souhaitez introduire de nouveaux types dans une application console, vous pouvez le faire en ajoutant des fichiers contenant les types à l’application. Par exemple, si vous ajoutez des fichiers contenant des types AccountInformation et MonthlyReportRecords à votre projet, la structure de fichiers du projet est simplifiée et facile à parcourir :

/MyProject
|__AccountInformation.cs
|__MonthlyReportRecords.cs
|__MyProject.csproj
|__Program.cs

Toutefois, cette structure plate fonctionne correctement lorsque la taille de votre projet est relativement petite. Pouvez-vous imaginer ce qui se passe si vous ajoutez 20 types au projet ? Le projet ne serait certainement pas facile à parcourir et à gérer avec autant de fichiers encombrant le répertoire racine du projet.

Pour organiser le projet, créez un dossier et nommez-le Models pour contenir les fichiers de type. Placez les fichiers de type dans le dossier Models :

/MyProject
|__/Models
   |__AccountInformation.cs
   |__MonthlyReportRecords.cs
|__MyProject.csproj
|__Program.cs

Les projets qui regroupent logiquement des fichiers dans des dossiers sont faciles à parcourir et à gérer. Dans la section suivante, vous allez créer un exemple plus complexe avec des dossiers et des tests unitaires.

Organisation et test utilisant l’exemple « NewTypes Pets »

Prerequisites

Génération de l’exemple

Pour les étapes suivantes, vous pouvez suivre l’exemple NewTypes Pets ou créer vos propres fichiers et dossiers. Les types sont organisés logiquement en structure de dossiers qui autorisent l’ajout de types plus tard, et les tests sont également placés logiquement dans les dossiers autorisant l’ajout d’autres tests ultérieurement.

L’exemple contient deux types, Dog et Cat, et les amène à implémenter une interface commune, IPet. Pour le NewTypes projet, votre objectif est d’organiser les types liés aux animaux dans un dossier Animaux de compagnie. Si un autre ensemble de types est ajouté ultérieurement, WildAnimals , par exemple, sont placés dans le dossier NewTypes en même temps que le dossier Pets . Le dossier WildAnimals peut contenir des types pour les animaux qui ne sont pas des animaux de compagnie, tels que les types Squirrel et Rabbit. De cette façon, à mesure que les types sont ajoutés, le projet reste bien organisé.

Créez la structure de dossiers suivante avec le contenu du fichier indiqué :

/NewTypes
|__/src
   |__/NewTypes
      |__/Pets
         |__Dog.cs
         |__Cat.cs
         |__IPet.cs
      |__Program.cs
      |__NewTypes.csproj

IPet.cs :

using System;

namespace Pets
{
    public interface IPet
    {
        string TalkToOwner();
    }
}

Dog.cs :

using System;

namespace Pets
{
    public class Dog : IPet
    {
        public string TalkToOwner() => "Woof!";
    }
}

Cat.cs :

using System;

namespace Pets
{
    public class Cat : IPet
    {
        public string TalkToOwner() => "Meow!";
    }
}

Program.cs :

using System;
using Pets;
using System.Collections.Generic;

namespace ConsoleApplication
{
    public class Program
    {
        public static void Main(string[] args)
        {
            List<IPet> pets = new List<IPet>
            {
                new Dog(),
                new Cat()
            };

            foreach (var pet in pets)
            {
                Console.WriteLine(pet.TalkToOwner());
            }
        }
    }
}

NewTypes.csproj :

<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>net8.0</TargetFramework>
    <Nullable>enable</Nullable>
  </PropertyGroup>

</Project>

Exécutez la commande suivante :

dotnet run

Obtenez la sortie suivante :

Woof!
Meow!

Exercice facultatif : vous pouvez ajouter un nouveau type d’animal de compagnie, tel qu’un Bird, en étendant ce projet. Faites en sorte que la méthode de TalkToOwner l’oiseau donne un Tweet! au propriétaire. Réexécutez l’application. La sortie inclut Tweet!

Test de l’exemple

Le NewTypes projet est en place et vous l’avez organisé en conservant les types liés aux animaux de compagnie dans un dossier. Ensuite, créez votre projet de test et commencez à écrire des tests avec l’infrastructure de test xUnit . Les tests unitaires vous permettent de vérifier automatiquement le comportement de vos types d’animaux pour vérifier qu’ils fonctionnent correctement.

Revenez au dossier src et créez un dossier de test avec un dossier NewTypesTests dans celui-ci. À l’invite de commandes à partir du dossier NewTypesTests , exécutez dotnet new xunit. Cette commande produit deux fichiers : NewTypesTests.csproj et UnitTest1.cs.

Le projet de test ne peut actuellement pas tester les types dans NewTypes et nécessite une référence au projet NewTypes. Pour ajouter une référence de projet, utilisez la dotnet reference add commande suivante :

dotnet reference add ../../src/NewTypes/NewTypes.csproj

Vous avez également la possibilité d’ajouter manuellement la référence de projet en ajoutant un <ItemGroup> nœud au fichier NewTypesTests.csproj :

<ItemGroup>
  <ProjectReference Include="../../src/NewTypes/NewTypes.csproj" />
</ItemGroup>

NewTypesTests.csproj :

<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    <TargetFramework>net8.0</TargetFramework>
    <Nullable>enable</Nullable>
  </PropertyGroup>

  <ItemGroup>
    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.10.0" />
    <PackageReference Include="xunit" Version="2.8.1" />
    <PackageReference Include="xunit.runner.visualstudio" Version="2.8.1" />
  </ItemGroup>

  <ItemGroup>
    <ProjectReference Include="../../src/NewTypes/NewTypes.csproj"/>
  </ItemGroup>

</Project>

Le fichier NewTypesTests.csproj contient les références de package suivantes :

  • Microsoft.NET.Test.Sdk, l’infrastructure de test .NET
  • xunit, l’infrastructure de test xUnit
  • xunit.runner.visualstudio, le lanceur de tests
  • NewTypes, le code à tester

Remplacez le nom de UnitTest1.cs par PetTests.cs et remplacez le code dans le fichier par le code suivant :

using System;
using Xunit;
using Pets;

public class PetTests
{
    [Fact]
    public void DogTalkToOwnerReturnsWoof()
    {
        string expected = "Woof!";
        string actual = new Dog().TalkToOwner();

        Assert.NotEqual(expected, actual);
    }

    [Fact]
    public void CatTalkToOwnerReturnsMeow()
    {
        string expected = "Meow!";
        string actual = new Cat().TalkToOwner();

        Assert.NotEqual(expected, actual);
    }
}

Exercice facultatif : si vous avez ajouté un Bird type précédemment qui génère un Tweet! résultat au propriétaire, ajoutez une méthode de test au fichier PetTests.cs , BirdTalkToOwnerReturnsTweetpour vérifier que la TalkToOwner méthode fonctionne correctement pour le Bird type.

Note

Bien que vous vous attendiez à ce que les valeurs expected et actual soient égales, une assertion initiale avec Assert.NotEqual vérification spécifie que ces valeurs ne sont pas égales. Créez toujours un test pour échouer afin de vérifier la logique du test. Après avoir confirmé que le test échoue, ajustez l’assertion pour permettre au test de réussir.

Voici la structure complète du projet :

/NewTypes
|__/src
   |__/NewTypes
      |__/Pets
         |__Dog.cs
         |__Cat.cs
         |__IPet.cs
      |__Program.cs
      |__NewTypes.csproj
|__/test
   |__NewTypesTests
      |__PetTests.cs
      |__NewTypesTests.csproj

Démarrez dans le répertoire test/NewTypesTests . Exécutez les tests avec la dotnet test commande. Cette commande démarre l’exécuteur de test spécifié dans le fichier projet.

Comme prévu, le test échoue et la console affiche la sortie suivante :

Test run for C:\Source\dotnet\docs\samples\snippets\core\tutorials\testing-with-cli\csharp\test\NewTypesTests\bin\Debug\net5.0\NewTypesTests.dll (.NETCoreApp,Version=v5.0)
Microsoft (R) Test Execution Command Line Tool Version 16.8.1
Copyright (c) Microsoft Corporation.  All rights reserved.

Starting test execution, please wait...
A total of 1 test files matched the specified pattern.
[xUnit.net 00:00:00.50]     PetTests.DogTalkToOwnerReturnsWoof [FAIL]
  Failed PetTests.DogTalkToOwnerReturnsWoof [6 ms]
  Error Message:
   Assert.NotEqual() Failure
Expected: Not "Woof!"
Actual:   "Woof!"
  Stack Trace:
     at PetTests.DogTalkToOwnerReturnsWoof() in C:\Source\dotnet\docs\samples\snippets\core\tutorials\testing-with-cli\csharp\test\NewTypesTests\PetTests.cs:line 13

Failed!  - Failed:     1, Passed:     1, Skipped:     0, Total:     2, Duration: 8 ms - NewTypesTests.dll (net5.0)

Remplacez les assertions de vos tests Assert.NotEqual par Assert.Equal:

using System;
using Xunit;
using Pets;

public class PetTests
{
    [Fact]
    public void DogTalkToOwnerReturnsWoof()
    {
        string expected = "Woof!";
        string actual = new Dog().TalkToOwner();

        Assert.Equal(expected, actual);
    }

    [Fact]
    public void CatTalkToOwnerReturnsMeow()
    {
        string expected = "Meow!";
        string actual = new Cat().TalkToOwner();

        Assert.Equal(expected, actual);
    }
}

Réexécutez les tests avec la dotnet test commande et obtenez la sortie suivante :

Test run for C:\Source\dotnet\docs\samples\snippets\core\tutorials\testing-with-cli\csharp\test\NewTypesTests\bin\Debug\net5.0\NewTypesTests.dll (.NETCoreApp,Version=v5.0)
Microsoft (R) Test Execution Command Line Tool Version 16.8.1
Copyright (c) Microsoft Corporation.  All rights reserved.

Starting test execution, please wait...
A total of 1 test files matched the specified pattern.

Passed!  - Failed:     0, Passed:     2, Skipped:     0, Total:     2, Duration: 2 ms - NewTypesTests.dll (net5.0)

Les tests réussissent. Les méthodes des types d’animaux retournent les valeurs correctes lors de la conversation avec le propriétaire.

Vous avez appris des techniques pour organiser et tester des projets à l’aide de xUnit. Poursuivez avec ces techniques en les appliquant dans vos propres projets. Codez bien !

  • Last updated on