Partilhar via

Organizando e testando projetos com a CLI do .NET

Este tutorial segue o Tutorial: Criar um aplicativo de console com .NET usando o Visual Studio Code, levando você além da criação de um aplicativo de console simples para desenvolver aplicativos avançados e bem organizados. Depois de mostrar como usar pastas para organizar seu código, o tutorial mostra como estender um aplicativo de console com a estrutura de teste xUnit .

Observação

Este tutorial recomenda que você coloque o projeto de aplicativo e o projeto de teste em pastas separadas. Alguns desenvolvedores preferem manter esses projetos na mesma pasta. Para obter mais informações, consulte GitHub issue dotnet/docs #26395.

Usando pastas para organizar o código

Se você quiser introduzir novos tipos em um aplicativo de console, poderá fazê-lo adicionando arquivos contendo os tipos ao aplicativo. Por exemplo, se você adicionar arquivos contendo AccountInformation e MonthlyReportRecords tipos ao seu projeto, a estrutura do arquivo de projeto será plana e fácil de navegar:

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

No entanto, essa estrutura plana só funciona bem quando o tamanho do seu projeto é relativamente pequeno. Você consegue imaginar o que acontece se você adicionar 20 tipos ao projeto? O projeto definitivamente não seria fácil de navegar e manter com tantos arquivos espalhados pelo diretório raiz do projeto.

Para organizar o projeto, crie uma nova pasta e nomeie-a Modelos para armazenar os arquivos de tipo. Coloque os arquivos de tipo na pasta Modelos :

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

Projetos que agrupam logicamente arquivos em pastas são fáceis de navegar e manter. Na próxima seção, você cria um exemplo mais complexo com pastas e testes de unidade.

Organização e teste usando o exemplo NewTypes Pets

Pré-requisitos

Construindo a amostra

Para as etapas a seguir, você pode acompanhar usando o exemplo NewTypes Pets ou criar seus próprios arquivos e pastas. Os tipos são organizados logicamente em uma estrutura de pastas que permite a adição de mais tipos mais tarde, e os testes também são logicamente colocados em pastas, permitindo a adição de mais testes posteriormente.

O exemplo contém dois tipos, Dog e Cat, e faz com que eles implementem uma interface comum, IPet. Para o NewTypes projeto, seu objetivo é organizar os tipos relacionados a animais de estimação em uma pasta Animais de estimação . Se outro conjunto de tipos for adicionado posteriormente, WildAnimals , por exemplo, eles serão colocados na pasta NewTypes ao lado da pasta Pets . A pasta WildAnimals pode conter tipos para animais que não são animais de estimação, como Squirrel e Rabbit tipos. Desta forma, à medida que os tipos são adicionados, o projeto permanece bem organizado.

Crie a seguinte estrutura de pastas com o conteúdo do arquivo indicado:

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

Execute o seguinte comando:

dotnet run

Obtenha a seguinte saída:

Woof!
Meow!

Exercício opcional: Você pode adicionar um novo tipo de animal de estimação, como um Bird, estendendo este projeto. Faça com que o método da TalkToOwner ave dê um Tweet! ao dono. Execute o aplicativo novamente. O resultado incluirá Tweet!

Testando a amostra

O projeto NewTypes está em andamento e foi organizado mantendo os tipos relacionados a animais de estimação numa pasta. Em seguida, crie seu projeto de teste e comece a escrever testes com a estrutura de teste xUnit . O teste de unidade permite que você verifique automaticamente o comportamento dos tipos de animais de estimação para confirmar se eles estão funcionando corretamente.

Navegue de volta para a pasta src e crie uma pasta de teste com uma pasta NewTypesTests dentro dela. Em um prompt de comando da pasta NewTypesTests , execute dotnet new xunit. Este comando produz dois ficheiros: NewTypesTests.csproj e UnitTest1.cs.

Atualmente, o projeto de teste não pode testar os tipos em NewTypes e requer uma referência ao projeto NewTypes. Para adicionar uma referência de projeto, use o dotnet reference add comando:

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

Ou, você também tem a opção de adicionar manualmente a referência do projeto adicionando um <ItemGroup> nó ao arquivo 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>

O arquivo NewTypesTests.csproj contém as seguintes referências de pacote:

  • Microsoft.NET.Test.Sdk, a infraestrutura de testes da plataforma .NET
  • xunit, a estrutura de teste xUnit
  • xunit.runner.visualstudio, o executor de testes
  • NewTypes, o código a testar

Altere o nome do UnitTest1.cs para PetTests.cs e substitua o código no arquivo com o seguinte código:

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

Exercício opcional: Se você adicionou um Bird tipo anteriormente que produz um Tweet! para o proprietário, adicione um método de teste ao arquivo PetTests.cs , BirdTalkToOwnerReturnsTweet, para verificar se o TalkToOwner método funciona corretamente para o Bird tipo.

Observação

Embora você espere que os expected valores e actual sejam iguais, uma asserção inicial com a Assert.NotEqual verificação especifica que esses valores não são iguais. Sempre inicialmente crie um teste para falhar, a fim de verificar a lógica do teste. Depois de confirmar que o teste falhou, ajuste a asserção para permitir que o teste seja aprovado.

A seguir mostra a estrutura completa do projeto:

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

Inicie no diretório test/NewTypesTests . Execute os testes com o dotnet test comando. Este comando inicia o executor de teste especificado no arquivo de projeto.

Como esperado, o teste falha e o console exibe a seguinte saída:

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)

Altere as asserções dos seus testes de Assert.NotEqual para 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);
    }
}

Execute novamente os testes com o dotnet test comando e obtenha a seguinte saída:

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)

Os testes são aprovados. Os métodos das categorias de animais de estimação devolvem os valores corretos quando interagem com o dono.

Você aprendeu técnicas para organizar e testar projetos usando xUnit. Vá em frente com essas técnicas aplicando-as em seus próprios projetos. Boa programação!

  • Last updated on