public async Task ItIsPossibleToCarryOutTheZipCodeCrud()
{
using (var myContext = _serviceProvider.GetService <MyContext>())
{
CountyImplementation countyImplementation = new CountyImplementation(myContext);
CountyEntity countyEntity = new CountyEntity
{
Name = Faker.Address.City(),
CodeIbge = Faker.RandomNumber.Next(1000000, 9999999),
FederalUnitId = new Guid("e7e416de-477c-4fa3-a541-b5af5f35ccf6"),
};
var recordCounty = await countyImplementation.InsertAsync(countyEntity);
Assert.NotNull(recordCounty);
Assert.Equal(countyEntity.Name, recordCounty.Name);
Assert.Equal(countyEntity.CodeIbge, recordCounty.CodeIbge);
Assert.Equal(countyEntity.FederalUnitId, recordCounty.FederalUnitId);
Assert.False(recordCounty.Id == Guid.Empty);
ZipCodeImplementation zipCodeImplementation = new ZipCodeImplementation(myContext);
ZipCodeEntity zipCodeEntity = new ZipCodeEntity
{
ZipCode = "13.481-001",
PublicPlace = Faker.Address.StreetName(),
Number = "0 até 2000",
CountyId = recordCounty.Id
};
var recordZipCode = await zipCodeImplementation.InsertAsync(zipCodeEntity);
Assert.NotNull(recordZipCode);
Assert.Equal(zipCodeEntity.ZipCode, recordZipCode.ZipCode);
Assert.Equal(zipCodeEntity.PublicPlace, recordZipCode.PublicPlace);
Assert.Equal(zipCodeEntity.Number, recordZipCode.Number);
Assert.Equal(zipCodeEntity.CountyId, recordZipCode.CountyId);
Assert.False(recordZipCode.Id == Guid.Empty);
zipCodeEntity.PublicPlace = Faker.Address.StreetName();
zipCodeEntity.Id = recordZipCode.Id;
var recordUpdate = await zipCodeImplementation.UpdateAsync(zipCodeEntity);
Assert.NotNull(recordUpdate);
Assert.Equal(zipCodeEntity.ZipCode, recordUpdate.ZipCode);
Assert.Equal(zipCodeEntity.PublicPlace, recordUpdate.PublicPlace);
Assert.Equal(zipCodeEntity.Number, recordUpdate.Number);
Assert.Equal(zipCodeEntity.CountyId, recordUpdate.CountyId);
Assert.True(recordZipCode.Id == zipCodeEntity.Id);
var recordExists = await zipCodeImplementation.ExistAsync(recordUpdate.Id);
Assert.True(recordExists);
var recordSelect = await zipCodeImplementation.SelectAsync(recordUpdate.Id);
Assert.NotNull(recordSelect);
Assert.Equal(recordSelect.ZipCode, recordUpdate.ZipCode);
Assert.Equal(recordSelect.PublicPlace, recordUpdate.PublicPlace);
Assert.Equal(recordSelect.Number, recordUpdate.Number);
Assert.Equal(recordSelect.CountyId, recordUpdate.CountyId);
recordSelect = await zipCodeImplementation.SelectAsync(recordUpdate.ZipCode);
Assert.NotNull(recordSelect);
Assert.Equal(recordSelect.ZipCode, recordUpdate.ZipCode);
Assert.Equal(recordSelect.PublicPlace, recordUpdate.PublicPlace);
Assert.Equal(recordSelect.Number, recordUpdate.Number);
Assert.Equal(recordSelect.CountyId, recordUpdate.CountyId);
Assert.NotNull(recordSelect.County);
Assert.NotNull(recordSelect.County.Id);
Assert.Equal(recordSelect.County.Name, countyEntity.Name);
Assert.Equal(recordSelect.County.FederalUnit.Initials, "SP");
var recordSelectAll = await zipCodeImplementation.SelectAsync();
Assert.NotNull(recordSelectAll);
Assert.True(recordSelectAll.Count() > 0);
var recordDelete = await zipCodeImplementation.DeleteAsync(recordSelect.Id);
Assert.True(recordDelete);
recordSelectAll = await zipCodeImplementation.SelectAsync();
Assert.NotNull(recordSelectAll);
Assert.True(recordSelectAll.Count() == 0);
}
}
public void ItIsPossibleToMapTheModelsZipCode()
{
var model = new ZipCodeModel
{
Id = Guid.NewGuid(),
ZipCode = Faker.RandomNumber.Next(1, 10000).ToString(),
PublicPlace = Faker.Address.StreetName().ToString(),
Number = Faker.RandomNumber.Next(1, 1000).ToString(),
CreateAt = DateTime.Now,
UpdateAt = DateTime.Now,
CountyId = Guid.NewGuid()
};
var listZipCodeEntity = new List <ZipCodeEntity>();
for (int i = 0; i < 5; i++)
{
var itemZipCodeEntity = new ZipCodeEntity
{
Id = Guid.NewGuid(),
ZipCode = Faker.RandomNumber.Next(1, 10000).ToString(),
PublicPlace = Faker.Address.StreetName(),
Number = Faker.RandomNumber.Next(1, 10000).ToString(),
CountyId = Guid.NewGuid(),
CreateAt = DateTime.Now,
UpdateAt = DateTime.Now,
County = new CountyEntity
{
Id = Guid.NewGuid(),
Name = Faker.Address.UsState(),
CodeIbge = Faker.RandomNumber.Next(1, 10000),
FederalUnitId = Guid.NewGuid(),
FederalUnit = new FederalUnitEntity
{
Id = Guid.NewGuid(),
Name = Faker.Address.UsState(),
Initials = Faker.Address.UsState().Substring(1, 3)
}
}
};
listZipCodeEntity.Add(itemZipCodeEntity);
}
#region Model => Entity
//Model => Entity
var zipCodeEntity = Mapper.Map <ZipCodeEntity>(model);
Assert.Equal(zipCodeEntity.Id, model.Id);
Assert.Equal(zipCodeEntity.PublicPlace, model.PublicPlace);
Assert.Equal(zipCodeEntity.Number, model.Number);
Assert.Equal(zipCodeEntity.CreateAt, model.CreateAt);
Assert.Equal(zipCodeEntity.UpdateAt, model.UpdateAt);
#endregion
#region Entity => Dto
//Entity => Dto
var zipCodeDto = Mapper.Map <ZipCodeDto>(zipCodeEntity);
Assert.Equal(zipCodeDto.Id, zipCodeEntity.Id);
Assert.Equal(zipCodeDto.PublicPlace, zipCodeEntity.PublicPlace);
Assert.Equal(zipCodeDto.Number, zipCodeEntity.Number);
Assert.Equal(zipCodeDto.ZipCode, zipCodeEntity.ZipCode);
#endregion
#region CompleteDto => Entity
// CompleteDto => Entity
var zipCodeCompleteDto = Mapper.Map <ZipCodeDto>(listZipCodeEntity.FirstOrDefault());
Assert.Equal(zipCodeCompleteDto.Id, listZipCodeEntity.FirstOrDefault().Id);
Assert.Equal(zipCodeCompleteDto.PublicPlace, listZipCodeEntity.FirstOrDefault().PublicPlace);
Assert.Equal(zipCodeCompleteDto.Number, listZipCodeEntity.FirstOrDefault().Number);
Assert.NotNull(zipCodeCompleteDto.County);
Assert.NotNull(zipCodeCompleteDto.County.FederalUnitId);
#endregion
#region List ZipCodeDto => List ZipCodeEntity
//List ZipCodeDto => List ZipCodeEntity
var listZipCodeDto = Mapper.Map <List <ZipCodeDto> >(listZipCodeEntity);
Assert.True(listZipCodeDto.Count() == listZipCodeEntity.Count());
for (int i = 0; i < listZipCodeDto.Count(); i++)
{
Assert.Equal(listZipCodeDto[i].Id, listZipCodeEntity[i].Id);
Assert.Equal(listZipCodeDto[i].ZipCode, listZipCodeEntity[i].ZipCode);
Assert.Equal(listZipCodeDto[i].PublicPlace, listZipCodeEntity[i].PublicPlace);
Assert.Equal(listZipCodeDto[i].Number, listZipCodeEntity[i].Number);
}
#endregion
#region ZipCode Entity => ZipCode Create Result Dto
// ZipCode Entity => ZipCode Create Result Dto
var zipCodeCreateResultDto = Mapper.Map <ZipCodeCreateResultDto>(zipCodeEntity);
Assert.Equal(zipCodeCreateResultDto.Id, zipCodeEntity.Id);
Assert.Equal(zipCodeCreateResultDto.ZipCode, zipCodeEntity.ZipCode);
Assert.Equal(zipCodeCreateResultDto.PublicPlace, zipCodeEntity.PublicPlace);
Assert.Equal(zipCodeCreateResultDto.Number, zipCodeEntity.Number);
#endregion
#region ZipCode Entity => ZipCode Update Result Dto
// ZipCode Entity => ZipCode Update Result Dto
var zipCodeUpdateResultDto = Mapper.Map <ZipCodeUpdateResultDto>(zipCodeEntity);
Assert.Equal(zipCodeUpdateResultDto.Id, zipCodeEntity.Id);
Assert.Equal(zipCodeUpdateResultDto.ZipCode, zipCodeEntity.ZipCode);
Assert.Equal(zipCodeUpdateResultDto.PublicPlace, zipCodeEntity.PublicPlace);
Assert.Equal(zipCodeUpdateResultDto.Number, zipCodeEntity.Number);
#endregion
#region Dto => Model
// Dto => Model
zipCodeDto.Number = "";
var zipCodemodel = Mapper.Map <ZipCodeModel>(zipCodeDto);
Assert.Equal(zipCodemodel.Id, zipCodeDto.Id);
Assert.Equal(zipCodemodel.ZipCode, zipCodeDto.ZipCode);
Assert.Equal(zipCodemodel.PublicPlace, zipCodeDto.PublicPlace);
Assert.Equal("S/N", zipCodeDto.Number);
#endregion
#region Model => Create Dto
//Model => Create Dto
var zipCodeCreateDto = Mapper.Map <ZipCodeCreateDto>(model);
Assert.Equal(zipCodeCreateDto.ZipCode, model.ZipCode);
Assert.Equal(zipCodeCreateDto.PublicPlace, model.PublicPlace);
Assert.Equal(zipCodeCreateDto.Number, model.Number);
#endregion
#region Model => Update Dto
//Model => Update Dto
var zipCodeUpdateDto = Mapper.Map <ZipCodeUpdateDto>(model);
Assert.Equal(zipCodeUpdateDto.Id, model.Id);
Assert.Equal(zipCodeUpdateDto.ZipCode, model.ZipCode);
Assert.Equal(zipCodeUpdateDto.PublicPlace, model.PublicPlace);
Assert.Equal(zipCodeUpdateDto.Number, model.Number);
#endregion
}
