def teardown_module(module):
"""teardown any state that was previously setup with a setup_module
method.
"""
# remove mock users
session.query(LoLUser).delete()
session.commit()
def test_create_lol_user(discord_id, riot_puuid):
"""
Tests that creating a new LoLUser works correctly
"""
queried_users = session.query(LoLUser).all()
if len(queried_users) > 0:
session.query(LoLUser).delete()
session.commit()
assert len(session.query(LoLUser).all()) == 0
user = LoLUser(discord_id, riot_puuid, winrate=True)
session.add(user)
session.commit()
queried_users = session.query(LoLUser).all()
assert len(queried_users) == 1
queried_user = queried_users[0]
assert queried_user.discord_id == discord_id
assert queried_user.riot_puuid == riot_puuid
assert queried_user.last_updated > 0
assert queried_user.winrate
assert queried_user.wins == 0
assert queried_user.losses == 0
def test_update_lol_user_winrate():
"""
Tests that a user's winrate can be updated sucessfully
"""
user = mock_users()[1] # user with winrate enabled
assert user.wins == 0
assert user.losses == 0
update_lol_user_winrate(user, GameResult.WIN)
user = (session.query(LoLUser).filter(
LoLUser.discord_id == user.discord_id).one())
assert user.wins == 1
update_lol_user_winrate(user, GameResult.LOSS)
# assert user.losses.compare(LoLUser.losses + 1)
user = (session.query(LoLUser).filter(
LoLUser.discord_id == user.discord_id).one())
assert user.losses == 1
update_lol_user_winrate(user, GameResult.NONE)
# assert user.wins.compare(LoLUser.wins + 1) and user.losses.compare(
# LoLUser.losses + 1
# )
user = (session.query(LoLUser).filter(
LoLUser.discord_id == user.discord_id).one())
assert user.wins == 1 and user.losses == 1
def test_create_new_lol_user():
"""
Tests that creating a new lol user works correctly
"""
current = session.query(LoLUser).all()
assert len(current) == 3
create_new_lol_user(4, "r4")
assert len(session.query(LoLUser).all()) == 4
def add_lol_user_points(user: LoLUser, points: int):
"""
Adds points to a given user
"""
session.query(LoLUser).filter(
LoLUser.discord_id == user.discord_id
).update({"points": user.points + points})
session.commit()
def remove_bet(bet: LoLBets):
"""
removes an active bet (marked as completed)
"""
session.query(LoLBets).filter(
LoLBets.player == bet.player, LoLBets.better == bet.better
).update({"completed": True})
session.commit()
def remove_lol_game(game_id: int, player_id: int):
"""
Removes an active lol game from the db
"""
session.query(LoLActiveGames).filter(
LoLActiveGames.game_id == game_id, LoLActiveGames.player == player_id
).delete()
session.commit()
def setup_module(module):
""" setup any state specific to the execution of the given module."""
# remove mock text
session.query(LoLText).delete()
session.commit()
# remove mock text_groups
session.query(LoLTextGroup).delete()
session.commit()
def test_create_lol_text(lol_text_group_name, lol_user):
"""
Tests that a lol text can be created successfully
"""
assert len(session.query(LoLText).all()) == 0
text = LoLText(lol_text_group_name, "ending.", lol_user)
session.add(text)
session.commit()
assert len(session.query(LoLText).all()) == 1
def test_delete_lol_text():
"""
Tests that deleting a LoLText object works successfully
"""
assert len(session.query(LoLText).all()) == 1
text_uuid = session.query(LoLText).all()[0].uuid
session.query(LoLText).filter(LoLText.uuid == text_uuid).delete()
session.commit()
assert len(session.query(LoLText).all()) == 0
def teardown_module(module):
"""teardown any state that was previously setup with a setup_module
method.
"""
# remove mock text
session.query(LoLText).delete()
session.commit()
# remove mock text_groups
session.query(LoLTextGroup).delete()
session.commit()
def test_create_lol_text_group(lol_text_group_name, lol_text_group_usage,
lol_user):
"""
Tests that a lol text group can be created successfully
"""
assert len(session.query(LoLTextGroup).all()) == 0
text_group = LoLTextGroup(lol_text_group_name, lol_text_group_usage,
lol_user)
session.add(text_group)
session.commit()
assert len(session.query(LoLTextGroup).all()) == 1
def get_all_lol_users() -> List[LoLUser]:
"""
Returns a list of all LoLUsers
Returns:
List[LoLUser]: all lol users
"""
return session.query(LoLUser).all()
def get_lol_users_with_winrate_enabled() -> List[LoLUser]:
"""
Returns all users who currently have winrate enabled
Returns:
List[LoLUser]: any lol user who's winrate flag is
set to true
"""
return session.query(LoLUser).filter(LoLUser.winrate).all()
def test_delete_lol_user(discord_id, riot_puuid):
"""
Tests that a LoLUser can be deleted
"""
queried_users = session.query(LoLUser).all()
user = None
if len(queried_users) != 1:
# user is not present, insert new user
user = LoLUser(discord_id, riot_puuid)
session.add(user)
session.commit()
else:
user = queried_users[0]
session.query(LoLUser).filter(LoLUser.discord_id == discord_id).delete()
session.commit()
assert len(session.query(LoLUser).all()) == 0
def test_delete_lol_text_group(lol_text_group_name, lol_text_group_usage,
lol_user):
"""
Tests that a lol text group can be deleted successfully
"""
queried_groups = session.query(LoLTextGroup).all()
group = None
if len(queried_groups) != 1:
group = LoLTextGroup(lol_text_group_name, lol_text_group_usage,
lol_user)
session.add(group)
session.commit()
else:
group = queried_groups[0]
session.query(LoLTextGroup).filter(
LoLTextGroup.name == lol_text_group_name).delete()
session.commit()
assert len(session.query(LoLTextGroup).all()) == 0
def get_lol_text_by_group(group_name: str) -> List[LoLText]:
"""
Returns all text from a specific group
Args:
group_name (str): the name of the text group to query
Returns:
List[LoLText]: All the text that belongs to the given group
"""
return session.query(LoLText).filter(LoLText.group == group_name).all()
def get_betters_on(user: LoLUser):
"""
Gets all active bets on a given user
"""
return (
session.query(LoLBets)
.filter(
LoLBets.player == user.discord_id, LoLBets.completed == false()
)
.all()
)
def setup_module(module):
""" setup any state specific to the execution of the given module."""
# clean db before insertions
session.query(LoLUser).delete()
session.commit()
session.query(LoLText).delete()
session.commit()
session.query(LoLTextGroup).delete()
session.commit()
# populate db with mock users to test with
users = mock_users()
for user in users:
session.add(user)
session.commit()
text_groups = mock_text_groups()
for text_group in text_groups:
session.add(text_group)
session.commit()
texts = mock_text(text_groups[0], text_groups[1])
for text in texts:
session.add(text)
session.commit()
def update_lol_user_winrate(user: LoLUser, game_result: GameResult):
"""
Updates a given users winrate
Note: currently only wins and losses are handled
Args:
user (LoLUser): the user to update
game_result (GameResult): the result of the game
"""
if game_result == GameResult.WIN:
# user.wins = LoLUser.wins + 1
session.query(LoLUser).filter(
LoLUser.discord_id == user.discord_id
).update({"wins": user.wins + 1})
session.commit()
if game_result == GameResult.LOSS:
# user.losses = LoLUser.losses + 1
session.query(LoLUser).filter(
LoLUser.discord_id == user.discord_id
).update({"losses": user.losses + 1})
session.commit()
def get_lol_user_by_discord_id(discord_id: int) -> Optional[LoLUser]:
"""
Returns the LoL user with the given discord id
Args:
discord_id (int): the discord id of the user to query
Returns
LoLUser: the lol user object with the given discord_id
"""
try:
return (
session.query(LoLUser)
.filter(LoLUser.discord_id == discord_id)
.one()
)
except NoResultFound:
return None
def setup_module(module):
""" setup any state specific to the execution of the given module."""
# clean db before insertions
session.query(LoLUser).delete()
session.commit()
def get_all_active_bets():
"""
Gets all the active bets for all
active discord ritoman users
"""
return session.query(LoLBets).filter(LoLBets.completed == false()).all()
def reset_all_lol_user_winrate():
"""
Resets the winrate of all LoLUsers to 0 - 0
"""
session.query(LoLUser).update({"wins": 0, "losses": 0})
session.commit()
def get_all_active_games():
"""
Gets all the active games for all
active discord ritoman users
"""
return session.query(LoLActiveGames).all()
