public void Invoke_TryEditPrivateConversation_ReturnsNull()
{
// prepare
var guid = Guid.NewGuid();
var roomFromDb = new DataAccess.Models.Room
{
Id = guid,
Name = "OldName",
IsPrivateConversation = true
};
var mockedRoomRepository = new Mock <IRoomRepository>();
mockedRoomRepository.Setup(r => r.GetById(It.IsAny <Guid>()))
.Returns(roomFromDb);
var mockedUnitOfWork = new Mock <IUnitOfWork>();
var action = new EditRoomName(mockedRoomRepository.Object, mockedUnitOfWork.Object);
// action
var room = action.Invoke(guid, "test");
// check
Assert.False(room);
mockedRoomRepository.Verify(r => r.GetById(It.IsAny <Guid>()), Times.Once);
mockedUnitOfWork.Verify(r => r.Save(), Times.Never);
}
public void Invoke_EmptyString_ReturnsTrue(string roomTopic)
{
var roomFromDb = new DataAccess.Models.Room
{
Topic = "OldTopic"
};
// prepare
DataAccess.Models.Room roomSaved = null;
var mockedRoomRepository = new Mock <IRoomRepository>();
mockedRoomRepository.Setup(r => r.GetById(It.IsAny <Guid>()))
.Returns(roomFromDb);
mockedRoomRepository.Setup(r => r.Edit(It.IsAny <DataAccess.Models.Room>()))
.Callback <DataAccess.Models.Room>(u => roomSaved = u);
var mockedUnitOfWork = new Mock <IUnitOfWork>();
var action = new EditRoomTopic(mockedRoomRepository.Object, mockedUnitOfWork.Object);
// action
var room = action.Invoke(Guid.NewGuid(), roomTopic);
// check
Assert.True(room);
Assert.Equal(roomTopic, roomSaved.Topic);
mockedRoomRepository.Verify(r => r.GetById(It.IsAny <Guid>()), Times.Once);
mockedUnitOfWork.Verify(r => r.Save(), Times.Once);
}
public void Invoke_ValidData_ReturnsCorrectModel()
{
var guid = Guid.NewGuid();
var roomFromDb = new DataAccess.Models.Room
{
Id = guid,
Name = "OldName"
};
// prepare
DataAccess.Models.Room roomSaved = null;
var mockedRoomRepository = new Mock <IRoomRepository>();
mockedRoomRepository.Setup(r => r.GetById(It.IsAny <Guid>()))
.Returns(roomFromDb);
mockedRoomRepository.Setup(r => r.Edit(It.IsAny <DataAccess.Models.Room>()))
.Callback <DataAccess.Models.Room>(u => roomSaved = u);
var mockedUnitOfWork = new Mock <IUnitOfWork>();
var action = new EditRoomName(mockedRoomRepository.Object, mockedUnitOfWork.Object);
// action
var room = action.Invoke(guid, "New Room Name");
// check
Assert.True(room);
Assert.Equal(guid, roomSaved.Id);
Assert.Equal("New Room Name", roomSaved.Name);
Assert.Null(roomSaved.DeletedOn);
mockedRoomRepository.Verify(r => r.GetById(It.IsAny <Guid>()), Times.Once);
mockedUnitOfWork.Verify(r => r.Save(), Times.Once);
}
public void Invoke_Zero_ReturnsTrue()
{
var roomFromDb = new DataAccess.Models.Room
{
Customization = 3
};
// prepare
DataAccess.Models.Room roomSaved = null;
var mockedRoomRepository = new Mock <IRoomRepository>();
mockedRoomRepository.Setup(r => r.GetById(It.IsAny <Guid>()))
.Returns(roomFromDb);
mockedRoomRepository.Setup(r => r.Edit(It.IsAny <DataAccess.Models.Room>()))
.Callback <DataAccess.Models.Room>(u => roomSaved = u);
var mockedUnitOfWork = new Mock <IUnitOfWork>();
var action = new EditRoomCustomization(mockedRoomRepository.Object, mockedUnitOfWork.Object);
// action
var room = action.Invoke(Guid.NewGuid(), 0);
// check
Assert.True(room);
Assert.Equal(0, roomSaved.Customization);
mockedRoomRepository.Verify(r => r.GetById(It.IsAny <Guid>()), Times.Once);
mockedUnitOfWork.Verify(r => r.Save(), Times.Once);
}
public void Invoke_ValidData_ReturnsCorrectModel()
{
// prepare
var guidRoom = Guid.NewGuid();
var guid = Guid.NewGuid();
var roomFromDb = new DataAccess.Models.Room
{
Id = guid,
Name = "TestRoom"
};
var mockedRoomRepository = new Mock <IRoomRepository>();
mockedRoomRepository.Setup(r => r.GetById(It.IsAny <Guid>())).Returns(roomFromDb);
var action = new GetRoomById(mockedRoomRepository.Object);
// action
var result = action.Invoke(guidRoom);
// check
Assert.NotNull(result);
Assert.Equal(guid, result.Id);
Assert.Equal("TestRoom", result.Name);
mockedRoomRepository.Verify(r => r.GetById(It.IsAny <Guid>()), Times.Once);
}
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);
}
public void Invoke_ValidData_ReturnsCorrectModel()
{
// prepare
var guidRoom = Guid.NewGuid();
var guid = Guid.NewGuid();
var tag = new Tag
{
Name = "TestTag"
};
var room = new DataAccess.Models.Room
{
Name = "TestRoom"
};
var lastMessage = new DataAccess.Models.Message
{
Text = "LastMessage"
};
var userRoomsFromDb = new List <DataAccess.Models.UserRoom>
{
new DataAccess.Models.UserRoom {
Id = guid,
Room = room,
LastMessage = lastMessage,
Tags = new List <Tag> {
tag
}
}
};
var mockedUserRepository = new Mock <IUserRepository>();
mockedUserRepository.Setup(r => r.GetPrivateConversations(It.IsAny <Guid>())).Returns(userRoomsFromDb.AsQueryable());
var action = new GetUserPrivateConversations(mockedUserRepository.Object);
// action
var result = action.Invoke(guidRoom);
// check
Assert.NotNull(result);
Assert.Equal(guid, result[0].Id);
Assert.Equal("TestTag", result[0].Tags[0].Name);
Assert.Equal("TestRoom", result[0].Room.Name);
Assert.Equal("LastMessage", result[0].LastMessage.Text);
mockedUserRepository.Verify(r => r.GetPrivateConversations(It.IsAny <Guid>()), Times.Once);
}
public void Invoke_ValidData_DeleteAndSaveAreCalled()
{
// prepare
var guid = Guid.NewGuid();
var roomFromDb = new DataAccess.Models.Room
{
Id = guid
};
var mockedRoomRepository = new Mock <IRoomRepository>();
mockedRoomRepository.Setup(r => r.GetById(guid)).Returns(roomFromDb);
var mockedUnitOfWork = new Mock <IUnitOfWork>();
var action = new DeleteRoomById(mockedRoomRepository.Object, mockedUnitOfWork.Object);
// action
var result = action.Invoke(guid);
// assert
Assert.True(result);
mockedRoomRepository.Verify(r => r.Delete(It.IsAny <DataAccess.Models.Room>()), Times.Once());
mockedUnitOfWork.Verify(r => r.Save(), Times.Once());
}
public RoomModel Invoke(Guid issuerUserId, List <Guid> users)
{
// Check if users wants to create a conversation with himself
if (issuerUserId == Guid.Empty || users.Count <= 0 || users.Count > 8 || users.Any(x => x.Equals(issuerUserId) || x.Equals(Guid.Empty)) || users.Distinct().Count() != users.Count)
{
return(null);
}
var issuerUser = userRepository.GetById(issuerUserId);
if (issuerUser == null)
{
return(null);
}
var privateConversationList = userRepository.GetPrivateConversationsTargets(issuerUserId).ToList();
var listRoom = privateConversationList.Select(x => x.Room).Distinct();
// Check if private conversation already exists
foreach (var room in listRoom)
{
var userRoomsList = privateConversationList.Where(x => x.Room == room);
var dict = new Dictionary <DataAccess.Models.UserRoom, bool>();
var searchedCount = 0;
// FIXME: Bug when creating multiple users priv conversation room when there's priv conversation to one of selected user list
foreach (var connection in userRoomsList)
{
dict.Add(connection, false);
if (users.Any(x => x.Equals(connection.User.Id)))
{
searchedCount += 1;
Debug.WriteLine("######### Znaleziono istniejące połączenie #########");
Debug.WriteLine(connection.User.Name);
dict[connection] = true;
}
}
if (searchedCount == users.Count)
{
Debug.WriteLine("######### Jest tyle samo znalezień co userów do których chce sie podpiąć #########");
}
if (dict.All(x => x.Value))
{
return(null);
}
}
// Create repository method for that?
var userList = userRepository.GetAll().Where(x => users.Contains(x.Id)).ToList();
var roomName = "";
foreach (var item in userList)
{
roomName += item.Name + ", ";
}
roomName += issuerUser.Name;
var userDomain = domainRepository.GetDomainByUserId(issuerUser.Id);
var newRoom = new DataAccess.Models.Room
{
Name = roomName,
Owner = AutoMapper.Mapper.Map <DataAccess.Models.User>(issuerUser),
Domain = userDomain,
IsPrivateConversation = true,
IsPublic = false
};
roomRepository.Add(newRoom);
var userRoom = new DataAccess.Models.UserRoom {
User = issuerUser, Room = newRoom
};
userRoomRepository.Add(userRoom);
foreach (var user in userList)
{
var userRoom2 = new DataAccess.Models.UserRoom {
User = user, Room = newRoom
};
userRoomRepository.Add(userRoom2);
}
var returnRoom = AutoMapper.Mapper.Map <RoomModel>(newRoom);
_unitOfWork.Save();
return(returnRoom);
}
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());
}
