public void Return_False_When_No_User_Saved_This_Tweet()
{
//Arrange
var fakeUnit = new Mock <IUnitOfWork>();
var dateTimeProvider = new TestDateTimeProvider();
var fakeTweetService = new Mock <ITweetService>();
var sut = new UserTweetService(fakeUnit.Object, fakeTweetService.Object, dateTimeProvider);
var fakeUserTweetRepo = new Mock <IGenericRepository <UserTweet> >();
var userTweet = new UserTweet {
UserId = "123", TweetId = "456"
};
var userTweetCollection = new List <UserTweet> {
userTweet
};
fakeUserTweetRepo.Setup(s => s.All).Returns(userTweetCollection.AsQueryable());
fakeUnit.Setup(u => u.UserTweets).Returns(fakeUserTweetRepo.Object);
//Act
var expectedResult = sut.AnyUserSavedThisTweetById("7777");
//Assert
Assert.IsFalse(expectedResult);
}
public void Return_Correct_Values_When_UserTweets_Exist()
{
//Arrange
var timeProvider = new TestDateTimeProvider();
var fakeUnit = new Mock <IUnitOfWork>();
var fakeTweetService = Mock.Of <ITweetService>();
var sut = new UserTweetService(fakeUnit.Object, fakeTweetService, timeProvider);
var fakeUserTweetRepo = new Mock <IGenericRepository <UserTweet> >();
var testTweet1 = new Tweet {
Text = "test1", TweetId = "10", OriginalTweetCreatedOn = timeProvider.OriginallyCreatedOn, FolloweeId = "666"
};
var testTweet2 = new Tweet {
Text = "test2", TweetId = "11", OriginalTweetCreatedOn = timeProvider.OriginallyCreatedOn, FolloweeId = "666"
};
var testTweet3 = new Tweet {
Text = "test3", TweetId = "12", OriginalTweetCreatedOn = timeProvider.OriginallyCreatedOn, FolloweeId = "789"
};
var testUserTweet1 = new UserTweet {
UserId = "100", Tweet = testTweet1, TweetId = testTweet1.TweetId
};
var testUserTweet2 = new UserTweet {
UserId = "100", Tweet = testTweet2, TweetId = testTweet2.TweetId
};
var testUserTweet3 = new UserTweet {
UserId = "100", Tweet = testTweet3, TweetId = testTweet3.TweetId
};
var userTweetCollection = new List <UserTweet> {
testUserTweet1, testUserTweet2, testUserTweet3
};
fakeUserTweetRepo.Setup(r => r.All).Returns(userTweetCollection.AsQueryable());
fakeUnit.Setup(u => u.UserTweets).Returns(fakeUserTweetRepo.Object);
var expectedTweet1 = new FakeTweetDto
{
TweetId = testTweet1.TweetId,
OriginalTweetCreatedOn = testTweet1.OriginalTweetCreatedOn,
Text = testTweet1.Text,
UsersMentioned = testTweet1.UsersMentioned
};
var expectedTweet2 = new FakeTweetDto
{
TweetId = testTweet2.TweetId,
OriginalTweetCreatedOn = testTweet2.OriginalTweetCreatedOn,
Text = testTweet2.Text,
UsersMentioned = testTweet2.UsersMentioned
};
var expectedTweetDtos = new List <FakeTweetDto> {
expectedTweet1, expectedTweet2
};
//Act
var actualTweetDtos = sut.GetTweetsByUserIdAndFolloweeId("100", "666");
//Assert
CollectionAssert.AreEqual(expectedTweetDtos, actualTweetDtos.ToList());
}
public void Invoke_SaveChanges_On_UnitOfWork_When_Found()
{
//Arrange
var fakeUnit = new Mock <IUnitOfWork>();
var fakeDateTimeProvider = Mock.Of <IDateTimeProvider>();
var fakeTweetService = Mock.Of <ITweetService>();
var sut = new UserTweetService(fakeUnit.Object, fakeTweetService, fakeDateTimeProvider);
var fakeUserTweetRepo = new Mock <IGenericRepository <UserTweet> >();
var userTweet = new UserTweet {
TweetId = "789", UserId = "123"
};
var userTweetCollection = new List <UserTweet> {
userTweet
};
fakeUserTweetRepo.Setup(r => r.All).Returns(userTweetCollection.AsQueryable());
fakeUnit.Setup(u => u.UserTweets).Returns(fakeUserTweetRepo.Object);
fakeUnit.Setup(s => s.SaveChanges()).Verifiable();
//Act
sut.DeleteUserTweet("123", "789");
//Assert
fakeUnit.Verify(v => v.SaveChanges(), Times.Once);
}
public void Return_False_When_UserTweet_Does_Not_Exist()
{
//Arrange
var fakeUnit = new Mock <IUnitOfWork>();
var fakeDateTimeProvider = Mock.Of <IDateTimeProvider>();
var fakeTweetService = Mock.Of <ITweetService>();
var sut = new UserTweetService(fakeUnit.Object, fakeTweetService, fakeDateTimeProvider);
var fakeUserTweetRepo = new Mock <IGenericRepository <UserTweet> >();
var userTweet = new UserTweet {
UserId = "123", TweetId = "456"
};
var userTweetCollection = new List <UserTweet> {
userTweet
};
fakeUserTweetRepo.Setup(r => r.All).Returns(userTweetCollection.AsQueryable());
fakeUnit.Setup(u => u.UserTweets).Returns(fakeUserTweetRepo.Object);
//Act
var exists = sut.UserTweetExists(userTweet.UserId, "666");
//Assert
Assert.IsFalse(exists);
}
public void Invoke_DeleteUserTweetAndEntities_In_Same_Method_When_Provided_Correct_Parameters_And_User_Saved_Tweets()
{
//Arrange
var fakeUserTweetSetvice = Mock.Of <IUserTweetService>();
var fakeUserFolloweeService = new Mock <IUserFolloweeService>();
var fakeUnit = new Mock <IUnitOfWork>();
var fakeFolloweeService = new Mock <IFolloweeService>();
var fakeTweetService = Mock.Of <ITweetService>();
var fakeTweetTagService = Mock.Of <ITweetTagService>();
var fakeAdminUserService = Mock.Of <IAdminUserService>();
var sut = new FakeCascadeDeleteService(fakeUserTweetSetvice, fakeUserFolloweeService.Object, fakeUnit.Object, fakeFolloweeService.Object, fakeTweetService, fakeTweetTagService, fakeAdminUserService);
var fakeUserFolloweeRepo = new Mock <IGenericRepository <UserFollowee> >();
var fakeUserTweetRepo = new Mock <IGenericRepository <UserTweet> >();
var userFollowees = new List <UserFollowee>();
var testTweet = new Tweet {
FolloweeId = "123", TweetId = "666"
};
var testUserTweet = new UserTweet {
Tweet = testTweet, TweetId = testTweet.TweetId, UserId = "456"
};
var userTweets = new List <UserTweet> {
testUserTweet
};
fakeUserFolloweeRepo.Setup(r => r.All).Returns(userFollowees.AsQueryable());
fakeUserTweetRepo.Setup(r => r.All).Returns(userTweets.AsQueryable());
fakeUnit.Setup(u => u.UserFollowees).Returns(fakeUserFolloweeRepo.Object);
fakeUnit.Setup(u => u.UserTweets).Returns(fakeUserTweetRepo.Object);
fakeUserFolloweeService.Setup(s => s.AnyUserSavedThisFolloweeById(It.IsAny <string>())).Returns(false);
//Act & Assert
Assert.ThrowsException <FakeTestException>(() => sut.DeleteUserFolloweeAndEntries("123", "456"));
}
public async Task <bool> DownloadTweet(string userId, Tweet tweet)
{
var isDownloaded = false;
var user = await this.DbContext.Users.FindAsync(userId);
if (user != null)
{
var userTweetExists = await this.DbContext.UserTweets.FindAsync(userId, tweet.Id);
if (userTweetExists == null)
{
var userTweet = new UserTweet()
{
UserId = userId,
User = user,
TweetId = tweet.Id,
Tweet = tweet
};
await this.DbContext.UserTweets.AddAsync(userTweet);
var tweetExists = await this.DbContext.Tweets.FindAsync(tweet.Id);
if (tweetExists != null)
{
if (tweetExists.IsDeleted)
{
tweetExists.IsDeleted = false;
var entry = this.DbContext.Entry(tweetExists);
entry.State = EntityState.Modified;
}
}
else
{
await this.DbContext.Tweets.AddAsync(tweet);
}
isDownloaded = true;
}
else
{
if (userTweetExists.IsDeleted)
{
userTweetExists.IsDeleted = false;
var entry = this.DbContext.Entry(userTweetExists);
entry.State = EntityState.Modified;
}
isDownloaded = true;
}
}
return(isDownloaded);
}
public int AddTweetToFavourites(string tweetId, UserDTO userDto)
{
if (tweetId.IsNullOrWhitespace())
{
throw new InvalidTweetIdException(nameof(tweetId));
}
if (userDto.IsNull())
{
throw new NullUserException(nameof(userDto));
}
var tweet = GetSavedTweetById(tweetId);
var user = this.mappingProvider.MapTo <User>(userDto);
UserTweet userTweet = null;
if (this.IsActuallyFavourite(tweet.Id, user.Id))
{
if (!this.IsDeleted(tweet.Id, user.Id))
{
throw new ArgumentException();
}
userTweet = this.userTweets
.AllAndDeleted
.SingleOrDefault(x =>
x.TweetId.Equals(tweet.Id)
&&
x.UserId.Equals(user.Id)
);
userTweet.IsDeleted = false;
this.userTweets.Update(userTweet);
}
else
{
userTweet = new UserTweet
{
User = user,
UserId = user.Id,
Tweet = tweet,
TweetId = tweet.TwitterId
};
userTweets.Add(userTweet);
}
return(this.saver.SaveChanges());
}
public async Task <bool> TweetDownloaded(User user, Tweet tweet)
{
var checkIfTweetExists = await this.DbContext.UserTweets.FindAsync(user.Id, tweet.Id);
if (checkIfTweetExists != null)
{
checkIfTweetExists.IsDeleted = false;
return(true);
}
else
{
var userTweet = new UserTweet()
{
UserId = user.Id,
User = user,
TweetId = tweet.Id,
Tweet = tweet
};
this.DbContext.UserTweets.Add(userTweet);
return(true);
}
}
public void Invoke_SaveChanges_In_UnitOfWork_When_Tweet_Exist_TweetTag_Is_Deleted()
{
//Arrange
var fakeUnit = new Mock <IUnitOfWork>();
var dateTimeProvider = new TestDateTimeProvider();
var fakeTweetService = new Mock <ITweetService>();
var sut = new UserTweetService(fakeUnit.Object, fakeTweetService.Object, dateTimeProvider);
var fakeUserTweetRepo = new Mock <IGenericRepository <UserTweet> >();
var fakeTweetRepo = new Mock <IGenericRepository <Tweet> >();
var tweet = new Tweet {
TweetId = "456"
};
var tweetCollection = new List <Tweet> {
tweet
};
var userTweet = new UserTweet {
TweetId = tweet.TweetId, UserId = "123", IsDeleted = true, DeletedOn = dateTimeProvider.DeletedOn
};
var userTweetCollection = new List <UserTweet> {
userTweet
};
fakeUnit.Setup(u => u.UserTweets).Returns(fakeUserTweetRepo.Object);
fakeTweetRepo.Setup(r => r.AllAndDeleted).Returns(tweetCollection.AsQueryable());
fakeUserTweetRepo.Setup(r => r.AllAndDeleted).Returns(userTweetCollection.AsQueryable());
fakeUnit.Setup(u => u.Tweets).Returns(fakeTweetRepo.Object);
fakeUnit.Setup(u => u.SaveChanges()).Verifiable();
//Act
sut.SaveSingleTweetToUserByTweetId("123", "456");
//Assert
fakeUnit.Verify(v => v.SaveChanges(), Times.Once);
}
public void Return_Correct_Value_When_Provided_Valid_Id()
{
//Arrange
var fakeUnitOfWork = new Mock <IUnitOfWork>();
var fakeUserTweetRepo = new Mock <IGenericRepository <UserTweet> >();
var fakeTimeProvider = new TestDateTimeProvider();
var testUser1 = new User {
UserName = "******", Id = "TestId1"
};
var testUser2 = new User {
UserName = "******", Id = "TestId2"
};
var testFollowee1 = new Followee {
ScreenName = "TestScreenName1"
};
var testFollowee2 = new Followee {
ScreenName = "TestScreenName1"
};
var testTweet1 = new Tweet {
Text = "testTweet1", OriginalTweetCreatedOn = fakeTimeProvider.CreatedOn, TweetId = "testTweet1Id", Followee = testFollowee1
};
var testTweet2 = new Tweet {
Text = "testTweet2", OriginalTweetCreatedOn = fakeTimeProvider.CreatedOn, TweetId = "testTweet2Id", Followee = testFollowee2
};
var testTweet3 = new Tweet {
Text = "testTweet3", OriginalTweetCreatedOn = fakeTimeProvider.CreatedOn, TweetId = "testTweet3Id", Followee = testFollowee1
};
var testUserTweet1 = new UserTweet {
Tweet = testTweet1, TweetId = testTweet1.TweetId, UserId = testUser1.Id, User = testUser1, IsDeleted = true, DeletedOn = fakeTimeProvider.DeletedOn
};
var testUserTweet2 = new UserTweet {
Tweet = testTweet2, TweetId = testTweet2.TweetId, UserId = testUser1.Id, User = testUser1, IsDeleted = false
};
var testUserTweet3 = new UserTweet {
Tweet = testTweet3, TweetId = testTweet3.TweetId, UserId = testUser2.Id, User = testUser2
};
var fakeUserTweetCollection = new List <UserTweet> {
testUserTweet1, testUserTweet2, testUserTweet3
};
fakeUserTweetRepo.Setup(r => r.AllAndDeleted).Returns(fakeUserTweetCollection.AsQueryable());
fakeUnitOfWork.Setup(u => u.UserTweets).Returns(fakeUserTweetRepo.Object);
var deletedModel = new FakeDeletedTweetsModel
{
TweetDeletedOn = testUserTweet1.DeletedOn.Value,
Text = testUserTweet1.Tweet.Text,
OriginalTweetCreatedOn = testUserTweet1.Tweet.OriginalTweetCreatedOn,
AuthorScreenName = testUserTweet1.Tweet.Followee.ScreenName
};
var expectedResult = new List <FakeDeletedTweetsModel> {
deletedModel
};
var sut = new TweetStatisticsService(fakeUnitOfWork.Object);
//Act
var actualResult = sut.GetDeletedTweetsyUserId("TestId1").ToList();
//Assert
CollectionAssert.AreEqual(expectedResult, actualResult);
}
public void SaveSingleTweetToUserByTweetId(string userId, string tweetId)
{
if (string.IsNullOrWhiteSpace(userId))
{
throw new ArgumentNullException(nameof(userId));
}
if (string.IsNullOrWhiteSpace(tweetId))
{
throw new ArgumentNullException(nameof(tweetId));
}
var tweetToSaveToUser = this.unitOfWork.Tweets.AllAndDeleted.FirstOrDefault(w => w.TweetId == tweetId);
if (tweetToSaveToUser == null) // if it's a new Tweet, it's a new UserTweet
{
tweetToSaveToUser = this.tweetService.CreateFromApiById(tweetId);
var userTweetToadd = new UserTweet {
UserId = userId, TweetId = tweetToSaveToUser.TweetId
};
this.unitOfWork.UserTweets.Add(userTweetToadd);
this.unitOfWork.SaveChanges();
}
else
{
if (tweetToSaveToUser.IsDeleted)
{
tweetToSaveToUser.IsDeleted = false;
tweetToSaveToUser.DeletedOn = null;
tweetToSaveToUser.ModifiedOn = this.dateTimeProvider.Now;
var tags = this.unitOfWork.TweetTags.AllAndDeleted.Where(w => w.TweetId == tweetId)
.Select(s => s.Tag).ToList();
foreach (var tag in tags)
{
var tweetTagToReAdd =
this.unitOfWork.TweetTags.AllAndDeleted.FirstOrDefault(
w => w.TagId == tag.Id && w.TweetId == tweetId);
if (tweetTagToReAdd != null && tweetTagToReAdd.IsDeleted)
{
tweetTagToReAdd.IsDeleted = false;
tweetTagToReAdd.DeletedOn = null;
tweetTagToReAdd.ModifiedOn = this.dateTimeProvider.Now;
}
if (tag.IsDeleted)
{
tag.IsDeleted = false;
tag.DeletedOn = null;
tag.ModifiedOn = this.dateTimeProvider.Now;
}
}
this.unitOfWork.SaveChanges();
}
if (!this.UserTweetExistsInDeleted(userId, tweetId))
{
var userTweetToadd = new UserTweet {
UserId = userId, TweetId = tweetId
};
this.unitOfWork.UserTweets.Add(userTweetToadd);
this.unitOfWork.SaveChanges();
}
else
{
var userTweetToBeReadded =
this.unitOfWork.UserTweets.AllAndDeleted.FirstOrDefault(a =>
a.TweetId == tweetId && a.UserId == userId);
if (userTweetToBeReadded != null)
{
userTweetToBeReadded.IsDeleted = false;
userTweetToBeReadded.DeletedOn = null;
userTweetToBeReadded.ModifiedOn = this.dateTimeProvider.Now;
this.unitOfWork.SaveChanges();
}
}
}
}
public void Return_Correct_Reports_When_Provided_Valid_Parameters()
{
//Arrange
var fakeUnitOfWork = new Mock <IUnitOfWork>();
var fakeUserRepo = new Mock <IGenericRepository <User> >();
var fakeUserTweetRepo = new Mock <IGenericRepository <UserTweet> >();
var fakeUserFolloweeRepo = new Mock <IGenericRepository <UserFollowee> >();
var fakeTimeProvider = new TestDateTimeProvider();
var testUser1 = new User {
UserName = "******", Id = "TestId1", CreatedOn = fakeTimeProvider.CreatedOn, IsDeleted = true
};
var testUser2 = new User {
UserName = "******", Id = "TestId2", CreatedOn = fakeTimeProvider.CreatedOn, IsDeleted = false
};
var fakeUserCollection = new List <User> {
testUser1, testUser2
};
var testUserFollowee1 = new UserFollowee {
User = testUser1, IsDeleted = true
};
var testUserFollowee2 = new UserFollowee {
User = testUser2, IsDeleted = true
};
var testUserFollowee3 = new UserFollowee {
User = testUser2, IsDeleted = false
};
var fakeUserFolloweeCollection = new List <UserFollowee> {
testUserFollowee1, testUserFollowee2, testUserFollowee3
};
var testUserTweet1 = new UserTweet {
User = testUser1, IsDeleted = true
};
var testUserTweet2 = new UserTweet {
User = testUser2, IsDeleted = true
};
var testUserTweet3 = new UserTweet {
User = testUser2, IsDeleted = false
};
var fakeUserTweetCollection = new List <UserTweet> {
testUserTweet1, testUserTweet2, testUserTweet3
};
fakeUserRepo.Setup(r => r.AllAndDeleted).Returns(fakeUserCollection.AsQueryable());
fakeUserTweetRepo.Setup(r => r.AllAndDeleted).Returns(fakeUserTweetCollection.AsQueryable());
fakeUserFolloweeRepo.Setup(r => r.AllAndDeleted).Returns(fakeUserFolloweeCollection.AsQueryable());
fakeUnitOfWork.Setup(u => u.Users).Returns(fakeUserRepo.Object);
fakeUnitOfWork.Setup(u => u.UserTweets).Returns(fakeUserTweetRepo.Object);
fakeUnitOfWork.Setup(u => u.UserFollowees).Returns(fakeUserFolloweeRepo.Object);
var sut = new StatisticsService(fakeUnitOfWork.Object);
var statisticsModel1 = new FakeUserStatisticsModel
{
ActivelyFollowedAccountsCount = 0,
DeletedAccountsCount = 1,
ActiveStatus = "Deleted",
UserId = "TestId1",
UserName = "******",
SavedTweetsCount = 0,
DeletedTweetsCount = 1,
UserNameCreatedOn = fakeTimeProvider.CreatedOn
};
var statisticsModel2 = new FakeUserStatisticsModel
{
ActivelyFollowedAccountsCount = 1,
DeletedAccountsCount = 1,
ActiveStatus = "Active",
UserId = "TestId2",
UserName = "******",
SavedTweetsCount = 1,
DeletedTweetsCount = 1,
UserNameCreatedOn = fakeTimeProvider.CreatedOn
};
var totalStatisticsModel = new FakeTotalStatisticsModel
{
TotalDeletedAccountsCount = 2,
TotalSavedTweetsCount = 1,
TotalDeletedTweetsCount = 2,
TotalUsers = 2,
TotalActivelyFollowedAccountsCount = 1,
TotalActiveUsers = 1,
TotalDeletedUsers = 1
};
var usesStatisticsModels = new Dictionary <string, UserStatisticsModel>
{
["TestUser1"] = statisticsModel1,
["TestUser2"] = statisticsModel2
};
var expectedOutput = new FakeStatisticsScreenModel {
TotalStatisticsModel = totalStatisticsModel, UserStatisticsModels = usesStatisticsModels.Values
};
//Act
var actualOutput = sut.UsersStatistics();
//Assert
Assert.AreEqual(expectedOutput.TotalStatisticsModel, actualOutput.TotalStatisticsModel);
CollectionAssert.AreEqual(expectedOutput.UserStatisticsModels.ToList(), actualOutput.UserStatisticsModels.ToList());
}
public async Task <HttpResponseMessage> Post([FromBody] UserTweet tweet)
{
var userAuthInfo = Program.GetUserAuthInfo(tweet.screenName);
if (userAuthInfo == null)
{
return(Request.CreateResponse(HttpStatusCode.OK));
}
var httpMethod = "POST";
var baseUrl = "https://api.twitter.com/1.1/statuses/update.json";
var twitterOauthParams = new Dictionary <string, string>()
{
{ TwitterOauthUtils.OAuthConsumerKeyKey, TwitterSignInController.consumer_key },
{ TwitterOauthUtils.OAuthNonceKey, TwitterOauthUtils.GenerateNonce() },
{ TwitterOauthUtils.OAuthSignatureMethodKey, TwitterOauthUtils.OAuthSignatureMethod },
{ TwitterOauthUtils.OAuthTimestampKey, TwitterOauthUtils.UnixTimeStamp() },
{ TwitterOauthUtils.OAuthVersionKey, TwitterOauthUtils.OAuthVersion },
{ TwitterOauthUtils.OAuthTokenKey, userAuthInfo.OAuthToken }
};
var twitterQueryParams = new Dictionary <string, string>();
twitterQueryParams.Add("status", tweet.message);
var twitterPostParams = new Dictionary <string, string>();
var oauthSignature = TwitterOauthUtils.CreateSignature(httpMethod,
baseUrl,
twitterQueryParams,
twitterPostParams,
twitterOauthParams,
TwitterSignInController.consumer_secret,
userAuthInfo.OAuthTokenSecret);
List <string> queryParamsList = new List <string>();
foreach (var kvp in twitterQueryParams)
{
queryParamsList.Add(string.Format("{0}={1}", kvp.Key, kvp.Value));
}
var url = string.Format("{0}?{1}", baseUrl, string.Join("&", queryParamsList));
HttpRequestMessage message = new HttpRequestMessage(HttpMethod.Post, url);
message.Headers.Add("Accept", "*/*");
message.Headers.Add("User-Agent", "weatherama-client-1.0");
message.Headers.Add("Host", "api.twitter.com");
var oauthParamsList = new List <string>();
foreach (var kvp in twitterOauthParams)
{
oauthParamsList.Add(string.Format("{0}=\"{1}\"", kvp.Key, TwitterOauthUtils.PercentEncode(kvp.Value)));
}
oauthParamsList.Add(string.Format("{0}=\"{1}\"", TwitterOauthUtils.OAuthSignatureKey, TwitterOauthUtils.PercentEncode(oauthSignature)));
var oauthHeader = string.Format("OAuth {0}", string.Join(",", oauthParamsList));
message.Headers.Add("Authorization", oauthHeader);
HttpClient httpClient = new HttpClient();
var responseMessage = await httpClient.SendAsync(message);
string responseContent = string.Empty;
if (responseMessage.Content != null)
{
responseContent = await responseMessage.Content.ReadAsStringAsync();
}
if (responseMessage.StatusCode == HttpStatusCode.OK)
{
System.Diagnostics.Debug.WriteLine(responseContent);
}
return(Request.CreateResponse(HttpStatusCode.OK));
}
