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))); }