public async Task Should_GenerateDisablementOrEnablement()
{
var request = FakeRequest();
var user = new UserFake().Builder
.RuleFor(x => x.Id, f => request.ToDisableId)
.Generate();
var disablementType = new DisablementTypeFake().Builder
.RuleFor(x => x.Id, f => request.DisablementTypeId)
.Generate();
var uowGeneralMock = new Mock <IUowGeneral>();
uowGeneralMock.Setup(x => x.UserRepository.Find(user.Id)).ReturnsAsync(user);
uowGeneralMock.Setup(x => x.DisablementTypeRepository.Find(disablementType.Id)).ReturnsAsync(disablementType);
uowGeneralMock.Setup(x => x.UserDisablementRepository.Create(It.IsAny <UserDisablement>())).ReturnsAsync(It.IsAny <UserDisablement>());
var mailServiceMock = new Mock <IMailService>();
var handler = new DisableUserCommandHandler(uowGeneralMock.Object, mailServiceMock.Object);
var response = await handler.Handle(request, default);
Assert.NotNull(user.DisabledAccountAt);
Assert.Equal(user.Id, response.UserId);
uowGeneralMock.Verify(x => x.UserRepository.Update(user), Times.Once);
uowGeneralMock.Verify(x =>
x.UserDisablementRepository.Create(It.IsAny <UserDisablement>()), Times.Once);
uowGeneralMock.Verify(x => x.SaveChanges(), Times.Once);
mailServiceMock.Verify(x =>
x.Enqueue(It.IsAny <MailTemplateData>(), typeof(IDisablementMail), It.IsAny <DisablementMailData>()),
Times.Once);
}
public async Task ShouldThrow_InvalidAccountException_OnPassword()
{
var request = FakeRequest();
var loginMaxAttempts = new LoginMaxAttemptFake().Builder.Generate();
var user = new UserFake().Builder
.RuleFor(x => x.Email, f => request.Email)
.Generate();
var uowGeneralMock = new Mock <IUowGeneral>();
uowGeneralMock.Setup(x =>
x.UserRepository.FindByEmail(request.Email)).ReturnsAsync(user);
uowGeneralMock.Setup(x =>
x.LoginMaxAttemptRepository.Find(GeneralConstants.DefaultId)).ReturnsAsync(loginMaxAttempts);
var passwordServiceMock = new Mock <IPasswordService>();
passwordServiceMock.Setup(x =>
x.Verify(request.Password, user.Password)).Returns(false);
var accessTokenServiceMock = new Mock <IAccessTokenService>();
var refreshTokenService = new RefreshTokenService(uowGeneralMock.Object);
var handler = new LoginUserCommandHandler(uowGeneralMock.Object, passwordServiceMock.Object,
accessTokenServiceMock.Object, refreshTokenService);
await Assert.ThrowsAsync <InvalidAccountException>(() =>
handler.Handle(request, default));
Assert.Equal(1, user.LoginAttempts);
Assert.Null(user.FindEvent(typeof(MaxLoginAttemptsReached)));
uowGeneralMock.Verify(x => x.SaveChanges(), Times.Once);
}
public async Task ShouldThrow_LoginMaxAttemptsReachedException()
{
var request = FakeRequest();
var loginMaxAttempts = new LoginMaxAttemptFake().Builder.Generate();
var user = new UserFake().Builder
.RuleFor(x => x.Email, f => request.Email)
.RuleFor(x => x.LoginAttempts, f => loginMaxAttempts.MaxAttempts + 1)
.Generate();
var uowGeneralMock = new Mock <IUowGeneral>();
uowGeneralMock.Setup(x =>
x.UserRepository.FindByEmail(request.Email)).ReturnsAsync(user);
uowGeneralMock.Setup(x =>
x.LoginMaxAttemptRepository.Find(GeneralConstants.DefaultId)).ReturnsAsync(loginMaxAttempts);
var passwordServiceMock = new Mock <IPasswordService>();
var accessTokenServiceMock = new Mock <IAccessTokenService>();
var refreshTokenService = new RefreshTokenService(uowGeneralMock.Object);
var handler = new LoginUserCommandHandler(uowGeneralMock.Object, passwordServiceMock.Object,
accessTokenServiceMock.Object, refreshTokenService);
await Assert.ThrowsAsync <LoginMaxAttemptsReachedException>(() =>
handler.Handle(request, default));
}
public async Task Should_LoginUser()
{
var request = FakeRequest();
var loginMaxAttempts = new LoginMaxAttemptFake().Builder.Generate();
var user = new UserFake().Builder
.RuleFor(x => x.Email, f => request.Email)
.Generate();
var uowGeneralMock = new Mock <IUowGeneral>();
uowGeneralMock.Setup(x =>
x.UserRepository.FindByEmail(request.Email)).ReturnsAsync(user);
uowGeneralMock.Setup(x =>
x.LoginMaxAttemptRepository.Find(GeneralConstants.DefaultId)).ReturnsAsync(loginMaxAttempts);
uowGeneralMock.Setup(x =>
x.RefreshTokenRepository.Create(It.IsAny <RefreshToken>())).ReturnsAsync(It.IsAny <RefreshToken>());
var passwordServiceMock = new Mock <IPasswordService>();
passwordServiceMock.Setup(x =>
x.Verify(request.Password, user.Password)).Returns(true);
var accessTokenServiceMock = new Mock <IAccessTokenService>();
var refreshTokenService = new RefreshTokenService(uowGeneralMock.Object);
var handler = new LoginUserCommandHandler(uowGeneralMock.Object, passwordServiceMock.Object,
accessTokenServiceMock.Object, refreshTokenService);
var response = await handler.Handle(request, default);
Assert.NotNull(response);
Assert.NotNull(user.FindEvent(typeof(UserLogged)));
accessTokenServiceMock.Verify(x => x.GetAccessToken(user), Times.Once);
uowGeneralMock.Verify(x => x.UserRepository.Update(user), Times.Once);
uowGeneralMock.Verify(x => x.SaveChanges(), Times.Once);
}
public void ShouldThrowArgumentExceptionWhenPassedValueIsTooLong()
{
//Arrange
var user = new UserFake("Name");
//Act & Assert
Assert.ThrowsException <ArgumentException>(() => user.Username = "******");
}
public void UsernameSetter_ShouldThrowArgumentException_WhenPassedNullOrWhitespaceString(string val)
{
// Arrange
string validUserName = "******";
var fakeUser = new UserFake(validUserName);
// Act and Assert
Assert.Throws <ArgumentException>(() => fakeUser.Username = val);
}
public void Ctor_ShouldSetPassedParametersCorrectly_WhenParametersAreValid()
{
// Arrange
string validUserName = "******";
// Act
var fakeUser = new UserFake(validUserName);
// Assert
Assert.AreSame(validUserName, fakeUser.Username);
}
public void ShouldCorrectlyAssignPassedValue()
{
//Arange
var user = new UserFake("Name");
//Act
user.Username = "******";
//Assert
Assert.AreEqual("Pesho", user.Username);
}
public void UsernameSetter_ShouldNotThrow_WhenPassedValidString()
{
// Arrange
string validUserName = "******";
var fakeUser = new UserFake(validUserName);
string newValidUserName = "******";
// Act and Assert
Assert.DoesNotThrow(
() => fakeUser.Username = newValidUserName);
}
public void UsernameSetter_ShouldThrowArgumentException_WhenPassedStringWithInvalidLength(int invalidLength)
{
// Arrange
string validUserName = "******";
var fakeUser = new UserFake(validUserName);
string usernameWithInvalidLength = new string('c', invalidLength);
// Act and Assert
Assert.Throws <ArgumentException>(
() => fakeUser.Username = usernameWithInvalidLength);
}
public void UsernameSetter_ShouldAssignCorrectly_WhenPassedValidString()
{
// Arrange
string validUserName = "******";
var fakeUser = new UserFake(validUserName);
string newValidUserName = "******";
// Act
fakeUser.Username = newValidUserName;
// Assert
Assert.AreSame(newValidUserName, fakeUser.Username);
}
public async Task ShouldThrow_AlreadyDisabledAccountException()
{
var request = FakeRequest();
var user = new UserFake().Builder
.RuleFor(x => x.Id, f => request.ToDisableId)
.RuleFor(x => x.DisabledAccountAt, f => f.Date.Recent())
.Generate();
var uowGeneralMock = new Mock <IUowGeneral>();
uowGeneralMock.Setup(x => x.UserRepository.Find(user.Id)).ReturnsAsync(user);
var mailServiceMock = new Mock <IMailService>();
var handler = new DisableUserCommandHandler(uowGeneralMock.Object, mailServiceMock.Object);
await Assert.ThrowsAsync <AlreadyDisabledAccountException>(() =>
handler.Handle(request, default));
}
public async Task ShouldThrow_ExistingAccountException()
{
var request = FakeRequest();
var user = new UserFake()
.Builder
.RuleFor(x => x.Email, request.Email)
.Generate();
var uowGeneralMock = new Mock <IUowGeneral>();
uowGeneralMock.Setup(x =>
x.UserRepository.FindByEmail(request.Email)).ReturnsAsync(user);
var passwordServiceMock = new Mock <IPasswordService>();
var handler = new CreateUserCommandHandler(uowGeneralMock.Object, passwordServiceMock.Object);
await Assert.ThrowsAsync <ExistingAccountException>(() =>
handler.Handle(request, default));
}
public async Task ShouldThrow_InvalidAccountException_OnDisabledAccount()
{
var request = FakeRequest();
var user = new UserFake().Builder
.RuleFor(x => x.DisabledAccountAt, f => f.Date.Recent())
.Generate();
var uowGeneralMock = new Mock <IUowGeneral>();
uowGeneralMock.Setup(x =>
x.UserRepository.FindByEmail(request.Email)).ReturnsAsync(user);
var passwordServiceMock = new Mock <IPasswordService>();
var accessTokenServiceMock = new Mock <IAccessTokenService>();
var refreshTokenService = new RefreshTokenService(uowGeneralMock.Object);
var handler = new LoginUserCommandHandler(uowGeneralMock.Object, passwordServiceMock.Object,
accessTokenServiceMock.Object, refreshTokenService);
await Assert.ThrowsAsync <InvalidAccountException>(() =>
handler.Handle(request, default));
}
private void CreateUser(int realEstateId, UserFake account)
{
var groupId = _context.UserGroup.First(i => i.StaticCode == account.UserStaticCode).Id;
var user = _context.UserAccount.Add(new UserAccount
{
Email = account.Email,
HasExternalAuthentication = false,
FirstName = account.Name,
LastName = account.Lastname,
IsConfirmed = true,
IsActive = true,
PasswordHash = _passwordService.HashUserPassword(account.Email, account.Password),
RegistrationDate = DateTime.Now,
UserName = account.Username
});
_context.UserAccountGroup.Add(new UserAccountGroup
{
DateCreated = DateTime.Now,
IsActive = 1,
UserAccountId = user.Entity.Id,
UserGroupId = groupId
});
if (CheckIfShouldBeAgent(account.UserStaticCode))
{
_context.Agent.Add(new Agent
{
UserAccountId = user.Entity.Id,
RealEstateId = realEstateId,
MetadataJson = "{}",
IsResponsible = CheckIfShouldBeResponsible(account.UserStaticCode)
});
}
_context.SaveChanges();
}
public void UserConstructor_ReturnUserName()
{
var sut = new UserFake("GeiLord");
Assert.AreEqual("GeiLord", sut.Username);
}
public void Username_ShouldThrowException_WhenInvalidValuePassed()
{
var sut = new UserFake("OnqOtVraca");
}
