def test06_get_player_name(self):
players = [(1, '*****@*****.**', 'John Johnson', False),
(2, '*****@*****.**', 'Bob Bobbson', False),
(42, '*****@*****.**', 'bigjoe99', False)]
aggregate.seed_playerid2name(players)
self.assertEquals(aggregate.get_player_name(1, 42), 'John Johnson')
self.assertEquals(aggregate.get_player_name(2, 1), 'Bob Bobbson')
self.assertEquals(aggregate.get_player_name(42, 2), 'bigjoe99')
# Should return 'You' when current_player_id equals the requested player.
self.assertEquals(aggregate.get_player_name(1, 1), 'You')
self.assertEquals(aggregate.get_player_name(2, 2), 'You')
self.assertEquals(aggregate.get_player_name(42, 42), 'You')
def test03_get_available_games(self):
c = self.db.cursor()
owner_id = 42
# Define some datetimes.
now = datetime.now()
an_hour_ago = now - timedelta(hours=1)
yesterday = now - timedelta(days=1)
two_days_ago = now - timedelta(days=2)
three_days_ago = now - timedelta(days=3)
sec = timedelta(seconds=1)
# Create some games.
sql = 'INSERT INTO games (id, owner_id, state, sentence, created) VALUES (?, ?, ?, ?, ?)'
games = [
[1, 'invitation', 'Story 1', three_days_ago],
[2, 'invitation', 'Story 2', two_days_ago],
[3, 'create', '', yesterday],
[4, 'voting', 'Story 4', yesterday],
[5, 'canceled', 'Story 5', an_hour_ago],
[6, 'complete', 'Story 6', an_hour_ago],
[7, 'invitation', 'Story 7', now],
]
for game in games:
c.execute(sql, [game[0], owner_id, game[1], game[2], game[3]])
# Seed the playerid2name data.
aggregate.seed_playerid2name([(owner_id, '*****@*****.**',
'John Johnson', False)])
# Fetching all available games since two days ago should yeild two results.
result = aggregate.get_available_games(c, two_days_ago - sec)
self.assertEquals(len(result), 2)
self.assertEquals(result[0]['game_id'], 2)
self.assertEquals(result[0]['owner_name'], 'John Johnson')
self.assertEquals(result[0]['sentence'], 'Story 2')
self.assertEquals(result[1]['game_id'], 7)
self.assertEquals(result[1]['owner_name'], 'John Johnson')
self.assertEquals(result[1]['sentence'], 'Story 7')
# Fetching all available games since three days ago should yeild three results,
# but we are excluding three of them with the third optional parameter,
# so there should be only one game in the result.
result = aggregate.get_available_games(c, three_days_ago - sec,
[2, 7, 888])
self.assertEquals(len(result), 1)
self.assertEquals(result[0]['game_id'], 1)
self.assertEquals(result[0]['owner_name'], 'John Johnson')
self.assertEquals(result[0]['sentence'], 'Story 1')
def test06_get_player_name(self):
players = [
(1, '*****@*****.**', 'John Johnson'),
(2, '*****@*****.**', 'Bob Bobbson'),
(42, '*****@*****.**', 'bigjoe99')
]
aggregate.seed_playerid2name(players)
self.assertEquals(aggregate.get_player_name(1, 42), 'John Johnson')
self.assertEquals(aggregate.get_player_name(2, 1), 'Bob Bobbson')
self.assertEquals(aggregate.get_player_name(42, 2), 'bigjoe99')
# Should return 'You' when current_player_id equals the requested player.
self.assertEquals(aggregate.get_player_name(1, 1), 'You')
self.assertEquals(aggregate.get_player_name(2, 2), 'You')
self.assertEquals(aggregate.get_player_name(42, 42), 'You')
def test03_get_available_games(self):
c = self.db.cursor()
owner_id = 42
# Define some datetimes.
now = datetime.now()
an_hour_ago = now - timedelta(hours=1)
yesterday = now - timedelta(days=1)
two_days_ago = now - timedelta(days=2)
three_days_ago = now - timedelta(days=3)
sec = timedelta(seconds=1)
# Create some games.
sql = 'INSERT INTO games (id, owner_id, state, sentence, created) VALUES (?, ?, ?, ?, ?)'
games = [
[1, 'invitation', 'Story 1', three_days_ago],
[2, 'invitation', 'Story 2', two_days_ago],
[3, 'create', '', yesterday],
[4, 'voting', 'Story 4', yesterday],
[5, 'canceled', 'Story 5', an_hour_ago],
[6, 'complete', 'Story 6', an_hour_ago],
[7, 'invitation', 'Story 7', now],
]
for game in games:
c.execute(sql, [game[0], owner_id, game[1], game[2], game[3]])
# Seed the playerid2name data.
aggregate.seed_playerid2name([(owner_id, '*****@*****.**', 'John Johnson')])
# Fetching all available games since two days ago should yeild two results.
result = aggregate.get_available_games(c, two_days_ago - sec)
self.assertEquals(len(result), 2)
self.assertEquals(result[0]['game_id'], 2)
self.assertEquals(result[0]['owner_name'], 'John Johnson')
self.assertEquals(result[0]['sentence'], 'Story 2')
self.assertEquals(result[1]['game_id'], 7)
self.assertEquals(result[1]['owner_name'], 'John Johnson')
self.assertEquals(result[1]['sentence'], 'Story 7')
# Fetching all available games since three days ago should yeild three results,
# but we are excluding three of them with the third optional parameter,
# so there should be only one game in the result.
result = aggregate.get_available_games(c, three_days_ago - sec, [2, 7, 888])
self.assertEquals(len(result), 1)
self.assertEquals(result[0]['game_id'], 1)
self.assertEquals(result[0]['owner_name'], 'John Johnson')
self.assertEquals(result[0]['sentence'], 'Story 1')
def loop(ws_db_path, django_db_path, email_list=None, verbose=False):
django_conn = sqlite3.connect(django_db_path)
cursor = django_conn.cursor()
players_list = aggregate.get_all_players(cursor)
aggregate.seed_playerid2name(players_list)
cursor.close()
django_conn.close()
smtp = send.smtp_open()
ws_conn = sqlite3.connect(ws_db_path)
cursor = ws_conn.cursor()
count = 0
for id, email, name, unsubscribed in players_list:
if email_list and not email in email_list:
continue
if unsubscribed:
continue
game_ids = aggregate.get_player_game_ids(cursor, id)
last_active = aggregate.get_players_last_activity(cursor, id)
yesterday = datetime.now() - timedelta(days=1)
recent_game_activities = aggregate.get_game_activities(
cursor, game_ids, id, happened_since=yesterday)
should_send = should_send_email(last_active, recent_game_activities)
if should_send:
context = get_context(cursor, id, game_ids, last_active)
# Don't send if there isn't any new info in the context.
if not is_context_empty(context):
if verbose:
print 'Sending email to %s' % email
send.send_mail(smtp, email, context)
count += 1
cursor.close()
ws_conn.close()
smtp.close()
return count
def loop(ws_db_path, django_db_path, email_list=None, verbose=False):
django_conn = sqlite3.connect(django_db_path)
cursor = django_conn.cursor()
players_list = aggregate.get_all_players(cursor)
aggregate.seed_playerid2name(players_list)
cursor.close()
django_conn.close()
smtp = send.smtp_open()
ws_conn = sqlite3.connect(ws_db_path)
cursor = ws_conn.cursor()
count = 0
for id, email, name, unsubscribed in players_list:
if email_list and not email in email_list:
continue
if unsubscribed:
continue
game_ids = aggregate.get_player_game_ids(cursor, id)
last_active = aggregate.get_players_last_activity(cursor, id)
yesterday = datetime.now() - timedelta(days=1)
recent_game_activities = aggregate.get_game_activities(cursor, game_ids, id, happened_since=yesterday)
should_send = should_send_email(last_active, recent_game_activities)
if should_send:
context = get_context(cursor, id, game_ids, last_active)
# Don't send if there isn't any new info in the context.
if not is_context_empty(context):
if verbose:
print 'Sending email to %s' % email
send.send_mail(smtp, email, context)
count += 1
cursor.close()
ws_conn.close()
smtp.close()
return count
def loop(ws_db_path, django_db_path):
django_conn = sqlite3.connect(django_db_path)
cursor = django_conn.cursor()
players_list = aggregate.get_all_players(cursor)
aggregate.seed_playerid2name(players_list)
cursor.close()
django_conn.close()
ws_conn = sqlite3.connect(ws_db_path)
cursor = ws_conn.cursor()
count = 0
for id, email, name in players_list:
last_active = aggregate.get_players_last_activity(cursor, id)
if should_send(id, last_active):
context = get_context(cursor, id, last_active)
# TODO: Make send_mail work something like this:
send.send_mail(email, name, context)
count += 1
cursor.close()
ws_conn.close()
return count
def test02_get_game_activities(self):
c = self.db.cursor()
game1 = 99
game2 = 199
sentence1 = 'This Story'
sentence2 = 'That Story'
player1 = 11
player2 = 12
invitee = 878
# Define some datetimes.
now = datetime.now()
an_hour_ago = now - timedelta(hours=1)
six_hours_ago = now - timedelta(hours=6)
yesterday = now - timedelta(days=1)
two_days_ago = now - timedelta(days=2)
three_days_ago = now - timedelta(days=3)
# Create two games.
sql = 'INSERT INTO games (id, owner_id, state, sentence, created) VALUES (?, ?, ?, ?, ?)'
c.execute(sql, [game1, player1, 'voting', sentence1, two_days_ago])
c.execute(sql, [game2, player1, 'invitation', sentence2, yesterday])
# Fill in some log data.
data = [
# Game 1
[game1, two_days_ago, event_log.GAME_CREATED, player1, ''],
[
game1, two_days_ago + timedelta(seconds=1),
event_log.OWNER_CHOSE_CARD, player1, 22
],
[
game1, two_days_ago + timedelta(seconds=2),
event_log.OWNER_WROTE_STORY, player1, sentence1
],
[game1, six_hours_ago, event_log.PLAYER_JOINED, player2, 33],
[game1, now, event_log.PLAYER_VOTED, player2, 33],
# Game 2
[game2, yesterday, event_log.GAME_CREATED, player1, ''],
[
game2, yesterday + timedelta(seconds=1),
event_log.OWNER_CHOSE_CARD, player1, 34
],
[
game2, six_hours_ago, event_log.OWNER_WROTE_STORY, player1,
sentence2
],
[game2, an_hour_ago, event_log.PLAYER_INVITED, player1, invitee],
[
game2, an_hour_ago + timedelta(seconds=1),
event_log.PLAYER_JOINED, invitee, ''
],
[game2, now, event_log.PLAYER_PICKED_CARD, invitee, 23]
]
for d in data:
c.execute(
'INSERT INTO event_logs (game_id, timestamp, event_type, player_id, data) VALUES (?, ?, ?, ?, ?)',
d)
# Seed the playerid2name data.
aggregate.seed_playerid2name([
(player1, '*****@*****.**', 'John Johnson', False),
(player2, '*****@*****.**', 'Bob Bobbson', False),
(invitee, '*****@*****.**', 'Mr. Invitee', False)
])
result = aggregate.get_game_activities(c, [game1],
player1,
happened_since=three_days_ago)
self.assertEquals(len(result), 1)
self.assertEquals(result[0]['game_id'], game1)
self.assertEquals(result[0]['state'], 'voting')
self.assertEquals(result[0]['owner_name'], 'You')
events = result[0]['events']
self.assertEquals(len(events), 5)
self.assertEquals(events[0], 'You created the game')
self.assertEquals(events[1], 'You chose the card')
self.assertEquals(events[2], 'You wrote the story')
self.assertEquals(events[3], 'Bob Bobbson joined the game')
self.assertEquals(events[4], 'Bob Bobbson voted')
since = six_hours_ago - timedelta(seconds=1)
result = aggregate.get_game_activities(c, [game1, game2],
invitee,
happened_since=since)
self.assertEquals(len(result), 2)
self.assertEquals(result[0]['game_id'], game1)
self.assertEquals(result[0]['state'], 'voting')
self.assertEquals(result[0]['owner_name'], 'John Johnson')
events1 = result[0]['events']
self.assertEquals(len(events1), 2)
self.assertEquals(events1[0], 'Bob Bobbson joined the game')
self.assertEquals(events1[1], 'Bob Bobbson voted')
events2 = result[1]['events']
self.assertEquals(len(events2), 4)
self.assertEquals(events2[0], 'John Johnson wrote the story')
self.assertEquals(events2[1],
'John Johnson invited You to join the game')
self.assertEquals(events2[2], 'You joined the game')
self.assertEquals(events2[3], 'You picked a fake card')
def test02_get_game_activities(self):
c = self.db.cursor()
game1 = 99
game2 = 199
sentence1 = 'This Story'
sentence2 = 'That Story'
player1 = 11
player2 = 12
invitee = 878
# Define some datetimes.
now = datetime.now()
an_hour_ago = now - timedelta(hours=1)
six_hours_ago = now - timedelta(hours=6)
yesterday = now - timedelta(days=1)
two_days_ago = now - timedelta(days=2)
three_days_ago = now - timedelta(days=3)
# Create two games.
sql = 'INSERT INTO games (id, owner_id, state, sentence, created) VALUES (?, ?, ?, ?, ?)'
c.execute(sql, [game1, player1, 'voting', sentence1, two_days_ago])
c.execute(sql, [game2, player1, 'invitation', sentence2, yesterday])
# Fill in some log data.
data = [
# Game 1
[game1, two_days_ago, event_log.GAME_CREATED, player1, ''],
[game1, two_days_ago + timedelta(seconds=1), event_log.OWNER_CHOSE_CARD, player1, 22],
[game1, two_days_ago + timedelta(seconds=2), event_log.OWNER_WROTE_STORY, player1, sentence1],
[game1, six_hours_ago, event_log.PLAYER_JOINED, player2, 33],
[game1, now, event_log.PLAYER_VOTED, player2, 33],
# Game 2
[game2, yesterday, event_log.GAME_CREATED, player1, ''],
[game2, yesterday + timedelta(seconds=1), event_log.OWNER_CHOSE_CARD, player1, 34],
[game2, six_hours_ago, event_log.OWNER_WROTE_STORY, player1, sentence2],
[game2, an_hour_ago, event_log.PLAYER_INVITED, player1, invitee],
[game2, an_hour_ago + timedelta(seconds=1), event_log.PLAYER_JOINED, invitee, ''],
[game2, now, event_log.PLAYER_PICKED_CARD, invitee, 23]
]
for d in data:
c.execute('INSERT INTO event_logs (game_id, timestamp, event_type, player_id, data) VALUES (?, ?, ?, ?, ?)', d)
# Seed the playerid2name data.
aggregate.seed_playerid2name([
(player1, '*****@*****.**', 'John Johnson'),
(player2, '*****@*****.**', 'Bob Bobbson'),
(invitee, '*****@*****.**', 'Mr. Invitee')
])
result = aggregate.get_game_activities(c, [game1], player1, happened_since=three_days_ago)
self.assertEquals(len(result), 1)
self.assertEquals(result[0]['game_id'], game1)
self.assertEquals(result[0]['state'], 'voting')
self.assertEquals(result[0]['owner_name'], 'You')
events = result[0]['events']
self.assertEquals(len(events), 5)
self.assertEquals(events[0], 'You created the game')
self.assertEquals(events[1], 'You chose the card')
self.assertEquals(events[2], 'You wrote the story')
self.assertEquals(events[3], 'Bob Bobbson joined the game')
self.assertEquals(events[4], 'Bob Bobbson voted')
since = six_hours_ago - timedelta(seconds=1)
result = aggregate.get_game_activities(c, [game1, game2], invitee, happened_since=since)
self.assertEquals(len(result), 2)
self.assertEquals(result[0]['game_id'], game1)
self.assertEquals(result[0]['state'], 'voting')
self.assertEquals(result[0]['owner_name'], 'John Johnson')
events1 = result[0]['events']
self.assertEquals(len(events1), 2)
self.assertEquals(events1[0], 'Bob Bobbson joined the game')
self.assertEquals(events1[1], 'Bob Bobbson voted')
events2 = result[1]['events']
self.assertEquals(len(events2), 4)
self.assertEquals(events2[0], 'John Johnson wrote the story')
self.assertEquals(events2[1], 'John Johnson invited You to join the game')
self.assertEquals(events2[2], 'You joined the game')
self.assertEquals(events2[3], 'You picked a fake card')
