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 VerifyCityDistrictsExistAsync_Should_Return_Verification_Fail() { var cityId = Guid.NewGuid(); var cityDistricts = new List <ICityDistrict> { new CityDistrict { Id = Guid.NewGuid(), Name = "Name", PolishName = "PolishName", CityId = Guid.NewGuid() } }; var cityDistrictIds = new List <Guid> { Guid.NewGuid() }; var errors = new Collection <IError> { new Error(CityDistrictErrorCodeEnumeration.NotFound, CityDistrictErrorMessage.NotFound) }; var expectedResult = VerificationResult.Fail(errors); _rivaAdministrativeDivisionApiClientServiceMock.Setup(x => x.GetCityDistrictsAsync(It.IsAny <Guid>())) .ReturnsAsync(cityDistricts); var result = await _service.VerifyCityDistrictsExistAsync(cityId, cityDistrictIds); result.Should().BeEquivalentTo(expectedResult); }
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 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_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_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 void VerifyAccountCanBeAuthenticated_Should_Return_VerificationResult_With_Success_False_When_Password_Is_Incorrect() { 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 errors = new Collection <IError> { new Error(AccountErrorCodeEnumeration.IncorrectPassword, AccountErrorMessage.IncorrectPassword) }; var expectedResult = VerificationResult.Fail(errors); _passwordServiceMock.Setup(x => x.VerifyHashedPassword(It.IsAny <string>(), It.IsAny <string>())) .Returns(false); var result = _accountVerificationService.VerifyAccountCanBeAuthenticated(account, "password"); result.Should().BeEquivalentTo(expectedResult); }
public async Task HandleAsync_Should_Throw_ConflictException_When_Name_And_PolishName_Are_Already_Used() { var command = new CreateStateCommand(Guid.NewGuid(), "Name", "PolishName"); var duplicateNameError = new Error(StateErrorCodeEnumeration.NameAlreadyInUse, StateErrorMessage.NameAlreadyInUse); var duplicatePolishNameError = new Error(StateErrorCodeEnumeration.PolishNameAlreadyInUse, StateErrorMessage.PolishNameAlreadyInUse); var nameIsNotTakenVerificationResult = VerificationResult.Fail(new Collection <IError> { duplicateNameError }); var polishNameIsNotTakenVerificationResult = VerificationResult.Fail(new Collection <IError> { duplicatePolishNameError }); var errors = new Collection <IError> { duplicateNameError, duplicatePolishNameError }; _stateVerificationServiceMock.Setup(x => x.VerifyNameIsNotTakenAsync(It.IsAny <string>())) .ReturnsAsync(nameIsNotTakenVerificationResult); _stateVerificationServiceMock.Setup(x => x.VerifyPolishNameIsNotTakenAsync(It.IsAny <string>())) .ReturnsAsync(polishNameIsNotTakenVerificationResult); Func <Task> result = async() => await _commandHandler.HandleAsync(command); var exceptionResult = await result.Should().ThrowExactlyAsync <ConflictException>(); exceptionResult.And.Errors.Should().BeEquivalentTo(errors); }
public static async Task ExpectNone(this ConnectedProjectionScenario <ProductContext> scenario) { var database = Guid.NewGuid().ToString("N"); var specification = scenario.Verify(async context => { var actualRecords = await context.AllRecords(); return(actualRecords.Length == 0 ? VerificationResult.Pass() : VerificationResult.Fail($"Expected 0 records but found {actualRecords.Length}.")); }); using (var context = CreateContextFor(database)) { var projector = new ConnectedProjector <ProductContext>(specification.Resolver); foreach (var message in specification.Messages) { var envelope = new Envelope(message, new Dictionary <string, object>()).ToGenericEnvelope(); await projector.ProjectAsync(context, envelope); } await context.SaveChangesAsync(); } using (var context = CreateContextFor(database)) { var result = await specification.Verification(context, CancellationToken.None); if (result.Failed) { throw specification.CreateFailedScenarioExceptionFor(result); } } }
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 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 void VerifyRoomForRentAnnouncementPreferences_Should_Return_Fail_VerificationResult_When_Prices_Can_Be_Changed() { var cityId = Guid.NewGuid(); var cityDistricts = new List <Guid> { Guid.NewGuid() }; var roomForRentAnnouncementPreferences = new List <RoomForRentAnnouncementPreference> { RoomForRentAnnouncementPreference.Builder() .SetId(Guid.NewGuid()) .SetCityId(cityId) .SetPriceMin(0) .SetPriceMax(1000) .SetRoomType(RoomTypeEnumeration.Single) .SetCityDistricts(cityDistricts) .Build(), RoomForRentAnnouncementPreference.Builder() .SetId(Guid.NewGuid()) .SetCityId(cityId) .SetPriceMin(0) .SetPriceMax(1500) .SetRoomType(RoomTypeEnumeration.Single) .SetCityDistricts(cityDistricts) .Build() }; var errors = new List <IError> { new Error(RoomForRentAnnouncementPreferenceErrorCode.ChangeablePrices, RoomForRentAnnouncementPreferenceErrorMessage.ChangeablePrices) }; var expectedResult = VerificationResult.Fail(errors); var result = _service.VerifyRoomForRentAnnouncementPreferences(roomForRentAnnouncementPreferences); result.Should().BeEquivalentTo(expectedResult); }
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 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 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 static Task ExpectNone(this ProjectionScenario <IAsyncDocumentSession> scenario) { return(scenario .Verify(async session => { using (var streamer = await session.Advanced.StreamAsync <RavenJObject>(Etag.Empty)) { if (await streamer.MoveNextAsync()) { var storedDocumentIdentifiers = new List <string>(); do { storedDocumentIdentifiers.Add(streamer.Current.Key); } while (await streamer.MoveNextAsync()); return VerificationResult.Fail( string.Format("Expected no documents, but found {0} document(s) ({1}).", storedDocumentIdentifiers.Count, string.Join(",", storedDocumentIdentifiers))); } return VerificationResult.Pass(); } }) .Assert()); }
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 void FailReturnsExpectedResult(string message) { var result = VerificationResult.Fail(message); Assert.That(result.Passed, Is.False); Assert.That(result.Failed, Is.True); Assert.That(result.Message, Is.EqualTo(message)); }
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 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_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 VerifyAccountToken_Should_Return_VerificationResult_With_Success_False_When_Token_Is_Null() { var errors = new Collection <IError> { new Error(AccountErrorCodeEnumeration.ConfirmationCodeWasNotGenerated, AccountErrorMessage.ConfirmationCodeWasNotGenerated) }; var expectedResult = VerificationResult.Fail(errors); var result = _accountVerificationService.VerifyConfirmationCode(null, "12345"); result.Should().BeEquivalentTo(expectedResult); }
public static Task Expect(this ProjectionScenario <MemoryCache> scenario, params CacheItem[] items) { if (items == null) { throw new ArgumentNullException("items"); } if (items.Length == 0) { return(scenario.ExpectNone()); } return(scenario. Verify(cache => { if (cache.GetCount() != items.Length) { if (cache.GetCount() == 0) { return Task.FromResult( VerificationResult.Fail( string.Format("Expected {0} cache item(s), but found 0 cache items.", items.Length))); } return Task.FromResult( VerificationResult.Fail( string.Format("Expected {0} cache item(s), but found {1} cache item(s) ({2}).", items.Length, cache.GetCount(), string.Join(",", cache.Select(pair => pair.Key))))); } if (!cache.Select(pair => cache.GetCacheItem(pair.Key)).SequenceEqual(items, new CacheItemEqualityComparer())) { var builder = new StringBuilder(); builder.AppendLine("Expected the following cache items:"); foreach (var expectedItem in items) { builder.AppendLine(expectedItem.Key + ": " + JToken.FromObject(expectedItem.Value).ToString()); } builder.AppendLine(); builder.AppendLine("But found the following cache items:"); foreach (var actualItem in cache) { builder.AppendLine(actualItem.Key + ": " + JToken.FromObject(actualItem.Value).ToString()); } return Task.FromResult(VerificationResult.Fail(builder.ToString())); } return Task.FromResult(VerificationResult.Pass()); }). Assert()); }
public async Task Given_no_messages_Then_list_is_empty() { var projection = new MunicipalityListProjections(); var resolver = ConcurrentResolve.WhenEqualToHandlerMessageType(projection.Handlers); await new ConnectedProjectionScenario <LegacyContext>(resolver) .Given() .Verify(async context => await context.MunicipalityList.AnyAsync() ? VerificationResult.Fail() : VerificationResult.Pass()) .Assert(); }
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 <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 static async Task Expect( this ConnectedProjectionScenario <ProductContext> scenario, params object[] records) { var database = Guid.NewGuid().ToString("N"); var specification = scenario.Verify(async context => { var comparisonConfig = new ComparisonConfig { MaxDifferences = 5 }; var comparer = new CompareLogic(comparisonConfig); var actualRecords = await context.AllRecords(); var result = comparer.Compare( actualRecords, records ); return(result.AreEqual ? VerificationResult.Pass() : VerificationResult.Fail(result.CreateDifferenceMessage(actualRecords, records))); }); using (var context = CreateContextFor(database)) { var projector = new ConnectedProjector <ProductContext>(specification.Resolver); var position = 0L; foreach (var message in specification.Messages) { var envelope = new Envelope(message, new Dictionary <string, object> { { "Position", position } }).ToGenericEnvelope(); await projector.ProjectAsync(context, envelope); position++; } await context.SaveChangesAsync(); } using (var context = CreateContextFor(database)) { var result = await specification.Verification(context, CancellationToken.None); if (result.Failed) { throw specification.CreateFailedScenarioExceptionFor(result); } } }