public void ShouldDeleteMessage()
{
var profile = new Profile
{
Id = Guid.NewGuid(),
Login = "******",
Avatar = Guid.NewGuid(),
Password = "******",
Name = "odmin",
Surname = "odmin"
};
const string chatName = "SendChat";
var usersRepository = new ProfilesRepository(Constants.Constants.ConnectionString);
var result = usersRepository.CreateProfile(profile);
_tempUsers.Add(result.Id);
var chatRepository = new ChatsRepository(Constants.Constants.ConnectionString, usersRepository);
var chatBefore = new Chat
{
ChatId = Guid.NewGuid(),
ChatName = chatName,
ChatMembers = new List <Guid>(new[] { profile.Id })
};
var chat = chatRepository.CreateChat(chatBefore);
_chats.Add(chat.ChatId);
var messageRepository = new MessagesRepository(Constants.Constants.ConnectionString);
var message = new Message
{
MessageId = Guid.NewGuid(),
ProfileId = profile.Id,
ChatId = chat.ChatId,
MessageText = "Hello, world!",
Date = DateTime.Now,
TimeToDestroy = 0,
Attachment = Guid.Empty
};
_messages.Add(message.MessageId);
messageRepository.CreateMessage(message);
messageRepository.DeleteMessage(message.MessageId);
try
{
messageRepository.GetMessage(message.MessageId);
}
catch (Exception)
{
return;
}
}
public void ShouldStartChatWithUser()
{
var profile = new Profile
{
Id = Guid.NewGuid(),
Login = "******",
Avatar = Guid.NewGuid(),
Password = "******",
Name = "odmin",
Surname = "odmin"
};
const string chatName = "UserChat";
var profileRepository = new ProfilesRepository(Constants.Constants.ConnectionString);
var result = profileRepository.CreateProfile(profile);
_tempUsers.Add(result.Id);
var chatRepository = new ChatsRepository(Constants.Constants.ConnectionString, profileRepository);
var chatBefore = new Chat
{
ChatId = Guid.NewGuid(),
ChatName = chatName,
ChatMembers = new List <Guid>(new[] { profile.Id })
};
var chat = chatRepository.CreateChat(chatBefore);
_chats.Add(chat.ChatId);
var userChats = profileRepository.GetProfileChats(profile.Id);
Assert.AreEqual(chatName, chat.ChatName);
Assert.AreEqual(profile.Id, chat.ChatMembers.Single());
var chats = userChats as IList <Chat> ?? userChats.ToList();
Assert.AreEqual(chat.ChatId, chats.Single().ChatId);
Assert.AreEqual(chat.ChatName, chats.Single().ChatName);
}
public void ShouldGetChat()
{
var profile = new Profile
{
Id = Guid.NewGuid(),
Login = "******",
Avatar = Guid.NewGuid(),
Password = "******",
Name = "odmin",
Surname = "odmin"
};
const string chatName = "GetChat";
var usersRepository = new ProfilesRepository(Constants.Constants.ConnectionString);
var result = usersRepository.CreateProfile(profile);
_tempUsers.Add(result.Id);
var chatRepository = new ChatsRepository(Constants.Constants.ConnectionString, usersRepository);
var chatBefore = new Chat
{
ChatId = Guid.NewGuid(),
ChatName = chatName,
ChatMembers = new List <Guid>(new[] { profile.Id })
};
var chat = chatRepository.CreateChat(chatBefore);
_chats.Add(chat.ChatId);
var resultChatById = chatRepository.GetChat(chat.ChatId);
Assert.AreEqual(chat.ChatName, resultChatById.ChatName);
}
public void ShouldDeleteChat()
{
var profile = new Profile
{
Id = Guid.NewGuid(),
Login = "******",
Avatar = Guid.NewGuid(),
Password = "******",
Name = "odmin",
Surname = "odmin"
};
const string chatName = "DeleteChat";
var usersRepository = new ProfilesRepository(Constants.Constants.ConnectionString);
var resProfile = usersRepository.CreateProfile(profile);
_tempUsers.Add(resProfile.Id);
var chatRepository = new ChatsRepository(Constants.Constants.ConnectionString, usersRepository);
var chatBefore = new Chat
{
ChatId = Guid.NewGuid(),
ChatName = chatName,
ChatMembers = new List <Guid>(new[] { profile.Id })
};
var chat = chatRepository.CreateChat(chatBefore);
_chats.Add(chat.ChatId);
chatRepository.DeleteChat(chat.ChatId);
try
{
chatRepository.GetChat(chat.ChatId);
}
catch (Exception)
{
}
}
public void ShouldAddDeleteMember()
{
var odminProfile = new Profile
{
Id = Guid.NewGuid(),
Login = "******",
Avatar = Guid.NewGuid(),
Password = "******",
Name = "odmin",
Surname = "odmin"
};
var userProfile = new Profile
{
Id = Guid.NewGuid(),
Login = "******",
Avatar = Guid.NewGuid(),
Password = "******",
Name = "user",
Surname = "user"
};
const string chatName = "AddChat";
var profilesRepository = new ProfilesRepository(Constants.Constants.ConnectionString);
var resodminProfile = profilesRepository.CreateProfile(odminProfile);
var resUserProfile = profilesRepository.CreateProfile(userProfile);
_tempUsers.Add(resodminProfile.Id);
_tempUsers.Add(resUserProfile.Id);
var chatRepository = new ChatsRepository(Constants.Constants.ConnectionString, profilesRepository);
var chatBefore = new Chat
{
ChatId = Guid.NewGuid(),
ChatName = chatName,
ChatMembers = new List <Guid>(new[] { odminProfile.Id })
};
var chat = chatRepository.CreateChat(chatBefore);
_chats.Add(chat.ChatId);
chatRepository.AddChatMember(resUserProfile.Id, chat.ChatId);
var userChats = profilesRepository.GetProfileChats(resUserProfile.Id).ToList();
Assert.AreEqual(chat.ChatId, userChats[0].ChatId);
Assert.AreEqual(chat.ChatName, userChats[0].ChatName);
chatRepository.DeleteChatMember(resUserProfile.Id, chat.ChatId);
userChats = profilesRepository.GetProfileChats(resUserProfile.Id).ToList();
try
{
Assert.AreEqual(chat.ChatId, userChats[0].ChatId);
Assert.AreEqual(chat.ChatName, userChats[0].ChatName);
}
catch (ArgumentOutOfRangeException)
{
}
}
public void ShouldGetProfileChats()
{
var profile = new Profile
{
Id = Guid.NewGuid(),
Login = "******",
Avatar = Guid.NewGuid(),
Password = "******",
Name = "odmin",
Surname = "odmin"
};
const string chatName1 = "ProfileChat#1";
const string chatName2 = "ProfileChat#2";
const string chatName3 = "ProfileChat#3";
const string chatName4 = "ProfileChat#4";
var profilesRepository = new ProfilesRepository(Constants.Constants.ConnectionString);
var resProfile = profilesRepository.CreateProfile(profile);
_tempUsers.Add(resProfile.Id);
var chatRepository = new ChatsRepository(Constants.Constants.ConnectionString, profilesRepository);
var chat1Before = new Chat
{
ChatId = Guid.NewGuid(),
ChatName = chatName1,
ChatMembers = new List <Guid>(new[] { profile.Id })
};
var chat2Before = new Chat
{
ChatId = Guid.NewGuid(),
ChatName = chatName2,
ChatMembers = new List <Guid>(new[] { profile.Id })
};
var chat3Before = new Chat
{
ChatId = Guid.NewGuid(),
ChatName = chatName3,
ChatMembers = new List <Guid>(new[] { profile.Id })
};
var chat4Before = new Chat
{
ChatId = Guid.NewGuid(),
ChatName = chatName4,
ChatMembers = new List <Guid>(new[] { profile.Id })
};
var chat1 = chatRepository.CreateChat(chat1Before);
var chat2 = chatRepository.CreateChat(chat2Before);
var chat3 = chatRepository.CreateChat(chat3Before);
var chat4 = chatRepository.CreateChat(chat4Before);
_chats.Add(chat1.ChatId);
_chats.Add(chat2.ChatId);
_chats.Add(chat3.ChatId);
_chats.Add(chat4.ChatId);
var profileChats = profilesRepository.GetProfileChats(profile.Id).ToList();
var ch = profileChats.Find(x => x.ChatId == chat1.ChatId);
Assert.AreEqual(chat1.ChatId, ch.ChatId);
Assert.AreEqual(chatName1, ch.ChatName);
ch = profileChats.Find(x => x.ChatId == chat2.ChatId);
Assert.AreEqual(chat2.ChatId, ch.ChatId);
Assert.AreEqual(chatName2, ch.ChatName);
ch = profileChats.Find(x => x.ChatId == chat3.ChatId);
Assert.AreEqual(chat3.ChatId, ch.ChatId);
Assert.AreEqual(chatName3, ch.ChatName);
ch = profileChats.Find(x => x.ChatId == chat4.ChatId);
Assert.AreEqual(chat4.ChatId, ch.ChatId);
Assert.AreEqual(chatName4, ch.ChatName);
}
public void Initialize()
{
var user1 = new User
{
FirstName = "Thomas",
LastName = "Anderson",
Login = "******",
Password = "******"
};
var user2 = new User
{
FirstName = "Smith",
LastName = "Smith",
Login = "******",
Password = "******"
};
var user3 = new User
{
FirstName = "Noname",
LastName = "Noname",
Login = "******",
Password = "******"
};
var usersRepository = new UsersRepository(_connectionString);
_users = new List <User>
{
usersRepository.CreateUser(user1),
usersRepository.CreateUser(user2),
usersRepository.CreateUser(user3)
};
_tmpUsers.AddRange(_users.Select(u => u.Id));
_chat = new Chat
{
Name = "ChatName",
Creater = _users[0],
Members = _users
};
var chatRepository = new ChatsRepository(_connectionString, usersRepository);
_chat = chatRepository.CreateChat(_chat);
_tmpChats.Add(_chat.Id);
foreach (var m in _chat.Members)
{
_tempChatIdMemberIds.Add(new ChatsRepositoryTests.ChatIdMemberId
{
ChatId = _chat.Id,
MemberId = m.Id
});
}
var attachments = new List <byte[]>
{
Encoding.UTF8.GetBytes("Image"),
Encoding.UTF8.GetBytes("Image2")
};
_message = new Message
{
User = _users[0],
Chat = _chat,
Date = DateTime.Now.ToUniversalTime(),
IsSelfDestructing = false,
Text = "Hello Tester, How are you?",
Attachments = attachments
};
}
public void Initialize()
{
var user1 = new User
{
FirstName = "Thomas",
LastName = "Anderson",
Login = "******",
Password = "******"
};
var user2 = new User
{
FirstName = "Smith",
LastName = "Smith",
Login = "******",
Password = "******"
};
var user3 = new User
{
FirstName = "Noname",
LastName = "Noname",
Login = "******",
Password = "******"
};
var usersRepository = new UsersRepository(_connectionString);
_users = new List <User>
{
usersRepository.CreateUser(user1),
usersRepository.CreateUser(user2),
usersRepository.CreateUser(user3)
};
_tempUserIds.AddRange(_users.Select(u => u.Id));
var chat = new Chat
{
Creater = _users[0],
Members = new[] { _users[0], _users[1] },
Name = "ChatName"
};
var chatsRepository = new ChatsRepository(_connectionString, usersRepository);
_chat = chatsRepository.CreateChat(chat);
_tempChatIds.Add(_chat.Id);
_tempChatIdMemberIds.AddRange(new[]
{
new ChatIdMemberId {
ChatId = _chat.Id, MemberId = _users[0].Id
},
new ChatIdMemberId {
ChatId = _chat.Id, MemberId = _users[1].Id
}
});
var message1 = new Message
{
Chat = _chat,
Date = DateTime.Now.ToUniversalTime(),
IsSelfDestructing = false,
Text = "Message1",
User = _users[0],
Attachments = new List <byte[]>
{
Encoding.UTF8.GetBytes("Hello"),
Encoding.UTF8.GetBytes("World")
}
};
var message2 = new Message
{
Chat = _chat,
Date = DateTime.Now.ToUniversalTime(),
IsSelfDestructing = false,
Text = "Message2",
User = _users[0]
};
var messagesRepository = new MessagesRepository(_connectionString, usersRepository, chatsRepository);
_messages = new List <Message>
{
messagesRepository.CreateMessage(message1),
messagesRepository.CreateMessage(message2)
};
_tempMessageIds.AddRange(_messages.Select(m => m.Id));
_chat.Messages = _messages;
}
public void ShouldCreateChat()
{
//arrange
var usersRepository = new UsersRepository(_connectionString);
var chatWithOneMember = new Chat
{
Name = "ChatName",
Creater = _users[0],
Members = new List <User> {
_users[0]
}
};
var chatWithTwoMembers = new Chat
{
Name = "ChatName",
Creater = _users[0],
Members = new List <User> {
_users[0], _users[1]
}
};
var chatWithThreeMembers = new Chat
{
Name = "ChatName",
Creater = _users[0],
Members = new List <User> {
_users[0], _users[1], _users[2]
}
};
//act
var chatsRepository = new ChatsRepository(_connectionString, usersRepository);
var createdChatWithTwoMembers = chatsRepository.CreateChat(chatWithTwoMembers);
var createdChatWithThreeMembers = chatsRepository.CreateChat(chatWithThreeMembers);
_tempChatIds.AddRange(new[] { createdChatWithTwoMembers.Id, createdChatWithThreeMembers.Id });
foreach (var c in new[] { createdChatWithTwoMembers, createdChatWithThreeMembers })
{
foreach (var m in c.Members)
{
_tempChatIdMemberIds.Add(new ChatIdMemberId
{
ChatId = c.Id,
MemberId = m.Id
});
}
}
//Assert
Assert.ThrowsException <ArgumentException>(() => chatsRepository.CreateChat(chatWithOneMember));
Assert.AreEqual(chatWithTwoMembers.Id, createdChatWithTwoMembers.Id);
Assert.AreEqual(chatWithTwoMembers.Name, createdChatWithTwoMembers.Name);
Assert.AreEqual(chatWithTwoMembers.Members.Count(), createdChatWithTwoMembers.Members.Count());
Assert.AreEqual(chatWithThreeMembers.Id, createdChatWithThreeMembers.Id);
Assert.AreEqual(chatWithThreeMembers.Name, createdChatWithThreeMembers.Name);
Assert.AreEqual(chatWithThreeMembers.Members.Count(), createdChatWithThreeMembers.Members.Count());
}
