Esempio n. 1
0
        public async Task ShouldUnblockUser()
        {
            var initiator = new User
            {
                Id = 1
            };
            var blocked = new User
            {
                Id = 2
            };
            var userRepository = new TestRepository <User>(new List <User>
            {
                initiator,
                blocked
            });
            var blackListRepository = new TestRepository <BlackList>(new List <BlackList>()
            {
                new BlackList
                {
                    Id          = 1,
                    Blocked     = blocked,
                    Initiator   = initiator,
                    BlockedId   = blocked.Id,
                    InitiatorId = initiator.Id
                }
            });
            var blackListService = new BlackListService(blackListRepository, _mapper);

            await blackListService.UnblockUserAsync(initiator.Id, blocked.Id);

            Assert.True(!blackListRepository.Any(bl => bl.InitiatorId == initiator.Id && bl.BlockedId == blocked.Id));
        }
Esempio n. 2
0
        public async Task ShouldCreateConversationCorrectly()
        {
            var firedEventsCount           = 0;
            var conversationRepository     = new TestRepository <Conversation>();
            var conversationUserRepository = new TestRepository <ConversationUser>();
            var blackListRepository        = new TestRepository <BlackList>();
            var chatActionRepository       = new TestRepository <ChatAction>();
            var messageRepository          = new TestRepository <Message>();
            var attachmentRepository       = new TestRepository <Attachment>();

            var blackListService        = new BlackListService(blackListRepository, _mapper);
            var conversationUserService = new ConversationUserService(conversationUserRepository, _mapper);


            var messageService      = new MessageService(messageRepository, attachmentRepository, _timeProvider, _attachmentContentProvider, blackListService, conversationUserService, _mapper);
            var conversationService = new ConversationService(conversationRepository, conversationUserRepository, chatActionRepository, blackListService, messageService, _timeProvider, _mapper);

            conversationService.OnConversationCreated += (conversationService) => firedEventsCount++;

            var initiator = new User {
                Id = 1, Username = "******"
            };
            var invited = new List <User>
            {
                new User
                {
                    Id       = 2,
                    Username = "******"
                },
                new User
                {
                    Id       = 3,
                    Username = "******"
                }
            };

            var response = await conversationService.CreateConversationAsync(initiator.Id, invited.Select(u => u.Id));

            Assert.Contains(conversationRepository.All(), c => c.Id == response.Entity.Id);
            Assert.Contains(chatActionRepository.All(), c => c.Type == ChatActionType.NewChat && c.ConversationId == response.Entity.Id);
            Assert.Contains(invited.Union(new User[] { initiator }), u => conversationUserRepository.Any(cu => cu.ConversationId == response.Entity.Id && cu.UserId == u.Id));
            Assert.Equal(1, firedEventsCount);
        }