public async Task ShouldDeleteMessage()
{
var firedEventsCount = 0;
var blackListRepository = new TestRepository <BlackList>();
var messageRepository = new TestRepository <Message>();
var conversationRepository = new TestRepository <Conversation>();
var conversationUserRepository = new TestRepository <ConversationUser>();
var attachmentRepository = new TestRepository <Attachment>();
var timeProvider = new TestTimeProvider();
var attachmentContentProvider = new TestAttachmentContentProvider();
var conversationUserService = new ConversationUserService(conversationUserRepository, _mapper);
var blackListService = new BlackListService(blackListRepository, _mapper);
var messageService = new MessageService(messageRepository, attachmentRepository, timeProvider, attachmentContentProvider, blackListService, conversationUserService, _mapper);
var sender = new User()
{
Id = 1
};
var conversation = new Conversation()
{
Id = 1
};
messageService.OnMessagesDeleted += (m) => firedEventsCount++;
var result = await messageService.SendMessageAsync(sender.Id,
conversation.Id, "test", new AttachmentDto[] { new AttachmentDto {
Id = 1, MessageId = 0
} });
await messageService.DeleteByIdsAsync(sender.Id, result.Entity.Id);
Assert.Empty(messageRepository.All());
Assert.Empty(attachmentRepository.All());
Assert.Equal(1, firedEventsCount);
}
public async Task ShouldCreateConversationUser()
{
var firedEventsCount = 0;
var conversationUserRepository = new TestRepository <ConversationUser>();
var conversationUserService = new ConversationUserService(conversationUserRepository, _mapper);
var conversationId = 1;
var userId = 1;
conversationUserService.OnUserAdded += (cu) => firedEventsCount++;
await conversationUserService.AddUserAsync(conversationId, userId);
Assert.Contains(conversationUserRepository.All(), (cu) => cu.ConversationId == conversationId && cu.UserId == userId);
Assert.Equal(1, firedEventsCount);
}
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);
}
public async Task ShouldDeleteConversationUser()
{
var firedEventsCount = 0;
var conversationId = 1;
var userId = 1;
var conversationUserRepository = new TestRepository <ConversationUser>();
var conversationUserService = new ConversationUserService(conversationUserRepository, _mapper);
conversationUserService.OnUserDeleted += (cu) => firedEventsCount++;
await conversationUserRepository.CreateAsync(new ConversationUser()
{
UserId = 1, ConversationId = 1
});
await conversationUserService.DeleteUserAsync(conversationId, userId);
Assert.Empty(conversationUserRepository.All());
Assert.Equal(1, firedEventsCount);
}
public async Task ShouldDeleteConversationCorrectly()
{
const long conversationId = 1;
const long messageId = 1;
var firedEventsCount = 0;
var initiator = new User {
Id = 1
};
var invited = new List <User>
{
new User
{
Id = 2
},
new User
{
Id = 3
}
};
var conversationUsers = invited.Union(new List <User> {
initiator
}).Select(u => new ConversationUser()
{
ConversationId = conversationId, UserId = u.Id
}).ToList();
var conversationUserRepository = new TestRepository <ConversationUser>(conversationUsers);
var blackListRepository = new TestRepository <BlackList>();
var chatActionRepository = new TestRepository <ChatAction>(new List <ChatAction>()
{
new ChatAction()
{
ConversationId = conversationId
}
});
var messageRepository = new TestRepository <Message>(new List <Message>()
{
new Message()
{
Id = messageId,
ConversationId = conversationId,
SenderId = initiator.Id,
Text = "test"
}
});;
var attachmentRepository = new TestRepository <Attachment>(new List <Attachment>()
{
new Attachment
{
Id = 1,
MessageId = messageId
}
});
var blackListService = new BlackListService(blackListRepository, _mapper);
var conversationUserService = new ConversationUserService(conversationUserRepository, _mapper);
var messageService = new MessageService(messageRepository, attachmentRepository, _timeProvider, _attachmentContentProvider, blackListService, conversationUserService, _mapper);
var conversation = new Conversation
{
Id = conversationId,
OwnerId = initiator.Id,
Users = conversationUsers
};
var conversationRepository = new TestRepository <Conversation>(new List <Conversation>()
{
conversation
});
var conversationService = new ConversationService(conversationRepository, conversationUserRepository, chatActionRepository, blackListService, messageService, _timeProvider, _mapper);
conversationService.OnConversationDeleted += (c) => firedEventsCount++;
await conversationService.DeleteConversationAsync(initiator.Id, conversation.Id);
Assert.Empty(conversationRepository.All());
Assert.Empty(messageRepository.All());
Assert.Empty(attachmentRepository.All());
Assert.Empty(conversationUserRepository.All());
Assert.Equal(1, firedEventsCount);
}
public async Task ShouldNotSendToBlockedUser()
{
var firedEventsCount = 0;
var senderId = 1;
var blockerId = 2;
var conversationId = 1;
var sender = new User()
{
Id = senderId
};
var conversation = new Conversation()
{
Id = conversationId
};
var conversationUsers = new List <ConversationUser>()
{
new ConversationUser()
{
ConversationId = conversationId,
UserId = senderId
},
new ConversationUser()
{
ConversationId = conversationId,
UserId = blockerId
}
};
var blackListRepository = new TestRepository <BlackList>(new List <BlackList>()
{
new BlackList()
{
InitiatorId = blockerId, BlockedId = senderId
}
});
var messageRepository = new TestRepository <Message>();
var attachmentRepository = new TestRepository <Attachment>();
var timeProvider = new TestTimeProvider();
var attachmentContentProvider = new TestAttachmentContentProvider();
var blackListService = new BlackListService(blackListRepository, _mapper);
var conversationUserService = new ConversationUserService(new TestRepository <ConversationUser>(conversationUsers), _mapper);
var messageService = new MessageService(messageRepository,
attachmentRepository,
timeProvider,
attachmentContentProvider,
blackListService,
conversationUserService,
_mapper);
messageService.OnMessageSent += (m) => firedEventsCount++;
await messageService.SendMessageAsync(sender.Id, conversation.Id, "test", new AttachmentDto[] { new AttachmentDto {
Id = 1, MessageId = 1
} });
Assert.Empty(messageRepository.All());
Assert.Empty(attachmentRepository.All());
Assert.Equal(0, firedEventsCount);
}
