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