def testAddingAndRemovingStars(self):
user = User.objects.get(name='user1')
old_bank_account = bank.get_user_bank(user_id=user.obfuscated_id)
# Add some stars
bank_account = bank.add_to_bank(user_id=user.obfuscated_id, stars=config.DEFAULT_STARS)
self.assertEqual(old_bank_account.stars + config.DEFAULT_STARS, bank_account.stars)
# Remove some stars
bank_account = bank.add_to_bank(user_id=user.obfuscated_id, stars=(-1 * config.DEFAULT_STARS))
self.assertEqual(old_bank_account.stars, bank_account.stars)
bank_account = bank.add_to_bank(user_id=user.obfuscated_id, stars=(-1 * config.DEFAULT_STARS))
self.assertEqual(0, bank_account.stars)
# Try removing more stars
self.assertRaises(RemoteException, bank.add_to_bank, user_id=user.obfuscated_id, stars=-1)
bank_account = bank.add_to_bank(user_id=user.obfuscated_id, stars=0)
self.assertEqual(0, bank_account.stars)
bank_account = bank.add_to_bank(user_id=user.obfuscated_id, stars=1)
self.assertEqual(1, bank_account.stars)
bank_account = bank.decrement_bank(user_id=user.obfuscated_id)
self.assertEqual(0, bank_account.stars)
self.assertRaises(RemoteException, bank.decrement_bank, user_id=user.obfuscated_id)
# check still at 0
bank_account = bank.get_user_bank(user_id=user.obfuscated_id)
self.assertEqual(0, bank_account.stars)
def update(user_id):
"""
Returns all the user's friends and games associated with friends
"""
if user_id is None:
raise RemoteException('User ID cannot be blank.')
try:
user = User.objects.get(obfuscated_id=user_id)
except User.DoesNotExist:
raise RemoteException("User doesn't exist")
friends = friend.get_user_friends(user_id=user_id).friends
bank_account = bank.get_user_bank(user_id=user_id)
score_account = score.get_user_score(user_id=user_id)
return Poll(friends=friends,
bank_account=bank_account,
score=score_account)
def get_new_word(user_id, game_id):
"""
Get new word prompt
"""
try:
user = User.objects.get(obfuscated_id=user_id)
except User.DoesNotExist:
raise RemoteException('User does not exist')
try:
game = Game.objects.get(id=game_id)
except Game.DoesNotExist:
raise RemoteException('Game does not exist')
friend_id = _get_friend_id(user_model=user, game_model=game)
if friend_id is None:
raise RemoteException('User ID and game ID combination not valid')
if not game.active:
raise RemoteException('Game is inactive')
# Remove a star
bank.decrement_bank(user_id=user_id)
if int(user_id) != _get_curr_photographer(game_model=game):
raise RemoteException('This user cannot get a new word prompt')
words_seen = _get_words_played(game_id=game_id)
new_word = _get_random_word()
while (new_word.word in words_seen):
new_word = _get_random_word()
round_num = game.curr_round
turn = Turn.objects.get(turn_num=round_num, game_id=game_id)
old_word = WordPrompt.objects.get(id=turn.word_prompt_id).word
words_seen.remove(old_word)
turn.word_prompt_id = new_word.id
turn.save()
words_seen.append(new_word.word)
friend_score = 0
user_score = 0
if game.user_id1 == user_id:
user_score = game.user1_score
friend_score = game.user2_score
else:
user_score = game.user2_score
friend_score = game.user1_score
return RemoteGame(game_id=game_id,
user_id=user_id,
friend_id=friend_id,
active=True,
curr_round=round_num,
user_score=user_score,
friend_score=friend_score,
words_seen=words_seen,
curr_word=new_word.word,
is_photographer=True,
is_turn=True,
bank_account=bank.get_user_bank(user_id=user_id))
def end_game(user_id, game_id, award_stars=True):
"""
Ends a pre-existing game by setting it to inactive
"""
if user_id is 0 or game_id is 0:
raise RemoteException('User ID and game ID cannot be blank.')
try:
user = User.objects.get(obfuscated_id=user_id)
except User.DoesNotExist:
raise RemoteException('User does not exist')
try:
game = Game.objects.get(id=game_id)
except Game.DoesNotExist:
raise RemoteException('Game does not exist')
if (game.active == False):
raise RemoteException('Game is already inactive')
friend_id = _get_friend_id(user_model=user, game_model=game)
if (friend_id is None):
raise RemoteException('User ID and game ID combination not valid')
words_seen = _get_words_played(game_id=game_id)
game.active = False
game.save()
# Remove picture if exists
filename = config.FILE_PATH + ('%s_%s.jpg' %
(str(game_id), str(game.curr_round)))
if os.path.isfile(filename):
os.remove(filename)
if award_stars:
# Award stars to users
user1_stars = int(game.user1_score / config.SCORE_PER_STAR)
user2_stars = int(game.user2_score / config.SCORE_PER_STAR)
if game.user1_score > game.user2_score:
user1_stars += config.WINNER_BONUS_STAR
elif game.user1_score < game.user2_score:
user2_stars += config.WINNER_BONUS_STAR
else:
user1_stars += config.TIE_BONUS_STAR
user2_stars += config.TIE_BONUS_STAR
bank.add_to_bank(user_id=game.user_id1, stars=user1_stars)
bank.add_to_bank(user_id=game.user_id2, stars=user2_stars)
# Award points to users also
score.add_to_score(user_id=game.user_id1, points=game.user1_score)
score.add_to_score(user_id=game.user_id2, points=game.user2_score)
friend_score = 0
user_score = 0
if game.user_id1 == user_id:
user_score = game.user1_score
friend_score = game.user2_score
else:
user_score = game.user2_score
friend_score = game.user1_score
return RemoteGame(game_id=game_id,
user_id=user_id,
friend_id=friend_id,
active=False,
user_score=user_score,
friend_score=friend_score,
curr_round=game.curr_round,
words_seen=words_seen,
bank_account=bank.get_user_bank(user_id=user_id))
def testGameFlow2(self):
user1_id = User.objects.get(name='user1').obfuscated_id
user2_id = User.objects.get(name='user2').obfuscated_id
user1_score = score.get_user_score(user_id=user1_id).points
user2_score = score.get_user_score(user_id=user2_id).points
user1_game_score = 0
user2_game_score = 0
user1_stars = bank.get_user_bank(user_id=user1_id).stars
user2_stars = bank.get_user_bank(user_id=user2_id).stars
words_seen = []
photo = config.BLANK_PICTURE
game_remote = game.start_new_game(user_id=user1_id, friend_id=user2_id)
game_id = game_remote.game_id
words_seen.append(game_remote.curr_word)
game_remote = game.send_picture(user_id=user1_id, game_id=game_id, photo=photo)
self.assertEqual(game_id, game_remote.game_id)
self.assertEqual(user2_id, game_remote.friend_id)
self.assertTrue(game_remote.is_photographer)
self.assertFalse(game_remote.is_turn)
self.assertEqual(set(words_seen), set(game_remote.words_seen))
self.assertIsNone(game_remote.current_score)
self.assertIsNone(game_remote.elapsed_time)
self.assertEqual(1, game_remote.curr_round)
self.assertEqual(user1_game_score, game_remote.user_score)
# User 2 will see the picture and User 2 will try to guess after 10 seconds or so, scoring lowest points
photo_remote = game.get_picture(user_id=user2_id, game_id=game_id)
self.assertEqual(config.MAX_SCORE_GUESSING, photo_remote.current_score)
self.assertEqual(photo, photo_remote.dataURL)
time.sleep(10) # seconds
# Client passes invalid score; the server will just use the actual score instead
game_remote = game.validate_guess(user_id=user2_id, game_id=game_id, guess=game_remote.curr_word, score=config.MAX_SCORE_GUESSING)
user1_game_score += config.SCORE_SENDING
user2_game_score += config.MIN_SCORE_GUESSING
words_seen.append(game_remote.curr_word)
# User 2 sends a picture
game.send_picture(user_id=user2_id, game_id=game_id, photo=photo)
# User 1 should get the picture and do a correct guess after 10 seconds
game.get_picture(user_id=user1_id, game_id=game_id)
time.sleep(10) # seconds
# Give up
game_remote = game.give_up_turn(user_id=user1_id, game_id=game_id)
# Game should be over at this point
self.assertFalse(game_remote.active)
# Calculate stars that each user should've gotten
user1_game_stars = int(user1_game_score / config.SCORE_PER_STAR)
user2_game_stars = int(user2_game_score / config.SCORE_PER_STAR)
# User 2 won
user2_game_stars += config.WINNER_BONUS_STAR
user1_stars += user1_game_stars
user2_stars += user2_game_stars
# The actual score of users 1 and 2
user1_score += user1_game_score
user2_score += user2_game_score
# check stars correct
self.assertEqual(user1_stars, bank.get_user_bank(user_id=user1_id).stars)
self.assertEqual(user2_stars, bank.get_user_bank(user_id=user2_id).stars)
# check scores correct
self.assertEqual(user1_score, score.get_user_score(user_id=user1_id).points)
self.assertEqual(user2_score, score.get_user_score(user_id=user2_id).points)
def testGameFlow1(self):
user1_id = User.objects.get(name='user1').obfuscated_id
user2_id = User.objects.get(name='user2').obfuscated_id
user1_score = score.get_user_score(user_id=user1_id).points
user2_score = score.get_user_score(user_id=user2_id).points
user1_game_score = 0
user2_game_score = 0
user1_stars = bank.get_user_bank(user_id=user1_id).stars
user2_stars = bank.get_user_bank(user_id=user2_id).stars
words_seen = []
photo = config.BLANK_PICTURE
game_remote = game.start_new_game(user_id=user1_id, friend_id=user2_id)
game_id = game_remote.game_id
words_seen.append(game_remote.curr_word)
game_remote = game.get_game_status(user_id=user1_id, friend_id=user2_id)
self.assertEqual(game_id, game_remote.game_id)
self.assertEqual(user2_id, game_remote.friend_id)
self.assertTrue(game_remote.is_photographer)
self.assertTrue(game_remote.is_turn)
self.assertEqual(set(words_seen), set(game_remote.words_seen))
self.assertIsNone(game_remote.current_score)
self.assertIsNone(game_remote.elapsed_time)
self.assertEqual(1, game_remote.curr_round)
self.assertEqual(user1_game_score, game_remote.user_score)
game_remote = game.get_game_status(user_id=user2_id, friend_id=user1_id)
self.assertEqual(game_id, game_remote.game_id)
self.assertEqual(user1_id, game_remote.friend_id)
self.assertFalse(game_remote.is_photographer)
self.assertFalse(game_remote.is_turn)
self.assertEqual(set(words_seen), set(game_remote.words_seen))
self.assertIsNone(game_remote.current_score)
self.assertIsNone(game_remote.elapsed_time)
self.assertEqual(1, game_remote.curr_round)
self.assertEqual(user2_game_score, game_remote.user_score)
self.assertRaises(RemoteException, game.send_picture, user_id=user2_id, game_id=game_id, photo=photo)
self.assertRaises(RemoteException, game.send_picture, user_id=user1_id, game_id=game_id, photo=None)
game_remote = game.send_picture(user_id=user1_id, game_id=game_id, photo=photo)
self.assertEqual(game_id, game_remote.game_id)
self.assertEqual(user2_id, game_remote.friend_id)
self.assertTrue(game_remote.is_photographer)
self.assertFalse(game_remote.is_turn)
self.assertEqual(set(words_seen), set(game_remote.words_seen))
self.assertIsNone(game_remote.current_score)
self.assertIsNone(game_remote.elapsed_time)
self.assertEqual(1, game_remote.curr_round)
self.assertEqual(user1_game_score, game_remote.user_score)
game_remote = game.get_game_status(user_id=user1_id, friend_id=user2_id)
self.assertEqual(game_id, game_remote.game_id)
self.assertEqual(user2_id, game_remote.friend_id)
self.assertTrue(game_remote.is_photographer)
self.assertFalse(game_remote.is_turn)
self.assertEqual(set(words_seen), set(game_remote.words_seen))
self.assertIsNone(game_remote.current_score)
self.assertIsNone(game_remote.elapsed_time)
self.assertEqual(1, game_remote.curr_round)
self.assertEqual(user1_game_score, game_remote.user_score)
game_remote = game.get_game_status(user_id=user2_id, friend_id=user1_id)
self.assertEqual(game_id, game_remote.game_id)
self.assertEqual(user1_id, game_remote.friend_id)
self.assertFalse(game_remote.is_photographer)
self.assertTrue(game_remote.is_turn)
self.assertEqual(set(words_seen), set(game_remote.words_seen))
self.assertIsNone(game_remote.current_score)
self.assertIsNone(game_remote.elapsed_time)
self.assertEqual(1, game_remote.curr_round)
self.assertEqual(user2_game_score, game_remote.user_score)
# User 1 can't guess anyway
self.assertRaises(RemoteException, game.validate_guess, user_id=user1_id, game_id=game_id, guess=game_remote.curr_word, score=config.MAX_SCORE_GUESSING)
# User 2 has not received the picture yet, so he can't guess
self.assertRaises(RemoteException, game.validate_guess, user_id=user2_id, game_id=game_id, guess=game_remote.curr_word, score=config.MAX_SCORE_GUESSING)
# User 1 can't get picture
self.assertRaises(RemoteException, game.get_picture, user_id=user1_id, game_id=game_id)
# User 2 will see the picture and User 2 will try to guess after 10 seconds or so, scoring lowest points
photo_remote = game.get_picture(user_id=user2_id, game_id=game_id)
self.assertEqual(config.MAX_SCORE_GUESSING, photo_remote.current_score)
self.assertEqual(photo, photo_remote.dataURL)
game_remote = game.get_game_status(user_id=user1_id, friend_id=user2_id)
self.assertEqual(game_id, game_remote.game_id)
self.assertEqual(user2_id, game_remote.friend_id)
self.assertTrue(game_remote.is_photographer)
self.assertFalse(game_remote.is_turn)
self.assertEqual(set(words_seen), set(game_remote.words_seen))
self.assertIsNone(game_remote.current_score)
self.assertIsNone(game_remote.elapsed_time)
self.assertEqual(1, game_remote.curr_round)
self.assertEqual(user1_game_score, game_remote.user_score)
game_remote = game.get_game_status(user_id=user2_id, friend_id=user1_id)
self.assertEqual(game_id, game_remote.game_id)
self.assertEqual(user1_id, game_remote.friend_id)
self.assertFalse(game_remote.is_photographer)
self.assertTrue(game_remote.is_turn)
self.assertEqual(set(words_seen), set(game_remote.words_seen))
self.assertAlmostEqual(config.MAX_SCORE_GUESSING, game_remote.current_score, delta=10) # likely less than 1s has passed
self.assertAlmostEqual(0, game_remote.elapsed_time, delta=1)
self.assertEqual(1, game_remote.curr_round)
self.assertEqual(user2_game_score, game_remote.user_score)
time.sleep(10) # seconds
game_remote = game.get_game_status(user_id=user1_id, friend_id=user2_id)
self.assertEqual(game_id, game_remote.game_id)
self.assertEqual(user2_id, game_remote.friend_id)
self.assertTrue(game_remote.is_photographer)
self.assertFalse(game_remote.is_turn)
self.assertEqual(set(words_seen), set(game_remote.words_seen))
self.assertIsNone(game_remote.current_score)
self.assertIsNone(game_remote.elapsed_time)
self.assertEqual(1, game_remote.curr_round)
self.assertEqual(user1_game_score, game_remote.user_score)
game_remote = game.get_game_status(user_id=user2_id, friend_id=user1_id)
self.assertEqual(game_id, game_remote.game_id)
self.assertEqual(user1_id, game_remote.friend_id)
self.assertFalse(game_remote.is_photographer)
self.assertTrue(game_remote.is_turn)
self.assertEqual(set(words_seen), set(game_remote.words_seen))
self.assertEqual(config.MIN_SCORE_GUESSING, game_remote.current_score)
self.assertAlmostEqual(10, game_remote.elapsed_time, delta=1)
self.assertEqual(1, game_remote.curr_round)
self.assertEqual(user2_game_score, game_remote.user_score)
# User 1 can't guess anyway
self.assertRaises(RemoteException, game.validate_guess, user_id=user1_id, game_id=game_id, guess=game_remote.curr_word, score=config.MIN_SCORE_GUESSING)
# User 2 guesses. On a successful guess he gets the game for the next round
self.assertRaises(RemoteException, game.validate_guess, user_id=user2_id, game_id=game_id, guess='bird', score=config.MIN_SCORE_GUESSING)
game_remote = game.validate_guess(user_id=user2_id, game_id=game_id, guess=game_remote.curr_word, score=config.MIN_SCORE_GUESSING)
user1_game_score += config.SCORE_SENDING
user2_game_score += config.MIN_SCORE_GUESSING
words_seen.append(game_remote.curr_word)
self.assertEqual(game_id, game_remote.game_id)
self.assertEqual(user1_id, game_remote.friend_id)
self.assertTrue(game_remote.is_photographer)
self.assertTrue(game_remote.is_turn)
self.assertEqual(set(words_seen), set(game_remote.words_seen))
self.assertIsNone(game_remote.current_score)
self.assertIsNone(game_remote.elapsed_time)
self.assertEqual(2, game_remote.curr_round)
self.assertEqual(user2_game_score, game_remote.user_score)
game_remote = game.get_game_status(user_id=user1_id, friend_id=user2_id)
self.assertEqual(game_id, game_remote.game_id)
self.assertEqual(user2_id, game_remote.friend_id)
self.assertFalse(game_remote.is_photographer)
self.assertFalse(game_remote.is_turn)
self.assertEqual(set(words_seen), set(game_remote.words_seen))
self.assertIsNone(game_remote.current_score)
self.assertIsNone(game_remote.elapsed_time)
self.assertEqual(2, game_remote.curr_round)
self.assertEqual(user1_game_score, game_remote.user_score)
game_remote = game.get_game_status(user_id=user2_id, friend_id=user1_id)
self.assertEqual(game_id, game_remote.game_id)
self.assertEqual(user1_id, game_remote.friend_id)
self.assertTrue(game_remote.is_photographer)
self.assertTrue(game_remote.is_turn)
self.assertEqual(set(words_seen), set(game_remote.words_seen))
self.assertIsNone(game_remote.current_score)
self.assertIsNone(game_remote.elapsed_time)
self.assertEqual(2, game_remote.curr_round)
self.assertEqual(user2_game_score, game_remote.user_score)
# User 2 sends a picture
game.send_picture(user_id=user2_id, game_id=game_id, photo=photo)
# User 1 should get the picture and do a correct guess after 10 seconds
game.get_picture(user_id=user1_id, game_id=game_id)
time.sleep(10) # seconds
game_remote = game.validate_guess(user_id=user1_id, game_id=game_id, guess=game_remote.curr_word, score=config.MIN_SCORE_GUESSING)
# Calculate points manually
user1_game_score += config.MIN_SCORE_GUESSING
user2_game_score += config.SCORE_SENDING
# Game should be over at this point
self.assertFalse(game_remote.active)
self.assertEqual(user1_game_score, game_remote.user_score)
self.assertEqual(user2_game_score, game_remote.friend_score)
# Calculate stars that each user should've gotten
user1_game_stars = int(user1_game_score / config.SCORE_PER_STAR)
user2_game_stars = int(user2_game_score / config.SCORE_PER_STAR)
# Since users tied, they both get bonus stars
user1_game_stars += config.TIE_BONUS_STAR
user2_game_stars += config.TIE_BONUS_STAR
user1_stars += user1_game_stars
user2_stars += user2_game_stars
# The actual score of users 1 and 2
user1_score += user1_game_score
user2_score += user2_game_score
# check stars correct
self.assertEqual(user1_stars, bank.get_user_bank(user_id=user1_id).stars)
self.assertEqual(user2_stars, bank.get_user_bank(user_id=user2_id).stars)
# check scores correct
self.assertEqual(user1_score, score.get_user_score(user_id=user1_id).points)
self.assertEqual(user2_score, score.get_user_score(user_id=user2_id).points)
def testGetUserBank(self):
user = User.objects.get(name='user1')
bank_account = bank.get_user_bank(user_id=user.obfuscated_id)
bank_object = Bank.objects.get(user_id=user.obfuscated_id)
self.assertEqual(bank_object.stars, bank_account.stars)