public async Task It_Is_Possible_To_Invoke_The_Controller_Create()
{
var serviceMock = new Mock <ICityService>();
serviceMock.Setup(s => s.Post(It.IsAny <CityDtoCreate>())).ReturnsAsync(
new CityDtoCreateResult
{
Id = Guid.NewGuid(),
Name = "Passo Fundo",
CreatedAt = DateTime.Now
});
_controller = new CitiesController(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 cityDtoCreate = new CityDtoCreate
{
Name = "Passo Fundo"
};
var result = await _controller.Post(cityDtoCreate);
Assert.True(result is CreatedResult);
var resultValue = ((CreatedResult)result).Value as CityDtoCreateResult;
Assert.NotNull(resultValue);
Assert.Equal(cityDtoCreate.Name, resultValue.Name);
}
public async Task It_Is_Possible_To_Invoke_The_Controller_Create()
{
var serviceMock = new Mock <ICityService>();
serviceMock.Setup(s => s.Post(It.IsAny <CityDtoCreate>())).ReturnsAsync(
new CityDtoCreateResult
{
Id = Guid.NewGuid(),
Name = "Passo Fundo",
CreatedAt = DateTime.Now
});
_controller = new CitiesController(serviceMock.Object);
_controller.ModelState.AddModelError("Name", "Nome é 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 cityDtoCreate = new CityDtoCreate
{
Name = "Passo Fundo",
IBGECode = 1
};
var result = await _controller.Post(cityDtoCreate);
Assert.True(result is BadRequestObjectResult);
}
public async Task <ActionResult> Post([FromBody] CityDtoCreate city)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
try
{
var result = await _service.Post(city);
if (result != null)
{
return(Created(new Uri(Url.Link("GetCityWithId", new { id = result.Id })), result));
}
else
{
return(BadRequest());
}
}
catch (ArgumentException e)
{
return(StatusCode((int)HttpStatusCode.InternalServerError, e.Message));
}
}
public async Task <CityDtoCreateResult> Post(CityDtoCreate city)
{
var model = _mapper.Map <CityModel>(city);
var entity = _mapper.Map <CityEntity>(model);
var result = await _repository.InsertAsync(entity);
return(_mapper.Map <CityDtoCreateResult>(result));
}
public async Task It_Is_Possible_To_Run_City_Crud()
{
await AddToken();
var cityDtoCreate = new CityDtoCreate
{
Name = "Passo Fundo",
IBGECode = 4314100,
StateId = new Guid("88970a32-3a2a-4a95-8a18-2087b65f59d1")
};
// Post
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);
// Get All
response = await Client.GetAsync($"{HostApi}/cities");
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
responseString = await response.Content.ReadAsStringAsync();
var cityDtos = JsonConvert.DeserializeObject <IEnumerable <CityDto> >(responseString);
Assert.NotNull(cityDtos);
Assert.True(cityDtos.Count() > 0);
Assert.True(cityDtos.Where(x => x.Id == cityDtoCreateResult.Id).Count() == 1);
// Put
var cityDtoUpdate = new CityDtoUpdate
{
Id = cityDtoCreateResult.Id,
Name = "Paraí",
IBGECode = 4314001,
StateId = new Guid("88970a32-3a2a-4a95-8a18-2087b65f59d1")
};
var content = new StringContent(JsonConvert.SerializeObject(cityDtoUpdate), Encoding.UTF8, "application/json");
response = await Client.PutAsync($"{HostApi}/cities", content);
responseString = await response.Content.ReadAsStringAsync();
var cityDtoUpdateResult = JsonConvert.DeserializeObject <CityDtoUpdateResult>(responseString);
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
Assert.Equal(cityDtoCreateResult.Id, cityDtoUpdateResult.Id);
Assert.NotEqual(cityDtoCreateResult.Name, cityDtoUpdateResult.Name);
Assert.NotEqual(cityDtoCreateResult.IBGECode, cityDtoUpdateResult.IBGECode);
Assert.Equal(cityDtoUpdate.Id, cityDtoUpdateResult.Id);
Assert.Equal(cityDtoUpdate.Name, cityDtoUpdateResult.Name);
Assert.Equal(cityDtoUpdate.IBGECode, cityDtoUpdateResult.IBGECode);
// Get
response = await Client.GetAsync($"{HostApi}/cities/{cityDtoUpdateResult.Id}");
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
responseString = await response.Content.ReadAsStringAsync();
var cityDto = JsonConvert.DeserializeObject <CityDto>(responseString);
Assert.NotNull(cityDto);
Assert.Equal(cityDtoUpdateResult.Name, cityDto.Name);
Assert.Equal(cityDtoUpdateResult.IBGECode, cityDto.IBGECode);
// GetCompleteById
response = await Client.GetAsync($"{HostApi}/cities/completeById/{cityDtoUpdateResult.Id}");
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
responseString = await response.Content.ReadAsStringAsync();
var cityDtoComplete = JsonConvert.DeserializeObject <CityDtoComplete>(responseString);
Assert.NotNull(cityDtoComplete);
Assert.Equal(cityDtoUpdateResult.Name, cityDtoComplete.Name);
Assert.Equal(cityDtoUpdateResult.IBGECode, cityDtoComplete.IBGECode);
Assert.NotNull(cityDtoComplete.State);
Assert.Equal("Rio Grande do Sul", cityDtoComplete.State.Name);
Assert.Equal("RS", cityDtoComplete.State.ShortName);
// GetCompleteByIBGECode
response = await Client.GetAsync($"{HostApi}/cities/completeByIBGECode/{cityDtoUpdateResult.IBGECode}");
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
responseString = await response.Content.ReadAsStringAsync();
cityDtoComplete = JsonConvert.DeserializeObject <CityDtoComplete>(responseString);
Assert.NotNull(cityDtoComplete);
Assert.Equal(cityDtoUpdateResult.Name, cityDtoComplete.Name);
Assert.Equal(cityDtoUpdateResult.IBGECode, cityDtoComplete.IBGECode);
Assert.NotNull(cityDtoComplete.State);
Assert.Equal("Rio Grande do Sul", cityDtoComplete.State.Name);
Assert.Equal("RS", cityDtoComplete.State.ShortName);
// Delete
response = await Client.DeleteAsync($"{HostApi}/cities/{cityDto.Id}");
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
// Get after Delete
response = await Client.GetAsync($"{HostApi}/cities/{cityDto.Id}");
Assert.Equal(HttpStatusCode.NotFound, response.StatusCode);
}
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);
}
public CityTests()
{
CityId = Guid.NewGuid();
CityName = Faker.Address.StreetName();
CityIBGECode = Faker.RandomNumber.Next(1, 10000);
CityNameUpdated = Faker.Address.StreetName();
CityIBGECodeUpdated = Faker.RandomNumber.Next(1, 10000);
StateId = Guid.NewGuid();
for (int i = 0; i < 10; i++)
{
cityDtos.Add(new CityDto
{
Id = Guid.NewGuid(),
Name = Faker.Name.FullName(),
IBGECode = Faker.RandomNumber.Next(1, 10000),
StateId = Guid.NewGuid()
});
}
cityDto = new CityDto
{
Id = CityId,
Name = CityName,
IBGECode = CityIBGECode,
StateId = StateId
};
cityDtoComplete = new CityDtoComplete
{
Id = CityId,
Name = CityName,
IBGECode = CityIBGECode,
StateId = StateId,
State = new StateDto
{
Id = Guid.NewGuid(),
Name = Faker.Address.UsState(),
ShortName = Faker.Address.UsStateAbbr()
}
};
cityDtoCreate = new CityDtoCreate
{
Name = CityName,
IBGECode = CityIBGECode,
StateId = StateId
};
cityDtoCreateResult = new CityDtoCreateResult
{
Id = CityId,
Name = CityName,
IBGECode = CityIBGECode,
StateId = StateId,
CreatedAt = DateTime.Now
};
cityDtoUpdate = new CityDtoUpdate
{
Id = CityId,
Name = CityNameUpdated,
IBGECode = CityIBGECodeUpdated,
StateId = StateId
};
cityDtoUpdateResult = new CityDtoUpdateResult
{
Id = CityId,
Name = CityNameUpdated,
IBGECode = CityIBGECodeUpdated,
StateId = StateId,
UpdatedAt = DateTime.UtcNow
};
}
