Organizowanie i testowanie projektów przy użyciu interfejsu wiersza polecenia platformy .NET

Artykuł
05/10/2023

W tym samouczku przedstawiono samouczek: tworzenie aplikacji konsolowej przy użyciu platformy .NET przy użyciu platformy Visual Studio Code, co wykracza poza tworzenie prostej aplikacji konsolowej w celu tworzenia zaawansowanych i dobrze zorganizowanych aplikacji. Po pokazaniu, jak używać folderów do organizowania kodu, w samouczku pokazano, jak rozszerzyć aplikację konsolową za pomocą platformy testowania xUnit .

Uwaga

W tym samouczku zaleca się umieszczenie projektu aplikacji i projektu testowego w oddzielnych folderach. Niektórzy deweloperzy wolą przechowywać te projekty w tym samym folderze. Aby uzyskać więcej informacji, zobacz problem z usługą GitHub dotnet/docs #26395.

Organizowanie kodu przy użyciu folderów

Jeśli chcesz wprowadzić nowe typy do aplikacji konsolowej, możesz to zrobić, dodając pliki zawierające typy do aplikacji. Jeśli na przykład dodasz pliki zawierające AccountInformation i MonthlyReportRecords typy do projektu, struktura plików projektu jest płaska i łatwa do nawigowania:

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

Jednak ta płaska struktura działa dobrze tylko wtedy, gdy rozmiar projektu jest stosunkowo mały. Czy można sobie wyobrazić, co się stanie, jeśli do projektu zostanie dodanych 20 typów? Projekt zdecydowanie nie byłby łatwy do nawigowania i konserwacji przy użyciu wielu plików zaśmiecających katalog główny projektu.

Aby zorganizować projekt, utwórz nowy folder i nadaj mu nazwę Models , aby przechowywać pliki typu. Umieść pliki typów w folderze Models :

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

Projekty, które logicznie grupują pliki w folderach, są łatwe do nawigowania i konserwacji. W następnej sekcji utworzysz bardziej złożony przykład z folderami i testowaniem jednostkowym.

Organizowanie i testowanie przy użyciu przykładu NewTypes Pets

Wymagania wstępne

Zestaw .NET 5.0 SDK lub nowsza wersja.

Kompilowanie przykładu

W poniższych krokach możesz wykonać czynności opisane w temacie NewTypes Pets Sample lub utworzyć własne pliki i foldery. Typy są logicznie zorganizowane w strukturę folderów, która pozwala na dodanie większej liczby typów później, a testy są również logicznie umieszczane w folderach, co pozwala na dodanie większej liczby testów później.

Przykład zawiera dwa typy i DogCat, i ma je zaimplementować wspólny interfejs: IPet. NewTypes W przypadku projektu twoim celem jest organizowanie typów związanych ze zwierzętami domowymi w folderze Zwierzęta domowe. Jeśli później zostanie dodany inny zestaw typów, na przykład wildAnimals zostaną one umieszczone w folderze NewTypes obok folderu Pets . Folder WildAnimals może zawierać typy zwierząt, które nie są zwierzętami, takimi jak Squirrel i Rabbit typy. W ten sposób w miarę dodawania typów projekt pozostaje dobrze zorganizowany.

Utwórz następującą strukturę folderów z wskazaną zawartością pliku:

/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>net6.0</TargetFramework>
    <Nullable>enable</Nullable>
  </PropertyGroup>

</Project>

Uruchom następujące polecenie:

dotnet run

Uzyskaj następujące dane wyjściowe:

Woof!
Meow!

Ćwiczenie opcjonalne: możesz dodać nowy typ zwierzaka Bird, taki jak , przez rozszerzenie tego projektu. Ustaw metodę ptaka TalkToOwner na właściciela Tweet! . Ponownie uruchom aplikację. Dane wyjściowe będą zawierać Tweet!

Testowanie przykładu

Projekt NewTypes jest w miejscu i został zorganizowany przez przechowywanie typów związanych ze zwierzętami w folderze. Następnie utwórz projekt testowy i rozpocznij pisanie testów za pomocą platformy testowej xUnit . Testowanie jednostkowe umożliwia automatyczne sprawdzanie zachowania typów zwierząt domowych w celu potwierdzenia, że działają prawidłowo.

Wróć do folderu src i utwórz folder testowy z folderem NewTypesTests w nim. W wierszu polecenia z folderu NewTypesTests wykonaj polecenie dotnet new xunit. To polecenie tworzy dwa pliki: NewTypesTests.csproj i UnitTest1.cs.

Projekt testowy nie może obecnie testować typów w programie NewTypes i wymaga odwołania NewTypes do projektu. Aby dodać odwołanie do projektu, użyj dotnet add reference polecenia :

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

Możesz też ręcznie dodać odwołanie do projektu, dodając <ItemGroup> węzeł do pliku NewTypesTests.csproj :

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

NewTypesTests.csproj:

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

  <PropertyGroup>
    <TargetFramework>net6.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>

Plik NewTypesTests.csproj zawiera następujące odwołania do pakietu:

Microsoft.NET.Test.Sdk, infrastruktura testowania platformy .NET
xunit, struktura testowania xUnit
xunit.runner.visualstudio, moduł uruchamiający testy
NewTypes, kod do przetestowania

Zmień nazwę pliku UnitTest1.cs na PetTests.cs i zastąp kod w pliku następującym kodem:

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);
    }
}

Ćwiczenie opcjonalne: Jeśli dodano Bird wcześniej typ, który daje Tweet! właścicielowi metodę testową, dodaj metodę testową do pliku PetTests.cs , aby sprawdzić, BirdTalkToOwnerReturnsTweetczy TalkToOwner metoda działa poprawnie dla Bird typu.

Uwaga

Chociaż oczekujesz, że expected wartości i actual są równe, początkowa asercja z sprawdzaniem Assert.NotEqual określa, że te wartości nie są równe. Zawsze należy najpierw utworzyć test, aby nie można było sprawdzić logiki testu. Po potwierdzeniu, że test zakończy się niepowodzeniem, dostosuj asercji, aby zezwolić na przeprowadzenie testu.

Poniżej przedstawiono pełną strukturę projektu:

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

Rozpocznij w katalogu test/NewTypesTests . Uruchom testy za pomocą dotnet test polecenia . To polecenie uruchamia moduł uruchamiający testy określony w pliku projektu.

Zgodnie z oczekiwaniami testowanie kończy się niepowodzeniem, a konsola wyświetla następujące dane wyjściowe:

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)

Zmień potwierdzenia testów z Assert.NotEqual na 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);
    }
}

Uruchom ponownie testy za dotnet test pomocą polecenia i uzyskaj następujące dane wyjściowe:

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)

Testowanie przebiegów. Metody typów zwierząt domowych zwracają prawidłowe wartości podczas rozmowy z właścicielem.

Znasz już techniki organizowania i testowania projektów przy użyciu narzędzia xUnit. Przejdź do przodu przy użyciu tych technik stosowania ich we własnych projektach. Szczęśliwe kodowanie!

Udostępnij za pośrednictwem