C#: aprenda a criar testes limpos com boas práticas

Declarando dependências - Apresentação

André: Olá! Boas-vindas a mais um curso da formação de boas práticas em C#, com ênfase em testes. Meu nome é André Bessa e te acompanharei ao longo dessa jornada!

Audiodescrição: André se descreve como um homem negro, com barba preta por fazer, rosto arredondado e cabelo curto preto. Ele veste uma camisa azul-marinho e está em um ambiente iluminado em azul, com uma porta à esquerda e uma estante branca atrás com alguns enfeites.

Daniel: Meu nome é Daniel Portugal e também estarei aqui com o André e com você!

Audiodescrição: André se descreve como um homem branco, com cabelos pretos lisos e curtos, barba preta, usa óculos de armação retangular preta, e veste uma camisa preta. Ele está em um ambiente de fundo azul.

Pré-requisitos

André: Este curso é para quem já tem conhecimento em C#, orientação a objetos e já tenha visto testes automatizados em algum momento na sua trajetória.

O primeiro curso da formação de boas práticas em C# é pré-requisito para este curso, visto que vamos dar continuidade ao projeto iniciado nele.

O que vamos aprender?

Daniel: Neste curso, continuaremos evoluindo a nossa aplicação que faz importação de pets através de arquivos para a API. André, vamos mostrar como a aplicação está atualmente e como pretendemos fazê-la evoluir até finalizarmos o curso?

André: Estamos com o projeto aberto no Visual Studio, nossa IDE e ferramenta de trabalho utilizada durante o curso.

Possuímos um projeto de testes que permite acompanhar a evolução da nossa aplicação. Temos o teste para documentação (GeraDocumentacaoTest.cs), para comunicação com a API do HttpClientPet.

Desenvolvemos algumas classes com responsabilidades bem específicas, como a LeitorDeArquivo.cs, a DocumentacaoDoSistema.cs. Temos também o arquivo Program.cs que está bem enxuto, legível e funcional.

Daniel: Quanto à futura aparência da aplicação, ela será muito mais enxuta, pois vamos aplicar padrões de projeto, princípios e boas práticas, e tudo isso será orientado por testes.

André: Exatamente, Daniel. Vamos abrir o gerenciador de testes da nossa solução e praticamente dobraremos a quantidade de testes criados, com foco nos comandos do nosso sistema.

Além dos vídeos, teremos também o apoio do fórum e da nossa comunidade ativa no Discord.

Convidamos você a estudar conosco. Vamos começar!

Declarando dependências - Identificando dependência de classes

Daniel: Vamos continuar aplicando boas práticas no nosso projeto do console, que faz a conexão com o AdoPet. Agora, vamos focar bastante nos comandos.

Identificando dependência de classes

Começaremos abrindo na máquina a classe Import.cs, que é o comando de importação. Especificamente, na linha 25, temos um código em que, por orientação a objetos, entendemos que estamos criando uma instância de objeto. O objeto é do tipo HttpClientPet.

Import.cs:

var httpCreatePet = new HttpClientPet();

Vamos abrir também a classe HttpClientPet.cs, localizada em "Servicos". Essa classe, por sua vez, também é responsável pela construção de um objeto chamado HttpClient (linha 17).

HttpClientPet.cs:

HttpClient _client = new HttpClient();

Esse objeto representa uma conexão HTTP fornecida pela Microsoft que vai se conectar com um servidor. A construção desse objeto acontece tanto no comando Import quanto no comando List (arquivo List.cs).

Otimizando a construção do objeto

O que queremos fazer agora é otimizar esse processo, diminuindo o número de vezes que criamos a conexão com o servidor.

André: Então, vamos passar para o construtor, tanto de Import.cs quanto de List.cs, a criação do objeto HttpClient.

Na classe Import.cs, vamos criar uma nova propriedade da classe na linha de código 11. O objetivo é otimizar a construção do objeto. Então, vamos adicionar no construtor das classes Import e List para utilizá-lo. Assim, quem for criar o objeto para nós, ficará responsável por passar a instância de HttpClient.

Criaremos um campo private readonly na classe Import, ou seja, apenas para leitura, chamado HttpClientPet do tipo clientPet.

Import.cs:

internal class Import:IComando
{
    private readonly HttpClientPet clientPet;

// código omitido

Agora podemos usar o Visual Studio para gerar o construtor para nós, utilizando o atalho "Ctrl + ." e selecionando a opção "Gerar construtor".

internal class Import:IComando
{
    private readonly HttpClientPet clientPet;

    public Import(HttpClientPet clientPet)
    {
        this.clientPet = clientPet;
    }

Após a criação do construtor, vamos utilizar o campo clientPet que acabamos de criar para fazer o CreatePetAsync(), em vez de criar uma nova instância de HttpClientPet na linha 32.

Trecho a ser removido da linha de código 32:

var httpCreatePet = new HttpClientPet();

try
{
    await clientPet.CreatePetAsync(pet);
}

Agora vamos para a classe List.cs fazer o mesmo processo. Primeiro, criaremos o campo clientPet; em seguida, criaremos o construtor.

List.cs:

internal class List: IComando
{
    private readonly HttpClientPet clientPet;

    public List(HttpClientPet clientPet)
    {
        this.clientPet = clientPet;
    }

Para finalizar, vamos remover a linha 24 e utilizar o clientPet junto a ListPetAsync() para fazer a listagem dos pets de maneira assíncrona.

Trecho a ser removido da linha 24:

var httpListPet = new HttpClientPet();

private async Task ListaDadosPetsDaAPIAsync()
{          
    IEnumerable<Pet>? pets = await clientPet.ListPetsAsync();
    System.Console.WriteLine("----- Lista de Pets importados no sistema -----");
    foreach (var pet in pets)
    {
        System.Console.WriteLine(pet);
    }
}

Ajustando o arquivo Program.cs

Concluídas as alterações em List e Import, agora, sempre que criarmos um objeto dessas classes, precisaremos passar um objeto do tipo HttpClientPet no construtor.

De volta ao arquivo Program.cs, poderemos verificar que o dicionário (Dictionary<>) começa a quebrar nas linhas 6 e 7. Então, vamos criar um novo objeto do tipo HttpClient que será compartilhado na criação tanto de Import quanto de List.

Na linha de código 3, vamos declarar uma variável chamada httpClientPet que receberá uma nova instância (new) de HttpClientPet().

Program.cs:

var httpClientPet = new HttpClientPet();

Nesse momento, precisamos fazer o using a partir de HttpClientPet():

using Alura.Adopet.Console.Servicos;

Agora usaremos a variável httpClientPet na criação do Import() na linha 8 e do List() na linha 9.

Dictionary<string, IComando> comandosDoSistema = new()
{
    {"help",new Help()},
    {"import",new Import(httpClientPet)},
    {"list",new List(httpClientPet)},
    {"show",new Show()},
};

Conclusão

Daniel: Dessa forma, compartilhamos o mesmo objeto para dois comandos, conforme dito pelo André anteriormente. Com isso, conseguimos economizar recursos.

Embora a aplicação execute um comando por vez e pare, compartilhar esse recurso ainda é benéfico e é ótimo que agora conseguimos fazer isso.

Agora vamos prosseguir com os comandos Import e List. Eles não têm a responsabilidade de saber como criar esse HttpClientPet. Isso é algo que iremos explorar mais tarde e trará consequências benéficas para nossos estudos futuros.

Além disso, não estamos criando de forma aleatória. Seguimos as orientações da documentação da Microsoft para trabalhar com esse tipo de HttpClient.

A Microsoft destaca que esse é um recurso que demanda alto processamento e estabelece uma conexão com o servidor através da internet, utilizando o protocolo HTTP. São sugeridas algumas recomendações de utilização. Há uma seção específica de como utilizar o recurso.

No próximo vídeo, abordaremos o segundo tópico exibido na documentação, para podermos nos alinhar ainda mais às recomendações da Microsoft.

André: Continuaremos na sequência!

Declarando dependências - IHttpClientFactory

André: Seguindo as recomendações da Microsoft, vamos abordar o segundo ponto da seção "Uso recomendado" que sugere a utilização de uma interface chamada IHttpClientFactory, que será responsável por criar os objetos do tipo HttpClient para nós.

Tópico da documentação da Microsoft:

Usando IHttpClientFactory, você pode ter vários clientes configurados de forma diferente para diferentes casos de uso. No entanto, lembre-se de que os clientes criados pela fábrica devem ter vida útil curta e, depois que o cliente for criado, a fábrica não terá mais controle sobre ele.

A fábrica agrupa instâncias de HttpMessageHandler e, se seu tempo de vida não tiver expirado, um manipulador poderá ser reutilizado do pool quando a fábrica criar uma nova instância de HttpClient. Essa reutilização evita problemas de esgotamento do soquete.

Se você desejar a capacidade de configuração que o IHttpClientFactory, recomendamos usar a abordagem de cliente com tipo.

IHttpClientFactory

Criando uma nova classe

Começaremos no gerenciador de soluções, na pasta "Servicos", sobre a qual clicaremos com o botão direito e adicionaremos uma nova classe ("Adicionar > Classe…") que implementará a interface. Nomearemos essa classe como AdopetAPIClientFactory.

Para implementar a interface, adicionamos dois-pontos e a interface IHttpClientFactory.

AdopetAPIClientFactory.cs:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Alura.Adopet.Console.Servicos : IHttpClientFactory
{
    internal class AdopetAPIClientFactory
    {
    }
}

Nesse momento, será necessário instalar o pacote Microsoft.Extensions.Http. Teclaremos "Ctrl + ." para localizar e instalar a versão mais recente.

Implementando a interface

Nosso código-fonte dará erro, porque ainda precisamos implementar o comportamento da interface. Clicando sobre o ícone de lâmpada amarela com um sinal vermelho, podemos implementar a interface que tem apenas um método, o CreateClient(), que recebe como parâmetro o nome (name) e as implementações que faremos na sequência.

// código omitido

namespace Alura.Adopet.Console.Servicos : IHttpClientFactory
{
    internal class AdopetAPIClientFactory
    {
        public HttpClient CreateClient(string name)
        {
            throw new NotImplementedException();
        }
    }
}

Começaremos apagando o conteúdo da linha 14.

Daniel: O nome que está sendo passado como argumento, serve para indicar justamente qual tipo de cliente queremos informar. No nosso caso, só temos um cliente neste sistema específico, mas no seu projeto pode haver vários clientes, várias conexões diferentes, e então você especificará o nome desejado. Neste caso, não fará diferença o nome passado.

André: A criação do Client ocorrerá na configuração no HttpClientPet.cs, no método ConfiguraHttpClient(). Todo o conteúdo deste método será transferido para o arquivo AdopetAPIClientFactory.cs.

AdopetAPIClientFactory.cs:

namespace Alura.Adopet.Console.Servicos
{
    internal class AdopetAPIClientFactory : IHttpClientFactory
    {
        public HttpClient CreateClient(string name)
        {
            HttpClient _client = new HttpClient();
            _client.DefaultRequestHeaders.Accept.Clear();
            _client.DefaultRequestHeaders.Accept.Add(
                new MediaTypeWithQualityHeaderValue("application/json"));
            _client.BaseAddress = new Uri(url);
            return _client;
        }
    }
}

Podemos apagar todo o método ConfiguraHttpClient() do arquivo HttpClientPet.cs.

HttpClient ConfiguraHttpClient(string url)
{
    HttpClient _client = new HttpClient();
    _client.DefaultRequestHeaders.Accept.Clear();
    _client.DefaultRequestHeaders.Accept.Add(
        new MediaTypeWithQualityHeaderValue("application/json"));
    _client.BaseAddress = new Uri(url);
    return _client;
}

Neste caso, precisaremos da URL utilizada, então criaremos um campo privado para contê-la.

Também temos esse campo no arquivo HttpClientPet.cs, então podemos apenas movê-lo para o arquivo AdopetAPIClientFactory.cs, na linha de código 13. Usaremos private ao início da linha para declarar o campo privado, e vamos alterar de uri para url.

private string url = "http://localhost:5057";

Ajustando a classe HttpClientPet

Também precisamos ajustar a classe HttpClientPet. Não teremos mais o parâmetro uri no construtor, então podemos removê-lo.

HttpClientPet.cs:

public HttpClientPet()
{
    client = ConfiguraHttpClient(uri);
}

Agora no construtor do HttpClient, em vez de passar a URL para a configuração, vamos passar a instância de HttpClient. Para isso, podemos usar a própria propriedade declarada na linha 9, teclar "Ctrl + .", e selecionar a opção "Gerar construtor".

Dessa forma, teremos um construtor que recebe client, e poderemos remover o que tínhamos anteriormente.

namespace Alura.Adopet.Console.Servicos
{
    public class HttpClientPet
    {
        private HttpClient client;     

        public HttpClientPet(HttpClient client)
        {
            this.client = client;
        }

// código omitido

Agora, o arquivo HttpClientPet.cs recebe no construtor o HttpClient que espera receber.

Utilizando a classe AdopetAPIClientFactory

Feito isso, o código em Program.cs irá quebrar, porque agora, ao criar a instância que será compartilhada tanto pelo Import quanto pelo List, precisaremos passar o client.

Nesse momento, utilizaremos a classe que acabamos de criar. Após o new entre os parênteses de HttpClientPet() na linha 4, digitaremos AdopetAPIClientFactory.

Quando instanciar esse objeto, chamaremos o CreateClient(), e precisaremos passar um nome como parâmetro que, para nós, não faz muita diferença. Contudo, para ficar de acordo com o que Daniel mencionou, daremos o nome de adopet.

Program.cs:

var httpClientPet = new HttpClientPet(new AdopetAPIClientFactory().CreateClient("adopet"));

Conclusão

Daniel: Neste vídeo, estamos reforçando a aplicação, agora aderindo à orientação da Microsoft, que é economizar o recurso HttpClient, usando uma implementação de IHttpClientFactory.

Enfatizamos a ideia de que sempre que precisar criar um objeto mais complexo, como o HttpClientPet ou o HttpClient, você deve explicitar essa dependência no construtor de sua classe. Por exemplo, Import e List declaram a necessidade de um HttpClientPet. Quem for construir, precisará passar um objeto desse tipo.

O mesmo acontece com o HttpClientPet. Ele diz que precisa de um HttpClient, logo, quem for construir (no caso, Program.cs) vai passar um objeto desse tipo.

Nosso próximo passo é focar nos testes. Nos baseamos bastante neles, mas no próximo vídeo, você notará que nossos testes sequer estão compilando.

André: Exatamente, vários pontos começaram a falhar. Vamos resolver isso na próxima etapa!

Sobre o curso C#: aprenda a criar testes limpos com boas práticas

O curso C#: aprenda a criar testes limpos com boas práticas possui 186 minutos de vídeos, em um total de 55 atividades. Gostou? Conheça nossos outros cursos de .NET em Programação, ou leia nossos artigos de Programação.

Matricule-se e comece a estudar com a gente hoje! Conheça outros tópicos abordados durante o curso:

• Declarando dependências
• Boas práticas em testes
• Extraindo resultados
• Isolando exibição
• Fábrica de comandos