public void Clean()
        {
            var usersRepository    = new UsersRepository(_connectionString);
            var chatsRepository    = new ChatsRepository(_connectionString, usersRepository);
            var messagesRepository = new MessagesRepository(_connectionString, usersRepository, chatsRepository);

            foreach (var cm in _tempChatIdMemberIds)
            {
                chatsRepository.DeleteMember(cm.ChatId, cm.MemberId);
            }

            foreach (var messageId in _tmpMessages)
            {
                messagesRepository.DeleteMessage(messageId);
            }

            foreach (var chatId in _tmpChats)
            {
                chatsRepository.DeleteChat(chatId);
            }

            foreach (var userId in _tmpUsers)
            {
                usersRepository.DeleteUser(userId);
            }
        }
Exemplo n.º 2
0
        public void ShouldDeleteChat()
        {
            //arrange
            var usersRepository = new UsersRepository(_connectionString);
            var chatsRepository = new ChatsRepository(_connectionString, usersRepository);

            //act
            chatsRepository.DeleteChat(_chat.Id);
            _tempChatIds.Remove(_chat.Id);

            //assert
            Assert.ThrowsException <ArgumentException>(() => chatsRepository.GetChatInfo(_chat.Id));
        }
Exemplo n.º 3
0
        public void ShouldDeleteChat()
        {
            Chat chat = Create.Chat();

            chatsRepository.DeleteChat(chat.ID);

            Assert.AreEqual(0, DB.Chats.Count(c => c.ID == chat.ID));

            try
            {
                chatsRepository.GetChat(chat.ID);
                Assert.Fail();
            }
            catch { }
        }
Exemplo n.º 4
0
 public void Clean()
 {
     foreach (var login in _tempUsers)
     {
         var user = new ProfilesRepository(Constants.Constants.ConnectionString);
         foreach (var chat in _chats)
         {
             var chatRepo = new ChatsRepository(Constants.Constants.ConnectionString, user);
             foreach (var message in _messages)
             {
                 new MessagesRepository(Constants.Constants.ConnectionString).DeleteMessage(message);
             }
             chatRepo.DeleteChat(chat);
         }
         user.DeleteProfile(login);
     }
 }
Exemplo n.º 5
0
        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)
            {
            }
        }
Exemplo n.º 6
0
 public void DeleteChat(Guid id)
 => _chatsRepository.DeleteChat(id);