public void Invoke_ValidData_AddsDomainToDatabaseWithCorrectValues()
{
// prepare
var domainData = new DomainModel
{
Name = "testdomain"
};
DataAccess.Models.Domain domainSaved = null;
var mockedDomainrepository = new Mock <IDomainRepository>();
mockedDomainrepository.Setup(r => r.Add(It.IsAny <DataAccess.Models.Domain>()))
.Callback <DataAccess.Models.Domain>(u => domainSaved = u);
var mockedUnitOfWork = new Mock <IUnitOfWork>();
var action = new AddNewDomain(mockedDomainrepository.Object, mockedUnitOfWork.Object);
// action
action.Invoke(domainData, Guid.NewGuid());
// assert
mockedDomainrepository.Verify(r => r.Add(It.IsAny <DataAccess.Models.Domain>()), Times.Once());
mockedUnitOfWork.Verify(r => r.Save(), Times.Exactly(1));
Assert.Equal("testdomain", domainSaved.Name);
}
public void Invoke_WrongDomain_ReturnsNull()
{
// prepare
var domainInDatabase = new DataAccess.Models.Domain
{
Name = "Database Domain"
};
var mockedUserRepository = new Mock <IUserRepository>();
var mockedDomainRepository = new Mock <IDomainRepository>();
var findDomainResult = new List <DataAccess.Models.Domain> {
domainInDatabase
};
mockedDomainRepository.Setup(r => r.FindBy(It.IsAny <Expression <Func <DataAccess.Models.Domain, bool> > >()))
.Returns(findDomainResult.AsQueryable);
var action = new GetUserByEmail(mockedUserRepository.Object, mockedDomainRepository.Object);
// action
var user = action.Invoke("*****@*****.**", "Database Domain");
// check
Assert.Null(user);
mockedUserRepository.Verify(r => r.FindBy(It.IsAny <Expression <Func <DataAccess.Models.User, bool> > >()), Times.Once);
mockedDomainRepository.Verify(r => r.FindBy(It.IsAny <Expression <Func <DataAccess.Models.Domain, bool> > >()), Times.Once);
}
public void Invoke_ValidData_ReturnsCorrectModel()
{
var id = Guid.NewGuid();
var domainFromDb = new DataAccess.Models.Domain
{
Id = id,
Name = "Name",
CreatedOn = DateTime.MinValue,
ModifiedOn = DateTime.MinValue,
DeletedOn = null
};
// prepare
var findByResult = new List <DataAccess.Models.Domain> {
domainFromDb
};
var mockedDomainRepository = new Mock <IDomainRepository>();
mockedDomainRepository.Setup(r => r.FindBy(It.IsAny <Expression <Func <DataAccess.Models.Domain, bool> > >()))
.Returns(findByResult.AsQueryable());
var action = new GetDomainByName(mockedDomainRepository.Object);
// action
var domain = action.Invoke(id.ToString());
// check
Assert.Equal(id, domain.Id);
Assert.Equal("Name", domain.Name);
Assert.Equal(DateTime.MinValue, domain.CreatedOn);
Assert.Equal(DateTime.MinValue, domain.ModifiedOn);
Assert.Null(domain.DeletedOn);
mockedDomainRepository.Verify(r => r.FindBy(It.IsAny <Expression <Func <DataAccess.Models.Domain, bool> > >()), Times.Once);
}
public void Invoke_NoUser_AddNorSaveAreCalled()
{
// prepare
var roomToAdd = new RoomModel {
Name = "TestRoom"
};
var domain = new DataAccess.Models.Domain
{
Name = "Test Domain"
};
var mockedRoomRepository = new Mock <IRoomRepository>();
var mockedUserRepo = new Mock <IUserRepository>();
var mockedUserRoomRepository = new Mock <IUserRoomRepository>();
var mockedDomainRoomRepository = new Mock <IDomainRepository>();
mockedDomainRoomRepository.Setup(x => x.GetById(It.IsAny <Guid>())).Returns(domain);
var mockedUnitOfWork = new Mock <IUnitOfWork>();
var action = new AddNewRoom(mockedRoomRepository.Object, mockedUserRepo.Object, mockedUserRoomRepository.Object, mockedDomainRoomRepository.Object, mockedUnitOfWork.Object);
// action
var actionResult = action.Invoke(roomToAdd, Guid.NewGuid(), Guid.NewGuid());
// assert
Assert.Equal(Guid.Empty, actionResult);
mockedDomainRoomRepository.Verify(r => r.GetById(It.IsAny <Guid>()), Times.Once);
mockedUserRepo.Verify(r => r.GetById(It.IsAny <Guid>()), Times.Once);
mockedRoomRepository.Verify(r => r.Add(It.IsAny <DataAccess.Models.Room>()), Times.Never);
mockedUnitOfWork.Verify(r => r.Save(), Times.Never);
}
public void Invoke_EmptyUser_ReturnsNull()
{
// prepare
var domain = new DataAccess.Models.Domain
{
Name = "Test Domain"
};
var mockedUserRepository = new Mock <IUserRepository>();
var findByResult = new List <DataAccess.Models.Domain> {
domain
};
var mockedDomainRepository = new Mock <IDomainRepository>();
mockedDomainRepository.Setup(r => r.FindBy(It.IsAny <Expression <Func <DataAccess.Models.Domain, bool> > >()))
.Returns(findByResult.AsQueryable);
var action = new AuthenticateUser(mockedUserRepository.Object, mockedDomainRepository.Object);
// action
var user = action.Invoke("*****@*****.**", "test", "123");
// check
Assert.Null(user);
mockedDomainRepository.Verify(r => r.FindBy(It.IsAny <Expression <Func <DataAccess.Models.Domain, bool> > >()), Times.Once);
mockedUserRepository.Verify(r => r.FindBy(It.IsAny <Expression <Func <DataAccess.Models.User, bool> > >()), Times.Once);
}
public void Invoke_ValidData_ReturnsCorrectModel()
{
var domainFromDb = new DataAccess.Models.Domain
{
Id = Guid.NewGuid(),
Name = "Name"
};
// prepare
var findByResult = new List <DataAccess.Models.Domain> {
domainFromDb
};
var mockedDomainRepository = new Mock <IDomainRepository>();
mockedDomainRepository.Setup(r => r.FindBy(It.IsAny <Expression <Func <DataAccess.Models.Domain, bool> > >()))
.Returns(findByResult.AsQueryable);
var action = new CheckDomainExistsByName(mockedDomainRepository.Object);
// action
var domain = action.Invoke("Name");
// check
Assert.True(domain);
mockedDomainRepository.Verify(r => r.FindBy(It.IsAny <Expression <Func <DataAccess.Models.Domain, bool> > >()), Times.Once);
}
public void Invoke_ValidData_DeleteAndSaveAreCalled()
{
// prepare
var guid = Guid.NewGuid();
var domainFromDb = new DataAccess.Models.Domain
{
Id = guid
};
var mockedDomainRepository = new Mock <IDomainRepository>();
mockedDomainRepository.Setup(r => r.GetById(guid)).Returns(domainFromDb);
var mockedUnitOfWork = new Mock <IUnitOfWork>();
var action = new DeleteDomainById(mockedDomainRepository.Object, mockedUnitOfWork.Object);
// action
var result = action.Invoke(guid);
// assert
Assert.True(result);
mockedDomainRepository.Verify(r => r.Delete(It.IsAny <DataAccess.Models.Domain>()), Times.Once());
mockedUnitOfWork.Verify(r => r.Save(), Times.Once());
}
public void Invoke_ValidData_ReturnsCorrectModel()
{
// prepare
var guid = Guid.NewGuid();
var domain = new DataAccess.Models.Domain
{
Name = "Test Domain"
};
var userFromDb = new DataAccess.Models.User
{
Id = guid,
Name = "Name",
Email = "*****@*****.**",
PasswordHash = "123",
Domain = domain
};
var findByResult = new List <DataAccess.Models.User> {
userFromDb
};
var mockedUserRepository = new Mock <IUserRepository>();
mockedUserRepository.Setup(r => r.FindBy(It.IsAny <Expression <Func <DataAccess.Models.User, bool> > >()))
.Returns(findByResult.AsQueryable);
var mockedDomainRepository = new Mock <IDomainRepository>();
var findDomainResult = new List <DataAccess.Models.Domain> {
domain
};
mockedDomainRepository.Setup(r => r.FindBy(It.IsAny <Expression <Func <DataAccess.Models.Domain, bool> > >()))
.Returns(findDomainResult.AsQueryable);
var action = new GetUserByEmail(mockedUserRepository.Object, mockedDomainRepository.Object);
// action
var user = action.Invoke("*****@*****.**", "Test Domain");
// check
Assert.NotNull(user);
Assert.Equal(guid, user.Id);
Assert.Equal("Name", user.Name);
Assert.Equal("*****@*****.**", user.Email);
Assert.Equal("Test Domain", user.Domain.Name);
mockedUserRepository.Verify(r => r.FindBy(It.IsAny <Expression <Func <DataAccess.Models.User, bool> > >()), Times.Once);
mockedDomainRepository.Verify(r => r.FindBy(It.IsAny <Expression <Func <DataAccess.Models.Domain, bool> > >()), Times.Once);
}
public void Invoke_WrongPassword_ReturnsNull()
{
// prepare
var domain = new DataAccess.Models.Domain
{
Name = "Test Domain"
};
var dataUser = new DataAccess.Models.User
{
Email = "*****@*****.**",
PasswordSalt = "salt-generated",
PasswordHash = "plain-hashed"
};
var findByResult = new List <DataAccess.Models.User> {
dataUser
};
var mockedUserRepository = new Mock <IUserRepository>();
mockedUserRepository.Setup(r => r.FindBy(It.IsAny <Expression <Func <DataAccess.Models.User, bool> > >()))
.Returns(findByResult.AsQueryable);
var mockedHasher = new Mock <IHasher>();
mockedHasher.Setup(h => h.CreatePasswordHash("wrongPassword", "salt-generated")).Returns("wrong-hashed");
var mockedDomainRepository = new Mock <IDomainRepository>();
var findDomainResult = new List <DataAccess.Models.Domain> {
domain
};
mockedDomainRepository.Setup(r => r.FindBy(It.IsAny <Expression <Func <DataAccess.Models.Domain, bool> > >()))
.Returns(findDomainResult.AsQueryable);
var action = new AuthenticateUser(mockedUserRepository.Object, mockedDomainRepository.Object, mockedHasher.Object);
// action
var user = action.Invoke("*****@*****.**", "wrongPassword", "123");
// check
Assert.Null(user);
mockedDomainRepository.Verify(r => r.FindBy(It.IsAny <Expression <Func <DataAccess.Models.Domain, bool> > >()), Times.Once);
mockedUserRepository.Verify(r => r.FindBy(It.IsAny <Expression <Func <DataAccess.Models.User, bool> > >()), Times.Once);
}
public void Invoke_ValidData_EditAndSaveAreCalled()
{
// prepare
var domainId = Guid.NewGuid();
var userId = Guid.NewGuid();
var domainFromDb = new DataAccess.Models.Domain
{
Id = domainId,
Owner = null
};
var userFromDb = new DataAccess.Models.User
{
Id = userId,
Name = "TestUser"
};
DataAccess.Models.Domain domainSaved = null;
var mockedDomainRepository = new Mock <IDomainRepository>();
mockedDomainRepository.Setup(r => r.GetById(domainId)).Returns(domainFromDb);
mockedDomainRepository.Setup(r => r.Edit(It.IsAny <DataAccess.Models.Domain>()))
.Callback <DataAccess.Models.Domain>(u => domainSaved = u);
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, domainId);
// assert
Assert.True(result);
Assert.Equal(userId, domainSaved.Owner.Id);
Assert.Equal("TestUser", domainSaved.Owner.Name);
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.Once());
mockedUnitOfWork.Verify(r => r.Save(), Times.Once());
}
public void Invoke_ValidData_ReturnsCorrectModel()
{
// prepare
var guidRoom = Guid.NewGuid();
var guid = Guid.NewGuid();
var domenka = new DataAccess.Models.Domain
{
Name = "sluzbowa"
};
var usersFromDb = new List <DataAccess.Models.User>
{
new DataAccess.Models.User {
Id = guid,
Name = "Name",
Email = "*****@*****.**",
EmailConfirmedOn = DateTime.MinValue,
CreatedOn = DateTime.MinValue,
ModifiedOn = DateTime.MinValue,
Domain = domenka
}
};
var mockedRoomRepository = new Mock <IRoomRepository>();
mockedRoomRepository.Setup(r => r.GetRoomUsers(It.IsAny <Guid>())).Returns(usersFromDb.AsQueryable());
var action = new GetRoomUsers(mockedRoomRepository.Object);
// action
var users = action.Invoke(guidRoom);
// check
Assert.NotNull(users);
Assert.Equal(guid, users[0].Id);
Assert.Equal("Name", users[0].Name);
Assert.Equal(DateTime.MinValue, users[0].ModifiedOn);
mockedRoomRepository.Verify(r => r.GetRoomUsers(It.IsAny <Guid>()), Times.Once);
}
public void Invoke_AlreadyExists_AddNorSaveAreCalled()
{
// prepare
var userData = new UserModel
{
Email = "email",
Password = "******",
Name = "Grzegorz"
};
var domainToAdd = new DomainModel
{
Name = "testdomain",
Owner = userData
};
var domainFromDb = new DataAccess.Models.Domain
{
Name = "testdomain"
};
var findByResult = new List <DataAccess.Models.Domain> {
domainFromDb
};
var mockedDomainRepository = new Mock <IDomainRepository>();
mockedDomainRepository.Setup(r => r.FindBy(It.IsAny <Expression <Func <DataAccess.Models.Domain, bool> > >()))
.Returns(findByResult.AsQueryable());
var mockedUnitOfWork = new Mock <IUnitOfWork>();
var action = new AddNewDomain(mockedDomainRepository.Object, mockedUnitOfWork.Object);
// action
var actionResult = action.Invoke(domainToAdd, Guid.NewGuid());
// assert
Assert.Equal(Guid.Empty, actionResult);
mockedDomainRepository.Verify(r => r.Add(It.IsAny <DataAccess.Models.Domain>()), Times.Never);
mockedUnitOfWork.Verify(r => r.Save(), Times.Never);
}
public void Invoke_ValidData_AddsRoomToDatabaseWithCorrectValues()
{
// prepare
var domain = new DataAccess.Models.Domain
{
Name = "Test Domain"
};
var user = new DataAccess.Models.User
{
Name = "Test"
};
var tag = new TagModel
{
Name = "TestTag"
};
var roomData = new RoomModel
{
Tags = new List <TagModel> {
tag
},
Name = "TestRoom",
Topic = "RoomTrool",
Description = "TroloRoom",
Customization = 1,
IsPublic = true
};
DataAccess.Models.Room roomSaved = null;
var mockedRoomRepository = new Mock <IRoomRepository>();
mockedRoomRepository.Setup(r => r.Add(It.IsAny <DataAccess.Models.Room>()))
.Callback <DataAccess.Models.Room>(u => roomSaved = u);
var mockedUserRepo = new Mock <IUserRepository>();
mockedUserRepo.Setup(x => x.GetById(It.IsAny <Guid>())).Returns(user);
var mockedUserRoomRepository = new Mock <IUserRoomRepository>();
var mockedDomainRoomRepository = new Mock <IDomainRepository>();
mockedDomainRoomRepository.Setup(x => x.GetById(It.IsAny <Guid>())).Returns(domain);
var mockedUnitOfWork = new Mock <IUnitOfWork>();
var action = new AddNewRoom(mockedRoomRepository.Object, mockedUserRepo.Object, mockedUserRoomRepository.Object, mockedDomainRoomRepository.Object, mockedUnitOfWork.Object);
// action
var actionResult = action.Invoke(roomData, Guid.NewGuid(), Guid.NewGuid());
// assert
Assert.Equal(Guid.Empty, actionResult);
Assert.Equal("TestTag", roomSaved.Tags.ElementAt(0).Name);
Assert.Equal("TestRoom", roomSaved.Name);
Assert.Equal("RoomTrool", roomSaved.Topic);
Assert.Equal("TroloRoom", roomSaved.Description);
Assert.False(roomSaved.IsPrivateConversation);
Assert.Equal(1, roomSaved.Customization);
Assert.True(roomSaved.IsPublic);
Assert.Equal("Test Domain", roomSaved.Domain.Name);
Assert.Equal("Test", roomSaved.Owner.Name);
mockedRoomRepository.Verify(r => r.Add(It.IsAny <DataAccess.Models.Room>()), Times.Once());
mockedUserRoomRepository.Verify(r => r.Add(It.IsAny <DataAccess.Models.UserRoom>()), Times.Once());
mockedUnitOfWork.Verify(r => r.Save(), Times.Once());
}
