public async Task CallSaveChangesOnce_WhenTweetSuccessfullyDeleted()
{
//Arrange
var unitOfWorkMock = new Mock <IUnitOfWork>();
var mappingProviderMock = new Mock <IMappingProvider>();
var userRepositoryMock = new Mock <IUserRepository>();
var tweetRepositoryMock = new Mock <ITweetRepository>();
var userId = "30";
var tweetId = "1905";
tweetRepositoryMock
.Setup(x => x.UserTweetIsDeleted(userId, tweetId))
.ReturnsAsync(true);
var tweetService = new TweetService(
unitOfWorkMock.Object,
mappingProviderMock.Object,
userRepositoryMock.Object,
tweetRepositoryMock.Object);
//Act
var tweetIsDeleted = await tweetService.DeleteTweet(userId, tweetId);
//Assert
unitOfWorkMock.Verify(x => x.SaveChangesAsync(), Times.Once);
}
public TweetController()
{
_commentService = new CommentService();
_appUserService = new AppUserService();
_likeService = new LikeService();
_tweetService = new TweetService();
}
public async Task ReturnFalse_WhenTweetRepositoryTweetIsDeletedMethodReturnsFalse()
{
//Arrange
var unitOfWorkMock = new Mock <IUnitOfWork>();
var mappingProviderMock = new Mock <IMappingProvider>();
var userRepositoryMock = new Mock <IUserRepository>();
var tweetRepositoryMock = new Mock <ITweetRepository>();
var userId = "30";
var tweetId = "1905";
tweetRepositoryMock
.Setup(x => x.UserTweetIsDeleted(userId, tweetId))
.ReturnsAsync(false);
var tweetService = new TweetService(
unitOfWorkMock.Object,
mappingProviderMock.Object,
userRepositoryMock.Object,
tweetRepositoryMock.Object);
//Act
var tweetIsDeleted = await tweetService.DeleteTweet(userId, tweetId);
//Assert
Assert.IsFalse(tweetIsDeleted);
}
public TweetPoster(TweetRepository tweetRepository)
{
_tweetService = new TweetService();
_tweetRepository = tweetRepository;
Task.Factory.StartNew(PostTweetsInBackGround);
}
public async void Delete_ErrorsOccurred_ShouldReturnErrorResponse()
{
var mock = new ServiceMockFacade <ITweetService, ITweetRepository>();
var model = new ApiTweetServerRequestModel();
var validatorMock = new Mock <IApiTweetServerRequestModelValidator>();
validatorMock.Setup(x => x.ValidateDeleteAsync(It.IsAny <int>())).Returns(Task.FromResult(new FluentValidation.Results.ValidationResult(new List <ValidationFailure>()
{
new ValidationFailure("text", "test")
})));
var service = new TweetService(mock.LoggerMock.Object,
mock.MediatorMock.Object,
mock.RepositoryMock.Object,
validatorMock.Object,
mock.DALMapperMockFactory.DALTweetMapperMock,
mock.DALMapperMockFactory.DALQuoteTweetMapperMock,
mock.DALMapperMockFactory.DALRetweetMapperMock);
ActionResponse response = await service.Delete(default(int));
response.Should().NotBeNull();
response.Success.Should().BeFalse();
validatorMock.Verify(x => x.ValidateDeleteAsync(It.IsAny <int>()));
mock.MediatorMock.Verify(x => x.Publish(It.IsAny <TweetDeletedNotification>(), It.IsAny <CancellationToken>()), Times.Never());
}
public TweetServiceTests()
{
_userService = new Mock <IUserService>().SetupAllProperties();
_sut = new TweetService();
_tweetFileSingleLine = $"{_basePath}singletweet.txt";
_tweetFileMultiLine = $"{_basePath}multipletweets.txt";
}
public void VerifyUniqueness()
{
var tweetsAsync = TweetService.GetTweets(new DateTime(2017, 1, 1), new DateTime(2017, 12, 31), 4).Result;
// Verify that we don't have any duplicate tweets
Assert.IsTrue(tweetsAsync.Distinct().Count() == tweetsAsync.Count);
}
public MemoryBoxManager()
{
if (_ms == null) _ms = new MemoryBoxService();
if (_msi == null) _msi = new MemoryBoxItemService();
if (_ts == null) _ts = new TweetService();
if (_is == null) _is = new ImageService();
}
protected override void Initialize(System.Web.Routing.RequestContext requestContext) {
if (tweetService == null) tweetService = new TweetService();
if (eventService == null) eventService = new EventService();
if (userService == null) userService = new UserService();
base.Initialize(requestContext);
}
public static async Task <IActionResult> Run(
[HttpTrigger(AuthorizationLevel.Function, "get", "post",
Route = null)] HttpRequest req, ILogger log)
{
log.LogInformation("C# HTTP trigger function processed a request.");
string requestBody = await new StreamReader(req.Body).ReadToEndAsync();
if (string.IsNullOrEmpty(requestBody))
{
return(new BadRequestObjectResult("You must supply a request body"));
}
log.LogInformation($"Original Tweet: { requestBody}");
TweetService service = new TweetService();
var result = service.ProcessTweet(requestBody);
if (result == false)
{
return(new BadRequestObjectResult($"We we're unable to process the Tweet: {requestBody}"));
}
return((ActionResult) new OkObjectResult($"The Tweet: {requestBody}, was processed successfully"));
}
public void Throws_ArgumentNullException_When_Called_With_StringEmpty_TweetId()
{
var unitOfWorkMock = new Mock<IUnitOfWork>();
var mapperMock = new Mock<IMappingProvider>();
var twitterApiCallServiceMock = new Mock<ITwitterApiCallService>();
var tweetTagServiceMock = new Mock<ITweetTagService>();
var tagServiceMock = new Mock<ITagService>();
var dateTimeParserMock = new Mock<IDateTimeParser>();
var repoMock = new Mock<IGenericRepository<Tweet>>();
var tweets = new List<Tweet>
{
new Tweet
{
TweetId = "1",
Text = "Tweet text",
OriginalTweetCreatedOn = DateTime.Now,
FolloweeId = "1"
}
};
mapperMock.Setup(x =>
x.MapTo<TweetDto>(tweets[0]))
.Returns(new TweetDto { TweetId = tweets[0].TweetId });
repoMock.Setup(r => r.All).Returns(tweets.AsQueryable());
unitOfWorkMock.Setup(u => u.Tweets).Returns(repoMock.Object);
var tweetService = new TweetService(mapperMock.Object, unitOfWorkMock.Object,
twitterApiCallServiceMock.Object, tweetTagServiceMock.Object,
tagServiceMock.Object, dateTimeParserMock.Object);
Assert.ThrowsException<ArgumentException>(() => tweetService.GetTweetByTweetId(""));
}
public void ThrowArgumentException_WhenInvokedWithInvalidEmptyTweetIdParameter()
{
//Arrange
var unitOfWorkMock = new Mock <IUnitOfWork>();
var mappingProviderMock = new Mock <IMappingProvider>();
var userRepositoryMock = new Mock <IUserRepository>();
var tweetRepositoryMock = new Mock <ITweetRepository>();
var tweetId = "30";
var tweet = new Tweet()
{
Text = "Netflix&Chill"
};
var expectedResult = new TweetDto()
{
Text = "Netflix&Chill"
};
tweetRepositoryMock
.Setup(x => x.Get(tweetId))
.ReturnsAsync(tweet);
mappingProviderMock
.Setup(x => x.MapTo <TweetDto>(tweet))
.Returns(expectedResult);
var tweetService = new TweetService(
unitOfWorkMock.Object,
mappingProviderMock.Object,
userRepositoryMock.Object,
tweetRepositoryMock.Object);
//Act && Assert
Assert.ThrowsExceptionAsync <ArgumentException>(async() => await tweetService.GetTweetById(string.Empty));
}
public async void TestGetOriginalTweets()
{
// Act
var tweets = await TweetService.Get().ConfigureAwait(false);
// Assert
Assert.NotNull(tweets);
Assert.NotEmpty(tweets);
var originalTweets = new List <Tweet>();
foreach (var tweet in tweets)
{
var name = tweet.Name;
var text = tweet.Text;
var retweetsCount = tweet.NumberOfRetweets;
var likesCount = tweet.NumberOfLikes;
var sameTweet = originalTweets.FirstOrDefault(tw =>
tw.Name == name && tw.Text == text && tw.NumberOfRetweets == retweetsCount &&
tw.NumberOfLikes == likesCount);
Assert.Null(sameTweet);
originalTweets.Add(tweet);
}
}
private static async void StreamThread(object callback)
{
Logger.Log(Logger.Info, $"Thread {Thread.CurrentThread.Name} started", Thread.CurrentThread.Name);
var stream = Tweetinvi.Stream.CreateFilteredStream();
var user = User.GetAuthenticatedUser();
stream.AddTrack("EDPostcards");
stream.AddTrack("ED_Postcards");
stream.MatchingTweetReceived += (sender, args) =>
{
Logger.Log(Logger.Info, "Received tweet matching filters.");
var tweet = args.Tweet;
if (!TweetService.CheckTweet(tweet, user))
{
return;
}
Logger.Log(Logger.Neutral, $" [ TWEETING ] \n{tweet.CreatedBy.ScreenName}\n{tweet.Text}\n{tweet.Media.Count} media files", "StreamListener");
TweetService.SendTweet(tweet);
};
stream.StreamStopped += (sender, args) =>
{
stream.StartStreamMatchingAllConditions();
};
stream.StartStreamMatchingAnyCondition();
await Task.Delay(-1);
}
static async Task LoadTweets(string tweetServiceUrl, string resultFileName, DateTime startDate, DateTime endDate)
{
TweetService service = new TweetService(tweetServiceUrl);
TweetLoader loader = new TweetLoader(service);
TweetLoaderResponse response = await loader.LoadTweetsByDate(startDate, endDate).ConfigureAwait(false);
if (!string.IsNullOrEmpty(response.ErrorMessage))
{
Console.WriteLine("Error while loading tweets: " + response.ErrorMessage);
}
else
{
Console.WriteLine("Loaded tweets count: " + response.Tweets.Count);
}
if (!string.IsNullOrEmpty(resultFileName) && response.Tweets != null)
{
try
{
loader.SaveToFile(response.Tweets, resultFileName);
Console.WriteLine("Saved tweets to: " + resultFileName);
}
catch (Exception ex)
{
Console.WriteLine("Error while saving tweets: " + ex.Message);
}
}
}
private static void InitApplication()
{
Authorize auth = new Authorize();
auth.AuthenticateUser();
TweetService.ClearLists();
tweetTimer = new Timer(TimerCallback, null, 0, 60000);
Console.ReadLine();
}
public HomeController()
{
_tweetService = new TweetService();
_appUserService = new AppUserService();
_commentService = new CommentService();
_likeService = new LikeService();
_retweetService = new RetweetService();
_dMSendService = new DMSendService();
}
public static async Task <IActionResult> Run(
[HttpTrigger(AuthorizationLevel.Anonymous, "get", Route = null)] HttpRequest req,
ILogger log)
{
var tweets = await TweetService.Get();
var json = JsonConvert.SerializeObject(new { tweets.First().TweetedImage });
return(new OkObjectResult(json));
}
public async Task ImgSender()
{
List <IAttachment> attachments = new List <IAttachment>();
var tempAttachments = new List <IAttachment>();
if (Context.Message.Attachments.Count > 0)
{
attachments.Add(Context.Message.Attachments.FirstOrDefault());
}
var delay = 15;
var botMsg = await ReplyAsync($"Waiting for more images...\nYour message will be sent to Twitter in {delay} seconds");
var typing = Context.Channel.EnterTypingState();
for (int i = 0; i < delay; i++)
{
var startExec = DateTime.Now;
var msgList = await Context.Channel.GetMessagesAsync(Context.Message, Direction.After, 10).FlattenAsync();
var tempMsgs = msgList.Where(m => m.Author.Id == Context.Message.Author.Id &&
m.Attachments.Count > 0);
if ((tempAttachments.Count + attachments.Count) < 4)
{
tempAttachments.Clear(); // Clear temp attachments before filling it
foreach (var mess in tempMsgs)
{
if (mess.Attachments.Count > 0 && (tempAttachments.Count + attachments.Count) < 4)
{
tempAttachments.Add(mess.Attachments.FirstOrDefault());
}
}
}
else
{
break;
}
var stopExec = DateTime.Now - startExec;
if (stopExec.TotalMilliseconds < 1000)
{
await Task.Delay((int)(1000 - stopExec.TotalMilliseconds));
}
await botMsg.ModifyAsync(m =>
{ m.Content = $"Waiting for more images...\nYour message will be sent to Twitter in {delay -1 - i} seconds"; });
}
attachments.AddRange(tempAttachments);
await botMsg.DeleteAsync();
var message = Context.Message.Content.Substring(Context.Message.Content.IndexOf("send", StringComparison.Ordinal) + "send".Length);
var user = await Context.Guild.GetUserAsync(Context.User.Id);
TweetService.DiscordTweet(message, user, attachments);
typing.Dispose();
await ReplyAsync($"Tweet sent with {attachments.Count} images !", deleteafter : TimeSpan.FromSeconds(3));
}
public async Task <string> GetData(DateTime start, DateTime end)
{
if (start > end)
{
throw new Exception("start date can't be greater than end!");
}
var tweets = await TweetService.GetTweets(start, end, _concurrencyLevel);
return(JsonConvert.SerializeObject(tweets));
}
public void ThrowArgumentNullEx_When_Twitter_IsNull()
{
var unitMock = new Mock <IUnitOfWork>();
var tweetRepoMock = new Mock <ITweetRepository>();
var tweetService = new TweetService(unitMock.Object, tweetRepoMock.Object);
string userId = "12";
Tweet tweet = null;
Assert.Throws <ArgumentNullException>(() => tweetService.SaveTweetByUserId(userId, tweet));
}
/// <summary>
/// プログラムを開始します。
/// </summary>
/// <param name="args">プログラムの引数を示す <see cref="System.String"/> 配列。</param>
private static void Main(string[] args)
{
Debug.Listeners.Add(new TextWriterTraceListener(Console.Out));
try {
using (var tweetService = new TweetService()) {
tweetService.AddOrUpdateTwitterStatus();
}
} catch (Exception ex) {
Console.WriteLine(ex);
}
}
public static async Task <IActionResult> Run(
[HttpTrigger(AuthorizationLevel.Anonymous, "get", Route = null)] HttpRequest req,
ILogger log)
{
log.LogInformation("C# HTTP trigger function processed a request.");
var tweets = await TweetService.Get();
var json = JsonConvert.SerializeObject(tweets);
return(new OkObjectResult(json));
}
public void ThrowArgumentEx_When_UserId_IsEmptyString()
{
var unitMock = new Mock <IUnitOfWork>();
var tweetRepoMock = new Mock <ITweetRepository>();
var tweetService = new TweetService(unitMock.Object, tweetRepoMock.Object);
string userId = String.Empty;
var tweet = new Tweet {
Id = "1284738912734897"
};
Assert.Throws <ArgumentException>(() => tweetService.SaveTweetByUserId(userId, tweet));
}
public async Task Check(string url = "")
{
try
{
var id = Int64.Parse(url.Split('/')[url.Split('/').Length - 1]);
var tweet = Tweet.GetTweet(id);
var msg = TweetService.CheckTweetDetails(tweet, User.GetAuthenticatedUser());
await ReplyAsync($"TWEET TESTS : ```{msg}```", deleteafter : TimeSpan.FromSeconds(10));
Logger.Log(Logger.Warning, "Whoopsie", "Discord Check");
}
catch
{ Logger.Log(Logger.Warning, "Whoopsie", "Discord Check"); }
}
public async System.Threading.Tasks.Task GetTextFromTweet_CorrectLink_TweetText()
{
//Arrange
TweetService tweetService = new TweetService(new System.Net.Http.HttpClient());
string tweetLink = "https://twitter.com/tweeter/status/489879052157595649";
string expected = "Stay safe. Love one another. Life is hard for everyone, so spread peace and happiness. #tweetlove";
//Act
var text = await tweetService.GetTextFromTweet(tweetLink);
//Assert
Assert.AreEqual(expected, text);
}
public void Invoke_Delete_When_Tweet_Exists()
{
//Arrange
var unitOfWorkMock = new Mock <IUnitOfWork>();
var mapperMock = new Mock <IMappingProvider>();
var twitterApiCallServiceMock = new Mock <ITwitterApiCallService>();
var tweetTagServiceMock = new Mock <ITweetTagService>();
var tagServiceMock = new Mock <ITagService>();
var dateTimeParserMock = new Mock <IDateTimeParser>();
var repoMock = new Mock <IGenericRepository <Tweet> >();
var tweet = new Tweet
{
TweetId = "1",
Text = "Tweet text",
OriginalTweetCreatedOn = DateTime.Now,
FolloweeId = "1"
};
var tweets = new List <Tweet>
{
new Tweet
{
TweetId = "1",
Text = "Tweet text",
OriginalTweetCreatedOn = DateTime.Now,
FolloweeId = "1"
}
};
mapperMock.Setup(x =>
x.MapTo <TweetDto>(tweets[0]))
.Returns(new TweetDto {
TweetId = tweets[0].TweetId
});
repoMock.Setup(r => r.All).Returns(tweets.AsQueryable());
unitOfWorkMock.Setup(u => u.Tweets).Returns(repoMock.Object);
var sut = new TweetService(mapperMock.Object, unitOfWorkMock.Object,
twitterApiCallServiceMock.Object, tweetTagServiceMock.Object,
tagServiceMock.Object, dateTimeParserMock.Object);
//Act
sut.Delete(tweet.TweetId);
//Assert
repoMock.Verify(v => v.Delete(It.IsAny <Tweet>()), Times.Once);
}
public void Throws_ArgumentNullException_When_Called_With_Null_FolloweeId_And_UserId()
{
var unitOfWorkMock = new Mock <IUnitOfWork>();
var mapperMock = new Mock <IMappingProvider>();
var twitterApiCallServiceMock = new Mock <ITwitterApiCallService>();
var tweetTagServiceMock = new Mock <ITweetTagService>();
var tagServiceMock = new Mock <ITagService>();
var dateTimeParserMock = new Mock <IDateTimeParser>();
var sut = new TweetService(mapperMock.Object, unitOfWorkMock.Object,
twitterApiCallServiceMock.Object, tweetTagServiceMock.Object,
tagServiceMock.Object, dateTimeParserMock.Object);
Assert.ThrowsException <ArgumentNullException>(() => sut.GetTweetsByFolloweeIdAndUserId(null, null));
}
public void NotReturnNull_When_TweetServiceCalled()
{
var unitOfWorkMock = new Mock <IUnitOfWork>();
var mapperMock = new Mock <IMappingProvider>();
var twitterApiCallServiceMock = new Mock <ITwitterApiCallService>();
var tweetTagServiceMock = new Mock <ITweetTagService>();
var tagServiceMock = new Mock <ITagService>();
var dateTimeParserMock = new Mock <IDateTimeParser>();
var tweetService = new TweetService(mapperMock.Object, unitOfWorkMock.Object,
twitterApiCallServiceMock.Object, tweetTagServiceMock.Object,
tagServiceMock.Object, dateTimeParserMock.Object);
Assert.IsNotNull(tweetService);
}
public async Task <ActionResult> SendTweet(string text)
{
TweetPost newTweet = null;
try
{
newTweet = await TweetService.Tweet(text);
}
catch (Exception ex)
{
throw ex;
}
return(Json(newTweet));
}
public void Test_Get_Tweets_When_Key_In_Db_Exists()
{
var apiTweetRepositoryMock = new ApiTweetRepositoryMock().Mock();
var dbTweetRepositoryMock = new TweetRepositoryMock().Mock();
var sentimentalAnalyzeServiceMocks = new SentimentalAnalysisServiceMock().Mock();
var unitOfWorkMock = new UnitOfWorkMock(dbTweetRepositoryMock.Object, apiTweetRepositoryMock.Object).Mock();
using (var service = new TweetService(unitOfWorkMock.Object, sentimentalAnalyzeServiceMocks.Object))
{
var testResult = service.GetTweetScoreByKey(TweetRepositoryMock.DbKeyWithList);
dbTweetRepositoryMock.Verify(x => x.FindByKey(It.Is <TweetQuery>(query => query.Key == TweetRepositoryMock.DbKeyWithList)), Times.Once);
apiTweetRepositoryMock.Verify(x => x.Get(It.IsAny <TweetQuery>()), Times.Never);
sentimentalAnalyzeServiceMocks.Verify(x => x.Analyze(It.IsAny <IEnumerable <Tweet> >()), Times.Never);
}
}
public void Throws_ArgumentException_When_Called_With_StringEmpty_TweetId()
{
var unitOfWorkMock = new Mock <IUnitOfWork>();
var mapperMock = new Mock <IMappingProvider>();
var twitterApiCallServiceMock = new Mock <ITwitterApiCallService>();
var tweetTagServiceMock = new Mock <ITweetTagService>();
var tagServiceMock = new Mock <ITagService>();
var dateTimeParserMock = new Mock <IDateTimeParser>();
var sut = new TweetService(mapperMock.Object, unitOfWorkMock.Object,
twitterApiCallServiceMock.Object, tweetTagServiceMock.Object,
tagServiceMock.Object, dateTimeParserMock.Object);
Assert.ThrowsException <ArgumentException>(() => sut.Delete(""));
}
public TweetManager()
{
if (_ts == null) _ts = new TweetService();
if (_is == null) _is = new ImageService();
}
public UpdateStatus()
{
UpdateStatusView = Create.TestObjectFor<UpdateStatusView>();
UpdateStatusPresenter = PresenterFactory.NewStatusPresenter(UpdateStatusView);
TweetService = UpdateStatusPresenter.TweetService;
}
static void Main(string[] args)
{
_service = new TweetService();
// Space so that ToUpper Doesnt Crashes!
string userInput = "";
while (userInput.ToUpper() != Quit)
{
Console.WriteLine("---------------");
Console.WriteLine("L) List all Tweets");
Console.WriteLine("#) Show specific Tweet");
Console.WriteLine("N) Enter a new Tweet");
Console.WriteLine("Q) Quit");
Console.Write("Please enter a command: ");
userInput = Console.ReadLine().ToUpper();
int tweetIndex = default(int);
if (userInput == ListAllTweets)
{
ListTweets();
}
else if (userInput == New)
{
EnterTweet();
}
else if (Int32.TryParse(userInput, out tweetIndex))
{
DisplayTweet(tweetIndex);
}
}
}
public virtual ActionResult SocialBar(int eventid, int photoid)
{
var es = new EventService();
var imgs = new ImageService();
var ts = new TweetService();
var model = new PhotoDetailsViewModel();
var theEvent = es.FindByID(eventid);
if (theEvent != null)
{
model.EventId = eventid;
model.EventSlug = theEvent.EventSlug;
model.Image = imgs.FindByID(photoid);
model.Tweets = ts.FindByImageID(photoid, eventid);
model.Event = theEvent;
model.HashTag =
theEvent.SearchTerms.Split(new string[] { " OR " }, StringSplitOptions.None)[0].Contains("#")
? theEvent.SearchTerms.Split(new string[] { " OR " }, StringSplitOptions.None)[0]
: "#" + theEvent.SearchTerms.Split(new string[] { " OR " }, StringSplitOptions.None)[0];
}
var apiClient = new Epilogr.APISoapClient();
model.ShortURL = apiClient.CreateUrl("http://epilogger.com/events/PhotoDetails/" + eventid + "/" + photoid).ShortenedUrl;
return PartialView(model);
}
