public async Task HandleAsync_Should_Delete_RoomForRentAnnouncement() { var roomForRentAnnouncement = RoomForRentAnnouncement.Builder() .SetId(Guid.NewGuid()) .SetTitle("Title") .SetSourceUrl("http://source") .SetCityId(Guid.NewGuid()) .SetCreated(DateTimeOffset.UtcNow) .SetDescription("Description") .SetPrice(1000) .SetCityDistricts(new List <Guid> { Guid.NewGuid() }) .SetRoomTypes(new List <RoomTypeEnumeration> { RoomTypeEnumeration.Double }) .Build(); var getRoomForRentAnnouncementResult = GetResult <RoomForRentAnnouncement> .Ok(roomForRentAnnouncement); var deleteRoomForRentAnnouncementCommand = new DeleteRoomForRentAnnouncementCommand(roomForRentAnnouncement.Id); _roomForRentAnnouncementGetterServiceMock.Setup(x => x.GetByIdAsync(It.IsAny <Guid>())) .ReturnsAsync(getRoomForRentAnnouncementResult); _roomForRentAnnouncementRepositoryMock.Setup(x => x.DeleteAsync(It.IsAny <RoomForRentAnnouncement>())) .Returns(Task.CompletedTask); Func <Task> result = async() => await _commandHandler.HandleAsync(deleteRoomForRentAnnouncementCommand); await result.Should().NotThrowAsync <Exception>(); }
public async Task HandleAsync_Should_Throw_ConflictException_When_Only_PolishName_Is_Already_Used() { var state = State.Builder() .SetId(Guid.NewGuid()) .SetRowVersion(Array.Empty <byte>()) .SetName("Name") .SetPolishName("PolishName") .Build(); var getStateResult = GetResult <State> .Ok(state); var command = new CreateCityCommand(Guid.NewGuid(), "Name", "PolishName", Guid.NewGuid()); var duplicatePolishNameError = new Error(CityErrorCodeEnumeration.PolishNameAlreadyInUse, CityErrorMessage.PolishNameAlreadyInUse); var nameIsNotTakenVerificationResult = VerificationResult.Ok(); var polishNameIsNotTakenVerificationResult = VerificationResult.Fail(new Collection <IError> { duplicatePolishNameError }); var errors = new Collection <IError> { duplicatePolishNameError }; _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_Create_City() { var state = State.Builder() .SetId(Guid.NewGuid()) .SetRowVersion(Array.Empty <byte>()) .SetName("Name") .SetPolishName("PolishName") .Build(); var command = new CreateCityCommand(Guid.NewGuid(), "Name", "PolishName", state.Id); var city = City.Builder() .SetId(command.CityId) .SetRowVersion(Array.Empty <byte>()) .SetName(command.Name) .SetPolishName(command.PolishName) .SetStateId(command.StateId) .Build(); var getStateResult = GetResult <State> .Ok(state); var nameIsNotTakenVerificationResult = VerificationResult.Ok(); var polishNameIsNotTakenVerificationResult = VerificationResult.Ok(); _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); _mapperMock.Setup(x => x.Map <CreateCityCommand, City>(It.IsAny <CreateCityCommand>())).Returns(city); _cityRepositoryMock.Setup(x => x.AddAsync(It.IsAny <City>())).Returns(Task.CompletedTask); Func <Task> result = async() => await _commandHandler.HandleAsync(command); await result.Should().NotThrowAsync <Exception>(); }
public void GetByByUserAndId_Should_Return_GetResult_Ok_With_FlatForRentAnnouncementPreference() { var id = Guid.NewGuid(); var flatForRentAnnouncementPreference = FlatForRentAnnouncementPreference.Builder() .SetId(id) .SetCityId(Guid.NewGuid()) .SetPriceMin(0) .SetPriceMax(3000) .SetRoomNumbersMin(1) .SetRoomNumbersMax(3) .SetCityDistricts(new List <Guid> { Guid.NewGuid() }) .Build(); var flatForRentAnnouncementPreferences = new List <FlatForRentAnnouncementPreference> { flatForRentAnnouncementPreference }; var user = User.Builder() .SetId(Guid.NewGuid()) .SetEmail("*****@*****.**") .SetServiceActive(DefaultUserSettings.ServiceActive) .SetAnnouncementPreferenceLimit(DefaultUserSettings.AnnouncementPreferenceLimit) .SetAnnouncementSendingFrequency(DefaultUserSettings.AnnouncementSendingFrequency) .SetFlatForRentAnnouncementPreferences(flatForRentAnnouncementPreferences) .Build(); var expectedResult = GetResult <FlatForRentAnnouncementPreference> .Ok(flatForRentAnnouncementPreference); var result = _service.GetByByUserAndId(user, id); result.Should().BeEquivalentTo(expectedResult); }
public async Task HandleAsync_Should_Update_State() { var command = new UpdateStateCommand(Guid.NewGuid(), Array.Empty <byte>(), "NewName", "NewPolishName"); var state = State.Builder() .SetId(Guid.NewGuid()) .SetRowVersion(command.RowVersion) .SetName("Name") .SetPolishName("PolishName") .Build(); var getStateResult = GetResult <State> .Ok(state); var nameIsNotTakenVerificationResult = VerificationResult.Ok(); var polishNameIsNotTakenVerificationResult = VerificationResult.Ok(); _stateGetterServiceMock.Setup(x => x.GetByIdAsync(It.IsAny <Guid>())) .ReturnsAsync(getStateResult); _stateVerificationServiceMock.Setup(x => x.VerifyNameIsNotTakenAsync(It.IsAny <string>())) .ReturnsAsync(nameIsNotTakenVerificationResult); _stateVerificationServiceMock.Setup(x => x.VerifyPolishNameIsNotTakenAsync(It.IsAny <string>())) .ReturnsAsync(polishNameIsNotTakenVerificationResult); _stateRepositoryMock.Setup(x => x.UpdateAsync(It.IsAny <State>())).Returns(Task.CompletedTask).Verifiable(); Func <Task> result = async() => await _commandHandler.HandleAsync(command); await result.Should().NotThrowAsync <Exception>(); _stateRepositoryMock.Verify(x => x.UpdateAsync(It.Is <State>(s => s.Name.Equals(state.Name) && s.PolishName.Equals(state.PolishName)))); }
public async Task HandleAsync_Should_Delete_Account() { var deleteAccountCommand = new DeleteAccountCommand(Guid.NewGuid()); var account = Account.Builder() .SetId(deleteAccountCommand.AccountId) .SetEmail("*****@*****.**") .SetConfirmed(true) .SetPasswordHash("PasswordHash") .SetSecurityStamp(Guid.NewGuid()) .SetCreated(DateTimeOffset.UtcNow) .SetRoles(new List <Guid> { Guid.NewGuid() }) .Build(); var getAccountResult = GetResult <Account> .Ok(account); var cancellationToken = new CancellationToken(); _accountGetterServiceMock.Setup(x => x.GetByIdAsync(It.IsAny <Guid>())).ReturnsAsync(getAccountResult); _communicationBusMock.Setup(x => x.DispatchDomainEventsAsync(It.IsAny <Account>(), It.IsAny <CancellationToken>())) .Returns(Task.CompletedTask); _accountDataConsistencyServiceMock.Setup(x => x.DeleteAccountWithRelatedPersistedGrants(It.IsAny <Account>())).Returns(Task.CompletedTask); _integrationEventBusMock.Setup(x => x.PublishIntegrationEventAsync(It.IsAny <IIntegrationEvent>())).Returns(Task.CompletedTask).Verifiable(); Func <Task> result = async() => await _commandHandler.HandleAsync(deleteAccountCommand, cancellationToken); await result.Should().NotThrowAsync <Exception>(); _communicationBusMock.Verify( x => x.DispatchDomainEventsAsync(It.Is <Account>(a => a == account), It.Is <CancellationToken>(ct => ct == cancellationToken)), Times.Once); _integrationEventBusMock .Verify(x => x.PublishIntegrationEventAsync(It.Is <IIntegrationEvent>(ie => ie.CorrelationId == deleteAccountCommand.CorrelationId))); }
public async Task IsActiveAsync_Should_Set_IsActive_To_True_When_Identity_Is_Not_Set() { var account = Account.Builder() .SetId(Guid.NewGuid()) .SetEmail("*****@*****.**") .SetConfirmed(true) .SetPasswordHash("PasswordHash") .SetSecurityStamp(Guid.NewGuid()) .SetCreated(DateTimeOffset.UtcNow) .SetRoles(new List <Guid> { Guid.NewGuid() }) .Build(); var getAccountResult = GetResult <Account> .Ok(account); var claims = new List <Claim> { new Claim(JwtClaimTypes.Email, account.Email) }; var claimsIdentities = new List <ClaimsIdentity> { new ClaimsIdentity(claims) }; var cp = new ClaimsPrincipal(claimsIdentities); var context = new IsActiveContext(cp, new Client(), "caller"); _accountGetterServiceMock.Setup(x => x.GetByEmailAsync(It.IsAny <string>())) .ReturnsAsync(getAccountResult); Func <Task> result = async() => await _profileService.IsActiveAsync(context); await result.Should().NotThrowAsync <Exception>(); context.IsActive.Should().BeTrue(); }
public async Task HandleAsync_Should_Update_User_When_Picture_Is_Not_Null() { var pictureDto = new PictureDto(Array.Empty <byte>(), "image/jpg"); var command = new UpdateUserCommand(Guid.NewGuid(), DefaultUserSettings.ServiceActive, DefaultUserSettings.AnnouncementPreferenceLimit, DefaultUserSettings.AnnouncementSendingFrequency, pictureDto); var user = User.Builder() .SetId(command.UserId) .SetEmail("*****@*****.**") .SetServiceActive(command.ServiceActive) .SetAnnouncementPreferenceLimit(command.AnnouncementPreferenceLimit) .SetAnnouncementSendingFrequency(command.AnnouncementSendingFrequency) .Build(); var getUserResult = GetResult <User> .Ok(user); const string pictureUrl = "pictureUrl"; _userGetterServiceMock.Setup(x => x.GetByIdAsync(It.IsAny <Guid>())).ReturnsAsync(getUserResult); _blobContainerServiceMock .Setup(x => x.UploadFileAsync(It.IsAny <byte[]>(), It.IsAny <string>(), It.IsAny <string>())) .ReturnsAsync(pictureUrl); _communicationBusMock .Setup(x => x.DispatchDomainEventsAsync(It.IsAny <User>(), It.IsAny <CancellationToken>())) .Returns(Task.CompletedTask); _userRepositoryMock.Setup(x => x.UpdateAsync(It.IsAny <User>())).Returns(Task.CompletedTask); _integrationEventBusMock.Setup(x => x.PublishIntegrationEventAsync(It.IsAny <IIntegrationEvent>())) .Returns(Task.CompletedTask); Func <Task> result = async() => await _commandHandler.HandleAsync(command); await result.Should().NotThrowAsync <Exception>(); }
public async Task HandleAsync_Should_Throw_ValidationException_When_Account_Is_Already_Confirmed() { var requestAccountConfirmationTokenCommand = new RequestAccountConfirmationTokenCommand("*****@*****.**"); var account = Account.Builder() .SetId(Guid.NewGuid()) .SetEmail(requestAccountConfirmationTokenCommand.Email) .SetConfirmed(false) .SetPasswordHash("PasswordHash") .SetSecurityStamp(Guid.NewGuid()) .SetCreated(DateTimeOffset.UtcNow) .SetRoles(new List <Guid> { Guid.NewGuid() }) .Build(); var getAccountResult = GetResult <Account> .Ok(account); var errors = new Collection <IError> { new Error(AccountErrorCodeEnumeration.AlreadyConfirmed, AccountErrorMessage.AlreadyConfirmed) }; var emailIsNotConfirmedVerificationResult = VerificationResult.Fail(errors); _accountGetterServiceMock.Setup(x => x.GetByEmailAsync(It.IsAny <string>())) .ReturnsAsync(getAccountResult); _accountVerificationServiceMock.Setup(x => x.VerifyAccountIsNotConfirmed(It.IsAny <bool>())) .Returns(emailIsNotConfirmedVerificationResult); Func <Task> result = async() => await _commandHandler.HandleAsync(requestAccountConfirmationTokenCommand); var exceptionResult = await result.Should().ThrowExactlyAsync <ValidationException>(); exceptionResult.And.Errors.Should().BeEquivalentTo(errors); }
public async Task HandleAsync_Should_Throw_ValidationException_When_Parent_Is_Not_Found() { var city = City.Builder() .SetId(Guid.NewGuid()) .SetRowVersion(Array.Empty <byte>()) .SetName("Name") .SetPolishName("PolishName") .SetStateId(Guid.NewGuid()) .Build(); var getCityResult = GetResult <City> .Ok(city); var errors = new Collection <IError> { new Error(CityDistrictErrorCodeEnumeration.ParentNotFound, CityDistrictErrorMessage.ParentNotFound) }; var parentExistsVerificationResult = VerificationResult.Fail(errors); var command = new CreateCityDistrictCommand(Guid.NewGuid(), "Name", "PolishName", city.Id, Guid.NewGuid(), new Collection <string> { "NameVariant" }); _cityGetterServiceMock.Setup(x => x.GetByIdAsync(It.IsAny <Guid>())).ReturnsAsync(getCityResult); _cityDistrictVerificationServiceMock.Setup(x => x.VerifyParentExistsAsync(It.IsAny <Guid>())) .ReturnsAsync(parentExistsVerificationResult); Func <Task> result = async() => await _commandHandler.HandleAsync(command); var exceptionResult = await result.Should().ThrowExactlyAsync <ValidationException>(); exceptionResult.And.Errors.Should().BeEquivalentTo(errors); }
public async Task GetByIdAsync_Should_Return_GetResult_Ok_With_User() { var id = Guid.NewGuid(); var flatForRentAnnouncementPreferences = new List <FlatForRentAnnouncementPreference> { FlatForRentAnnouncementPreference.Builder() .SetId(Guid.NewGuid()) .SetCityId(Guid.NewGuid()) .SetPriceMin(0) .SetPriceMax(3000) .SetRoomNumbersMin(1) .SetRoomNumbersMax(3) .SetCityDistricts(new List <Guid> { Guid.NewGuid() }) .Build() }; var user = User.Builder() .SetId(id) .SetEmail("*****@*****.**") .SetServiceActive(DefaultUserSettings.ServiceActive) .SetAnnouncementPreferenceLimit(DefaultUserSettings.AnnouncementPreferenceLimit) .SetAnnouncementSendingFrequency(DefaultUserSettings.AnnouncementSendingFrequency) .SetFlatForRentAnnouncementPreferences(flatForRentAnnouncementPreferences) .Build(); var expectedResult = GetResult <User> .Ok(user); _userRepositoryMock.Setup(x => x.GetByIdAsync(It.IsAny <Guid>())) .ReturnsAsync(user); var result = await _service.GetByIdAsync(id); result.Should().BeEquivalentTo(expectedResult); }
public async Task HandleAsync_Should_Throw_PreconditionFailedException_When_RowVersion_Does_Not_Match() { var cityDistrict = CityDistrict.Builder() .SetId(Guid.NewGuid()) .SetRowVersion(new byte[] { 1, 2, 4, 8, 16, 32, 64 }) .SetName("Name") .SetPolishName("PolishName") .SetCityId(Guid.NewGuid()) .SetNameVariants(new List <string> { "NameVariant" }) .SetParentId(Guid.NewGuid()) .Build(); var getCityDistrictResult = GetResult <CityDistrict> .Ok(cityDistrict); var command = new DeleteCityDistrictCommand(cityDistrict.Id, new byte[] { 1, 2, 4, 8, 16, 32, 128 }); _cityDistrictGetterServiceMock.Setup(x => x.GetByIdAsync(It.IsAny <Guid>())) .ReturnsAsync(getCityDistrictResult); _cityDistrictRepositoryMock.Setup(x => x.DeleteAsync(It.IsAny <CityDistrict>())).Returns(Task.CompletedTask); Func <Task> result = async() => await _commandHandler.HandleAsync(command); await result.Should().ThrowExactlyAsync <PreconditionFailedException>(); }
public async Task VerifyEmailIsNotTakenAsync_Should_Return_VerificationResult_With_Success_False_When_Email_Is_Already_Taken() { const string email = "*****@*****.**"; var account = Account.Builder() .SetId(Guid.NewGuid()) .SetEmail(email) .SetConfirmed(true) .SetPasswordHash("PasswordHash") .SetSecurityStamp(Guid.NewGuid()) .SetCreated(DateTimeOffset.UtcNow) .SetRoles(new List <Guid> { Guid.NewGuid() }) .Build(); var getAccountResult = GetResult <Account> .Ok(account); var errors = new Collection <IError> { new Error(AccountErrorCodeEnumeration.EmailIsAlreadyTaken, AccountErrorMessage.EmailIsAlreadyTaken) }; var expectedResult = VerificationResult.Fail(errors); _accountGetterServiceMock.Setup(x => x.GetByEmailAsync(It.IsAny <string>())).ReturnsAsync(getAccountResult); var result = await _accountVerificationService.VerifyEmailIsNotTakenAsync(email); result.Should().BeEquivalentTo(expectedResult); }
public async Task HandleAsync_Should_Throw_ValidationException_When_Account_Has_No_Password() { var changePasswordCommand = new ChangePasswordCommand(Guid.NewGuid(), "OldPassword", "NewPassword"); var account = Account.Builder() .SetId(Guid.NewGuid()) .SetEmail("*****@*****.**") .SetConfirmed(true) .SetPasswordHash("PasswordHash") .SetSecurityStamp(Guid.NewGuid()) .SetCreated(DateTimeOffset.UtcNow) .SetRoles(new List <Guid> { Guid.NewGuid() }) .Build(); var getAccountResult = GetResult <Account> .Ok(account); var errors = new Collection <IError> { new Error(AccountErrorCodeEnumeration.PasswordIsNotSet, AccountErrorMessage.PasswordIsNotSet) }; var passwordIsSetVerificationResult = VerificationResult.Fail(errors); _accountGetterServiceMock.Setup(x => x.GetByIdAsync(It.IsAny <Guid>())) .ReturnsAsync(getAccountResult); _accountVerificationServiceMock.Setup(x => x.VerifyPasswordIsSet(It.IsAny <string>())) .Returns(passwordIsSetVerificationResult); Func <Task> result = async() => await _commandHandler.HandleAsync(changePasswordCommand); var exceptionResult = await result.Should().ThrowAsync <ValidationException>(); exceptionResult.And.Errors.Should().BeEquivalentTo(errors); }
public async Task GetByIdAsync_Should_Return_GetResult_Ok() { var roomForRentAnnouncement = RoomForRentAnnouncement.Builder() .SetId(Guid.NewGuid()) .SetTitle("Title") .SetSourceUrl("http://sourceUrl") .SetCityId(Guid.NewGuid()) .SetCreated(DateTimeOffset.UtcNow) .SetDescription("Description") .SetCityDistricts(new List <Guid> { Guid.NewGuid() }) .SetPrice(100) .SetRoomTypes(new List <RoomTypeEnumeration> { RoomTypeEnumeration.Double }) .Build(); var expectedResult = GetResult <RoomForRentAnnouncement> .Ok(roomForRentAnnouncement); _roomForRentAnnouncementRepositoryMock.Setup(x => x.GetByIdAsync(It.IsAny <Guid>())) .ReturnsAsync(roomForRentAnnouncement); var result = await _service.GetByIdAsync(roomForRentAnnouncement.Id); result.Should().BeEquivalentTo(expectedResult); }
public async Task HandleAsync_Should_Throw_ResourceNotFoundException_When_FlatForRentAnnouncementPreference_Is_Not_Found() { var inputQuery = new GetFlatForRentAnnouncementPreferenceInputQuery(Guid.NewGuid(), Guid.NewGuid()); var user = User.Builder() .SetId(inputQuery.UserId) .SetEmail("*****@*****.**") .SetServiceActive(DefaultUserSettings.ServiceActive) .SetAnnouncementPreferenceLimit(DefaultUserSettings.AnnouncementPreferenceLimit) .SetAnnouncementSendingFrequency(DefaultUserSettings.AnnouncementSendingFrequency) .Build(); var getUserResult = GetResult <User> .Ok(user); var errors = new Collection <IError> { new Error(FlatForRentAnnouncementPreferenceErrorCode.NotFound, FlatForRentAnnouncementPreferenceErrorMessage.NotFound) }; var getFlatForRentAnnouncementPreferenceResult = GetResult <FlatForRentAnnouncementPreference> .Fail(errors); _userGetterServiceMock.Setup(x => x.GetByIdAsync(It.IsAny <Guid>())).ReturnsAsync(getUserResult); _flatForRentAnnouncementPreferenceGetterServiceMock .Setup(x => x.GetByByUserAndId(It.IsAny <User>(), It.IsAny <Guid>())) .Returns(getFlatForRentAnnouncementPreferenceResult); Func <Task <FlatForRentAnnouncementPreferenceOutputQuery> > result = async() => await _queryHandler.HandleAsync(inputQuery); var exceptionResult = await result.Should().ThrowExactlyAsync <ResourceNotFoundException>(); exceptionResult.And.Errors.Should().BeEquivalentTo(errors); }
public async Task HandleAsync_Should_Throw_ResourceNotFoundException_When_Room_For_Rent_Announcement_Preference_Is_Not_Found() { var command = new UpdateRoomForRentAnnouncementPreferenceCommand(Guid.NewGuid(), Guid.NewGuid(), Guid.NewGuid(), 1, 1500, RoomTypeEnumeration.Double, new List <Guid> { Guid.NewGuid() }); var user = User.Builder() .SetId(command.UserId) .SetEmail("*****@*****.**") .SetServiceActive(DefaultUserSettings.ServiceActive) .SetAnnouncementPreferenceLimit(DefaultUserSettings.AnnouncementPreferenceLimit) .SetAnnouncementSendingFrequency(DefaultUserSettings.AnnouncementSendingFrequency) .Build(); var getUserResult = GetResult <User> .Ok(user); var errors = new Collection <IError> { new Error(RoomForRentAnnouncementPreferenceErrorCode.NotFound, RoomForRentAnnouncementPreferenceErrorMessage.NotFound) }; var getRoomForRentAnnouncementPreferenceResult = GetResult <RoomForRentAnnouncementPreference> .Fail(errors); _userGetterServiceMock.Setup(x => x.GetByIdAsync(It.IsAny <Guid>())).ReturnsAsync(getUserResult); _roomForRentAnnouncementPreferenceGetterServiceMock .Setup(x => x.GetByByUserAndId(It.IsAny <User>(), It.IsAny <Guid>())) .Returns(getRoomForRentAnnouncementPreferenceResult); 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_ValidationException_When_City_And_City_Districts_Verification_Fails() { var command = new CreateRoomForRentAnnouncementPreferenceCommand(Guid.NewGuid(), Guid.NewGuid(), 1, 1000, RoomTypeEnumeration.Single, new List <Guid> { Guid.NewGuid() }); var user = User.Builder() .SetId(command.UserId) .SetEmail("*****@*****.**") .SetServiceActive(DefaultUserSettings.ServiceActive) .SetAnnouncementPreferenceLimit(DefaultUserSettings.AnnouncementPreferenceLimit) .SetAnnouncementSendingFrequency(DefaultUserSettings.AnnouncementSendingFrequency) .Build(); var getUserResult = GetResult <User> .Ok(user); var errors = new Collection <IError> { new Error(CityErrorCodeEnumeration.IncorrectCityDistricts, CityErrorMessage.IncorrectCityDistricts) }; var cityAndCityDistrictsVerificationResult = VerificationResult.Fail(errors); _userGetterServiceMock.Setup(x => x.GetByIdAsync(It.IsAny <Guid>())).ReturnsAsync(getUserResult); _cityVerificationServiceMock .Setup(x => x.VerifyCityAndCityDistrictsAsync(It.IsAny <Guid>(), It.IsAny <IEnumerable <Guid> >())) .ReturnsAsync(cityAndCityDistrictsVerificationResult); Func <Task> result = async() => await _commandHandler.HandleAsync(command); var exceptionResult = await result.Should().ThrowExactlyAsync <ValidationException>(); exceptionResult.And.Errors.Should().BeEquivalentTo(errors); }
public async Task HandleAsync_Should_Return_FlatForRentAnnouncementOutputQuery() { var flatForRentAnnouncement = FlatForRentAnnouncement.Builder() .SetId(Guid.NewGuid()) .SetTitle("Title") .SetSourceUrl("http://source") .SetCityId(Guid.NewGuid()) .SetCreated(DateTimeOffset.UtcNow) .SetDescription("Description") .SetNumberOfRooms(NumberOfRoomsEnumeration.One) .SetPrice(1000) .SetCityDistricts(new List <Guid> { Guid.NewGuid() }) .Build(); var getFlatForRentAnnouncementResult = GetResult <FlatForRentAnnouncement> .Ok(flatForRentAnnouncement); var flatForRentAnnouncementOutputQuery = new FlatForRentAnnouncementOutputQuery(flatForRentAnnouncement.Id, flatForRentAnnouncement.Title, flatForRentAnnouncement.SourceUrl, flatForRentAnnouncement.CityId, flatForRentAnnouncement.Created, flatForRentAnnouncement.Description, flatForRentAnnouncement.Price, flatForRentAnnouncement.NumberOfRooms, flatForRentAnnouncement.CityDistricts); _flatForRentAnnouncementGetterServiceMock.Setup(x => x.GetByIdAsync(It.IsAny <Guid>())) .ReturnsAsync(getFlatForRentAnnouncementResult); _mapperMock .Setup(x => x.Map <FlatForRentAnnouncement, FlatForRentAnnouncementOutputQuery>(It.IsAny <FlatForRentAnnouncement>())) .Returns(flatForRentAnnouncementOutputQuery); var result = await _queryHandler.HandleAsync(new GetFlatForRentAnnouncementInputQuery(flatForRentAnnouncement.Id)); result.Should().BeEquivalentTo(flatForRentAnnouncementOutputQuery); }
public async Task HandleAsync_Should_Delete_CityDistrict() { var cityDistrict = CityDistrict.Builder() .SetId(Guid.NewGuid()) .SetRowVersion(Array.Empty <byte>()) .SetName("Name") .SetPolishName("PolishName") .SetCityId(Guid.NewGuid()) .SetNameVariants(new List <string> { "NameVariant" }) .SetParentId(Guid.NewGuid()) .Build(); var getCityDistrictResult = GetResult <CityDistrict> .Ok(cityDistrict); var command = new DeleteCityDistrictCommand(cityDistrict.Id, cityDistrict.RowVersion); _cityDistrictGetterServiceMock.Setup(x => x.GetByIdAsync(It.IsAny <Guid>())) .ReturnsAsync(getCityDistrictResult); _cityDistrictRepositoryMock.Setup(x => x.DeleteAsync(It.IsAny <CityDistrict>())).Returns(Task.CompletedTask); Func <Task> result = async() => await _commandHandler.HandleAsync(command); await result.Should().NotThrowAsync <Exception>(); }
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 HandleAsync_Should_Return_RoomForRentAnnouncementOutputQuery() { var roomForRentAnnouncement = RoomForRentAnnouncement.Builder() .SetId(Guid.NewGuid()) .SetTitle("Title") .SetSourceUrl("http://source") .SetCityId(Guid.NewGuid()) .SetCreated(DateTimeOffset.UtcNow) .SetDescription("Description") .SetPrice(1000) .SetCityDistricts(new List <Guid> { Guid.NewGuid() }) .SetRoomTypes(new List <RoomTypeEnumeration> { RoomTypeEnumeration.Double }) .Build(); var getRoomForRentAnnouncementResult = GetResult <RoomForRentAnnouncement> .Ok(roomForRentAnnouncement); var roomForRentAnnouncementOutputQuery = new RoomForRentAnnouncementOutputQuery(roomForRentAnnouncement.Id, roomForRentAnnouncement.Title, roomForRentAnnouncement.SourceUrl, roomForRentAnnouncement.CityId, roomForRentAnnouncement.Created, roomForRentAnnouncement.Description, roomForRentAnnouncement.Price, roomForRentAnnouncement.RoomTypes, roomForRentAnnouncement.CityDistricts); _roomForRentAnnouncementGetterServiceMock.Setup(x => x.GetByIdAsync(It.IsAny <Guid>())) .ReturnsAsync(getRoomForRentAnnouncementResult); _mapperMock .Setup(x => x.Map <RoomForRentAnnouncement, RoomForRentAnnouncementOutputQuery>(It.IsAny <RoomForRentAnnouncement>())) .Returns(roomForRentAnnouncementOutputQuery); var result = await _queryHandler.HandleAsync(new GetRoomForRentAnnouncementInputQuery(roomForRentAnnouncement.Id)); result.Should().BeEquivalentTo(roomForRentAnnouncementOutputQuery); }
public async Task HandleAsync_Should_Throw_ValidationException_When_User_Is_Not_Allowed_To_Change_Announcement_Sending_Frequency() { var command = new UpdateUserCommand(Guid.NewGuid(), DefaultUserSettings.ServiceActive, DefaultUserSettings.AnnouncementPreferenceLimit, AnnouncementSendingFrequencyEnumeration.EveryHour, null); var user = User.Builder() .SetId(command.UserId) .SetEmail("*****@*****.**") .SetServiceActive(command.ServiceActive) .SetAnnouncementPreferenceLimit(command.AnnouncementPreferenceLimit) .SetAnnouncementSendingFrequency(DefaultUserSettings.AnnouncementSendingFrequency) .Build(); var getUserResult = GetResult <User> .Ok(user); var errors = new Collection <IError> { new Error(UserErrorCodeEnumeration.InsufficientPrivileges, UserErrorMessage.InsufficientPrivilegesToEditAnnouncementSendingFrequency) }; var announcementSendingFrequencyCanBeChangedVerificationResult = VerificationResult.Fail(errors); _userGetterServiceMock.Setup(x => x.GetByIdAsync(It.IsAny <Guid>())).ReturnsAsync(getUserResult); _userVerificationServiceMock.Setup(x => x.VerifyAnnouncementSendingFrequencyCanBeChanged()) .Returns(announcementSendingFrequencyCanBeChangedVerificationResult); Func <Task> result = async() => await _commandHandler.HandleAsync(command); var exceptionResult = await result.Should().ThrowExactlyAsync <ValidationException>(); exceptionResult.And.Errors.Should().BeEquivalentTo(errors); }
public async Task ProvideAccountForExternalLoginAsync_Should_Return_Existing_Confirmed_Account() { const string email = "*****@*****.**"; var account = Account.Builder() .SetId(Guid.NewGuid()) .SetEmail(email) .SetConfirmed(false) .SetPasswordHash(string.Empty) .SetSecurityStamp(Guid.NewGuid()) .SetCreated(DateTimeOffset.UtcNow) .SetRoles(new List <Guid> { Guid.NewGuid() }) .SetLastLogin(DateTimeOffset.UtcNow.AddDays(-1)) .Build(); var getAccountResult = GetResult <Account> .Ok(account); _accountGetterServiceMock.Setup(x => x.GetByEmailAsync(It.IsAny <string>())) .ReturnsAsync(getAccountResult); _communicationBusMock.Setup(x => x.DispatchDomainEventsAsync(It.IsAny <Account>(), It.IsAny <CancellationToken>())) .Returns(Task.CompletedTask); _accountRepositoryMock.Setup(x => x.UpdateAsync(It.IsAny <Account>())).Returns(Task.CompletedTask); var result = await _accountProviderService.ProvideAccountForExternalLoginAsync(email, Guid.NewGuid()); result.Email.Should().Be(email); result.Confirmed.Should().BeTrue(); }
public async Task HandleAsync_Should_Complete_Account_Creation_With_Success_When_UserCreationCompletedIntegrationEvent_Is_Received_And_Account_Has_Not_Confirmation_Token() { var userCreationCompletedIntegrationEvent = new UserCreationCompletedIntegrationEvent(Guid.NewGuid(), DateTimeOffset.UtcNow, Guid.NewGuid()); var account = Account.Builder() .SetId(userCreationCompletedIntegrationEvent.UserId) .SetEmail("*****@*****.**") .SetConfirmed(false) .SetPasswordHash("PasswordHash") .SetSecurityStamp(Guid.NewGuid()) .SetCreated(DateTimeOffset.UtcNow) .SetRoles(new List <Guid> { Guid.NewGuid() }) .Build(); var getAccountResult = GetResult <Account> .Ok(account); _accountGetterServiceMock.Setup(x => x.GetByIdAsync(It.IsAny <Guid>())).ReturnsAsync(getAccountResult); _integrationEventBusMock.Setup(x => x.PublishIntegrationEventAsync(It.IsAny <IIntegrationEvent>())) .Returns(Task.CompletedTask).Verifiable(); Func <Task> result = async() => await _userCreatedIntegrationEventHandler.HandleAsync(userCreationCompletedIntegrationEvent); await result.Should().NotThrowAsync <Exception>(); _integrationEventBusMock.Verify(x => x.PublishIntegrationEventAsync(It.Is <IIntegrationEvent>(ie => IsPublishedIntegrationEventCorrect((AccountCreationCompletedIntegrationEvent)ie, userCreationCompletedIntegrationEvent.CorrelationId, account.Id)))); }
public async Task HandleAsync_Should_Throw_ConflictException_When_Name_And_PolishName_Are_Already_Used() { var cityDistrict = CityDistrict.Builder() .SetId(Guid.NewGuid()) .SetRowVersion(Array.Empty <byte>()) .SetName("Name") .SetPolishName("PolishName") .SetCityId(Guid.NewGuid()) .SetParentId(Guid.NewGuid()) .SetNameVariants(new List <string> { "NameVariant" }) .Build(); var getCityDistrict = GetResult <CityDistrict> .Ok(cityDistrict); var city = City.Builder() .SetId(Guid.NewGuid()) .SetRowVersion(Array.Empty <byte>()) .SetName("Name") .SetPolishName("PolishName") .SetStateId(Guid.NewGuid()) .Build(); var getCityResult = GetResult <City> .Ok(city); var parentExistsVerificationResult = VerificationResult.Ok(); var nameIsNotTakenError = new Error(CityDistrictErrorCodeEnumeration.NameAlreadyInUse, CityDistrictErrorMessage.NameAlreadyInUse); var nameIsNotTakenVerificationResult = VerificationResult.Fail(new Collection <IError> { nameIsNotTakenError }); var polishNameIsNotTakenError = new Error(CityDistrictErrorCodeEnumeration.PolishNameAlreadyInUse, CityDistrictErrorMessage.PolishNameAlreadyInUse); var polishNameIsNotTakenVerificationResult = VerificationResult.Fail(new Collection <IError> { polishNameIsNotTakenError }); var command = new UpdateCityDistrictCommand(cityDistrict.Id, cityDistrict.RowVersion, "NewName", "NewPolishName", city.Id, Guid.NewGuid(), new Collection <string> { "NewNameVariant" }); var errors = new Collection <IError> { nameIsNotTakenError, polishNameIsNotTakenError }; _cityDistrictGetterServiceMock.Setup(x => x.GetByIdAsync(It.IsAny <Guid>())) .ReturnsAsync(getCityDistrict); _cityGetterServiceMock.Setup(x => x.GetByIdAsync(It.IsAny <Guid>())).ReturnsAsync(getCityResult); _cityDistrictVerificationServiceMock.Setup(x => x.VerifyParentExistsAsync(It.IsAny <Guid>())) .ReturnsAsync(parentExistsVerificationResult); _cityDistrictVerificationServiceMock .Setup(x => x.VerifyNameIsNotTakenAsync(It.IsAny <string>(), It.IsAny <Guid>())) .ReturnsAsync(nameIsNotTakenVerificationResult); _cityDistrictVerificationServiceMock .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_ValidationException_When_Flat_For_Rent_Announcement_Preferences_Verification_Fails() { var command = new CreateFlatForRentAnnouncementPreferenceCommand(Guid.NewGuid(), Guid.NewGuid(), 1, 1000, 1, 1, new List <Guid> { Guid.NewGuid() }); var user = User.Builder() .SetId(command.UserId) .SetEmail("*****@*****.**") .SetServiceActive(DefaultUserSettings.ServiceActive) .SetAnnouncementPreferenceLimit(DefaultUserSettings.AnnouncementPreferenceLimit) .SetAnnouncementSendingFrequency(DefaultUserSettings.AnnouncementSendingFrequency) .Build(); var getUserResult = GetResult <User> .Ok(user); var cityAndCityDistrictsVerificationResult = VerificationResult.Ok(); var announcementPreferenceLimitIsNotExceededVerificationResult = VerificationResult.Ok(); var flatForRentAnnouncementPreference = FlatForRentAnnouncementPreference.Builder() .SetId(command.FlatForRentAnnouncementPreferenceId) .SetCityId(command.CityId) .SetPriceMin(command.PriceMin) .SetPriceMax(command.PriceMax) .SetRoomNumbersMin(command.RoomNumbersMin) .SetRoomNumbersMax(command.RoomNumbersMax) .SetCityDistricts(command.CityDistricts) .Build(); var errors = new Collection <IError> { new Error(FlatForRentAnnouncementPreferenceErrorCode.ExpansibleCityDistricts, FlatForRentAnnouncementPreferenceErrorMessage.ExpansibleCityDistricts) }; var flatForRentAnnouncementPreferencesVerificationResult = VerificationResult.Fail(errors); _userGetterServiceMock.Setup(x => x.GetByIdAsync(It.IsAny <Guid>())).ReturnsAsync(getUserResult); _cityVerificationServiceMock .Setup(x => x.VerifyCityAndCityDistrictsAsync(It.IsAny <Guid>(), It.IsAny <IEnumerable <Guid> >())) .ReturnsAsync(cityAndCityDistrictsVerificationResult); _userVerificationServiceMock .Setup(x => x.VerifyAnnouncementPreferenceLimitIsNotExceeded(It.IsAny <int>(), It.IsAny <int>())) .Returns(announcementPreferenceLimitIsNotExceededVerificationResult); _mapperMock.Setup(x => x.Map <CreateFlatForRentAnnouncementPreferenceCommand, FlatForRentAnnouncementPreference>( It.IsAny <CreateFlatForRentAnnouncementPreferenceCommand>())) .Returns(flatForRentAnnouncementPreference); _flatForRentAnnouncementPreferenceVerificationServiceMock .Setup(x => x.VerifyFlatForRentAnnouncementPreferences( It.IsAny <IEnumerable <FlatForRentAnnouncementPreference> >())) .Returns(flatForRentAnnouncementPreferencesVerificationResult); Func <Task> result = async() => await _commandHandler.HandleAsync(command); var exceptionResult = await result.Should().ThrowExactlyAsync <ValidationException>(); exceptionResult.And.Errors.Should().BeEquivalentTo(errors); }
public async Task HandleAsync_Should_Create_Flat_For_Rent_Announcement_Preference() { var command = new CreateFlatForRentAnnouncementPreferenceCommand(Guid.NewGuid(), Guid.NewGuid(), 1, 1000, 1, 1, new List <Guid> { Guid.NewGuid() }); var user = User.Builder() .SetId(command.UserId) .SetEmail("*****@*****.**") .SetServiceActive(DefaultUserSettings.ServiceActive) .SetAnnouncementPreferenceLimit(DefaultUserSettings.AnnouncementPreferenceLimit) .SetAnnouncementSendingFrequency(DefaultUserSettings.AnnouncementSendingFrequency) .Build(); var getUserResult = GetResult <User> .Ok(user); var cityAndCityDistrictsVerificationResult = VerificationResult.Ok(); var announcementPreferenceLimitIsNotExceededVerificationResult = VerificationResult.Ok(); var flatForRentAnnouncementPreference = FlatForRentAnnouncementPreference.Builder() .SetId(command.FlatForRentAnnouncementPreferenceId) .SetCityId(command.CityId) .SetPriceMin(command.PriceMin) .SetPriceMax(command.PriceMax) .SetRoomNumbersMin(command.RoomNumbersMin) .SetRoomNumbersMax(command.RoomNumbersMax) .SetCityDistricts(command.CityDistricts) .Build(); var flatForRentAnnouncementPreferencesVerificationResult = VerificationResult.Ok(); _userGetterServiceMock.Setup(x => x.GetByIdAsync(It.IsAny <Guid>())).ReturnsAsync(getUserResult); _cityVerificationServiceMock .Setup(x => x.VerifyCityAndCityDistrictsAsync(It.IsAny <Guid>(), It.IsAny <IEnumerable <Guid> >())) .ReturnsAsync(cityAndCityDistrictsVerificationResult); _userVerificationServiceMock .Setup(x => x.VerifyAnnouncementPreferenceLimitIsNotExceeded(It.IsAny <int>(), It.IsAny <int>())) .Returns(announcementPreferenceLimitIsNotExceededVerificationResult); _mapperMock.Setup(x => x.Map <CreateFlatForRentAnnouncementPreferenceCommand, FlatForRentAnnouncementPreference>( It.IsAny <CreateFlatForRentAnnouncementPreferenceCommand>())) .Returns(flatForRentAnnouncementPreference); _flatForRentAnnouncementPreferenceVerificationServiceMock .Setup(x => x.VerifyFlatForRentAnnouncementPreferences( It.IsAny <IEnumerable <FlatForRentAnnouncementPreference> >())) .Returns(flatForRentAnnouncementPreferencesVerificationResult); _communicationBusMock .Setup(x => x.DispatchDomainEventsAsync(It.IsAny <User>(), It.IsAny <CancellationToken>())) .Returns(Task.CompletedTask); _userRepositoryMock.Setup(x => x.UpdateAsync(It.IsAny <User>())).Returns(Task.CompletedTask); _integrationEventBusMock.Setup(x => x.PublishIntegrationEventAsync(It.IsAny <IIntegrationEvent>())) .Returns(Task.CompletedTask); Func <Task> result = async() => await _commandHandler.HandleAsync(command); await result.Should().NotThrowAsync <Exception>(); }
public async Task HandleAsync_Should_Update_RoomForRentAnnouncement() { var cityDistrictToRemove = Guid.NewGuid(); var roomTypeToRemove = RoomTypeEnumeration.MultiPerson; var roomForRentAnnouncement = RoomForRentAnnouncement.Builder() .SetId(Guid.NewGuid()) .SetTitle("Title") .SetSourceUrl("http://source") .SetCityId(Guid.NewGuid()) .SetCreated(DateTimeOffset.UtcNow) .SetDescription("Description") .SetPrice(1000) .SetCityDistricts(new List <Guid> { cityDistrictToRemove }) .SetRoomTypes(new List <RoomTypeEnumeration> { roomTypeToRemove }) .Build(); var getRoomForRentAnnouncementResult = GetResult <RoomForRentAnnouncement> .Ok(roomForRentAnnouncement); var cityVerificationResult = VerificationResult.Ok(); var cityDistrictsVerificationResult = VerificationResult.Ok(); const string newTitle = "NewTitle"; var cityDistrictToAdd = Guid.NewGuid(); var roomTypeToAdd = RoomTypeEnumeration.Single; var updateRoomForRentAnnouncementCommand = new UpdateRoomForRentAnnouncementCommand( roomForRentAnnouncement.Id, newTitle, roomForRentAnnouncement.SourceUrl, roomForRentAnnouncement.CityId, roomForRentAnnouncement.Description, roomForRentAnnouncement.Price, new List <RoomTypeEnumeration> { roomTypeToAdd }, new List <Guid> { cityDistrictToAdd }); _roomForRentAnnouncementGetterServiceMock.Setup(x => x.GetByIdAsync(It.IsAny <Guid>())) .ReturnsAsync(getRoomForRentAnnouncementResult); _cityVerificationServiceMock.Setup(x => x.VerifyCityExistsAsync(It.IsAny <Guid>())) .ReturnsAsync(cityVerificationResult); _cityDistrictVerificationServiceMock .Setup(x => x.VerifyCityDistrictsExistAsync(It.IsAny <Guid>(), It.IsAny <IEnumerable <Guid> >())) .ReturnsAsync(cityDistrictsVerificationResult); _roomForRentAnnouncementRepositoryMock.Setup(x => x.UpdateAsync(It.IsAny <RoomForRentAnnouncement>())) .Returns(Task.CompletedTask); Func <Task> result = async() => await _commandHandler.HandleAsync(updateRoomForRentAnnouncementCommand); await result.Should().NotThrowAsync <Exception>(); roomForRentAnnouncement.Title.Should().Be(newTitle); roomForRentAnnouncement.CityDistricts.Should().NotContain(cityDistrictToRemove); roomForRentAnnouncement.CityDistricts.Should().Contain(cityDistrictToAdd); roomForRentAnnouncement.RoomTypes.Should().NotContain(roomTypeToRemove); roomForRentAnnouncement.RoomTypes.Should().Contain(roomTypeToAdd); }
public async Task HandleAsync_Should_Throw_ValidationException_When_Room_For_Rent_Announcement_Preferences_Verification_Fails() { var command = new UpdateRoomForRentAnnouncementPreferenceCommand(Guid.NewGuid(), Guid.NewGuid(), Guid.NewGuid(), 1, 1500, RoomTypeEnumeration.Double, new List <Guid> { Guid.NewGuid() }); var user = User.Builder() .SetId(command.UserId) .SetEmail("*****@*****.**") .SetServiceActive(DefaultUserSettings.ServiceActive) .SetAnnouncementPreferenceLimit(DefaultUserSettings.AnnouncementPreferenceLimit) .SetAnnouncementSendingFrequency(DefaultUserSettings.AnnouncementSendingFrequency) .Build(); var getUserResult = GetResult <User> .Ok(user); var roomForRentAnnouncementPreference = RoomForRentAnnouncementPreference.Builder() .SetId(command.RoomForRentAnnouncementPreferenceId) .SetCityId(Guid.NewGuid()) .SetPriceMin(1) .SetPriceMax(1000) .SetRoomType(RoomTypeEnumeration.Single) .SetCityDistricts(new List <Guid> { Guid.NewGuid() }) .Build(); var getRoomForRentAnnouncementPreferenceResult = GetResult <RoomForRentAnnouncementPreference> .Ok(roomForRentAnnouncementPreference); var cityAndCityDistrictsVerificationResult = VerificationResult.Ok(); var errors = new Collection <IError> { new Error(RoomForRentAnnouncementPreferenceErrorCode.ExpansibleCityDistricts, RoomForRentAnnouncementPreferenceErrorMessage.ExpansibleCityDistricts) }; var roomForRentAnnouncementPreferencesVerificationResult = VerificationResult.Fail(errors); _userGetterServiceMock.Setup(x => x.GetByIdAsync(It.IsAny <Guid>())).ReturnsAsync(getUserResult); _roomForRentAnnouncementPreferenceGetterServiceMock .Setup(x => x.GetByByUserAndId(It.IsAny <User>(), It.IsAny <Guid>())) .Returns(getRoomForRentAnnouncementPreferenceResult); _cityVerificationServiceMock .Setup(x => x.VerifyCityAndCityDistrictsAsync(It.IsAny <Guid>(), It.IsAny <IEnumerable <Guid> >())) .ReturnsAsync(cityAndCityDistrictsVerificationResult); _roomForRentAnnouncementPreferenceVerificationServiceMock .Setup(x => x.VerifyRoomForRentAnnouncementPreferences( It.IsAny <IEnumerable <RoomForRentAnnouncementPreference> >())) .Returns(roomForRentAnnouncementPreferencesVerificationResult); Func <Task> result = async() => await _commandHandler.HandleAsync(command); var exceptionResult = await result.Should().ThrowExactlyAsync <ValidationException>(); exceptionResult.And.Errors.Should().BeEquivalentTo(errors); }