public void Invoke_FromSuperAdminToSuperAdmin_NotSavedInDatabase()
{
// Prepare
var dataUser = new DataAccess.Models.User
{
IsSuperAdmin = true
};
var dataUserSaved = dataUser;
var mockedUserRepository = new Mock <IUserRepository>();
var mockedUserAppsRepository = new Mock <IUserAppRepository>();
mockedUserRepository.Setup(r => r.GetById(It.IsAny <int>()))
.Returns(dataUser);
mockedUserRepository.Setup(r => r.Edit(It.IsAny <DataAccess.Models.User>()))
.Callback <DataAccess.Models.User>(user => dataUserSaved = user);
var action = new GrantRole(mockedUserAppsRepository.Object, mockedUserRepository.Object);
// Action
var actionResult = action.Invoke(1, 1, Enums.UserRole.SuperAdmin);
// Check
Assert.False(actionResult);
Assert.True(dataUserSaved.IsSuperAdmin);
mockedUserRepository.Verify(r => r.Edit(It.IsAny <DataAccess.Models.User>()), Times.Never);
mockedUserRepository.Verify(r => r.Save(), Times.Never);
mockedUserAppsRepository.Verify(r => r.Save(), Times.Never);
}
public void Verify_AlreadyLocked_SaveNorEditAreCalled()
{
// prepare
DateTime dateNow = DateTime.UtcNow;
var userFromDb = new DataAccess.Models.User()
{
Id = 1,
LockedOn = dateNow,
};
var mockedUserRepo = new Mock <IUserRepository>();
mockedUserRepo.Setup(r => r.GetById(1))
.Returns(userFromDb);
var action = new BusinessLogic.Actions.User.Implementation.LockUser(mockedUserRepo.Object);
// action
action.Invoke(1);
// assert
Assert.Equal(userFromDb.LockedOn, dateNow);
mockedUserRepo.Verify(r => r.Edit(It.IsAny <DataAccess.Models.User>()), Times.Never);
mockedUserRepo.Verify(r => r.Save(), Times.Never);
}
public void Invoke_ForSuperAdmin_ReturnsSuperAdmin()
{
// prepare
var dataUser = new DataAccess.Models.User
{
IsSuperAdmin = true
};
var dataUserApp = new UserApps
{
Role = UserRole.Manager
};
var mockedUserRepository = new Mock <IUserRepository>();
mockedUserRepository.Setup(r => r.GetById(It.IsAny <int>())).Returns(dataUser);
var getUserAppResult = new List <UserApps> {
dataUserApp
};
var mockedUserAppRepository = new Mock <IUserAppRepository>();
mockedUserAppRepository.Setup(r => r.FindBy(It.IsAny <Expression <Func <UserApps, bool> > >()))
.Returns(getUserAppResult.AsQueryable());
var action = new BusinessLogic.Actions.User.Implementation
.GetAppUserRole(mockedUserAppRepository.Object, mockedUserRepository.Object);
// action
var actionResult = action.Invoke(1, 2);
// check
Assert.Equal("SuperAdmin", actionResult.ToString());
}
public void Invoke_NoToken_SaveNorEditAreCalled()
{
// prepare
var guid = Guid.NewGuid();
var userFromDb = new DataAccess.Models.User
{
Id = guid,
Name = "Name",
PasswordHash = "hash",
PasswordSalt = "salt"
};
var mockedUserRepository = new Mock <IUserRepository>();
mockedUserRepository.Setup(r => r.GetById(It.IsAny <Guid>()))
.Returns(userFromDb);
var mockedUserTokenRepo = new Mock <IUserTokenRepository>();
var mockedUnitOfWork = new Mock <IUnitOfWork>();
var action = new EditUserPassword(mockedUserTokenRepo.Object, mockedUserRepository.Object, mockedUnitOfWork.Object);
// action
var actionResult = action.Invoke(guid, "123");
// assert
Assert.False(actionResult);
mockedUnitOfWork.Verify(r => r.Save(), Times.Never);
mockedUserRepository.Verify(r => r.Edit(It.IsAny <DataAccess.Models.User>()), Times.Never);
mockedUserTokenRepo.Verify(r => r.FindBy(It.IsAny <Expression <Func <DataAccess.Models.UserToken, bool> > >()), Times.Once);
mockedUserTokenRepo.Verify(r => r.Delete(It.IsAny <DataAccess.Models.UserToken>()), Times.Never);
mockedUnitOfWork.Verify(r => r.Save(), Times.Never);
}
public void Verify_ForDoubledAction_UpdatesLockedOnOnce()
{
// prepare
var userFromDb = new DataAccess.Models.User()
{
Id = 1,
LockedOn = null,
};
DataAccess.Models.User userSaved = null;
var mockedUserRepo = new Mock <IUserRepository>();
mockedUserRepo.Setup(r => r.GetById(1))
.Returns(userFromDb);
mockedUserRepo.Setup(r => r.Edit(It.IsAny <DataAccess.Models.User>()))
.Callback <DataAccess.Models.User>(u => userSaved = u);
var action = new BusinessLogic.Actions.User.Implementation.LockUser(mockedUserRepo.Object);
// action
action.Invoke(1);
action.Invoke(1);
// assert
Assert.NotNull(userSaved.LockedOn);
mockedUserRepo.Verify(r => r.Edit(It.IsAny <DataAccess.Models.User>()), Times.Once);
mockedUserRepo.Verify(r => r.Save(), Times.Once());
}
public void Invoke_ValidData_UpdatesEmailConfirmedOn()
{
// prepare
var userFromDb = new DataAccess.Models.User()
{
Id = 1,
EmailConfirmedOn = null,
};
DataAccess.Models.User userSaved = null;
var mockedUserRepo = new Mock <IUserRepository>();
mockedUserRepo.Setup(r => r.GetById(1))
.Returns(userFromDb);
mockedUserRepo.Setup(r => r.Edit(It.IsAny <DataAccess.Models.User>()))
.Callback <DataAccess.Models.User>(u => userSaved = u);
var action = new BusinessLogic.Actions.User.Implementation.ConfirmUserEmail(mockedUserRepo.Object);
// action
action.Invoke(1);
// assert
Assert.NotNull(userSaved.EmailConfirmedOn);
}
public void Invoke_EmptyDomain_EditNorSaveAreCalled()
{
// prepare
var userId = Guid.NewGuid();
var userFromDb = new DataAccess.Models.User
{
Id = userId
};
var mockedDomainRepository = new Mock <IDomainRepository>();
var mockedUserRepository = new Mock <IUserRepository>();
mockedUserRepository.Setup(r => r.GetById(userId)).Returns(userFromDb);
var mockedUnitOfWork = new Mock <IUnitOfWork>();
var action = new SetDomainOwner(mockedDomainRepository.Object, mockedUserRepository.Object, mockedUnitOfWork.Object);
// action
var result = action.Invoke(userId, Guid.NewGuid());
// assert
Assert.False(result);
mockedUserRepository.Verify(r => r.GetById(It.IsAny <Guid>()), Times.Once);
mockedDomainRepository.Verify(r => r.GetById(It.IsAny <Guid>()), Times.Once);
mockedDomainRepository.Verify(r => r.Edit(It.IsAny <DataAccess.Models.Domain>()), 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;
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.CreateHash("plain", "salt-generated")).Returns("plain-hashed");
var action = new AddNewUser(mockedUserRepo.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());
mockedUserRepo.Verify(r => r.Save(), Times.Once());
}
public void Invoke_ValidData_ReturnsCorrectModel()
{
var userFromDb = new DataAccess.Models.User()
{
Id = 1,
Name = "Name",
Email = "*****@*****.**",
EmailConfirmedOn = DateTime.MinValue,
LockedOn = null,
CreatedOn = DateTime.MinValue,
ModifiedOn = DateTime.MinValue,
DeletedOn = null,
};
// prepare
var mockedUserRepository = new Mock <IUserRepository>();
mockedUserRepository.Setup(r => r.GetById(It.IsAny <int>()))
.Returns(userFromDb);
var action = new GetUserById(mockedUserRepository.Object);
// action
var user = action.Invoke(1);
// check
Assert.Equal(1, 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);
}
public void Invoke_InvalidData_SaveNorEditAreCalled()
{
// prepare
var userFromDb = new DataAccess.Models.User()
{
Id = 1
};
var userUpdated = new UserModel()
{
Id = 1
};
var mockedUserRepo = new Mock <IUserRepository>();
mockedUserRepo.Setup(r => r.GetById(1))
.Returns(userFromDb);
var action = new EditUser(mockedUserRepo.Object);
// action
var actionResult = action.Invoke(userUpdated);
// assert
Assert.False(actionResult);
mockedUserRepo.Verify(r => r.Save(), Times.Never);
mockedUserRepo.Verify(r => r.Edit(It.IsAny <DataAccess.Models.User>()), Times.Never);
}
public void Invoke_ValidData_UpdatesName()
{
// prepare
var userFromDb = new DataAccess.Models.User()
{
Id = 1,
Name = "Name",
};
var userUpdated = new UserModel()
{
Id = 1,
Name = "Name2", // updated value
};
DataAccess.Models.User userSaved = null;
var mockedUserRepo = new Mock <IUserRepository>();
mockedUserRepo.Setup(r => r.GetById(1))
.Returns(userFromDb);
mockedUserRepo.Setup(r => r.Edit(It.IsAny <DataAccess.Models.User>()))
.Callback <DataAccess.Models.User>(u => userSaved = u);
var action = new EditUser(mockedUserRepo.Object);
// action
var actionResult = action.Invoke(userUpdated);
// assert
Assert.True(actionResult);
Assert.Equal("Name2", userSaved.Name);
}
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 Delete(int id)
{
var user = new DataAccess.Models.User {
Id = id
};
_activityContext.Users.Remove(user);
_activityContext.SaveChanges();
}
public void Invoke_ValidData_EditAndSaveAreCalled()
{
// prepare
var user = new DataAccess.Models.User
{
Name = "TestUser"
};
var role = new DataAccess.Models.Role
{
Name = "TestRole"
};
var message = new DataAccess.Models.Message
{
Text = "TestMessage"
};
var room = new DataAccess.Models.Room();
var userRoomInDb = new List <DataAccess.Models.UserRoom>
{
new DataAccess.Models.UserRoom
{
Messages = new List <DataAccess.Models.Message> {
message
},
LastMessage = message,
Room = room,
User = user,
Role = role,
LockedUntil = DateTime.MaxValue
}
};
var mockedUserRoomRepository = new Mock <IUserRoomRepository>();
mockedUserRoomRepository.Setup(r => r.FindBy(It.IsAny <Expression <Func <DataAccess.Models.UserRoom, bool> > >()))
.Returns(userRoomInDb.AsQueryable());
var action = new GetUserRoomByIds(mockedUserRoomRepository.Object);
// action
var result = action.Invoke(Guid.NewGuid(), Guid.NewGuid());
// assert
Assert.NotNull(result);
Assert.Equal("TestMessage", result.Messages[0].Text);
//Assert.Equal("TestUser", result.Room.Users[0].Name);
Assert.Equal("TestUser", result.User.Name);
Assert.Equal("TestRole", result.Role.Name);
Assert.Equal(DateTime.MaxValue, result.LockedUntil);
mockedUserRoomRepository.Verify(r => r.FindBy(It.IsAny <Expression <Func <DataAccess.Models.UserRoom, bool> > >()), Times.Once);
}
