Histórico da Página
| Índice |
|---|
Construímos o TNF O TNF foi construído voltado para que a as boas praticas e os princípios de um código limpo fossem respeitados.
Para que isso aconteça um dos principais pontos a serem abordados aqui nesta seção são os testes de unidade e testes integrados.
Nesse tópico será descrito como realizar os testes de unidade, validando regra a regra de uma aplicação construída com o TNF também como os testes integrados passando de camada a camada de sua aplicação.
Frameworks
devemos construir um código que possibilite ser testado tentando obter o máximo de cobertura possível.
Vamos conhecer a estrutura que o TNF oferece para criação de nossos testes unitários e integrados.
Frameworks
O TNF prove algumas estruturas para realização de testes em sua aplicação. Não é uma regra, mas sugerimos os seguintes frameworks para utilização em seu projeto.
Xunit.net
É um framework free, voltado a comunidade Framework open source, largamente utilizado para realizar testes na plataforma .NET. Ele suporte que suporta todas as tecnologias, atualmente fazendo . Atualmente faz parte do .NET Foundation.
Para sua instalação basta realizar a adição de 2 pacotes via nuget ao seu assembly: xunit e xunit.runner.visualstudio.
Shouldly
Framework com estrutura de asserção. Junto com o Xunit fornece uma gama de métodos de extensão para realizar os asserts e validações de regras, objetos e comportamentos.
Referencia: https://xunit.github.iocom/shouldly/shouldly
NSubstitute
Consiste em um framework Framework open source para realização de .NET mocking. Com ele é possível realizar mock de propriedades, classes, interfaces entre outras funcionalidades. Para sua utilização, basta realizar a instalação do pacote NSubstitute via interface nuget.
Referencia: http://nsubstitute.github.io/
Shouldly
Framework com estrutura de asserção. Junto com o Xunit fornece uma gama de metodos de extensão para realizar os assert e validações de regras, objetos e comportamentos.
Para sua utilização, basta realizar a instalação do pacote Shouldly via interface nuget.
Cenário de testes
Todos os cenários descritos a seguir estão dispostos em nosso github no endereço: https://github.com/totvsnetcore/tnf-samples/tree/master/TnfSample-Architecture
Camada de infraestrutura
Nossa aplicação contem em sua camada de infraestrutura dois repositórios de dados: Entity Framework Core e Carol (SAS desenvolvido pela TOTVS).
Entidade no Entity Framework Core e Dto:
| Bloco de código | ||||||||
|---|---|---|---|---|---|---|---|---|
| ||||||||
[AutoMap(typeof(CountryDto))]
[Table("Countries")]
public class Country : Entity
{
public const int MaxNameLength = 256;
[Required]
[MaxLength(MaxNameLength)]
public string Name { get; set; }
public Country()
{
}
public Country(int id, string name)
{
Id = id;
Name = name;
}
}
public class CountryDto : IDto
{
public IList<string> _expandables { get; set; }
public string Name { get; set; }
} |
Entidade no Carol e Dto:
| Bloco de código | ||||||||
|---|---|---|---|---|---|---|---|---|
| ||||||||
[JsonObject("president")]
public class PresidentEntity : CarolEntity
{
public string Name { get; set; }
public string ZipCode { get; set; }
public override object GetStagingMapping()
{
return new
{
name = "string",
zipCode = "string"
};
}
}
public class PresidentDto : IDto
{
public IList<string> _expandables { get; set; }
public PresidentDto()
{
}
public PresidentDto(string id, string name, string zipCode)
{
Id = id;
Name = name;
ZipCode = new ZipCode(zipCode);
}
public string Id { get; set; }
public string Name { get; set; }
public ZipCode ZipCode { get; set; }
} |
Camada de Domínio
Serviço WhiteHouseService responsável pela persistência das entidade de presidentes no Carol.
Abaixo temos a implementação do serviço WhiteHouseService usando um repositório chamado IWhiteHouseRepositoriy implementado pela camada de infraestrutura consumindo dados do Carol.
| Bloco de código | ||||||||
|---|---|---|---|---|---|---|---|---|
| ||||||||
// Domain service interface
public interface IWhiteHouseService : IDomainService
{
Task<PresidentDto> InsertPresidentAsync(PresidentDto request);
}
// Domain service
public class WhiteHouseService : AppDomainService<IWhiteHouseRepository>, IWhiteHouseService
{
private readonly IEventBus _eventBus;
public WhiteHouseService(IWhiteHouseRepository repository, IEventBus eventBus)
: base(repository)
{
_eventBus = eventBus;
}
public Task<PresidentDto> InsertPresidentAsync(PresidentDto request)
{
var response = new DtoResponseBase<PresidentDto>();
var builder = new PresidentBuilder()
.WithId(item.Id)
.WithName(item.Name);
var president = builder.Build();
if (!Notification.HasNotification())
{
var ids = await Repository.InsertPresidentsAsync(new List<President>() { president }, sync);
dto.Id = ids[0];
// Trigger president created event
_eventBus.Trigger(new PresidentCreatedEvent(president));
}
return response;
}
} |
Além da validação da entidade nosso caso de testes faz uso de Domain Events e dispara um evento após inserir a entidade de presidente.
| Bloco de código | ||||||||
|---|---|---|---|---|---|---|---|---|
| ||||||||
internal class PresidentBuilder : Builder<President>
{
public PresidentBuilder(INotificationHandler notification)
: base(notification)
{
}
public PresidentBuilder(President instance, INotificationHandler notification)
: base(instance, notification)
{
}
public PresidentBuilder WithId(string id)
{
Instance.Id = id;
return this;
}
public PresidentBuilder WithName(string name)
{
Instance.Name = name;
return this;
}
protected override void Specifications()
{
AddSpecification(new PresidentShouldHaveNameSpecification());
}
public override President Build()
{
base.Validate();
return base.Build();
}
} |
Camada de aplicação
Serviços de aplicação em nosso cenário:
- CountryAppService: Consumindo dados do Entity Framework Core utilizando a criação de CRUD padrão do TNF.
| Bloco de código | ||||||||
|---|---|---|---|---|---|---|---|---|
| ||||||||
public interface ICountryAppService : IAsyncCrudAppService<CountryDto>
{
} |
- WhiteHouseAppService: Consumindo dados do Carol
| Bloco de código | ||||||||
|---|---|---|---|---|---|---|---|---|
| ||||||||
public interface IWhiteHouseAppService : IApplicationService
{
Task<ListDto<PresidentDto>> GetAllPresidents(GetAllPresidentsDto request);
Task<PresidentDto> GetPresidentById(RequestDto<string> id);
Task<PresidentDto> InsertPresidentAsync(PresidentDto president, bool sync = true);
Task<PresidentDto> UpdatePresidentAsync(string id, PresidentDto president);
Task DeletePresidentAsync(string id);
} |
Camada de Serviços
API com padrão RESTful para os dois serviços de aplicação criados expostos com ASP NET Core.Referencia: https://github.com/shouldly/shouldly
Visão Geral
Import HTML Content
Conteúdo das Ferramentas
Tarefas