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_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 ValidateAsync_Should_Set_Fail_GrantValidationResult_When_Account_Does_Not_Exist()
{
var errors = new Collection <IError>
{
new Error(AccountErrorCodeEnumeration.NotFound, AccountErrorMessage.NotFound)
};
var getAccountResult = GetResult <Account> .Fail(errors);
var context = new ResourceOwnerPasswordValidationContext
{
Request = new ValidatedTokenRequest
{
GrantType = GrantType.ResourceOwnerPassword
}
};
var expectedResult = new GrantValidationResult(TokenRequestErrors.InvalidTarget, "Invalid credentials");
_accountGetterServiceMock.Setup(x => x.GetByEmailAsync(It.IsAny <string>()))
.ReturnsAsync(getAccountResult);
Func <Task> result = async() => await _resourceOwnerPasswordValidator.ValidateAsync(context);
await result.Should().NotThrowAsync <Exception>();
context.Result.Should().BeEquivalentTo(expectedResult);
}
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 ProvideAccountForExternalLoginAsync_Should_Return_Created_Account()
{
var errors = new Collection <IError>
{
new Error(AccountErrorCodeEnumeration.NotFound, AccountErrorMessage.NotFound)
};
var getAccountResult = GetResult <Account> .Fail(errors);
const string email = "*****@*****.**";
var account = Account.Builder()
.SetId(Guid.NewGuid())
.SetEmail(email)
.SetConfirmed(true)
.SetPasswordHash(string.Empty)
.SetSecurityStamp(Guid.NewGuid())
.SetCreated(DateTimeOffset.UtcNow)
.SetRoles(new List <Guid> {
Guid.NewGuid()
})
.Build();
_accountGetterServiceMock.Setup(x => x.GetByEmailAsync(It.IsAny <string>()))
.ReturnsAsync(getAccountResult);
_accountCreatorServiceMock.Setup(x => x.CreateAsync(It.IsAny <Guid>(), It.IsAny <string>(),
It.IsAny <string>(), It.IsAny <Guid>())).ReturnsAsync(account);
var result = await _accountProviderService.ProvideAccountForExternalLoginAsync(email, Guid.NewGuid());
result.Email.Should().Be(email);
result.Confirmed.Should().BeTrue();
}
public async Task IsActiveAsync_Should_Set_IsActive_To_False_When_Account_Is_Not_Found()
{
var errors = new Collection <IError>
{
new Error(AccountErrorCodeEnumeration.NotFound, AccountErrorMessage.NotFound)
};
var getAccountResult = GetResult <Account> .Fail(errors);
var claims = new List <Claim>
{
new Claim(ClaimTypes.Name, "*****@*****.**"),
new Claim(ClaimTypes.NameIdentifier, Guid.NewGuid().ToString())
};
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().BeFalse();
}
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 <GetResult <User> > GetByIdAsync(Guid id)
{
var user = await _userRepository.GetByIdAsync(id);
if (user is null)
{
var errors = new List <IError>
{
new Error(UserErrorCodeEnumeration.NotFound, UserErrorMessage.NotFound)
};
return(GetResult <User> .Fail(errors));
}
return(GetResult <User> .Ok(user));
}
public async Task <GetResult <FlatForRentAnnouncement> > GetByIdAsync(Guid id)
{
var flatForRentAnnouncement = await _flatForRentAnnouncementRepository.GetByIdAsync(id);
if (flatForRentAnnouncement is null)
{
var errors = new Collection <IError>
{
new Error(FlatForRentAnnouncementErrorCodeEnumeration.NotFound, FlatForRentAnnouncementErrorMessage.NotFound)
};
return(GetResult <FlatForRentAnnouncement> .Fail(errors));
}
return(GetResult <FlatForRentAnnouncement> .Ok(flatForRentAnnouncement));
}
public async Task <GetResult <City> > GetByIdAsync(Guid id)
{
var city = await _cityRepository.GetByIdAsync(id);
if (city is null)
{
var errors = new Collection <IError>
{
new Error(CityErrorCodeEnumeration.NotFound, CityErrorMessage.NotFound)
};
return(GetResult <City> .Fail(errors));
}
return(GetResult <City> .Ok(city));
}
public GetResult <RoomForRentAnnouncementPreference> GetByByUserAndId(User user, Guid id)
{
var roomForRentAnnouncementPreference = user.RoomForRentAnnouncementPreferences.SingleOrDefault(x => x.Id == id);
if (roomForRentAnnouncementPreference is null)
{
var errors = new Collection <IError>
{
new Error(RoomForRentAnnouncementPreferenceErrorCode.NotFound, RoomForRentAnnouncementPreferenceErrorMessage.NotFound)
};
return(GetResult <RoomForRentAnnouncementPreference> .Fail(errors));
}
return(GetResult <RoomForRentAnnouncementPreference> .Ok(roomForRentAnnouncementPreference));
}
public async Task <GetResult <State> > GetByIdAsync(Guid id)
{
var state = await _stateRepository.GetByIdAsync(id);
if (state is null)
{
var errors = new Collection <IError>
{
new Error(StateErrorCodeEnumeration.NotFound, StateErrorMessage.NotFound)
};
return(GetResult <State> .Fail(errors));
}
return(GetResult <State> .Ok(state));
}
public async Task GetByEmailAsync_Should_Return_GetResult_With_Errors_When_Account_Is_Not_Found()
{
const string email = "*****@*****.**";
var errors = new Collection <IError>
{
new Error(AccountErrorCodeEnumeration.NotFound, AccountErrorMessage.NotFound)
};
var expectedResult = GetResult <Account> .Fail(errors);
_accountRepositoryMock.Setup(x => x.GetByEmailAsync(It.IsAny <string>())).Returns(Task.FromResult <Account>(null));
var result = await _accountGetterService.GetByEmailAsync(email);
result.Should().BeEquivalentTo(expectedResult);
}
public async Task <GetResult <Account> > GetByEmailAsync(string email)
{
var account = await _accountRepository.GetByEmailAsync(email);
if (account is null)
{
var errors = new Collection <IError>
{
new Error(AccountErrorCodeEnumeration.NotFound, AccountErrorMessage.NotFound)
};
return(GetResult <Account> .Fail(errors));
}
return(GetResult <Account> .Ok(account));
}
public async Task GetByIdAsync_Should_Return_GetResult_With_Errors_When_State_Is_Not_Found()
{
var id = Guid.NewGuid();
var errors = new Collection <IError>
{
new Error(StateErrorCodeEnumeration.NotFound, StateErrorMessage.NotFound)
};
var expectedResult = GetResult <State> .Fail(errors);
_stateRepositoryMock.Setup(x => x.GetByIdAsync(It.IsAny <Guid>())).Returns(Task.FromResult <State>(null));
var result = await _stateGetterService.GetByIdAsync(id);
result.Should().BeEquivalentTo(expectedResult);
}
public async Task GetByIdAsync_Should_Return_GetResult_Fail()
{
var errors = new Collection <IError>
{
new Error(RoomForRentAnnouncementErrorCodeEnumeration.NotFound, RoomForRentAnnouncementErrorMessage.NotFound)
};
var expectedResult = GetResult <RoomForRentAnnouncement> .Fail(errors);
_roomForRentAnnouncementRepositoryMock.Setup(x => x.GetByIdAsync(It.IsAny <Guid>()))
.Returns(Task.FromResult <RoomForRentAnnouncement>(null));
var result = await _service.GetByIdAsync(Guid.NewGuid());
result.Should().BeEquivalentTo(expectedResult);
}
public async Task <GetResult <Role> > GetByIdAsync(Guid id)
{
var role = await _roleRepository.GetByIdAsync(id);
if (role is null)
{
var errors = new Collection <IError>
{
new Error(RoleErrorCodeEnumeration.NotFound, RoleErrorMessage.NotFound)
};
return(GetResult <Role> .Fail(errors));
}
return(GetResult <Role> .Ok(role));
}
public async Task GetByIdAsync_Should_Return_GetResult_With_Errors_When_CityDistrict_Is_Not_Found()
{
var errors = new Collection <IError>
{
new Error(CityDistrictErrorCodeEnumeration.NotFound, CityDistrictErrorMessage.NotFound)
};
var expectedResult = GetResult <CityDistrict> .Fail(errors);
_cityDistrictRepositoryMock.Setup(x => x.GetByIdAsync(It.IsAny <Guid>()))
.Returns(Task.FromResult <CityDistrict>(null));
var result = await _service.GetByIdAsync(Guid.NewGuid());
result.Should().BeEquivalentTo(expectedResult);
}
public async Task VerifyUserDoesNotExistAsync_Should_Return_VerificationResult_With_Success_True()
{
var errors = new List <IError>
{
new Error(UserErrorCodeEnumeration.NotFound, UserErrorMessage.NotFound)
};
var getUserResult = GetResult <User> .Fail(errors);
var expectedResult = VerificationResult.Ok();
_userGetterServiceMock.Setup(x => x.GetByIdAsync(It.IsAny <Guid>())).ReturnsAsync(getUserResult);
var result = await _service.VerifyUserDoesNotExistAsync(Guid.NewGuid());
result.Should().BeEquivalentTo(expectedResult);
}
public async Task HandleAsync_Should_Throw_ResourceNotFoundException_When_FlatForRentAnnouncement_Is_Not_Found()
{
var errors = new Collection <IError>
{
new Error(FlatForRentAnnouncementErrorCodeEnumeration.NotFound, FlatForRentAnnouncementErrorMessage.NotFound)
};
var getFlatForRentAnnouncementResult = GetResult <FlatForRentAnnouncement> .Fail(errors);
_flatForRentAnnouncementGetterServiceMock.Setup(x => x.GetByIdAsync(It.IsAny <Guid>()))
.ReturnsAsync(getFlatForRentAnnouncementResult);
Func <Task <FlatForRentAnnouncementOutputQuery> > result = async() => await _queryHandler.HandleAsync(new GetFlatForRentAnnouncementInputQuery(Guid.NewGuid()));
var exceptionResult = await result.Should().ThrowExactlyAsync <ResourceNotFoundException>();
exceptionResult.And.Errors.Should().BeEquivalentTo(errors);
}
public async Task HandleAsync_Should_Throw_ResourceNotFoundException_When_State_Is_Not_Found()
{
var command = new DeleteStateCommand(Guid.NewGuid(), new byte[] { 1, 2, 4, 8, 16, 32, 64 });
var errors = new Collection <IError>
{
new Error(StateErrorCodeEnumeration.NotFound, StateErrorMessage.NotFound)
};
var getStateResult = GetResult <State> .Fail(errors);
_stateGetterServiceMock.Setup(x => x.GetByIdAsync(It.IsAny <Guid>())).ReturnsAsync(getStateResult);
Func <Task> result = async() => await _commandHandler.HandleAsync(command);
var exceptionResult = await result.Should().ThrowAsync <ResourceNotFoundException>();
exceptionResult.And.Errors.Should().BeEquivalentTo(errors);
}
public async Task HandleAsync_Should_Throw_ResourceNotFoundException_When_Role_Is_Not_Found()
{
var deleteRoleCommand = new DeleteRoleCommand(Guid.NewGuid(), Array.Empty <byte>());
var errors = new Collection <IError>
{
new Error(RoleErrorCodeEnumeration.NotFound, RoleErrorMessage.NotFound)
};
var getRoleResult = GetResult <Role> .Fail(errors);
_roleGetterServiceMock.Setup(x => x.GetByIdAsync(It.IsAny <Guid>())).ReturnsAsync(getRoleResult);
Func <Task> result = async() => await _commandHandler.HandleAsync(deleteRoleCommand);
var exceptionResult = await result.Should().ThrowAsync <ResourceNotFoundException>();
exceptionResult.And.Errors.Should().BeEquivalentTo(errors);
}
public async Task HandleAsync_Should_Throw_ResourceNotFoundException_When_State_Does_Not_Exist()
{
var command = new UpdateStateCommand(Guid.NewGuid(), Array.Empty <byte>(), "NewName", "NewPolishName");
var errors = new Collection <IError>
{
new Error(StateErrorCodeEnumeration.NotFound, StateErrorMessage.NotFound)
};
var getStateResult = GetResult <State> .Fail(errors);
_stateGetterServiceMock.Setup(x => x.GetByIdAsync(It.IsAny <Guid>())).ReturnsAsync(getStateResult);
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_ResourceNotFoundException_When_User_Is_Not_Found()
{
var inputQuery = new GetFlatForRentAnnouncementPreferenceInputQuery(Guid.NewGuid(), Guid.NewGuid());
var errors = new List <IError>
{
new Error(UserErrorCodeEnumeration.NotFound, UserErrorMessage.NotFound)
};
var getUserResult = GetResult <User> .Fail(errors);
_userGetterServiceMock.Setup(x => x.GetByIdAsync(It.IsAny <Guid>())).ReturnsAsync(getUserResult);
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_State_Does_Not_Exist()
{
var id = Guid.NewGuid();
var errors = new Collection <IError>
{
new Error(StateErrorCodeEnumeration.NotFound, StateErrorMessage.NotFound)
};
var getStateResult = GetResult <State> .Fail(errors);
_stateGetterServiceMock.Setup(x => x.GetByIdAsync(It.IsAny <Guid>())).ReturnsAsync(getStateResult);
Func <Task <StateOutputQuery> > result = async() => await _queryHandler.HandleAsync(new GetStateInputQuery(id));
var exceptionResult = await result.Should().ThrowExactlyAsync <ResourceNotFoundException>();
exceptionResult.And.Errors.Should().BeEquivalentTo(errors);
}
public async Task HandleAsync_Should_Throw_ResourceNotFoundException_When_User_Is_Not_Found()
{
var command = new DeleteUserCommand(Guid.NewGuid());
var errors = new List <IError>
{
new Error(UserErrorCodeEnumeration.NotFound, UserErrorMessage.NotFound)
};
var getUserResult = GetResult <User> .Fail(errors);
_userGetterServiceMock.Setup(x => x.GetByIdAsync(It.IsAny <Guid>())).ReturnsAsync(getUserResult);
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_ResourceNotFoundException_When_Account_Is_Not_Found()
{
var changePasswordCommand = new ChangePasswordCommand(Guid.NewGuid(), "OldPassword", "NewPassword");
var errors = new Collection <IError>
{
new Error(AccountErrorCodeEnumeration.NotFound, AccountErrorMessage.NotFound)
};
var getAccountResult = GetResult <Account> .Fail(errors);
_accountGetterServiceMock.Setup(x => x.GetByIdAsync(It.IsAny <Guid>()))
.ReturnsAsync(getAccountResult);
Func <Task> result = async() => await _commandHandler.HandleAsync(changePasswordCommand);
var exceptionResult = await result.Should().ThrowAsync <ResourceNotFoundException>();
exceptionResult.And.Errors.Should().BeEquivalentTo(errors);
}
public async Task HandleAsync_Should_Throw_ValidationException_When_State_Is_Not_Found()
{
var stateId = Guid.NewGuid();
var command = new CreateCityCommand(Guid.NewGuid(), "Name", "PolishName", stateId);
var errors = new Collection <IError>
{
new Error(StateErrorCodeEnumeration.NotFound, StateErrorMessage.NotFound)
};
var getStateResult = GetResult <State> .Fail(errors);
_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_Throw_ValidationException_When_Account_Is_Not_Found()
{
var resetPasswordCommand = new ResetPasswordCommand("*****@*****.**", "123456", "Password");
var errors = new Collection <IError>
{
new Error(AccountErrorCodeEnumeration.NotFound, AccountErrorMessage.NotFound)
};
var getAccountResult = GetResult <Account> .Fail(errors);
_accountGetterServiceMock.Setup(x => x.GetByEmailAsync(It.IsAny <string>()))
.ReturnsAsync(getAccountResult);
Func <Task> result = async() => await _commandHandler.HandleAsync(resetPasswordCommand);
var exceptionResult = await result.Should().ThrowAsync <ValidationException>();
exceptionResult.And.Errors.Should().BeEquivalentTo(errors);
}
public async Task HandleAsync_Should_Throw_ResourceNotFoundException_When_FlatForRentAnnouncement_Is_Not_Found()
{
var errors = new Collection <IError>
{
new Error(FlatForRentAnnouncementErrorCodeEnumeration.NotFound, FlatForRentAnnouncementErrorMessage.NotFound)
};
var getFlatForRentAnnouncementResult = GetResult <FlatForRentAnnouncement> .Fail(errors);
var updateFlatForRentAnnouncementCommand = new UpdateFlatForRentAnnouncementCommand(Guid.NewGuid(), "Title",
"http://sourceUrl", Guid.NewGuid(), "Description", null, null, new List <Guid>());
_flatForRentAnnouncementGetterServiceMock.Setup(x => x.GetByIdAsync(It.IsAny <Guid>()))
.ReturnsAsync(getFlatForRentAnnouncementResult);
Func <Task> result = async() => await _commandHandler.HandleAsync(updateFlatForRentAnnouncementCommand);
var exceptionResult = await result.Should().ThrowExactlyAsync <ResourceNotFoundException>();
exceptionResult.And.Errors.Should().BeEquivalentTo(errors);
}