public VerificationResult VerifyAccountCanBeAuthenticated(Account account, string password) { var emailIsConfirmedVerificationResult = VerifyAccountIsConfirmed(account.Confirmed); if (!emailIsConfirmedVerificationResult.Success) { return(emailIsConfirmedVerificationResult); } var passwordIsSetVerificationResult = VerifyPasswordIsSet(account.PasswordHash); if (!passwordIsSetVerificationResult.Success) { return(passwordIsSetVerificationResult); } var passwordVerificationResult = VerifyPassword(account.PasswordHash, password); if (!passwordVerificationResult.Success) { return(passwordVerificationResult); } return(VerificationResult.Ok()); }
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 VerificationResult VerifyFlatForRentAnnouncementPreferences(IEnumerable <FlatForRentAnnouncementPreference> flatForRentAnnouncementPreferences) { var flatForRentAnnouncementPreferencesGroupedByCityId = GetFlatForRentAnnouncementPreferencesGroupedByCityId(flatForRentAnnouncementPreferences); var errors = new List <IError>(); if (AreAnyWithExpansibleCityDistricts(flatForRentAnnouncementPreferencesGroupedByCityId)) { var error = new Error(FlatForRentAnnouncementPreferenceErrorCode.ExpansibleCityDistricts, FlatForRentAnnouncementPreferenceErrorMessage.ExpansibleCityDistricts); errors.Add(error); } if (AreAnyWithChangeablePrices(flatForRentAnnouncementPreferencesGroupedByCityId)) { var error = new Error(FlatForRentAnnouncementPreferenceErrorCode.ChangeablePrices, FlatForRentAnnouncementPreferenceErrorMessage.ChangeablePrices); errors.Add(error); } if (AreAnyWithChangeableRoomNumbers(flatForRentAnnouncementPreferencesGroupedByCityId)) { var error = new Error(FlatForRentAnnouncementPreferenceErrorCode.ChangeableRoomNumbers, FlatForRentAnnouncementPreferenceErrorMessage.ChangeableRoomNumbers); errors.Add(error); } return(errors.Any() ? VerificationResult.Fail(errors) : VerificationResult.Ok()); }
public async Task HandleAsync_Should_Throw_ValidationException_When_Any_Of_CityDistricts_Is_Not_Found() { var cityVerificationResult = VerificationResult.Ok(); var errors = new Collection <IError> { new Error(CityDistrictErrorCodeEnumeration.NotFound, CityDistrictErrorMessage.NotFound) }; var cityDistrictsVerificationResult = VerificationResult.Fail(errors); var createRoomForRentAnnouncementCommand = new CreateRoomForRentAnnouncementCommand(Guid.NewGuid(), "Title", "http://sourceUrl", Guid.NewGuid(), "Description", null, new List <RoomTypeEnumeration> { RoomTypeEnumeration.Single }, new List <Guid>()); _cityVerificationServiceMock.Setup(x => x.VerifyCityExistsAsync(It.IsAny <Guid>())) .ReturnsAsync(cityVerificationResult); _cityDistrictVerificationServiceMock .Setup(x => x.VerifyCityDistrictsExistAsync(It.IsAny <Guid>(), It.IsAny <IEnumerable <Guid> >())) .ReturnsAsync(cityDistrictsVerificationResult); Func <Task> result = async() => await _commandHandler.HandleAsync(createRoomForRentAnnouncementCommand); var exceptionResult = await result.Should().ThrowExactlyAsync <ValidationException>(); exceptionResult.And.Errors.Should().BeEquivalentTo(errors); }
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_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 VerificationResult VerifyConfirmationCode(Token token, string confirmationCode) { if (token is null) { var errors = new Collection <IError> { new Error(AccountErrorCodeEnumeration.ConfirmationCodeWasNotGenerated, AccountErrorMessage.ConfirmationCodeWasNotGenerated) }; return(VerificationResult.Fail(errors)); } if (!token.Value.Equals(confirmationCode)) { var errors = new Collection <IError> { new Error(AccountErrorCodeEnumeration.IncorrectConfirmationCode, AccountErrorMessage.IncorrectConfirmationCode) }; return(VerificationResult.Fail(errors)); } if (DateTimeOffset.UtcNow > token.Expires) { var errors = new Collection <IError> { new Error(AccountErrorCodeEnumeration.ConfirmationCodeExpired, AccountErrorMessage.ConfirmationCodeExpired) }; return(VerificationResult.Fail(errors)); } return(VerificationResult.Ok()); }
public async Task HandleAsync_Should_Create_User() { var command = new CreateUserCommand(Guid.NewGuid(), "*****@*****.**", DefaultUserSettings.ServiceActive, DefaultUserSettings.AnnouncementPreferenceLimit, DefaultUserSettings.AnnouncementSendingFrequency); var userDoesNotExistsVerificationResult = VerificationResult.Ok(); var accountExistsVerificationResult = VerificationResult.Ok(); var user = User.Builder() .SetId(command.UserId) .SetEmail(command.Email) .SetServiceActive(command.ServiceActive) .SetAnnouncementPreferenceLimit(command.AnnouncementPreferenceLimit) .SetAnnouncementSendingFrequency(command.AnnouncementSendingFrequency) .Build(); _userVerificationServiceMock.Setup(x => x.VerifyUserDoesNotExistAsync(It.IsAny <Guid>())) .ReturnsAsync(userDoesNotExistsVerificationResult); _accountVerificationServiceMock.Setup(x => x.VerifyAccountExistsAsync(It.IsAny <Guid>(), It.IsAny <string>())) .ReturnsAsync(accountExistsVerificationResult); _mapperMock.Setup(x => x.Map <CreateUserCommand, User>(It.IsAny <CreateUserCommand>())).Returns(user); _communicationBusMock .Setup(x => x.DispatchDomainEventsAsync(It.IsAny <User>(), It.IsAny <CancellationToken>())) .Returns(Task.CompletedTask); _userRepositoryMock.Setup(x => x.AddAsync(It.IsAny <User>())).Returns(Task.CompletedTask); Func <Task> result = async() => await _commandHandler.HandleAsync(command); await result.Should().NotThrowAsync <Exception>(); }
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 <VerificationResult> VerifyNameIsNotTakenAsync(string name) { return(await IsNameAlreadyUsedAsync(name) ? VerificationResult.Fail(new Collection <IError> { new Error(StateErrorCodeEnumeration.NameAlreadyInUse, StateErrorMessage.NameAlreadyInUse) }) : VerificationResult.Ok()); }
public async Task <VerificationResult> VerifyPolishNameIsNotTakenAsync(string polishName, Guid cityId) { return(await IsPolishNameAlreadyUsedAsync(polishName, cityId) ? VerificationResult.Fail(new Collection <IError> { new Error(CityDistrictErrorCodeEnumeration.PolishNameAlreadyInUse, CityDistrictErrorMessage.PolishNameAlreadyInUse) }) : VerificationResult.Ok()); }
public void VerifyAnnouncementPreferenceLimitCanBeChanged_Should_Return_VerificationResult_With_Success_True() { _authorizationServiceMock.Setup(x => x.IsAdministrator()).Returns(true); var expectedResult = VerificationResult.Ok(); var result = _service.VerifyAnnouncementPreferenceLimitCanBeChanged(); result.Should().BeEquivalentTo(expectedResult); }
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_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_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_Reset_Password() { var resetPasswordCommand = new ResetPasswordCommand("*****@*****.**", "123456", "Password"); var token = Token.Builder() .SetIssued(DateTimeOffset.UtcNow) .SetExpires(DateTimeOffset.UtcNow.AddDays(1)) .SetType(TokenTypeEnumeration.PasswordReset) .SetValue(resetPasswordCommand.Code) .Build(); var account = Account.Builder() .SetId(Guid.NewGuid()) .SetEmail(resetPasswordCommand.Email) .SetConfirmed(false) .SetPasswordHash("PasswordHash") .SetSecurityStamp(Guid.NewGuid()) .SetCreated(DateTimeOffset.UtcNow) .SetRoles(new List <Guid> { Guid.NewGuid() }) .SetTokens(new List <Token> { token }) .Build(); var getAccountResult = GetResult <Account> .Ok(account); var accountIsConfirmedVerificationResult = VerificationResult.Ok(); var passwordIsSetVerificationResult = VerificationResult.Ok(); var tokenIsCorrectVerificationResult = VerificationResult.Ok(); const string newPasswordHash = "NewPasswordHash"; var cancellationToken = new CancellationToken(); _accountGetterServiceMock.Setup(x => x.GetByEmailAsync(It.IsAny <string>())) .ReturnsAsync(getAccountResult); _accountVerificationServiceMock.Setup(x => x.VerifyAccountIsConfirmed(It.IsAny <bool>())) .Returns(accountIsConfirmedVerificationResult); _accountVerificationServiceMock.Setup(x => x.VerifyPasswordIsSet(It.IsAny <string>())) .Returns(passwordIsSetVerificationResult); _accountVerificationServiceMock.Setup(x => x.VerifyConfirmationCode(It.IsAny <Token>(), It.IsAny <string>())) .Returns(tokenIsCorrectVerificationResult); _passwordServiceMock.Setup(x => x.HashPassword(It.IsAny <string>())).Returns(newPasswordHash); _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); Func <Task> result = async() => await _commandHandler.HandleAsync(resetPasswordCommand, cancellationToken); await result.Should().NotThrowAsync <Exception>(); account.PasswordHash.Should().Be(newPasswordHash); account.Tokens.Should().NotContain(token); _communicationBusMock.Verify( x => x.DispatchDomainEventsAsync(It.Is <Account>(a => a == account), It.Is <CancellationToken>(ct => ct == cancellationToken)), Times.Once); }
public async Task VerifyNameIsNotTakenAsync_Should_Return_Success_VerificationResult() { var expectedResult = VerificationResult.Ok(); _cityDistrictRepositoryMock.Setup(x => x.GetByNameAndCityIdAsync(It.IsAny <string>(), It.IsAny <Guid>())) .Returns(Task.FromResult <CityDistrict>(null)); var result = await _service.VerifyNameIsNotTakenAsync("Name", Guid.NewGuid()); result.Should().BeEquivalentTo(expectedResult); }
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); }
public void VerifyAnnouncementPreferenceLimitIsNotExceeded_Should_Return_VerificationResult_With_Success_True() { const int announcementPreferenceLimit = 10; const int currentAnnouncementPreferencesCount = 1; var expectedResult = VerificationResult.Ok(); var result = _service.VerifyAnnouncementPreferenceLimitIsNotExceeded(announcementPreferenceLimit, currentAnnouncementPreferencesCount); result.Should().BeEquivalentTo(expectedResult); }
public async Task VerifyPolishNameIsNotTakenAsync_Should_Return_VerificationResult_With_Success_True() { const string polishName = "PolishName"; var expectedResult = VerificationResult.Ok(); _stateRepositoryMock.Setup(x => x.GetByPolishNameAsync(It.IsAny <string>())).Returns(Task.FromResult <State>(null)); var result = await _stateVerificationService.VerifyPolishNameIsNotTakenAsync(polishName); result.Should().BeEquivalentTo(expectedResult); }
public async Task VerifyNameIsNotTakenAsync_Should_Return_VerificationResult_With_Success_True() { const string name = "Name"; var expectedResult = VerificationResult.Ok(); _cityRepositoryMock.Setup(x => x.GetByNameAndStateIdAsync(It.IsAny <string>(), It.IsAny <Guid>())) .Returns(Task.FromResult <City>(null)); var result = await _cityVerificationService.VerifyNameIsNotTakenAsync(name, Guid.NewGuid()); result.Should().BeEquivalentTo(expectedResult); }
public async Task HandleAsync_Should_Update_Room_For_Rent_Announcement_Preference_When_CityId_Is_Different() { 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 roomForRentAnnouncementPreferencesVerificationResult = VerificationResult.Ok(); _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); _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 ValidateAsync_Should_Set_Success_GrantValidationResult() { 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 accountCanBeAuthenticatedResult = VerificationResult.Ok(); var accountClaims = new List <Claim> { new Claim(JwtClaimTypes.Subject, account.Id.ToString()), new Claim(JwtClaimTypes.Email, account.Email), new Claim(JwtClaimTypes.EmailVerified, account.Confirmed.ToString(), ClaimValueTypes.Boolean), new Claim(JwtClaimTypes.Scope, "Scope"), new Claim(ClaimTypes.Name, account.Email), new Claim(ClaimTypes.NameIdentifier, account.Id.ToString()) }; var context = new ResourceOwnerPasswordValidationContext { Request = new ValidatedTokenRequest { GrantType = GrantType.ResourceOwnerPassword }, Password = "******", UserName = account.Email }; _accountGetterServiceMock.Setup(x => x.GetByEmailAsync(It.IsAny <string>())) .ReturnsAsync(getAccountResult); _accountVerificationServiceMock .Setup(x => x.VerifyAccountCanBeAuthenticated(It.IsAny <Account>(), It.IsAny <string>())) .Returns(accountCanBeAuthenticatedResult); _accountClaimsCreatorServiceMock.Setup(x => x.CreateAccountClaimsAsync(It.IsAny <Account>())).ReturnsAsync(accountClaims); Func <Task> result = async() => await _resourceOwnerPasswordValidator.ValidateAsync(context); await result.Should().NotThrowAsync <Exception>(); _accountGetterServiceMock.Verify(x => x.GetByEmailAsync(It.Is <string>(e => e == context.UserName)), Times.Once); _accountVerificationServiceMock.Verify(x => x.VerifyAccountCanBeAuthenticated(It.Is <Account>(a => a == account), It.Is <string>(p => p == context.Password)), Times.Once); _accountClaimsCreatorServiceMock.Verify(x => x.CreateAccountClaimsAsync(It.Is <Account>(a => a == account)), Times.Once); }
public VerificationResult VerifyPasswordIsNotSet(string passwordHash) { if (!string.IsNullOrWhiteSpace(passwordHash)) { var errors = new Collection <IError> { new Error(AccountErrorCodeEnumeration.PasswordAlreadySet, AccountErrorMessage.PasswordAlreadySet) }; return(VerificationResult.Fail(errors)); } return(VerificationResult.Ok()); }
public VerificationResult VerifyPassword(string passwordHash, string password) { if (!_passwordService.VerifyHashedPassword(passwordHash, password)) { var errors = new Collection <IError> { new Error(AccountErrorCodeEnumeration.IncorrectPassword, AccountErrorMessage.IncorrectPassword) }; return(VerificationResult.Fail(errors)); } return(VerificationResult.Ok()); }
public VerificationResult VerifyAccountIsConfirmed(bool confirmed) { if (!confirmed) { var errors = new Collection <IError> { new Error(AccountErrorCodeEnumeration.NotConfirmed, AccountErrorMessage.NotConfirmed) }; return(VerificationResult.Fail(errors)); } return(VerificationResult.Ok()); }
public async Task VerifyEmailIsNotTakenAsync_Should_Return_VerificationResult_With_Success_True() { const string email = "*****@*****.**"; var getAccountResult = GetResult <Account> .Fail(new List <IError>()); var expectedResult = VerificationResult.Ok(); _accountGetterServiceMock.Setup(x => x.GetByEmailAsync(It.IsAny <string>())).ReturnsAsync(getAccountResult); var result = await _accountVerificationService.VerifyEmailIsNotTakenAsync(email); result.Should().BeEquivalentTo(expectedResult); }
public async Task <VerificationResult> VerifyCityDistrictsExistAsync(Guid cityId, IEnumerable <Guid> cityDistrictIds) { var cityDistricts = await _rivaAdministrativeDivisionsApiClientService.GetCityDistrictsAsync(cityId); if (cityDistrictIds.Except(cityDistricts.Select(x => x.Id)).Any()) { var errors = new Collection <IError> { new Error(CityDistrictErrorCodeEnumeration.NotFound, CityDistrictErrorMessage.NotFound) }; return(VerificationResult.Fail(errors)); } return(VerificationResult.Ok()); }
public async Task <VerificationResult> VerifyNameIsNotTakenAsync(string name) { var role = await _roleRepository.GetByNameAsync(name); if (role != null) { var errors = new Collection <IError> { new Error(RoleErrorCodeEnumeration.NameIsAlreadyTaken, RoleErrorMessage.NameIsAlreadyTaken) }; return(VerificationResult.Fail(errors)); } return(VerificationResult.Ok()); }
public VerificationResult VerifyAnnouncementPreferenceLimitIsNotExceeded(int announcementPreferenceLimit, int currentAnnouncementPreferencesCount) { if (currentAnnouncementPreferencesCount == announcementPreferenceLimit) { var errors = new Collection <IError> { new Error(UserErrorCodeEnumeration.AnnouncementPreferenceLimitExceeded, UserErrorMessage.AnnouncementPreferenceLimitExceeded) }; return(VerificationResult.Fail(errors)); } return(VerificationResult.Ok()); }