public async Task <IHttpActionResult> Put(UpdateCityCommand command)
{
var response = await
Bus.Send <UpdateCityCommand, UpdateCityCommandResponse>(command);
return(Ok(response));
}
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 async Task HandleAsync_Should_Throw_ValidationException_When_State_Is_Not_Found()
{
var command = new UpdateCityCommand(Guid.NewGuid(), Array.Empty <byte>(), "NewName", "NewPolishName",
Guid.NewGuid());
var city = City.Builder()
.SetId(command.CityId)
.SetRowVersion(command.RowVersion)
.SetName("Name")
.SetPolishName("PolishName")
.SetStateId(Guid.NewGuid())
.Build();
var getCityResult = GetResult <City> .Ok(city);
var errors = new Collection <IError>
{
new Error(StateErrorCodeEnumeration.NotFound, StateErrorMessage.NotFound)
};
var getStateResult = GetResult <State> .Fail(errors);
_cityGetterServiceMock.Setup(x => x.GetByIdAsync(It.IsAny <Guid>())).ReturnsAsync(getCityResult);
_stateGetterServiceMock.Setup(x => x.GetByIdAsync(It.IsAny <Guid>())).ReturnsAsync(getStateResult);
Func <Task> result = async() => await _commandHandler.HandleAsync(command);
var exceptionResult = await result.Should().ThrowExactlyAsync <ValidationException>();
exceptionResult.And.Errors.Should().BeEquivalentTo(errors);
}
public async Task ShouldUpdateCity()
{
var userId = await RunAsDefaultUserAsync();
var result = await SendAsync(new CreateCityCommand
{
Name = "Kayyysseri"
});
var command = new UpdateCityCommand
{
Id = result.Data.Id,
Name = "Kayseri"
};
await SendAsync(command);
var city = await FindAsync <City>(result.Data.Id);
city.Name.Should().Be(command.Name);
city.Modifier.Should().NotBeNull();
city.Modifier.Should().Be(userId);
city.ModifyDate.Should().NotBeNull();
city.ModifyDate.Should().BeCloseTo(DateTime.Now, 1000);
}
public void Handle(UpdateCityCommand Message)
{
if (Message != null)
{
var city = _mapper.Map <City>(Message);
_repository.Update(city);
}
}
public async Task <ActionResult <Result> > UpdateCity([FromBody] UpdateCityCommand command)
{
var result = await Mediator.Send(command);
if (!result.Succeeded)
{
return(BadRequest(result));
}
return(Ok(result));
}
public async void CityShouldThrowNotFoundException()
{
var updatedCity = new UpdateCityCommand {
Id = GConst.InvalidId, Name = GConst.ValidName
};
var status = await Record.ExceptionAsync(async() => await sut.Handle(updatedCity, CancellationToken.None));
Assert.NotNull(status);
Assert.Equal(string.Format(GConst.NotFoundExceptionMessage, GConst.City, GConst.InvalidId), status.Message);
}
public void ShouldRequireValidCityId()
{
var command = new UpdateCityCommand
{
Id = 99,
Name = "Kayseri"
};
FluentActions.Invoking(() =>
SendAsync(command)).Should().Throw <NotFoundException>();
}
public async Task <ActionResult> Update(int id, UpdateCityCommand command)
{
if (id != command.Id)
{
return(BadRequest());
}
await Mediator.Send(command);
return(NoContent());
}
public async void CityShouldUpdateCorrect()
{
var updatedCity = new UpdateCityCommand {
Id = cityId, Name = GConst.ValidName, CountryId = countryId
};
var status = Task <Unit> .FromResult(await sut.Handle(updatedCity, CancellationToken.None));
var resultId = context.Cities.SingleOrDefault(x => x.Name == GConst.ValidName).Id;
Assert.Equal(cityId, resultId);
Assert.Equal(GConst.SuccessStatus, status.Status.ToString());
Assert.Equal(GConst.ValidCount, context.Cities.Count());
}
public City Update(UpdateCityCommand command)
{
var city = _repository.Get(command.Id);
city.Update(command.Title, command.IsActved);
_repository.Update(city);
if (Commit())
{
return(city);
}
return(null);
}
public async Task ShouldRequireValidCityId()
{
var command = new UpdateCityCommand
{
Id = 99,
Name = "Kayseri"
};
var result = await SendAsync(command);
result.Should().NotBeNull();
result.Succeeded.Should().BeFalse();
result.Error.Should().Be(ServiceError.NotFount);
}
public async Task HandleAsync_Should_Throw_ConflictException_When_Name_And_PolishName_Are_Already_Used()
{
var command = new UpdateCityCommand(Guid.NewGuid(), Array.Empty <byte>(), "NewName", "NewPolishName",
Guid.NewGuid());
var city = City.Builder()
.SetId(command.CityId)
.SetRowVersion(command.RowVersion)
.SetName("Name")
.SetPolishName("PolishName")
.SetStateId(Guid.NewGuid())
.Build();
var getCityResult = GetResult <City> .Ok(city);
var state = State.Builder()
.SetId(command.StateId)
.SetRowVersion(Array.Empty <byte>())
.SetName("Name")
.SetPolishName("PolishName")
.Build();
var getStateResult = GetResult <State> .Ok(state);
var duplicateNameError = new Error(CityErrorCodeEnumeration.NameAlreadyInUse, CityErrorMessage.NameAlreadyInUse);
var duplicatePolishNameError = new Error(CityErrorCodeEnumeration.PolishNameAlreadyInUse, CityErrorMessage.PolishNameAlreadyInUse);
var nameIsNotTakenVerificationResult = VerificationResult.Fail(new Collection <IError> {
duplicateNameError
});
var polishNameIsNotTakenVerificationResult = VerificationResult.Fail(new Collection <IError> {
duplicatePolishNameError
});
var errors = new Collection <IError> {
duplicateNameError, duplicatePolishNameError
};
_cityGetterServiceMock.Setup(x => x.GetByIdAsync(It.IsAny <Guid>())).ReturnsAsync(getCityResult);
_stateGetterServiceMock.Setup(x => x.GetByIdAsync(It.IsAny <Guid>())).ReturnsAsync(getStateResult);
_cityVerificationServiceMock.Setup(x => x.VerifyNameIsNotTakenAsync(It.IsAny <string>(), It.IsAny <Guid>()))
.ReturnsAsync(nameIsNotTakenVerificationResult);
_cityVerificationServiceMock.Setup(x => x.VerifyPolishNameIsNotTakenAsync(It.IsAny <string>(), It.IsAny <Guid>()))
.ReturnsAsync(polishNameIsNotTakenVerificationResult);
Func <Task> result = async() => await _commandHandler.HandleAsync(command);
var exceptionResult = await result.Should().ThrowExactlyAsync <ConflictException>();
exceptionResult.And.Errors.Should().BeEquivalentTo(errors);
}
public async Task HandleAsync_Should_Throw_ResourceNotFoundException_When_City_Is_Not_Found()
{
var command = new UpdateCityCommand(Guid.NewGuid(), Array.Empty <byte>(), "NewName", "NewPolishName",
Guid.NewGuid());
var errors = new Collection <IError>
{
new Error(CityErrorCodeEnumeration.NotFound, CityErrorMessage.NotFound)
};
var getCityResult = GetResult <City> .Fail(errors);
_cityGetterServiceMock.Setup(x => x.GetByIdAsync(It.IsAny <Guid>())).ReturnsAsync(getCityResult);
Func <Task> result = async() => await _commandHandler.HandleAsync(command);
var exceptionResult = await result.Should().ThrowExactlyAsync <ResourceNotFoundException>();
exceptionResult.And.Errors.Should().BeEquivalentTo(errors);
}
public async Task HandleAsync_Should_Throw_PreconditionFailedException_When_RowVersion_Is_Incorrect()
{
var command = new UpdateCityCommand(Guid.NewGuid(), new byte[] { 1, 2, 4, 8, 16, 32, 64 }, "NewName",
"NewPolishName", Guid.NewGuid());
var city = City.Builder()
.SetId(command.CityId)
.SetRowVersion(new byte[] { 1, 2, 4, 8, 16, 32, 128 })
.SetName("Name")
.SetPolishName("PolishName")
.SetStateId(Guid.NewGuid())
.Build();
var getCityResult = GetResult <City> .Ok(city);
_cityGetterServiceMock.Setup(x => x.GetByIdAsync(It.IsAny <Guid>())).ReturnsAsync(getCityResult);
Func <Task> result = async() => await _commandHandler.HandleAsync(command);
await result.Should().ThrowExactlyAsync <PreconditionFailedException>();
}
public async Task <UpdateCityCommandResponse> Handle(UpdateCityCommand command)
{
var isExist = await _cityRepository.AsQuery()
.AnyAsync(item => item.Code == command.Code && item.Id != command.Id);
if (isExist)
{
throw new DomainException("شهر با این کد قبلا ثبت شده است");
}
var city = await _cityRepository.AsQuery().SingleOrDefaultAsync(p => p.Id == command.Id);
if (city == null)
{
throw new DomainException("شهر یافت نشد");
}
city.CityName = command.CityName;
city.Code = command.Code;
return(new UpdateCityCommandResponse());
}
public async Task HandleAsync_Should_Update_City()
{
var command = new UpdateCityCommand(Guid.NewGuid(), Array.Empty <byte>(), "NewName", "NewPolishName",
Guid.NewGuid());
var city = City.Builder()
.SetId(command.CityId)
.SetRowVersion(command.RowVersion)
.SetName("Name")
.SetPolishName("PolishName")
.SetStateId(Guid.NewGuid())
.Build();
var getCityResult = GetResult <City> .Ok(city);
var state = State.Builder()
.SetId(command.StateId)
.SetRowVersion(Array.Empty <byte>())
.SetName("Name")
.SetPolishName("PolishName")
.Build();
var getStateResult = GetResult <State> .Ok(state);
var nameIsNotTakenVerificationResult = VerificationResult.Ok();
var polishNameIsNotTakenVerificationResult = VerificationResult.Ok();
_cityGetterServiceMock.Setup(x => x.GetByIdAsync(It.IsAny <Guid>())).ReturnsAsync(getCityResult);
_stateGetterServiceMock.Setup(x => x.GetByIdAsync(It.IsAny <Guid>())).ReturnsAsync(getStateResult);
_cityVerificationServiceMock.Setup(x => x.VerifyNameIsNotTakenAsync(It.IsAny <string>(), It.IsAny <Guid>()))
.ReturnsAsync(nameIsNotTakenVerificationResult);
_cityVerificationServiceMock.Setup(x => x.VerifyPolishNameIsNotTakenAsync(It.IsAny <string>(), It.IsAny <Guid>()))
.ReturnsAsync(polishNameIsNotTakenVerificationResult);
_cityRepositoryMock.Setup(x => x.UpdateAsync(It.IsAny <City>())).Returns(Task.CompletedTask).Verifiable();
Func <Task> result = async() => await _commandHandler.HandleAsync(command);
await result.Should().NotThrowAsync <Exception>();
_cityRepositoryMock.Verify(x =>
x.UpdateAsync(It.Is <City>(s =>
s.Name.Equals(command.Name) && s.PolishName.Equals(command.PolishName) && s.StateId.Equals(command.StateId))));
}
public async Task ShouldRequireUniqueName()
{
var city = await SendAsync(new CreateCityCommand
{
Name = "Malatya"
});
await SendAsync(new CreateCityCommand
{
Name = "Denizli"
});
var command = new UpdateCityCommand
{
Id = city.Data.Id,
Name = "Denizli"
};
FluentActions.Invoking(() =>
SendAsync(command))
.Should().Throw <ValidationException>().Where(ex => ex.Errors.ContainsKey("Name"))
.And.Errors["Name"].Should().Contain("The specified city already exists. If you just want to activate the city leave the name field blank!");
}
public async Task ShouldRequireUniqueName()
{
var city = await SendAsync(new CreateCityCommand
{
Name = "Malatya"
});
await SendAsync(new CreateCityCommand
{
Name = "Denizli"
});
var command = new UpdateCityCommand
{
Id = city.Data.Id,
Name = "Denizli"
};
var result = await SendAsync(command);
result.Should().NotBeNull();
result.Succeeded.Should().BeFalse();
result.Error.Should().Be(ServiceError.NotFount);
}
public async Task <ActionResult> Update([FromForm] UpdateCityCommand command)
{
await Mediator.Send(command);
return(NoContent());
}
public UpdateCityCommandValidatorTests()
{
this.updateValidator = new UpdateCityCommandValidator();
this.updateCommand = new UpdateCityCommand();
}
public async Task <ActionResult <Unit> > Update(int id, UpdateCityCommand command)
{
command.Id = id;
return(await Mediator.Send(command));
}
public async Task <IActionResult> UpdateCity([FromBody] UpdateCityCommand command)
{
var result = await Mediator.Send(command);
return(Ok(new { result }));
}
public async Task <ActionResult <ServiceResult <CityDto> > > Update(UpdateCityCommand command)
{
return(Ok(await Mediator.Send(command)));
}
