public async Task Should_Update_City_When_Requesting_By_Administrator_Client()
{
var cityEntity = await InsertCityEntityAsync(_fixture.AdministratorDbContext);
var updateCityRequest = new UpdateCityRequest
{
Id = cityEntity.Id,
Name = "UpdateCityIntegrationTestNewName",
PolishName = "UpdateCityIntegrationTestNewPolishName",
StateId = cityEntity.StateId
};
var updateCityRequestString = JsonConvert.SerializeObject(updateCityRequest);
var requestContent = new StringContent(updateCityRequestString, Encoding.UTF8, "application/json");
_fixture.AdministratorHttpClient.DefaultRequestHeaders.Add("api-version", "1");
_fixture.AdministratorHttpClient.DefaultRequestHeaders.Add(HeaderNames.IfMatch, $"\"{Convert.ToBase64String(cityEntity.RowVersion)}\"");
var response = await _fixture.AdministratorHttpClient.PutAsync($"api/cities/{cityEntity.Id}", requestContent);
var responseContentString = await response.Content.ReadAsStringAsync();
var expectedResponse = await PrepareExpectedResponseAsync(_fixture.AdministratorDbContext, cityEntity.Id);
response.StatusCode.Should().BeEquivalentTo(HttpStatusCode.OK);
responseContentString.Should().BeEquivalentTo(expectedResponse);
}
public async Task UpdateCityAsync_Should_Return_OkObjectResult_With_CityResponse()
{
var rowVersion = new byte[] { 1, 2, 4, 8, 16, 32, 64 };
var cityId = Guid.NewGuid();
var updateCityRequest = new UpdateCityRequest
{
Id = cityId,
Name = "Name",
PolishName = "PolishName",
StateId = Guid.NewGuid()
};
var updateCityCommand = new UpdateCityCommand(updateCityRequest.Id, rowVersion, updateCityRequest.Name,
updateCityRequest.PolishName, updateCityRequest.StateId);
var cityOutputQuery = new CityOutputQuery(updateCityCommand.CityId, new byte[] { 1, 2, 4, 8, 16, 32, 128 },
updateCityCommand.Name, updateCityCommand.PolishName, updateCityCommand.StateId);
var cityResponse = new CityResponse(cityOutputQuery.Id, cityOutputQuery.RowVersion,
cityOutputQuery.Name, cityOutputQuery.PolishName, cityOutputQuery.StateId);
_mapperMock.Setup(x => x.Map <UpdateCityRequest, UpdateCityCommand>(It.IsAny <UpdateCityRequest>()))
.Returns(updateCityCommand);
_communicationBusMock.Setup(x => x.SendCommandAsync(It.IsAny <UpdateCityCommand>(), It.IsAny <CancellationToken>()))
.Returns(Task.CompletedTask);
_getCityQueryHandlerMock
.Setup(x => x.HandleAsync(It.IsAny <GetCityInputQuery>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(cityOutputQuery);
_mapperMock.Setup(x => x.Map <CityOutputQuery, CityResponse>(It.IsAny <CityOutputQuery>())).Returns(cityResponse);
var result = await _controller.UpdateCityAsync(cityId, updateCityRequest, rowVersion);
var okObjectResult = result.As <OkObjectResult>();
okObjectResult.Value.Should().BeEquivalentTo(cityResponse);
}
public City UpdateCity([FromBody] City city)
{
if (city != null)
{
var business = CityBusiness.Instance;
var request = new UpdateCityRequest(this.Context);
request.City = city;
city = business.UpdateCity(request);
}
return(city);
}
public City UpdateCity(UpdateCityRequest request)
{
City city = null;
if (request != null && request.City != null)
{
var dataAccess = new CityDataAccess(request.Context);
city = dataAccess.Update(request.City);
}
return(city);
}
public async Task <IActionResult> UpdateCityAsync([FromRoute] Guid id, [FromBody] UpdateCityRequest request, [FromHeader(Name = "If-Match")] byte[] rowVersion)
{
ValidatePathIdWithRequestBodyId(id, request.Id);
request.SetRowVersion(rowVersion);
var updateCityCommand = _mapper.Map <UpdateCityRequest, UpdateCityCommand>(request);
await _communicationBus.SendCommandAsync(updateCityCommand);
var getCityOutputQuery = await _getCityQueryHandler.HandleAsync(new GetCityInputQuery(updateCityCommand.CityId));
var cityResponse = _mapper.Map <CityOutputQuery, CityResponse>(getCityOutputQuery);
return(Ok(cityResponse));
}
public async Task <IActionResult> CreateCity([FromBody] UpdateCityRequest city)
{
try
{
var created = await _cityService.CreateCityAsync(city);
return(Ok(new { status = 200, data = created, message = "City was successfully created" }));
}
catch (DuplicateFoundException ex)
{
return(StatusCode(409, new { status = 409, message = ex.Message }));
}
catch (Exception ex)
{
return(StatusCode(500, new { status = 500, message = ex.Message }));
}
}
public async Task Should_Return_Unauthorized_Status_Code_When_Requesting_By_Anonymous_Client()
{
var updateCityRequest = new UpdateCityRequest
{
Id = Guid.NewGuid(),
Name = "UpdateCityIntegrationTestNewName",
PolishName = "UpdateCityIntegrationTestNewPolishName",
StateId = Guid.NewGuid()
};
var updateCityRequestString = JsonConvert.SerializeObject(updateCityRequest);
var requestContent = new StringContent(updateCityRequestString, Encoding.UTF8, "application/json");
_fixture.AnonymousHttpClient.DefaultRequestHeaders.Add("api-version", "1");
var response = await _fixture.AnonymousHttpClient.PutAsync($"api/cities/{updateCityRequest.Id}", requestContent);
response.StatusCode.Should().BeEquivalentTo(HttpStatusCode.Unauthorized);
}
public async Task <IActionResult> UpdateCityById([FromBody] UpdateCityRequest city, int id)
{
try
{
var updated = await _cityService.UpdateCityByIdAsync(id, city);
return(Ok(new { status = 200, data = updated, message = "City was successfully updated" }));
}
catch (IdNotFoundException ex)
{
return(NotFound(new { status = 400, message = ex.Message }));
}
catch (DuplicateFoundException ex)
{
return(Conflict(new { status = 409, message = ex.Message }));
}
catch (Exception ex)
{
return(StatusCode(500, new { status = 500, message = ex.Message }));
}
}
