public async Task It_Is_Possible_To_Invoke_The_Controller_Create()
{
var serviceMock = new Mock <IAddressService>();
serviceMock.Setup(s => s.Post(It.IsAny <AddressDtoCreate>())).ReturnsAsync(
new AddressDtoCreateResult
{
Id = Guid.NewGuid(),
Street = "Rua Morom",
CreatedAt = DateTime.Now
});
_controller = new AddressesController(serviceMock.Object);
_controller.ModelState.AddModelError("Street", "Logradouro é obrigatório.");
Mock <IUrlHelper> url = new Mock <IUrlHelper>();
url.Setup(s => s.Link(It.IsAny <string>(), It.IsAny <object>())).Returns("http://localhost:5000");
_controller.Url = url.Object;
var addressDtoCreate = new AddressDtoCreate
{
Street = "Rua Morom"
};
var result = await _controller.Post(addressDtoCreate);
Assert.True(result is BadRequestObjectResult);
}
public async Task It_Is_Possible_To_Invoke_The_Controller_Create()
{
var serviceMock = new Mock <IAddressService>();
serviceMock.Setup(s => s.Post(It.IsAny <AddressDtoCreate>())).ReturnsAsync(
new AddressDtoCreateResult
{
Id = Guid.NewGuid(),
Street = "Rua Morom",
CreatedAt = DateTime.Now
});
_controller = new AddressesController(serviceMock.Object);
Mock <IUrlHelper> url = new Mock <IUrlHelper>();
url.Setup(s => s.Link(It.IsAny <string>(), It.IsAny <object>())).Returns("http://localhost:5000");
_controller.Url = url.Object;
var addressDtoCreate = new AddressDtoCreate
{
Street = "Rua Morom"
};
var result = await _controller.Post(addressDtoCreate);
Assert.True(result is CreatedResult);
var resultValue = ((CreatedResult)result).Value as AddressDtoCreateResult;
Assert.NotNull(resultValue);
Assert.Equal(addressDtoCreate.Street, resultValue.Street);
}
public async Task <ActionResult> Post([FromBody] AddressDtoCreate address)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
try
{
var result = await _service.Post(address);
if (result != null)
{
return(Created(new Uri(Url.Link("GetAddressWithId", new { id = result.Id })), result));
}
else
{
return(BadRequest());
}
}
catch (ArgumentException e)
{
return(StatusCode((int)HttpStatusCode.InternalServerError, e.Message));
}
}
public async Task <AddressDtoCreateResult> Post(AddressDtoCreate address)
{
var model = _mapper.Map <AddressModel>(address);
var entity = _mapper.Map <AddressEntity>(model);
var result = await _repository.InsertAsync(entity);
return(_mapper.Map <AddressDtoCreateResult>(result));
}
public AddressTests()
{
CityId = Guid.NewGuid();
AddressId = Guid.NewGuid();
AddressZipCode = Faker.RandomNumber.Next(10000, 99999).ToString();
AddressNumber = Faker.RandomNumber.Next(1, 1000).ToString();
AddressStreet = Faker.Address.StreetName();
AddressZipCodeUpdated = Faker.RandomNumber.Next(10000, 99999).ToString();
AddressNumberUpdated = Faker.RandomNumber.Next(1, 1000).ToString();
AddressStreetUpdated = Faker.Address.StreetName();
for (int i = 0; i < 10; i++)
{
addressDtos.Add(new AddressDto()
{
Id = Guid.NewGuid(),
ZipCode = Faker.RandomNumber.Next(10000, 99999).ToString(),
Street = Faker.Address.StreetName(),
Number = Faker.RandomNumber.Next(1, 1000).ToString(),
CityId = Guid.NewGuid(),
City = new CityDtoComplete
{
Id = CityId,
Name = Faker.Address.City(),
IBGECode = Faker.RandomNumber.Next(1, 10000),
StateId = Guid.NewGuid(),
State = new StateDto
{
Id = Guid.NewGuid(),
Name = Faker.Address.UsState(),
ShortName = Faker.Address.UsStateAbbr()
}
}
});
}
addressDto = new AddressDto
{
Id = AddressId,
ZipCode = AddressZipCode,
Street = AddressStreet,
Number = AddressNumber,
CityId = CityId,
City = new CityDtoComplete
{
Id = CityId,
Name = Faker.Address.City(),
IBGECode = Faker.RandomNumber.Next(1, 10000),
StateId = Guid.NewGuid(),
State = new StateDto
{
Id = Guid.NewGuid(),
Name = Faker.Address.UsState(),
ShortName = Faker.Address.UsStateAbbr()
}
}
};
addressDtoCreate = new AddressDtoCreate
{
ZipCode = AddressZipCode,
Street = AddressStreet,
Number = AddressNumber,
CityId = CityId
};
addressDtoCreateResult = new AddressDtoCreateResult
{
Id = AddressId,
ZipCode = AddressZipCode,
Street = AddressStreet,
Number = AddressNumber,
CityId = CityId,
CreatedAt = DateTime.Now
};
addressDtoUpdate = new AddressDtoUpdate
{
Id = AddressId,
ZipCode = AddressZipCodeUpdated,
Street = AddressStreetUpdated,
Number = AddressNumberUpdated,
CityId = CityId,
};
addressDtoUpdateResult = new AddressDtoUpdateResult
{
Id = CityId,
ZipCode = AddressZipCodeUpdated,
Street = AddressStreetUpdated,
Number = AddressNumberUpdated,
CityId = CityId,
UpdatedAt = DateTime.Now
};
}
public async Task It_Is_Possible_To_Run_Address_Crud()
{
await AddToken();
var cityDtoCreate = new CityDtoCreate
{
Name = "Passo Fundo",
IBGECode = 4314100,
StateId = new Guid("88970a32-3a2a-4a95-8a18-2087b65f59d1")
};
// Post City
var response = await PostJsonAsync(cityDtoCreate, $"{HostApi}/cities", Client);
var responseString = await response.Content.ReadAsStringAsync();
var cityDtoCreateResult = JsonConvert.DeserializeObject <CityDtoCreateResult>(responseString);
Assert.Equal(HttpStatusCode.Created, response.StatusCode);
Assert.Equal("Passo Fundo", cityDtoCreateResult.Name);
Assert.Equal(4314100, cityDtoCreateResult.IBGECode);
Assert.False(cityDtoCreateResult.Id == default);
var addressDtoCreate = new AddressDtoCreate
{
Street = "Rua Morom",
ZipCode = "99.010-030",
Number = "930",
CityId = cityDtoCreateResult.Id
};
// Post
response = await PostJsonAsync(addressDtoCreate, $"{HostApi}/addresses", Client);
responseString = await response.Content.ReadAsStringAsync();
var addressDtoCreateResult = JsonConvert.DeserializeObject <AddressDtoCreateResult>(responseString);
Assert.Equal(HttpStatusCode.Created, response.StatusCode);
Assert.Equal("Rua Morom", addressDtoCreateResult.Street);
Assert.Equal("99.010-030", addressDtoCreateResult.ZipCode);
Assert.Equal("930", addressDtoCreateResult.Number);
Assert.False(addressDtoCreateResult.Id == default);
// Put
var addressDtoUpdate = new AddressDtoUpdate
{
Id = addressDtoCreateResult.Id,
Street = "Rua Dez de Abril",
ZipCode = "99.010-210",
Number = "403",
CityId = cityDtoCreateResult.Id
};
var content = new StringContent(JsonConvert.SerializeObject(addressDtoUpdate), Encoding.UTF8, "application/json");
response = await Client.PutAsync($"{HostApi}/addresses", content);
responseString = await response.Content.ReadAsStringAsync();
var addressDtoUpdateResult = JsonConvert.DeserializeObject <AddressDtoUpdateResult>(responseString);
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
Assert.Equal(addressDtoCreateResult.Id, addressDtoUpdateResult.Id);
Assert.NotEqual(addressDtoCreateResult.Street, addressDtoUpdateResult.Street);
Assert.NotEqual(addressDtoCreateResult.ZipCode, addressDtoUpdateResult.ZipCode);
Assert.NotEqual(addressDtoCreateResult.Number, addressDtoUpdateResult.Number);
Assert.Equal(addressDtoUpdate.Id, addressDtoUpdateResult.Id);
Assert.Equal(addressDtoUpdate.Street, addressDtoUpdateResult.Street);
Assert.Equal(addressDtoUpdate.ZipCode, addressDtoUpdateResult.ZipCode);
Assert.Equal(addressDtoUpdate.Number, addressDtoUpdateResult.Number);
// Get
response = await Client.GetAsync($"{HostApi}/addresses/{addressDtoUpdateResult.Id}");
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
responseString = await response.Content.ReadAsStringAsync();
var addressDto = JsonConvert.DeserializeObject <AddressDto>(responseString);
Assert.NotNull(addressDto);
Assert.Equal(addressDtoUpdateResult.Street, addressDto.Street);
Assert.Equal(addressDtoUpdateResult.ZipCode, addressDto.ZipCode);
Assert.Equal(addressDtoUpdateResult.Number, addressDto.Number);
// GetByZipCode
response = await Client.GetAsync($"{HostApi}/addresses/byZipCode/{addressDtoUpdateResult.ZipCode}");
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
responseString = await response.Content.ReadAsStringAsync();
addressDto = JsonConvert.DeserializeObject <AddressDto>(responseString);
Assert.NotNull(addressDto);
Assert.Equal(addressDtoUpdateResult.Street, addressDto.Street);
Assert.Equal(addressDtoUpdateResult.ZipCode, addressDto.ZipCode);
Assert.Equal(addressDtoUpdateResult.Number, addressDto.Number);
// Delete
response = await Client.DeleteAsync($"{HostApi}/addresses/{addressDto.Id}");
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
// Get after Delete
response = await Client.GetAsync($"{HostApi}/addresses/{addressDto.Id}");
Assert.Equal(HttpStatusCode.NotFound, response.StatusCode);
}
