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])