def test_conflict_check_inside_lower_bound_of_default(self):
time_11_15 = self.now + timedelta(minutes=15)
#existing 11:00 event is within 15 minutes before new 11:15 event
edge_lower = db_utils.check_time_room_conflict(time_11_15, self.loc)
self.assertTrue(edge_lower)
time_11_10 = self.now + timedelta(minutes=10)
inside_lower = db_utils.check_time_room_conflict(time_11_10, self.loc)
self.assertTrue(inside_lower)
def test_conflict_inside_upper_bound_default_time(self):
time_10_30 = self.now - timedelta(minutes=30)
# existing 11:00 event is within 30 minutes of new 10:30 event
edge_upper = db_utils.check_time_room_conflict(time_10_30, self.loc)
self.assertTrue(edge_upper)
time_10_45 = self.now - timedelta(minutes=15)
inside_upper = db_utils.check_time_room_conflict(time_10_45, self.loc)
self.assertTrue(inside_upper)
def test_conflict_inside_and_outside_non_default_lower_time(self):
time_11_59 = self.now + timedelta(minutes=59)
# existing 11:00 time is within 60 mins beforw new 11:59 event
inside_lower = db_utils.check_time_room_conflict(time_11_59,
self.loc, mins_before=60)
self.assertTrue(inside_lower)
time_12_01 = self.now - timedelta(minutes=61)
outside_lower = db_utils.check_time_room_conflict(time_12_01,
self.loc, mins_before=60)
self.assertFalse(outside_lower)
def test_conflict_inside_and_outside_non_default_upper_time(self):
time_10_01 = self.now - timedelta(minutes=59)
# existing 11:00 time is within 60 mins after new 10:01 event
inside_upper = db_utils.check_time_room_conflict(time_10_01,
self.loc, mins_after=60)
self.assertTrue(inside_upper)
time_9_50 = self.now - timedelta(minutes=70)
outside_upper = db_utils.check_time_room_conflict(time_9_50,
self.loc, mins_after=60)
self.assertFalse(outside_upper)
def loadtest_logic(self, tweet, tweet_id, screen_name, user_id):
"""Logic similar to what is being used in the real bot so that we can
load test how much volume it can handle before twitter kicks it off
"""
# use SUTime to parse a datetime out of tweet
time_room = self.parse_time_room(tweet)
# fake time in the future that imitates a event's start time
local_tz = pytz.timezone('US/Pacific')
sample_time = datetime.datetime.now(local_tz) + datetime.timedelta(
minutes=10)
sample_time = sample_time.strftime("%Y-%m-%d %H:%M:%S")
converted_time = time_utils.convert_to_utc(sample_time)
room = "r123"
# check for a time and room conflict, only 1 set of retweets per event
conflict = db_utils.check_time_room_conflict(converted_time, room)
# send message to slack when a tweet is scheduled to go out
slack_message = "{} From: {}, id: {}".format(tweet, screen_name,
user_id)
self.slacker.chat.post_message('#loadtest_tweets', slack_message)
# This record lets us check that retweets not for same event
db_utils.create_event(description=tweet,
start=converted_time,
location=room,
creator=screen_name)
tweet_utils.loadtest_schedule_tweets(screen_name, tweet, tweet_id,
converted_time)
print("tweet scheduled for retweet: {}".format(tweet))
def retweet_logic(self, tweet, tweet_id, screen_name, user_id):
"""Use SUTime to try to parse a datetime out of a tweet, if successful
save tweet to OutgoingTweet to be retweeted
"""
# use SUTime to parse a datetime out of tweet
time_room = self.parse_time_room(tweet)
# make sure both time and room extracted and only one val each
val_check = self.value_check(time_room)
if val_check == (1, 1):
room = time_room["room"][0]
date_mention = tweet_utils.check_date_mention(tweet)
converted_time = time_utils.convert_to_utc(time_room["date"][0],
date_mention)
# check for a time and room conflict, only 1 set of retweets per event
# default time range that a room is resrved for is -15 +30 mins
conflict = db_utils.check_time_room_conflict(converted_time, room)
if not conflict:
# send message to slack when a tweet is scheduled to go out
slack_message = "{} From: {}, id: {}".format(
tweet, screen_name, user_id)
self.send_slack_message('#outgoing_tweets', slack_message)
self.send_mention_tweet(screen_name)
# This record lets us check that retweets not for same event
db_utils.create_event(description=tweet,
start=converted_time,
location=room,
creator=screen_name)
tweet_utils.schedule_tweets(screen_name, tweet, tweet_id,
converted_time)
loggly.info(
"scheduled this tweet for retweet: {}".format(tweet))
else:
message = """Tweet recived for an event bot is already scheduled
to retweet about. Sender: {}, room: {}, time: {},
tweet: {} tweet_id: {}
"""
message = message.format(screen_name, room, converted_time,
tweet, tweet_id)
self.send_slack_message("#event_conflict", message)
loggly.info(message)
elif val_check == (0, 0):
# tweet found but without valid time or room extracted, ignore
pass
else:
# tweet with relevant information but not exactly 1 time & 1 room
message = """Tweet found that needs review: {} tweet_id: {}
screen_name: {}, user_id: {}
"""
message = message.format(tweet, tweet_id, screen_name, user_id)
self.send_slack_message("#need_review", message)
def loadtest_logic(self, tweet, tweet_id, screen_name, user_id):
"""Logic similar to what is being used in the real bot so that we can
load test how much volume it can handle before twitter kicks it off
"""
# use SUTime to parse a datetime out of tweet
time_room = self.parse_time_room(tweet)
# fake time in the future that imitates a event's start time
local_tz = pytz.timezone('US/Eastern')
sample_time = datetime.datetime.now(local_tz) + datetime.timedelta(
minutes=10)
sample_time = sample_time.strftime("%Y-%m-%d %H:%M:%S")
event_time = time_utils.convert_to_utc(sample_time)
room = random.randint(0, 3000)
# check for a time and room conflict, only 1 set of retweets per event
conflict = db_utils.check_time_room_conflict(event_time, room)
if not conflict:
# This record lets us check that retweets not for same event
event_obj = db_utils.create_event(description=tweet,
start=event_time,
location=room,
creator=screen_name)
tweet_utils.loadtest_schedule_tweets(screen_name=screen_name,
tweet=tweet,
tweet_id=tweet_id,
event_time=event_time,
event_obj=event_obj)
print("tweet scheduled for retweet: {}".format(tweet))
slack_msg = "{} From: {}, id: {}".format(tweet, screen_name,
user_id)
# self.send_slack_message('#outgoing_tweets', slack_message)
send_slack_message(user_id=user_id,
tweet_id=tweet_id,
screen_name=screen_name,
tweet_created=True,
tweet=tweet,
slack_msg=slack_msg,
event_obj=event_obj)
else:
print("conflict when scheduling the tweet")
def retweet_logic(self, tweet, tweet_id, screen_name, user_id):
"""Use SUTime to try to parse a datetime out of a tweet, if successful
save tweet to OutgoingTweet to be retweeted
"""
# use SUTime to parse a datetime out of tweet
time_room = self.parse_time_room(tweet)
# make sure both time and room extracted and only one val each
val_check = self.value_check(time_room)
if val_check == (1, 1):
room = time_room["room"][0]
date_mention = tweet_utils.check_date_mention(tweet)
converted_time = time_utils.convert_to_utc(time_room["date"][0],
date_mention)
# check for a time and room conflict, only 1 set of retweets per event
# default time range that a room is resrved for is -15 +30 mins
conflict = db_utils.check_time_room_conflict(converted_time, room)
if not conflict:
# This record lets us check that retweets not for same event
event_obj = db_utils.create_event(description=tweet,
start=converted_time,
location=room,
creator=screen_name)
tweet_utils.schedule_tweets(screen_name, tweet, tweet_id,
converted_time, event_obj)
slack_msg = "{} \n Tweet from: {}, \n id: {}".format(
tweet, screen_name, user_id)
send_slack_message(user_id=user_id,
tweet_id=tweet_id,
screen_name=screen_name,
tweet_created=True,
tweet=tweet,
slack_msg=slack_msg)
self.send_mention_tweet(screen_name)
else:
message = f"Tweet found for an already scheduled event: \n {tweet}"
send_slack_message(user_id=user_id,
tweet_id=tweet_id,
screen_name=screen_name,
tweet_created=False,
tweet=tweet,
slack_msg=message,
channel="conflict")
elif val_check == (0, 0):
# tweet found but without valid time or room extracted, ignore
pass
else:
# tweet with relevant information but not exactly 1 time & 1 room
slack_msg = "Tweet found that needs review: {} \n tweet_id: {} \n screen_name: {} \n user_id: {}"
slack_msg = slack_msg.format(tweet, tweet_id, screen_name, user_id)
send_slack_message(user_id=user_id,
tweet_id=tweet_id,
screen_name=screen_name,
tweet_created=False,
tweet=tweet,
slack_msg=slack_msg)
def test_conflict_check_outside_upper_bound_default_time(self):
time_10_29 = self.now - timedelta(minutes=31)
# exisiting 11:00 event is more than 30 minutes after new 10:29 event
upper_check = db_utils.check_time_room_conflict(time_10_29, self.loc)
self.assertFalse(upper_check)
def test_conflict_check_outside_lower_bound_default_time(self):
time_11_16 = self.now + timedelta(minutes=16)
# existing 11:00 event is more than 15 mins before new 11:16 event
lower_check = db_utils.check_time_room_conflict(time_11_16, self.loc)
self.assertFalse(lower_check)
def test_conflict_check_returns_exact_match_as_expected(self):
exact_match = db_utils.check_time_room_conflict(self.now, self.loc)
self.assertTrue(exact_match)
def test_conflict_check_works_correctly_with_different_rooms(self):
# same time but different room is fine
diff_room = db_utils.check_time_room_conflict(self.now, "Z123")
self.assertFalse(diff_room)
