Condividi tramite

Organizzazione e test di progetti con l'interfaccia della riga di comando di .NET

Questa esercitazione segue Esercitazione: Creare un'applicazione console con .NET usando Visual Studio Code, portandoti al di là della creazione di una semplice app console per sviluppare applicazioni avanzate e ben organizzate. Dopo aver illustrato come usare le cartelle per organizzare il codice, l'esercitazione illustra come estendere un'applicazione console con il framework di test xUnit .

Annotazioni

Questa esercitazione consiglia di inserire il progetto dell'applicazione e il progetto di test in cartelle separate. Alcuni sviluppatori preferiscono mantenere questi progetti nella stessa cartella. Per altre informazioni, vedere Problema di GitHub dotnet/docs #26395.

Uso delle cartelle per organizzare il codice

Se vuoi introdurre nuovi tipi in un'app console, puoi farlo aggiungendo file contenenti i tipi all'app. Ad esempio, se si aggiungono file contenenti AccountInformation tipi e MonthlyReportRecords al progetto, la struttura dei file di progetto è semplice e facile da esplorare:

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

Tuttavia, questa struttura piatta funziona correttamente solo quando le dimensioni del progetto sono relativamente piccole. Si può immaginare cosa accade se si aggiungono 20 tipi al progetto? Il progetto sicuramente non sarebbe facile da esplorare e gestire con così tanti file che ingombrano la directory radice del progetto.

Per organizzare il progetto, creare una nuova cartella e denominarla Models per contenere i file di tipo. Inserire i file di tipo nella cartella Models :

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

I progetti che raggruppano logicamente i file in cartelle sono facili da esplorare e gestire. Nella sezione successiva viene creato un esempio più complesso con cartelle e unit test.

Organizzazione e test con l'esempio NewTypes Pets

Prerequisiti

Compilazione dell'esempio

Per i passaggi seguenti, è possibile seguire la procedura usando l'esempio NewTypes Pets o creare file e cartelle personalizzati. I tipi sono organizzati logicamente in una struttura di cartelle che consente l'aggiunta di più tipi in un secondo momento e anche i test vengono inseriti logicamente nelle cartelle consentendo l'aggiunta di altri test in un secondo momento.

L'esempio contiene due tipi, Dog e Cat, e li fa implementare un'interfaccia comune, IPet. Per il progetto, l'obiettivo NewTypes è organizzare i tipi correlati agli animali domestici in una cartella Animali domestici . Se un altro set di tipi viene aggiunto in un secondo momento, WildAnimals , ad esempio, viene inserito nella cartella NewTypes insieme alla cartella Pets . La cartella WildAnimals può contenere tipi per gli animali che non sono animali domestici, ad esempio Squirrel e Rabbit tipi. In questo modo, man mano che vengono aggiunti i tipi, il progetto rimane ben organizzato.

Creare la struttura di cartelle seguente con il contenuto del file indicato:

/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>

Eseguire il comando seguente:

dotnet run

Ottenere l'output seguente:

Woof!
Meow!

Esercizio facoltativo: è possibile aggiungere un nuovo tipo di animale domestico, ad esempio , Birdestendendo questo progetto. Fai sì che il metodo dell'uccello TalkToOwner dia un Tweet! al proprietario. Eseguire di nuovo l'app. L'output includerà Tweet!

Test dell'esempio

Il progetto NewTypes è stato messo in atto e lo hai organizzato mantenendo i tipi relativi agli animali domestici in una cartella. Creare quindi il progetto di test e iniziare a scrivere test con il framework di test xUnit . Gli unit test consentono di controllare automaticamente il comportamento dei tipi di animali domestici per verificare che funzionino correttamente.

Tornare alla cartella src e creare una cartella di test con una cartella NewTypesTests al suo interno. Dal prompt dei comandi nella cartella NewTypesTests, eseguire dotnet new xunit. Questo comando genera due file: NewTypesTests.csproj e UnitTest1.cs.

Il progetto di test non è attualmente in grado di testare i tipi in NewTypes e richiede un riferimento al NewTypes progetto. Per aggiungere un riferimento al progetto, usare il dotnet reference add comando :

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

In alternativa, è anche possibile aggiungere manualmente il riferimento al progetto aggiungendo un <ItemGroup> nodo al file 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>

Il file NewTypesTests.csproj contiene i riferimenti al pacchetto seguenti:

  • Microsoft.NET.Test.Sdk, l'infrastruttura di test .NET
  • xunit, il framework di test xUnit
  • xunit.runner.visualstudio, l'esecutore del test
  • NewTypes, il codice da testare

Modificare il nome di UnitTest1.cs in PetTests.cs e sostituire il codice nel file con il codice seguente:

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

Esercizio facoltativo: se in precedenza hai aggiunto un Bird che produce un Tweet! per il proprietario, aggiungi un metodo di test al file PetTests.cs, BirdTalkToOwnerReturnsTweet, per verificare che il metodo TalkToOwner funzioni correttamente per il tipo Bird.

Annotazioni

Anche se si prevede che i expected valori e actual siano uguali, un'asserzione iniziale con il Assert.NotEqual controllo specifica che questi valori non sono uguali. Creare inizialmente un test destinato a fallire per verificare la logica del test. Dopo aver verificato che il test non riesce, modificare l'asserzione per consentire il superamento del test.

Di seguito è illustrata la struttura completa del progetto:

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

Iniziare nella directory test/NewTypesTests . Eseguire i test con il dotnet test comando . Questo comando avvia il test runner specificato nel file di progetto.

Come previsto, i test hanno esito negativo e la console visualizza l'output seguente:

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)

Modificare le asserzioni dei test da Assert.NotEqual a 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);
    }
}

Eseguire di nuovo i test con il dotnet test comando e ottenere l'output seguente:

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)

Test superati. I metodi dei tipi di animali domestici restituiscono i valori corretti quando si comunica con il proprietario.

Sono state apprese tecniche per organizzare e testare i progetti usando xUnit. Procedere con queste tecniche applicandole nei propri progetti. Buona codifica!

  • Last updated on