ASP.NET Core  -  Realizando Testes Unitários - I

Neste artigo veremos como realizar testes unitáriois na ASP .NET Core usando o xUnit.

Porque preciso realizar testes ?

Errar é humano, e, no desenvolvimento de software essa verdade se apresenta de forma mais clara e patente.

Assim, nossos aplicativos estão sujeitos a erros e podem falhar de formas inesperadas depois de sofreram qualquer alteração. Por isso, o teste automático é necessário depois de fazer qualquer alteração de código.

Podemos realizar o teste manual que é a forma mais lenta, menos confiável e mais cara de testar um aplicativo. No entanto, se os aplicativos não forem projetados para testes, o teste manual poderá ser o único meio disponível para a realização dos testes.

Portanto, o primeiro passo é garantir que o aplicativo seja projetado para ser testável. Aplicativos que seguem bons princípios de arquitetura, como Separação de Interesses, Inversão de Dependência, Responsabilidade Única, Não repetem código desnecessário (DRY), etc., são facilmente testáveis.

A ASP.NET Core suporta testes automatizados de unidade, de integração e testes funcionais.

Neste artigo vamos focar na realização de testes de unidade em um projeto ASP .NET Core Web API.

Testes Unitários

O Teste de unidade ou Teste Unitário é a fase do processo de teste em que se testam as menores unidades de software desenvolvidas (pequenas partes ou unidades do sistema). O alvo são os métodos dos objetos ou módulos/funções ou mesmo pequenos trechos de código. O objetivo é encontrar falhas de funcionamento em uma pequena parte do sistema funcionando independentemente do todo.(wikipedia)

Os testes de unidade são feitos pelo próprio programador geralmente usando o método caixa branca ou funcional. Eles são criados durante a fase de desenvolvimento ou no seu inicio. O objetivo dos testes unitário é testar a menor funcionalidade existente do software, ou seja, isolar parte dos códigos e métodos, e analisar se essas funcionalidades tenham o retorno esperado mediando a um valor informado.

Vamos aplicar o seguinte roteiro para realizar testes unitários :

Criando o projeto ASP .NET Core Web API

Vamos criar um novo projeto WEB API usando o Visual Studio 2019 Community Preview e a ASP .NET Core 3.0 preview 7.

Abra o VS 2019 Community preview e clique em Create a new project:

A seguir selecione :

Escolha o template ASP .NET Core Web Application e clique em Next :

Informe o nome do projeto APICompras e escolha a pasta onde deseja salvar o projeto e clique em Create:

Agora escolha .NET Core e ASP .NET Core 3.0 e o template API e clique em Create:

Observe que estamos usando o SDK 3.0.100-preview7.

Ao final teremos o projeto Web API APICompras criado com a seguinte estrutura :

O projeto APICompras possui :

- A pasta Controllers contendo o controlador WeatherForecastController

- A classe Startup

- A classe WeatherForecast

 

Se você executar o projeto poderá acesssar a API na url: https://localhost:xxx/weatherforecast

Vamos remover o controlador criado na pasta Controllers e a classe WeatherForecast do projeto.

Configurando o projeto

Vamos criar as pastas Models e Services em nosso projeto.

Na pasta Models vamos definir o modelo de domínio representando pela classe CompraItem:

using System;
using System.ComponentModel.DataAnnotations;
namespace APICompras.Models
{
    public class CompraItem
    {
        public int Id { get; set; }
        [Required]
        public string Nome { get; set; }
        public decimal Preco { get; set; }
        public string Fabricante { get; set; }
    }
}

Na pasta Services vamos incluir uma interface chamada ICompraService :

using APICompras.Models;
using System;
using System.Collections.Generic;
namespace APICompras.Services
{
    public interface ICompraService
    {
        IEnumerable<CompraItem> GetAllItems();
        CompraItem Add(CompraItem novoItem);
        CompraItem GetById(int id);
        void Remove(int id);
    }
}

A seguir na mesma pasta vamos criar a classe CompraService  que implementa a interface acima:

using APICompras.Models;
using System;
using System.Collections.Generic;
namespace APICompras.Services
{
    public class CompraService : ICompraService
    {
        public CompraItem Add(CompraItem novoItem)
        {
            throw new NotImplementedException();
        }
        public IEnumerable<CompraItem> GetAllItems()
        {
            throw new NotImplementedException();
        }
        public CompraItem GetById(int id)
        {
            throw new NotImplementedException();
        }
        public void Remove(int id)
        {
            throw new NotImplementedException();
        }
    }
}

Como nosso objetivo é apenas mostrar os testes de unidades vamos apenas implementar os métodos sem definir nenhuma funcionalidade.

Agora podemos criar o nosso controlador.

Criando o controlador ComprasController

Na janela Add Scaffold selecione API Controller - Empty e clique em Add;

Informe o nome ComprasController na janela Add Empty API Controller e clique em Add;

Agora abra o arquivo ComprasController e inclua o código abaixo:

using APICompras.Models;
using APICompras.Services;
using Microsoft.AspNetCore.Mvc;
using System;
using System.Collections.Generic;
namespace APICompras.Controllers
{
    [Route("api/[controller]")]
    [ApiController]
    public class ComprasController : ControllerBase
    {
        private readonly ICompraService _service;
        public ComprasController(ICompraService service)
        {
            _service = service;
        }
        // GET api/compras
        [HttpGet]
        public ActionResult<IEnumerable<CompraItem>> Get()
        {
            var items = _service.GetAllItems();
            return Ok(items);
        }
        // GET api/compras/5
        [HttpGet("{id}")]
        public ActionResult<CompraItem> Get(int id)
        {
            var item = _service.GetById(id);
            if (item == null)
            {
                return NotFound();
            }
            return Ok(item);
        }
        // POST api/compras
        [HttpPost]
        public ActionResult Post([FromBody] CompraItem value)
        {
            if (!ModelState.IsValid)
            {
                return BadRequest(ModelState);
            }
            var item = _service.Add(value);
            return CreatedAtAction("Get", new { id = item.Id }, item);
        }
        // DELETE api/compras/5
        [HttpDelete("{id}")]
        public ActionResult Remove(int id)
        {
            var existingItem = _service.GetById(id);
            if (existingItem == null)
            {
                return NotFound();
            }
            _service.Remove(id);
            return Ok();
        }
    }
}

Com isso concluímos a criação da nossa API ComprasController e a seguir vamos criar o projeto de testes.

Faremos isso na próxima parte do artigo.

"E tu, ó menino, serás chamado profeta do Altíssimo, Porque hás de ir ante a face do Senhor, a preparar os seus caminhos;
Para dar ao seu povo conhecimento da salvação, Na remissão dos seus pecados;
Pelas entranhas da misericórdia do nosso Deus, Com que o oriente do alto nos visitou;"
 Lucas 1:76-78

Veja os Destaques e novidades do SUPER DVD Visual Basic (sempre atualizado) : clique e confira !

Quer migrar para o VB .NET ?

Quer aprender C# ??

Quer aprender os conceitos da Programação Orientada a objetos ?

Quer aprender o gerar relatórios com o ReportViewer no VS 2013 ?

Quer aprender a criar aplicações Web Dinâmicas usando a ASP .NET MVC 5 ?

Referências:

José Carlos Macoratti