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