def setUp(self):
self.tag_name_alt = TAGS[1]
self.all_tags = TAGS
self.test_user_id = TEST_USER_ID
engine, Session = startup()
self.session = Session()
self.test_game_id = TEST_GAME_ID
self.test_game_ids = self.create_replay_names()
test_user = self.session.query(Player).filter(Player.platformid == self.test_user_id).first()
if test_user is None:
test_user = Player(platformid=self.test_user_id)
self.session.add(test_user)
for i in range(len(self.test_game_ids)):
tag_name = self.all_tags[i]
tag = self.session.query(Tag).filter(Tag.owner == self.test_user_id, Tag.name == tag_name).first()
if tag is None:
tag = Tag(owner=self.test_user_id, name=tag_name)
self.session.add(tag)
for game_id in self.test_game_ids:
game = self.session.query(Game).filter(Game.hash == game_id).first()
if game is None:
game = Game(hash=game_id)
self.session.add(game)
self.session.commit()
# add some spice to the games :>
for i in range(len(self.test_game_ids)):
game_id = self.test_game_ids[i]
for j in range(len(self.test_game_ids) - i):
TagWrapper.add_tag_to_game(self.session, game_id, self.test_user_id, self.all_tags[j])
def apply_tags_to_game(query_params: Dict[str, any] = None,
game_id=None,
session=None):
if query_params is None:
return None
if 'tags' not in query_params and 'private_tag_keys' not in query_params:
return None
tags = query_params['tags'] if 'tags' in query_params else []
private_ids = query_params[
'private_tag_keys'] if 'private_tag_keys' in query_params else []
if len(tags) > 0:
player_id = query_params['player_id']
if session.query(Player).filter(
Player.platformid == player_id).first() is None:
log_error(PlayerNotFound())
else:
for tag in tags:
created_tag = Tag.create(tag,
session=session,
player_id=player_id)
TagWrapper.add_tag_to_game(session, game_id,
created_tag.db_tag)
for private_id in private_ids:
tag_id, private_key = Tag.decode_tag(private_id)
tag = TagWrapper.get_tag_by_id(session, tag_id)
if tag.private_id is not None and tag.private_id == private_key:
TagWrapper.add_tag_to_game(session, game_id, tag)
def create(name: str,
session=None,
player_id=None,
private_key=None) -> 'Tag':
"""
Creates a new instance of Tag, add one to the db if it does not exist.
:param name: Tag name
:param session: Database session
:param player_id
:param private_key
:return:
"""
# Check if tag exists
try:
dbtag = TagWrapper.get_tag_by_name(
session, get_current_user_id(player_id=player_id), name)
tag = Tag.create_from_dbtag(dbtag)
return tag
except DBTagNotFound:
pass
dbtag = TagWrapper.create_tag(session,
get_current_user_id(player_id=player_id),
name,
private_key=private_key)
tag = Tag.create_from_dbtag(dbtag)
return tag
def test_add_tag_to_replay_success(self):
TagWrapper.add_tag_to_game(self.session, self.test_game_id, self.test_user_id, self.tag_name)
tag = self.session.query(Tag).filter(Tag.owner == self.test_user_id, Tag.name == self.tag_name).first()
game = self.session.query(Game).filter(Game.hash == self.test_game_id).first()
self.assertIsNotNone(tag)
self.assertIsNotNone(game)
self.assertIn(tag, game.tags)
def test_remove_tag_from_replay_success(self):
# a bit dirty to do it like this...
TagWrapper.add_tag_to_game(self.session, self.test_game_id, self.test_user_id, self.tag_name)
TagWrapper.remove_tag_from_game(self.session, self.test_game_id, self.test_user_id, self.tag_name)
tag = self.session.query(Tag).filter(Tag.owner == self.test_user_id, Tag.name == self.tag_name).first()
game = self.session.query(Game).filter(Game.hash == self.test_game_id).first()
self.assertIsNotNone(tag)
self.assertIsNotNone(game)
self.assertNotIn(tag, game.tags)
def test_rename_tag_name_taken(self):
tag = Tag(owner=self.test_user_id, name=self.tag_name)
self.session.add(tag)
tag2 = Tag(owner=self.test_user_id, name=self.tag_name_new)
self.session.add(tag2)
self.session.commit()
with self.assertRaises(IntegrityError):
TagWrapper.rename_tag(self.session, self.test_user_id, self.tag_name, self.tag_name_new)
def test_remove_tag_success(self):
tag = Tag(owner=self.test_user_id, name=self.tag_name)
self.session.add(tag)
self.session.commit()
TagWrapper.delete_tag(self.session, self.test_user_id, self.tag_name)
tag = self.session.query(Tag).filter(Tag.owner == self.test_user_id, Tag.name == self.tag_name).first()
self.assertIsNone(tag)
def test_get_tag_tag_not_found(self):
tag = self.session.query(Tag).filter(Tag.owner == self.test_user_id, Tag.name == self.tag_name).first()
if tag is not None:
self.session.delete(tag)
self.session.commit()
with self.assertRaises(DBTagNotFound):
TagWrapper.get_tag(self.session, self.test_user_id, self.tag_name)
def test_remove_tag_tag_not_found(self):
# make sure that this tag isn't there
tag = self.session.query(Tag).filter(Tag.owner == self.test_user_id, Tag.name == self.tag_name).first()
if tag is not None:
self.session.delete(tag)
self.session.commit()
with self.assertRaises(DBTagNotFound):
TagWrapper.delete_tag(self.session, self.test_user_id, self.tag_name)
def add_private_key(name: str,
private_key: str,
session=None,
player_id=None):
try:
TagWrapper.add_private_key_to_tag(
session, get_current_user_id(player_id=player_id), name,
private_key)
except DBTagNotFound:
raise TagNotFound()
def create(name: str, session=None) -> 'Tag':
# Check if tag exists
try:
dbtag = TagWrapper.get_tag(session, g.user.platformid, name)
tag = Tag.create_from_dbtag(dbtag)
return tag
except DBTagNotFound:
pass
dbtag = TagWrapper.create_tag(session, g.user.platformid, name)
tag = Tag.create_from_dbtag(dbtag)
return tag
def test_rename_tag_tag_not_found(self):
# assert that tag isn't present
tag = self.session.query(Tag).filter(Tag.owner == self.test_user_id, Tag.name == self.tag_name).first()
if tag is not None:
self.session.delete(tag)
self.session.commit()
with self.assertRaises(DBTagNotFound):
TagWrapper.rename_tag(self.session, self.test_user_id, self.tag_name, self.tag_name_new)
tag = self.session.query(Tag).filter(Tag.owner == self.test_user_id, Tag.name == self.tag_name).first()
self.assertIsNone(tag)
def rename(current_name: str, new_name: str, session=None) -> 'Tag':
# Check if name already exists
try:
TagWrapper.get_tag(session, g.user.platformid, new_name)
raise CalculatedError(409,
f"Tag with name {new_name} already exists.")
except DBTagNotFound:
pass
try:
dbtag = TagWrapper.rename_tag(session, g.user.platformid,
current_name, new_name)
except DBTagNotFound:
raise TagNotFound()
tag = Tag.create_from_dbtag(dbtag)
return tag
def test_get_tag_success(self):
tag = Tag(owner=self.test_user_id, name=self.tag_name)
self.session.add(tag)
self.session.commit()
tag = TagWrapper.get_tag(self.session, self.test_user_id, self.tag_name)
self.assertIsNotNone(tag)
def initialize_database_tags(initialize_database_small_replays):
from backend.blueprints.spa_api.service_layers.replay.json_tag import JsonTag
from backend.database.wrapper.tag_wrapper import TagWrapper
session = initialize_database_small_replays.get_session()
replay_ids = initialize_database_small_replays.get_ids()
tags = [
("tag1", 0, 5, "private_id1"), # grabs the first 5 replays in the list
("tag2", 2, 2,
None), # starts at the 2nd replay and then gets the next 2
("tag3", -5, 4, "private_id2"), # grabs the last 4 replays in the list
("tag4", -6, 4,
None), # starts 6 back from the end and grabs 4 replays
]
tagged_games = {}
for tag in tags:
tagged_games[tag[0]] = []
created_tag = JsonTag.create(tag[0],
session=session,
player_id=default_player_id(),
private_id=tag[3])
game_ids = replay_ids[tag[1]:tag[1] + tag[2]]
for game_id in game_ids:
tagged_games[tag[0]].append(game_id)
TagWrapper.add_tag_to_game(session, game_id, created_tag.db_tag)
class wrapper:
def get_session(self):
return session
def get_protos(self):
return initialize_database_small_replays.get_protos()
def get_ids(self):
return replay_ids
def get_tags(self):
return tags
def get_tagged_games(self):
return tagged_games
return wrapper()
def test_get_all_replays_with_tags_invalid_private_id(self, initialize_database_tags, test_client, mock_user):
session = initialize_database_tags.get_session()
tags = initialize_database_tags.get_tags()
tag_id = TagWrapper.get_tag_by_name(session, mock_user.get_user().platformid, tags[0][0]).id
invalid_private_id = JsonTag.encode_tag(tag_id, 'invalid_key')
r = Request('GET', LOCAL_URL + '/api/replay', params={'limit': 200, 'page': 0,
'private_tag_keys': [invalid_private_id]})
response = test_client.send(r)
assert(response.status_code == 400)
def get_all(session=None) -> List['Tag']:
dbtags = TagWrapper.get_tags(session, get_current_user_id())
tags = [Tag.create_from_dbtag(dbtag) for dbtag in dbtags]
return tags
def get_all(session=None) -> List['Tag']:
dbtags = TagWrapper.get_tags(session, g.user.platformid)
tags = [Tag.create_from_dbtag(dbtag) for dbtag in dbtags]
return tags
def remove_tag_from_game(name: str, replay_id: str, session=None) -> None:
try:
TagWrapper.remove_tag_from_game(session, replay_id,
g.user.platformid, name)
except DBTagNotFound:
raise TagNotFound()
def add_tag_to_game(name: str, replay_id: str, session=None) -> None:
try:
TagWrapper.add_tag_by_name_to_game(session, replay_id,
get_current_user_id(), name)
except DBTagNotFound:
raise TagNotFound()
def delete(name: str, session=None) -> None:
try:
TagWrapper.delete_tag(session, g.user.platformid, name)
except DBTagNotFound:
raise TagNotFound()
def test_create_tag_tag_already_exists(self):
TagWrapper.create_tag(self.session, self.test_user_id, self.tag_name)
with self.assertRaises(IntegrityError):
TagWrapper.create_tag(self.session, self.test_user_id, self.tag_name)
def remove_tag_from_game(name: str, replay_id: str, session=None) -> None:
try:
TagWrapper.remove_tag_from_game(session, replay_id,
get_current_user_id(), name)
except DBTagNotFound:
raise TagNotFound()
def test_create_tag_success(self):
TagWrapper.create_tag(self.session, self.test_user_id, self.tag_name)
tag = self.session.query(Tag).filter(Tag.owner == self.test_user_id, Tag.name == self.tag_name).first()
self.assertIsNotNone(tag)
def test_get_tagged_games(self):
for i in range(0, len(self.test_game_ids)):
tags = [self.all_tags[x] for x in range(len(self.test_game_ids) - i)]
games = TagWrapper.get_tagged_games(self.session, self.test_user_id, tags)
for game in games:
self.assertIn(game, [self.test_game_ids[j] for j in range(i + 1)])
def delete(name: str, session=None) -> None:
try:
TagWrapper.delete_tag(session, get_current_user_id(), name)
except DBTagNotFound:
raise TagNotFound()
def get_tag(name: str, session=None) -> 'Tag':
dbtag = TagWrapper.get_tag_by_name(session, get_current_user_id(),
name)
return Tag.create_from_dbtag(dbtag)
def test_add_tag_to_replay_tag_not_found(self):
with self.assertRaises(DBTagNotFound):
TagWrapper.add_tag_to_game(self.session, self.test_game_id, self.test_user_id, TAGS[1])
