public async Task ShouldNotCreateConversationIfNotAllowedConvertMessageToConversation()
{
// Arrange
SocialAccount socialAccount = MakeSocialAccount();
socialAccount.IfConvertMessageToConversation = false;
IMessage testMessage = MakeTestMessage(socialAccount);
var socialUserServiceMock = new Mock <ISocialUserService>();
socialUserServiceMock
.Setup(t => t.GetOrCreateTwitterUser(testMessage.Sender))
.ReturnsAsync(new SocialUser {
Id = 1
});
socialUserServiceMock
.Setup(t => t.GetOrCreateTwitterUser(testMessage.Recipient))
.ReturnsAsync(socialAccount.SocialUser);
var dependencyResolver = new DependencyResolverBuilder()
.WithSocialUserService(socialUserServiceMock.Object)
.Build();
var service = dependencyResolver.Resolve <TwitterDirectMessageService>();
service.UnitOfWorkManager = DependencyResolverBuilder.MockUnitOfWorkManager().Object;
// Act
var processResult = await service.ProcessDirectMessage(socialAccount, testMessage);
// Assert
Assert.Equal(0, processResult.NewConversations.Count());
}
public async Task ShouldSetDefaultAssigneeWhenCreatePost()
{
// Arrange
var account = MakeSocialAccount();
account.ConversationPriority = ConversationPriority.High;
account.ConversationDepartmentId = 10;
account.ConversationAgentId = 100;
var socialUserServiceMock = MockSocialUserService(account);
var fbClientMock = MockFbClient(account.SocialUser.OriginalId, account.Token, MakeSinglePostPagingData());
var dependencyResolver = new DependencyResolverBuilder()
.WithSocialUserService(socialUserServiceMock.Object)
.WithFacebookClient(fbClientMock.Object)
.Build();
var pullJobService = dependencyResolver.Resolve <PullJobService>();
// Act
FacebookProcessResult processResult = await pullJobService.PullTaggedVisitorPosts(account);
// Assert
var conversation = processResult.NewConversations.First();
Assert.Equal(10, conversation.DepartmentId);
Assert.Equal(100, conversation.AgentId);
Assert.Equal(ConversationPriority.High, conversation.Priority);
}
public async Task ShouldIngoreDuplicatePost()
{
// Arrange
var account = MakeSocialAccount();
var conversationServiceMock = new Mock <IConversationService>();
// make duplicate data
var duplicateConversations = new List <Conversation>
{
new Conversation {
Source = ConversationSource.FacebookVisitorPost,
OriginalId = "post_1"
}
};
conversationServiceMock.Setup(t => t.FindAll()).Returns(duplicateConversations.AsQueryable());
var socialUserServiceMock = MockSocialUserService(account);
var fbClientMock = MockFbClient(account.SocialUser.OriginalId, account.Token, MakeSinglePostPagingData());
var dependencyResolver = new DependencyResolverBuilder()
.WithConversationService(conversationServiceMock.Object)
.WithSocialUserService(socialUserServiceMock.Object)
.WithFacebookClient(fbClientMock.Object)
.Build();
var pullJobService = dependencyResolver.Resolve <PullJobService>();
// Act
FacebookProcessResult processResult = await pullJobService.PullTaggedVisitorPosts(account);
// Assert
Assert.Equal(0, processResult.NewConversations.Count());
}
public async Task ShouldNotCreateMessageForCommentsIfParentMessageNotExists()
{
// Arrange
var account = MakeSocialAccount();
var conversationServiceMock = new Mock <IConversationService>();
var existingConversations = new List <Conversation>();
existingConversations.Add(new Conversation {
Id = 1, OriginalId = "post_1"
});
conversationServiceMock.Setup(t => t.FindAll()).Returns(existingConversations.AsQueryable());
var messageServiceMock = new Mock <IMessageService>();
var existingMessages = new List <Message>();// make sure parent message not exists.
messageServiceMock.Setup(t => t.FindAll()).Returns(existingMessages.AsQueryable());
var socialUserServiceMock = MockSocialUserService(account);
var postWithComments = MakePostWithCommentsPaingData();
var fbClientMock = MockFbClient(account.SocialUser.OriginalId, account.Token, postWithComments);
var dependencyResolver = new DependencyResolverBuilder()
.WithConversationService(conversationServiceMock.Object)
.WithMessageService(messageServiceMock.Object)
.WithSocialUserService(socialUserServiceMock.Object)
.WithFacebookClient(fbClientMock.Object)
.Build();
var pullJobService = dependencyResolver.Resolve <PullJobService>();
// Act
FacebookProcessResult processResult = await pullJobService.PullTaggedVisitorPosts(account);
// Assert
Assert.Equal(0, processResult.NewMessages.Count());
}
/// <summary>
/// Runs when the HTTP application starts.
/// </summary>
protected void Application_Start()
{
// Configure the application.
GlobalHttpApplication.ConfigureApplication(GlobalConfiguration.Configuration);
// Register the dependency resolver.
GlobalConfiguration.Configuration.DependencyResolver = DependencyResolverBuilder.BuildDependencyResolver();
}
public async Task ShouldCreateConversationForNextPageDataFromFacebook()
{
// Arrange
var account = MakeSocialAccount();
var conversationServiceMock = new Mock <IConversationService>();
var socialUserServiceMock = MockSocialUserService(account);
var firstPageData = new FbPagingData <FbPost>
{
data = new List <FbPost>
{
new FbPost {
id = "post_1",
from = new FbUser {
id = "user_1"
},
created_time = new DateTime(2000, 1, 1, 1, 1, 1, DateTimeKind.Utc),
message = "test_content 1"
}
},
paging = new FbPaging
{
next = "http://api.facebook.com/122312"
}
};
var secondPageData = new FbPagingData <FbPost>
{
data = new List <FbPost>
{
new FbPost {
id = "post_2",
from = new FbUser {
id = "user_1"
},
created_time = new DateTime(2001, 1, 1, 1, 1, 1, DateTimeKind.Utc),
message = "test_content 2"
}
}
};
var fbClientMock = MockFbClient(account.SocialUser.OriginalId, account.Token, firstPageData);
fbClientMock.Setup(t => t.GetPagingData <FbPost>("http://api.facebook.com/122312"))
.ReturnsAsync(secondPageData);
var dependencyResolver = new DependencyResolverBuilder()
.WithConversationService(conversationServiceMock.Object)
.WithSocialUserService(socialUserServiceMock.Object)
.WithFacebookClient(fbClientMock.Object)
.Build();
var pullJobService = dependencyResolver.Resolve <PullJobService>();
// Act
FacebookProcessResult processResult = await pullJobService.PullTaggedVisitorPosts(account);
// Assert
conversationServiceMock.Verify(t => t.InsertAsync(It.IsAny <Conversation>()), Times.Exactly(2));
}
public async Task ShouldCreateConversationForWallPost()
{
// Arrange
var account = MakeSocialAccount();
var conversationServiceMock = new Mock <IConversationService>();
var messageService = new Mock <IMessageService>().Object;
var socialUserServiceMock = new Mock <ISocialUserService>();
socialUserServiceMock
.Setup(t => t.GetOrCreateSocialUsers(account.Token, It.IsAny <List <FbUser> >()))
.ReturnsAsync(
new List <SocialUser> {
new SocialUser {
Id = 1, OriginalId = account.SocialUser.OriginalId
}
}
);
var wallPostData = MakeSinglePostPagingData();
wallPostData.data.First().from = new FbUser
{
id = account.SocialUser.OriginalId
};
var fbClientMock = MockFbClient(account.SocialUser.OriginalId, account.Token, wallPostData);
var dependencyResolver = new DependencyResolverBuilder()
.WithConversationService(conversationServiceMock.Object)
.WithSocialUserService(socialUserServiceMock.Object)
.WithFacebookClient(fbClientMock.Object)
.Build();
var pullJobService = dependencyResolver.Resolve <PullJobService>();
// Act
FacebookProcessResult processResult = await pullJobService.PullVisitorPostsFromFeed(account);
// Assert
var conversation = processResult.NewConversations.First();
Assert.NotNull(conversation);
conversationServiceMock.Verify(t => t.InsertAsync(conversation));
Assert.Equal("post_1", conversation.OriginalId);
Assert.Equal(1, conversation.LastMessageSenderId);
Assert.Equal(new DateTime(2000, 1, 1, 1, 1, 1, DateTimeKind.Utc), conversation.LastMessageSentTime);
Assert.Equal(ConversationSource.FacebookWallPost, conversation.Source);
Assert.Equal(ConversationPriority.Normal, conversation.Priority);
Assert.Equal(ConversationStatus.New, conversation.Status);
var message = conversation.Messages.First();
Assert.Equal("test_content", message.Content);
Assert.Equal(MessageSource.FacebookPost, message.Source);
Assert.Equal(1, message.SenderId);
Assert.Equal(888, message.ReceiverId);
Assert.Equal(new DateTime(2000, 1, 1, 1, 1, 1, DateTimeKind.Utc), message.SendTime);
}
public async Task ShouldCreateMessageForReplyComments()
{
// Arrange
var account = MakeSocialAccount();
var conversationServiceMock = new Mock <IConversationService>();
var existingConversations = new List <Conversation>();
existingConversations.Add(new Conversation {
Id = 1, OriginalId = "post_1"
});
conversationServiceMock.Setup(t => t.FindAll()).Returns(existingConversations.AsQueryable());
var messageServiceMock = new Mock <IMessageService>();
var existingMessages = new List <Message>();
existingMessages.Add(new Message {
Id = 1, ConversationId = 1, OriginalId = "post_1", SenderId = 777, Source = MessageSource.FacebookPost
});
existingMessages.Add(new Message {
Id = 2, ConversationId = 1, OriginalId = "comment_1", SenderId = 777, ParentId = 1, Source = MessageSource.FacebookPostComment
});
messageServiceMock.Setup(t => t.FindAll()).Returns(existingMessages.AsQueryable());
var socialUserServiceMock = MockSocialUserService(account);
var postWithReplyComments = MakePostWithReplyCommentsPaingData();
var fbClientMock = MockFbClient(account.SocialUser.OriginalId, account.Token, postWithReplyComments);
var dependencyResolver = new DependencyResolverBuilder()
.WithConversationService(conversationServiceMock.Object)
.WithMessageService(messageServiceMock.Object)
.WithSocialUserService(socialUserServiceMock.Object)
.WithFacebookClient(fbClientMock.Object)
.Build();
var pullJobService = dependencyResolver.Resolve <PullJobService>();
// Act
FacebookProcessResult processResult = await pullJobService.PullTaggedVisitorPosts(account);
// Assert
Assert.Equal(1, processResult.NewMessages.Count());
var message = processResult.NewMessages.First();
Assert.Equal("test_reply_comment_content1", message.Content);
Assert.Equal(MessageSource.FacebookPostReplyComment, message.Source);
Assert.Equal(1, message.SenderId);
Assert.Equal(1, message.ConversationId);
Assert.Equal(777, message.ReceiverId);
Assert.Equal(new DateTime(2000, 1, 2, 1, 1, 1, DateTimeKind.Utc), message.SendTime);
}
public async Task ShouldAddMessageToExistingConversation()
{
// Arrange
SocialAccount socialAccount = MakeSocialAccount();
IMessage testMessage = MakeTestMessage(socialAccount);
var socialUserServiceMock = new Mock <ISocialUserService>();
socialUserServiceMock
.Setup(t => t.GetOrCreateTwitterUser(testMessage.Sender))
.ReturnsAsync(new SocialUser {
Id = 1
});
socialUserServiceMock
.Setup(t => t.GetOrCreateTwitterUser(testMessage.Recipient))
.ReturnsAsync(socialAccount.SocialUser);
var existingConversation = new Conversation {
Id = 10
};
var conversationServiceMock = new Mock <IConversationService>();
conversationServiceMock.Setup(t => t.GetTwitterDirectMessageConversation(
It.Is <SocialUser>(r => r.Id == 1),
It.Is <SocialUser>(r => r.Id == socialAccount.Id)
)).Returns(existingConversation);
var dependencyResolver = new DependencyResolverBuilder()
.WithConversationService(conversationServiceMock.Object)
.WithSocialUserService(socialUserServiceMock.Object)
.Build();
var service = dependencyResolver.Resolve <TwitterDirectMessageService>();
service.UnitOfWorkManager = DependencyResolverBuilder.MockUnitOfWorkManager().Object;
// Act
var processResult = await service.ProcessDirectMessage(socialAccount, testMessage);
// Assert
conversationServiceMock.Verify(t => t.Update(existingConversation));
var message = processResult.NewMessages.First();
Assert.Equal(testMessage.Text, message.Content);
Assert.Equal(existingConversation.Id, message.ConversationId);
Assert.Equal(MessageSource.TwitterDirectMessage, message.Source);
Assert.Equal(1, message.SenderId);
Assert.Equal(socialAccount.Id, message.ReceiverId);
}
public async Task ShouldCreateConversationForDirectMessage()
{
// Arrange
SocialAccount socialAccount = MakeSocialAccount();
IMessage testMessage = MakeTestMessage(socialAccount);
var socialUserServiceMock = new Mock <ISocialUserService>();
socialUserServiceMock
.Setup(t => t.GetOrCreateTwitterUser(testMessage.Sender))
.ReturnsAsync(new SocialUser {
Id = 1
});
socialUserServiceMock
.Setup(t => t.GetOrCreateTwitterUser(testMessage.Recipient))
.ReturnsAsync(socialAccount.SocialUser);
var dependencyResolver = new DependencyResolverBuilder()
.WithSocialUserService(socialUserServiceMock.Object)
.Build();
var service = dependencyResolver.Resolve <TwitterDirectMessageService>();
service.UnitOfWorkManager = DependencyResolverBuilder.MockUnitOfWorkManager().Object;
// Act
var processResult = await service.ProcessDirectMessage(socialAccount, testMessage);
// Assert
var conversatoin = processResult.NewConversations.First();
Assert.NotNull(conversatoin);
Assert.Equal(testMessage.Id.ToString(), conversatoin.OriginalId);
Assert.Equal(ConversationSource.TwitterDirectMessage, conversatoin.Source);
Assert.Equal(ConversationStatus.New, conversatoin.Status);
Assert.Equal(ConversationPriority.Normal, conversatoin.Priority);
Assert.Equal(testMessage.Text, conversatoin.Subject);
Assert.Equal(testMessage.SenderId, conversatoin.LastMessageSenderId);
Assert.Equal(testMessage.CreatedAt, conversatoin.LastMessageSentTime);
var message = conversatoin.Messages.First();
Assert.NotNull(message);
Assert.Equal(testMessage.Text, message.Content);
Assert.Equal(MessageSource.TwitterDirectMessage, message.Source);
Assert.Equal(1, message.SenderId);
Assert.Equal(socialAccount.Id, message.ReceiverId);
}
public async Task ShouldCreateMessageForNextPageReplyComments()
{
// Arrange
var account = MakeSocialAccount();
var conversationServiceMock = new Mock <IConversationService>();
var existingConversations = new List <Conversation>();
existingConversations.Add(new Conversation {
Id = 1, OriginalId = "post_1"
});
conversationServiceMock.Setup(t => t.FindAll()).Returns(existingConversations.AsQueryable());
var messageServiceMock = new Mock <IMessageService>();
var existingMessages = new List <Message>();
existingMessages.Add(new Message {
Id = 1, ConversationId = 1, OriginalId = "post_1", SenderId = 777, Source = MessageSource.FacebookPost
});
existingMessages.Add(new Message {
Id = 2, ConversationId = 1, OriginalId = "comment_1", SenderId = 777, ParentId = 1, Source = MessageSource.FacebookPostComment
});
messageServiceMock.Setup(t => t.FindAll()).Returns(existingMessages.AsQueryable());
var socialUserServiceMock = MockSocialUserService(account);
var postWithReplyComments = MakePostWithReplyCommentsPaingData();
postWithReplyComments.data.First().comments.data.First().comments.paging
= new FbPaging {
next = "http://api.facebook.com/next-page-reply-comment/121123"
};
var fbClientMock = MockFbClient(account.SocialUser.OriginalId, account.Token, postWithReplyComments);
var dependencyResolver = new DependencyResolverBuilder()
.WithConversationService(conversationServiceMock.Object)
.WithMessageService(messageServiceMock.Object)
.WithSocialUserService(socialUserServiceMock.Object)
.WithFacebookClient(fbClientMock.Object)
.Build();
var pullJobService = dependencyResolver.Resolve <PullJobService>();
// Act
FacebookProcessResult processResult = await pullJobService.PullTaggedVisitorPosts(account);
// Assert
fbClientMock.Verify(t => t.GetPagingData <FbComment>("http://api.facebook.com/next-page-reply-comment/121123"));
}
public async Task ShouldNotCreateConversationIfDisabledIfConvertWallPostToConversation()
{
// Arrange
var account = MakeSocialAccount();
account.IfConvertWallPostToConversation = false;
var conversationServiceMock = new Mock <IConversationService>();
var messageService = new Mock <IMessageService>().Object;
var socialUserServiceMock = new Mock <ISocialUserService>();
socialUserServiceMock
.Setup(t => t.GetOrCreateSocialUsers(account.Token, It.IsAny <List <FbUser> >()))
.ReturnsAsync(
new List <SocialUser> {
new SocialUser {
Id = 1, OriginalId = account.SocialUser.OriginalId
}
}
);
var wallPostData = MakeSinglePostPagingData();
wallPostData.data.First().from = new FbUser
{
id = account.SocialUser.OriginalId
};
var fbClientMock = MockFbClient(account.SocialUser.OriginalId, account.Token, wallPostData);
var dependencyResolver = new DependencyResolverBuilder()
.WithConversationService(conversationServiceMock.Object)
.WithSocialUserService(socialUserServiceMock.Object)
.WithFacebookClient(fbClientMock.Object)
.Build();
var pullJobService = dependencyResolver.Resolve <PullJobService>();
// Act
FacebookProcessResult processResult = await pullJobService.PullVisitorPostsFromFeed(account);
// Assert
Assert.Equal(0, processResult.NewConversations.Count());
}
public async Task ShouldCreateConversationsForMultiplePost()
{
// Arrange
var account = MakeSocialAccount();
var conversationServiceMock = new Mock <IConversationService>();
var socialUserServiceMock = MockSocialUserService(account);
var testDataFromFb = new FbPagingData <FbPost>
{
data = new List <FbPost>
{
new FbPost {
id = "post_1",
from = new FbUser {
id = "user_1"
},
created_time = new DateTime(2000, 1, 1, 1, 1, 1, DateTimeKind.Utc),
message = "test_content 1"
},
new FbPost {
id = "post_2",
from = new FbUser {
id = "user_1"
},
created_time = new DateTime(2001, 1, 1, 1, 1, 1, DateTimeKind.Utc),
message = "test_content 2"
},
}
};
var fbClientMock = MockFbClient(account.SocialUser.OriginalId, account.Token, testDataFromFb);
var dependencyResolver = new DependencyResolverBuilder()
.WithConversationService(conversationServiceMock.Object)
.WithSocialUserService(socialUserServiceMock.Object)
.WithFacebookClient(fbClientMock.Object)
.Build();
var pullJobService = dependencyResolver.Resolve <PullJobService>();
// Act
FacebookProcessResult processResult = await pullJobService.PullTaggedVisitorPosts(account);
// Assert
conversationServiceMock.Verify(t => t.InsertAsync(It.IsAny <Conversation>()), Times.Exactly(2));
}
public async Task ShouldIgnoreIfRecipientIsOtherIntegrationAccountWhenCreatePost()
{
// Arrange
var account = MakeSocialAccount();
var socialUserServiceMock = MockSocialUserService(account);
var allAccounts = new List <SocialUser> {
account.SocialUser,
new SocialUser
{
Id = 999,
Source = SocialUserSource.Facebook,
Type = SocialUserType.IntegrationAccount,
OriginalId = "test_page_id2"
}
};
socialUserServiceMock.Setup(t => t.FindAll()).Returns(allAccounts.AsQueryable());
var postPagingData = MakeSinglePostPagingData();
postPagingData.data.First().to = new FbData <FbUser>
{
data = new List <FbUser>
{
new FbUser {
id = "test_page_id2"
}
}
};
var fbClientMock = MockFbClient(account.SocialUser.OriginalId, account.Token, postPagingData);
var dependencyResolver = new DependencyResolverBuilder()
.WithSocialUserService(socialUserServiceMock.Object)
.WithFacebookClient(fbClientMock.Object)
.Build();
var pullJobService = dependencyResolver.Resolve <PullJobService>();
// Act
FacebookProcessResult processResult = await pullJobService.PullTaggedVisitorPosts(account);
// Assert
Assert.Equal(0, processResult.NewConversations.Count());
}
public async Task ShouldPullVisitorPostFromFeed()
{
// Arrange
var account = MakeSocialAccount();
var socialUserServiceMock = MockSocialUserService(account);
var fbClientMock = MockFbClient(account.SocialUser.OriginalId, account.Token, MakeSinglePostPagingData());
var dependencyResolver = new DependencyResolverBuilder()
.WithSocialUserService(socialUserServiceMock.Object)
.WithFacebookClient(fbClientMock.Object)
.Build();
var pullJobService = dependencyResolver.Resolve <PullJobService>();
// Act
FacebookProcessResult processResult = await pullJobService.PullVisitorPostsFromFeed(account);
// Assert
fbClientMock.Verify(t => t.GetVisitorPosts(account.SocialUser.OriginalId, account.Token));
}
public async Task ShouldCreateConversationForSinglePost()
{
// Arrange
var account = MakeSocialAccount();
var conversationServiceMock = new Mock <IConversationService>();
var messageService = new Mock <IMessageService>().Object;
var socialUserServiceMock = MockSocialUserService(account);
var fbClientMock = MockFbClient(account.SocialUser.OriginalId, account.Token, MakeSinglePostPagingData());
var dependencyResolver = new DependencyResolverBuilder()
.WithConversationService(conversationServiceMock.Object)
.WithSocialUserService(socialUserServiceMock.Object)
.WithFacebookClient(fbClientMock.Object)
.Build();
var pullJobService = dependencyResolver.Resolve <PullJobService>();
// Act
FacebookProcessResult processResult = await pullJobService.PullTaggedVisitorPosts(account);
// Assert
var conversation = processResult.NewConversations.First();
Assert.NotNull(conversation);
conversationServiceMock.Verify(t => t.InsertAsync(conversation));
Assert.Equal("post_1", conversation.OriginalId);
Assert.Equal(1, conversation.LastMessageSenderId);
Assert.Equal(new DateTime(2000, 1, 1, 1, 1, 1, DateTimeKind.Utc), conversation.LastMessageSentTime);
Assert.Equal(ConversationSource.FacebookVisitorPost, conversation.Source);
Assert.Equal(ConversationPriority.Normal, conversation.Priority);
Assert.Equal(ConversationStatus.New, conversation.Status);
var message = conversation.Messages.First();
Assert.Equal("test_content", message.Content);
Assert.Equal(MessageSource.FacebookPost, message.Source);
Assert.Equal(1, message.SenderId);
Assert.Equal(888, message.ReceiverId);
Assert.Equal(new DateTime(2000, 1, 1, 1, 1, 1, DateTimeKind.Utc), message.SendTime);
}
public async Task ShouldSetRecipientWhenCreatePost()
{
// Arrange
var account = MakeSocialAccount();
var socialUserServiceMock = MockSocialUserService(account);
var allAccounts = new List <SocialUser> {
account.SocialUser
};
socialUserServiceMock.Setup(t => t.FindAll()).Returns(allAccounts.AsQueryable());
var postPagingData = MakeSinglePostPagingData();
postPagingData.data.First().to = new FbData <FbUser>()
{
data = new List <FbUser>
{
new FbUser {
id = account.SocialUser.OriginalId
}
}
};
var fbClientMock = MockFbClient(account.SocialUser.OriginalId, account.Token, postPagingData);
var dependencyResolver = new DependencyResolverBuilder()
.WithSocialUserService(socialUserServiceMock.Object)
.WithFacebookClient(fbClientMock.Object)
.Build();
var pullJobService = dependencyResolver.Resolve <PullJobService>();
// Act
FacebookProcessResult processResult = await pullJobService.PullTaggedVisitorPosts(account);
// Assert
var message = processResult.NewConversations.First().Messages.First();
Assert.Equal(account.Id, message.ReceiverId);
}
public async Task ShouldNotCreateConversationIfDuplicatedMessageHaveBeenFound()
{
// Arrange
SocialAccount socialAccount = MakeSocialAccount();
IMessage testMessage = MakeTestMessage(socialAccount);
var socialUserServiceMock = new Mock <ISocialUserService>();
socialUserServiceMock
.Setup(t => t.GetOrCreateTwitterUser(testMessage.Sender))
.ReturnsAsync(new SocialUser {
Id = 1
});
socialUserServiceMock
.Setup(t => t.GetOrCreateTwitterUser(testMessage.Recipient))
.ReturnsAsync(socialAccount.SocialUser);
var messageServiceMock = new Mock <IMessageService>();
messageServiceMock
.Setup(t => t.IsDuplicatedMessage(
MessageSource.TwitterDirectMessage, testMessage.Id.ToString()))
.Returns(true);
var dependencyResolver = new DependencyResolverBuilder()
.WithMessageService(messageServiceMock.Object)
.WithSocialUserService(socialUserServiceMock.Object)
.Build();
var service = dependencyResolver.Resolve <TwitterDirectMessageService>();
service.UnitOfWorkManager = DependencyResolverBuilder.MockUnitOfWorkManager().Object;
// Act
var processResult = await service.ProcessDirectMessage(socialAccount, testMessage);
// Assert
Assert.Equal(0, processResult.NewConversations.Count());
}
