Testes Integrados

Introdução

Testes de integração compreendem uma segunda fase do ciclo de testes de uma aplicação.

Após testar cada unidade o próximo passo é testar um grupo de funcionalidades, como um todo, fazendo a integração de todos os módulos da aplicação

Para este tipo de teste o TNF traz algumas classe e definições na hora de criação do seu teste integrado.

As estruturas de asserts dos testes descritos abaixo foram criados usando o Xunit.

Testes na camada de aplicação

Para criar testes dessa camada temos que analisar o que sua aplicação utiliza como infraestrutura.

Testando a camada de aplicação com Entity Framework Core em memória.

Considere para os cenários a seguir a seguinte tabela criada no Entity Framework Core e seu DTO

[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
{
	public string Name { get; set; }
}

Para realizar teste em cenários com o uso de Entity Framework Core em memórioa o TNF prove alguns facilitadores.

Vamos começar com a criação do modulo que fará o carregamento da estrutura de testes:

[DependsOn(
	typeof(AppModule),
    typeof(TnfTestBaseModule))]
public class AppTestModule : TnfModule
{
	public override void PreInitialize()
    {
    	Configuration.Modules
        	.TnfEfCoreInMemory(IocManager.IocContainer)
            .RegisterDbContextInMemory<ArchitectureDbContext>();
	}
    
    public override void Initialize()
	{
    	IocManager.RegisterAssemblyByConvention(Assembly.GetExecutingAssembly());
    }
}

O modulo "AppTestModule" foi criado no projeto de testes sendo responsável por carregar toda a estrutura de sua aplicação para o teste integrado.

Note que o atributo do modulo "DependsOn" tem como referencia outro modulo chamado "AppModule". Este modulo é um modulo da camada de aplicação de nossa aplicação concreta a ser testada. Esse modulo também contém dependências de outras camadas como domínio e infraestrutura onde as entidades estão sendo persistidas com o Entity Framework Core.

O código exemplificado acima, carrega o modulo da camada a ser testada, configurando no método "PreInitialize" o uso do Entity Framework em memoria para o DbContext "ArchitectureDbContext". Essa configuração irá habilitar o uso da estrutura em memoria podendo assim criar um setup em cada teste criado onde será possível incluir a estrutura em memoria no ORM (setup) executando assim o teste em cima da camada de serviço.

Para criação do Setup de cada teste o TNF disponibiliza uma classe abstrata chamada "TnfEfCoreIntegratedTestBase<Module>" que recebe um TnfModule ("AppTestModule" vide exemplo anterior):

public class AppTestBase : TnfEfCoreIntegratedTestBase<AppTestModule>
{
	protected override void InitializeIntegratedTest()
    {
    	UsingDbContext<ArchitectureDbContext>(
        	context =>
            {
            	context.Countries.Add(new Country(1, "Brasil"));
                context.Countries.Add(new Country(2, "EUA"));
                context.Countries.Add(new Country(3, "Uruguai"));
                context.Countries.Add(new Country(4, "Paraguai"));
                context.Countries.Add(new Country(5, "Venezuela"));
            });
	}
}

A classe TnfEfCoreIntegratedTestBase força a implementação do método "InitializeIntegratedTest" onde será definido o setup de nosso contexto do Entity Framework Core em memoria. A mesma classe expõe alguns métodos para inclusão de dados na memoria do contexto como o do exemplo acima "UsingDbContext<DbContext>".

Definida a classe que fará o setup de cada teste criado, podemos começar a escrita de nossos testes sobre os serviços de aplicação:

public interface ICountryAppService : IAsyncCrudAppService<CountryDto>
{
}

public class CountryAppService : AsyncCrudAppService<Country, CountryDto>, ICountryAppService
{
	public CountryAppService(IRepository<Country> repository)
    	: base(repository)
	{
    }
}

O serviço de aplicação do exemplo acima utiliza o AsyncCrudAppService do TNF que cria a estrutura de CRUD automaticamente.

Após criar nosso serviço de aplicação, podemos começar o desenvolvimento dos testes:

public class CountryAppServiceTests : AppTestBase
{
	private readonly ICountryAppService _countryAppService;
    public CountryAppServiceTests()
    {
    	_countryAppService = LocalIocManager.Resolve<ICountryAppService>();
	}


	[Fact]
    public void Service_Should_Not_Be_Null()
    {
    	_countryAppService.ShouldNotBeNull();
    }
 
	[Fact]
	public async Task Create_Item_With_Sucess()
    {
    	var result = await _countryAppService.Create(new CountryDto()
        {
        	Id = 6,
            Name = "Mexico"
		});
		result.Name.ShouldBe("Mexico");
	}
 
	[Fact]
    public async Task Get_Return_Item_With_Sucess()
    {
 		var result = await _countryAppService.Get(new EntityDto<int>(1));
        result.Id.ShouldBe(1);
        result.Name.ShouldBe("Brasil");
	}
}

Note que no exemplo acima realizamos a herança da nossa classe que realiza o setup dos dados em nosso contexto em memoria. Agora podemos executar nossos testes em nosso serviço de aplicação normalmente em cima da estrutura em memoria do Entity Framework Core.

Cada teste executado no cenário acima será de forma reproduzido de forma isolada.