// TODO: Check for user in domain || Not necessary if we checking email??
public DataAccess.Models.User Invoke(Models.UserModel user)
{
if (!user.IsValid() || userRepository.FindBy(x => x.Email == user.Email).Count() > 0)
{
return(null);
}
var newUser = AutoMapper.Mapper.Map <DataAccess.Models.User>(user);
newUser.PasswordSalt = hasher.GenerateRandomSalt();
newUser.PasswordHash = hasher.CreatePasswordHash(user.Password, newUser.PasswordSalt);
userRepository.Add(newUser);
var newUserToken = new DataAccess.Models.UserToken
{
User = newUser,
SecretToken = hasher.GenerateRandomGuid()
};
userTokenRepository.Add(newUserToken);
_unitOfWork.Save();
return(newUser);
}
public void Invoke_ValidData_DeleteAndSaveAreCalled()
{
var guid = new Guid();
var userTokenFromDb = new DataAccess.Models.UserToken
{
Id = guid
};
var findByResult = new List <DataAccess.Models.UserToken> {
userTokenFromDb
};
var mockedUserTokenRepository = new Mock <IUserTokenRepository>();
mockedUserTokenRepository.Setup(r => r.FindBy(It.IsAny <Expression <Func <DataAccess.Models.UserToken, bool> > >()))
.Returns(findByResult.AsQueryable());
var mockedUnitOfWork = new Mock <IUnitOfWork>();
var action = new DeleteUserTokenByTokenString(mockedUserTokenRepository.Object, mockedUnitOfWork.Object);
// action
var actionResult = action.Invoke("123");
// assert
Assert.True(actionResult);
mockedUserTokenRepository.Verify(r => r.Delete(It.IsAny <DataAccess.Models.UserToken>()), Times.Once());
mockedUnitOfWork.Verify(r => r.Save(), Times.Once());
}
public void Invoke_ValidData_AddsUserToDatabaseWithCorrectValues()
{
var user = new DataAccess.Models.User
{
Name = "Ryszard"
};
DataAccess.Models.UserToken tokensaved = null;
var mockedUserTokenRepository = new Mock <IUserTokenRepository>();
var mockedUserRepository = new Mock <IUserRepository>();
var mockedHasher = new Mock <IHasher>();
mockedUserRepository.Setup(r => r.GetById(It.IsAny <Guid>())).Returns(user);
mockedHasher.Setup(r => r.GenerateRandomGuid()).Returns("123");
mockedUserTokenRepository.Setup(r => r.Add(It.IsAny <DataAccess.Models.UserToken>()))
.Callback <DataAccess.Models.UserToken>(u => tokensaved = u);
var mockedUnitOfWork = new Mock <IUnitOfWork>();
var action = new AddUserTokenToUser(mockedUserTokenRepository.Object, mockedUserRepository.Object, mockedUnitOfWork.Object, mockedHasher.Object);
action.Invoke(Guid.NewGuid());
Assert.Equal("Ryszard", tokensaved.User.Name);
Assert.Equal("123", tokensaved.SecretToken);
mockedUserTokenRepository.Verify(r => r.Delete(It.IsAny <DataAccess.Models.UserToken>()), Times.Never);
mockedUserTokenRepository.Verify(r => r.Add(It.IsAny <DataAccess.Models.UserToken>()), Times.Once());
mockedUnitOfWork.Verify(r => r.Save(), Times.Once());
}
public string Invoke(Guid userId)
{
if (userId == Guid.Empty)
{
return(string.Empty);
}
var user = userRepository.GetById(userId);
if (user == null)
{
return(string.Empty);
}
var token = userTokenRepository.GetById(userId);
if (token != null)
{
userTokenRepository.Delete(token);
}
var userToken = new DataAccess.Models.UserToken
{
User = user,
SecretToken = hasher.GenerateRandomGuid()
};
userTokenRepository.Add(userToken);
_unitOfWork.Save();
return(userToken.SecretToken);
}
public void Invoke_ValidData_SavedAndEditAreCalled()
{
// prepare
var guid = new Guid();
var userFromDb = new DataAccess.Models.User
{
Id = guid,
Name = "Name",
PasswordHash = "hash",
PasswordSalt = "salt"
};
var userToken = new DataAccess.Models.UserToken
{
SecretToken = "123"
};
var findByResult = new List <DataAccess.Models.UserToken> {
userToken
};
DataAccess.Models.User userSaved = null;
var mockedUserRepository = new Mock <IUserRepository>();
mockedUserRepository.Setup(r => r.GetById(It.IsAny <Guid>())).Returns(userFromDb);
mockedUserRepository.Setup(r => r.Edit(It.IsAny <DataAccess.Models.User>()))
.Callback <DataAccess.Models.User>(u => userSaved = u);
var mockedUserTokenRepo = new Mock <IUserTokenRepository>();
mockedUserTokenRepo.Setup(r => r.FindBy(It.IsAny <Expression <Func <DataAccess.Models.UserToken, bool> > >()))
.Returns(findByResult.AsQueryable);
var mockedHasher = new Mock <IHasher>();
mockedHasher.Setup(h => h.GenerateRandomSalt()).Returns("salt-generated");
mockedHasher.Setup(h => h.CreatePasswordHash("plain", "salt-generated")).Returns("plain-hashed");
var mockedUnitOfWork = new Mock <IUnitOfWork>();
var action = new EditUserPassword(mockedUserTokenRepo.Object, mockedUserRepository.Object, mockedUnitOfWork.Object, mockedHasher.Object);
// action
var actionResult = action.Invoke(Guid.NewGuid(), "plain");
// assert
Assert.True(actionResult);
Assert.Equal("plain-hashed", userSaved.PasswordHash);
Assert.Equal("salt-generated", userSaved.PasswordSalt);
Assert.Equal("Name", userSaved.Name);
Assert.Equal("123", userToken.SecretToken);
mockedHasher.Verify(r => r.GenerateRandomSalt(), Times.Once);
mockedHasher.Verify(r => r.CreatePasswordHash(It.IsAny <string>(), It.IsAny <string>()), Times.Once);
mockedUserRepository.Verify(r => r.Edit(It.IsAny <DataAccess.Models.User>()), Times.Once());
mockedUserTokenRepo.Verify(r => r.Delete(It.IsAny <DataAccess.Models.UserToken>()), Times.Once());
mockedUnitOfWork.Verify(r => r.Save(), Times.Once());
}
public void Verify_ForDoubledAction_UpdatesEmailConfirmedOnOnce()
{
// prepare
var guid = new Guid();
var userFromDb = new DataAccess.Models.User
{
Id = guid,
EmailConfirmedOn = null
};
var userTokenFromDb = new DataAccess.Models.UserToken
{
User = userFromDb,
SecretToken = "123",
SecretTokenTimeStamp = DateTime.UtcNow.AddDays(1)
};
DataAccess.Models.User userSaved = null;
var getAllResults = new List <DataAccess.Models.UserToken> {
userTokenFromDb
};
var mockedUserTokenRepository = new Mock <IUserTokenRepository>();
mockedUserTokenRepository.SetupSequence(r => r.FindBy(It.IsAny <Expression <Func <DataAccess.Models.UserToken, bool> > >()))
.Returns(getAllResults.AsQueryable())
.Returns(new List <DataAccess.Models.UserToken>().AsQueryable());
var mockedUserRepo = new Mock <IUserRepository>();
mockedUserRepo.Setup(r => r.Edit(It.IsAny <DataAccess.Models.User>()))
.Callback <DataAccess.Models.User>(u => userSaved = u);
var mockedUnitOfWork = new Mock <IUnitOfWork>();
var action = new ConfirmUserEmailByToken(mockedUserTokenRepository.Object, mockedUserRepo.Object, mockedUnitOfWork.Object);
// action
action.Invoke("1");
action.Invoke("1");
// assert
Assert.NotNull(userSaved.EmailConfirmedOn);
mockedUserRepo.Verify(r => r.Edit(It.IsAny <DataAccess.Models.User>()), Times.Once());
mockedUserTokenRepository.Verify(r => r.Delete(It.IsAny <DataAccess.Models.UserToken>()), Times.Once());
mockedUnitOfWork.Verify(r => r.Save(), Times.Once());
}
public void Invoke_ValidData_ReturnsCorrectModel()
{
var guid = new Guid();
var userFromDb = new DataAccess.Models.User
{
Id = guid,
Name = "Name",
Email = "*****@*****.**",
EmailConfirmedOn = DateTime.MinValue,
LockedOn = null,
CreatedOn = DateTime.MinValue,
ModifiedOn = DateTime.MinValue,
DeletedOn = null
};
var userTokenFromDb = new DataAccess.Models.UserToken
{
Id = new Guid(),
User = userFromDb,
SecretToken = "123"
};
var findByResult = new List <DataAccess.Models.UserToken> {
userTokenFromDb
};
// prepare
var mockedUserTokenRepository = new Mock <IUserTokenRepository>();
mockedUserTokenRepository.Setup(r => r.FindBy(It.IsAny <Expression <Func <DataAccess.Models.UserToken, bool> > >()))
.Returns(findByResult.AsQueryable);
var action = new GetUserByToken(mockedUserTokenRepository.Object);
// action
var user = action.Invoke("123");
// check
Assert.Equal(guid, user.Id);
Assert.Equal("Name", user.Name);
Assert.Equal("*****@*****.**", user.Email);
Assert.Equal(DateTime.MinValue, user.EmailConfirmedOn);
Assert.Null(user.LockedOn);
Assert.Equal(DateTime.MinValue, user.CreatedOn);
Assert.Equal(DateTime.MinValue, user.ModifiedOn);
Assert.Null(user.DeletedOn);
mockedUserTokenRepository.Verify(r => r.FindBy(It.IsAny <Expression <Func <DataAccess.Models.UserToken, bool> > >()), Times.Once);
}
public void Invoke_ValidData_NoUser()
{
// prepare
var userToken = new DataAccess.Models.UserToken
{
SecretToken = "123"
};
var findByResult = new List <DataAccess.Models.UserToken> {
userToken
};
DataAccess.Models.User userSaved = null;
var mockedUserRepository = new Mock <IUserRepository>();
var mockedUserTokenRepo = new Mock <IUserTokenRepository>();
mockedUserTokenRepo.Setup(r => r.FindBy(It.IsAny <Expression <Func <DataAccess.Models.UserToken, bool> > >()))
.Returns(findByResult.AsQueryable);
var mockedHasher = new Mock <IHasher>();
mockedHasher.Setup(h => h.GenerateRandomSalt()).Returns("salt-generated");
mockedHasher.Setup(h => h.CreatePasswordHash("plain", "salt-generated")).Returns("plain-hashed");
var mockedUnitOfWork = new Mock <IUnitOfWork>();
var action = new EditUserPassword(mockedUserTokenRepo.Object, mockedUserRepository.Object, mockedUnitOfWork.Object, mockedHasher.Object);
// action
var actionResult = action.Invoke(Guid.NewGuid(), "plain");
// assert
Assert.False(actionResult);
Assert.Null(userSaved);
mockedHasher.Verify(r => r.GenerateRandomSalt(), Times.Never);
mockedHasher.Verify(r => r.CreatePasswordHash(It.IsAny <string>(), It.IsAny <string>()), Times.Never);
mockedUserRepository.Verify(r => r.Edit(It.IsAny <DataAccess.Models.User>()), Times.Never);
mockedUnitOfWork.Verify(r => r.Save(), Times.Never);
mockedUserTokenRepo.Verify(r => r.Delete(It.IsAny <DataAccess.Models.UserToken>()), Times.Never);
mockedUnitOfWork.Verify(r => r.Save(), Times.Never);
}
public void Invoke_ValidData_AddsUserToDatabaseWithCorrectValues()
{
// prepare
var userData = new UserModel
{
Email = "email",
Password = "******",
Name = "Ryszard"
};
DataAccess.Models.User userSaved = null;
DataAccess.Models.UserToken userTokenSaved = null;
var mockedUserTokenRepository = new Mock <IUserTokenRepository>();
mockedUserTokenRepository.Setup(r => r.Add(It.IsAny <DataAccess.Models.UserToken>()))
.Callback <DataAccess.Models.UserToken>(u => userTokenSaved = u);
var mockedUserRepo = new Mock <IUserRepository>();
mockedUserRepo.Setup(r => r.Add(It.IsAny <DataAccess.Models.User>()))
.Callback <DataAccess.Models.User>(u => userSaved = u);
var mockedHasher = new Mock <IHasher>();
mockedHasher.Setup(h => h.GenerateRandomSalt()).Returns("salt-generated");
mockedHasher.Setup(h => h.CreatePasswordHash("plain", "salt-generated")).Returns("plain-hashed");
var mockedUnitOfWork = new Mock <IUnitOfWork>();
var action = new AddNewUser(mockedUserRepo.Object, mockedUserTokenRepository.Object, mockedUnitOfWork.Object, mockedHasher.Object);
// action
action.Invoke(userData);
// assert
Assert.Equal("plain-hashed", userSaved.PasswordHash);
Assert.Equal("salt-generated", userSaved.PasswordSalt);
Assert.Equal("Ryszard", userSaved.Name);
mockedUserRepo.Verify(r => r.Add(It.IsAny <DataAccess.Models.User>()), Times.Once());
mockedUserTokenRepository.Verify(r => r.Add(It.IsAny <DataAccess.Models.UserToken>()), Times.Once());
mockedUnitOfWork.Verify(r => r.Save(), Times.Exactly(1));
Assert.NotNull(userTokenSaved);
}
public void Invoke_ValidData_ReturnsCorrectModel()
{
var guid = Guid.NewGuid();
var userTokenFromDb = new DataAccess.Models.UserToken
{
Id = guid,
SecretToken = "123",
SecretTokenTimeStamp = DateTime.MaxValue,
CreatedOn = DateTime.MinValue,
ModifiedOn = DateTime.MinValue,
DeletedOn = null,
User = new DataAccess.Models.User {
Name = "bob"
}
};
var findByResult = new List <DataAccess.Models.UserToken> {
userTokenFromDb
};
// prepare
var userTokenRepository = new Mock <IUserTokenRepository>();
userTokenRepository.Setup(r => r.FindBy(It.IsAny <Expression <Func <DataAccess.Models.UserToken, bool> > >()))
.Returns(findByResult.AsQueryable());
var action = new GetUserTokenByUserId(userTokenRepository.Object);
// action
var userToken = action.Invoke(guid);
// check
Assert.Equal(guid, userToken.Id);
Assert.Equal("bob", userToken.User.Name);
Assert.Equal("123", userToken.SecretToken);
Assert.Equal(DateTime.MaxValue, userToken.SecretTokenTimeStamp);
Assert.Equal(DateTime.MinValue, userToken.CreatedOn);
Assert.Equal(DateTime.MinValue, userToken.ModifiedOn);
Assert.Null(userToken.DeletedOn);
}
public void Verify_EmailAlreadyConfirmed_SaveNorEditCalled()
{
// prepare
DateTime dateNow = DateTime.UtcNow;
var guid = new Guid();
var userFromDb = new DataAccess.Models.User
{
Id = guid,
EmailConfirmedOn = dateNow
};
var userTokenFromDb = new DataAccess.Models.UserToken
{
User = userFromDb,
SecretToken = "123"
};
var getAllResults = new List <DataAccess.Models.UserToken> {
userTokenFromDb
};
var mockedUserTokenRepository = new Mock <IUserTokenRepository>();
mockedUserTokenRepository.Setup(r => r.FindBy(It.IsAny <Expression <Func <DataAccess.Models.UserToken, bool> > >()))
.Returns(getAllResults.AsQueryable());
var mockedUserRepo = new Mock <IUserRepository>();
var mockedUnitOfWork = new Mock <IUnitOfWork>();
var action = new ConfirmUserEmailByToken(mockedUserTokenRepository.Object, mockedUserRepo.Object, mockedUnitOfWork.Object);
// action
action.Invoke("123");
// assert
Assert.Equal(userFromDb.EmailConfirmedOn, dateNow);
mockedUserRepo.Verify(r => r.Edit(It.IsAny <DataAccess.Models.User>()), Times.Never);
mockedUnitOfWork.Verify(r => r.Save(), Times.Never);
}
public void Invoke_ValidData_DeleteAndSaveAreCalled()
{
// prepare
var guid = Guid.NewGuid();
var userTokenFromDb = new DataAccess.Models.UserToken
{
Id = guid
};
var mockedUserTokenRepository = new Mock <IUserTokenRepository>();
mockedUserTokenRepository.Setup(r => r.GetById(guid)).Returns(userTokenFromDb);
var mockedUnitOfWork = new Mock <IUnitOfWork>();
var action = new DeleteUserTokenById(mockedUserTokenRepository.Object, mockedUnitOfWork.Object);
// action
var actionResult = action.Invoke(guid);
// assert
Assert.True(actionResult);
mockedUserTokenRepository.Verify(r => r.Delete(It.IsAny <DataAccess.Models.UserToken>()), Times.Once());
mockedUnitOfWork.Verify(r => r.Save(), Times.Once());
}
