def test_tag_encodes_decodes_correctly(self):
str1 = 150
str2 = "World"
encoded = ServiceTag.encode_tag(str1, str2)
out1, out2 = ServiceTag.decode_tag(encoded)
assert out1 == str1
assert out2 == str2
def test_key_encode_decode(self):
ids = [10, 20000, 5, 12345678, 5, 20, 5]
keys = ['10', '::::', 'banana', 'abcdefghijklmnopqrstuvwxyz', '', 'test', '!@#$%^&*()+']
for index, id in enumerate(ids):
encoded = ServiceTag.encode_tag(id, keys[index])
test_id, test_key = ServiceTag.decode_tag(encoded)
assert test_id == id
assert test_key == keys[index]
def test_get_all_replays_with_tags_private_id_and_name(self, initialize_database_tags, test_client, mock_user):
session = initialize_database_tags.get_session()
tags = initialize_database_tags.get_tags()
tagged_games = initialize_database_tags.get_tagged_games()
encoded_key_0 = JsonTag.get_encoded_private_key(tags[0][0], session=session)
encoded_key_2 = JsonTag.get_encoded_private_key(tags[2][0], session=session)
r = Request('GET', LOCAL_URL + '/api/replay', params={'limit': 200, 'page': 0,
'tag_names': [tags[3][0]],
'private_tag_keys': [encoded_key_0, encoded_key_2]})
response = test_client.send(r)
assert(response.status_code == 200)
data = response.json
assert data['totalCount'] != len(data['replays']) == 10
def create_with_filters(page: int,
limit: int,
session=None,
**kwargs) -> 'MatchHistory':
tags = JsonTag.get_tags_from_query_params(**kwargs, session=session)
builder = QueryFilterBuilder().as_game()
if len(tags) > 0:
builder.with_tags([tag.id for tag in tags])
QueryFilterBuilder.apply_arguments_to_query(builder, kwargs)
query = builder.build_query(session)
if 'min_length' in kwargs:
query = query.filter(Game.length > kwargs['min_length'])
if 'max_length' in kwargs:
query = query.filter(Game.length < kwargs['max_length'])
if 'map' in kwargs:
query = query.filter(Game.map == kwargs['map'])
count = query.count()
games = query.order_by(desc(Game.match_date))[page * limit:(page + 1) *
limit]
matches = MatchHistory(
count, [Replay.create_from_game(game) for game in games])
return matches
def create_from_game(game: Game, full=True, groups=False, session=None) -> 'Replay':
group_map = None
if groups and session is not None:
players = session.query(Player).filter(Player.platformid.in_(game.players)).all()
group_map = {player.platformid: player.groups for player in players}
return Replay(
id_=game.hash,
name=game.name,
date=game.match_date.isoformat(),
map=game.map,
game_mode=get_playlist(game.playlist, game.teamsize),
game_score=GameScore.create_from_game(game),
players=[
ReplayPlayer.create_from_player_game(player_game, full=full)
for player_game in sort_player_games_by_team_then_id(
cast(List[PlayerGame], game.playergames))
],
tags=[
JsonTag.create_from_dbtag(tag)
for tag in game.tags if tag.owner == get_current_user_id()
],
visibility=game.visibility,
ranks=game.ranks,
mmrs=game.mmrs,
group_map=group_map
)
def test_tag_modification_with_private_key(self, test_client, mock_user):
fake_session = get_current_session()
# Create tag
r = Request('PUT', LOCAL_URL + '/api/tag/TAG')
response = test_client.send(r)
assert(response.status_code == 201)
data = response.json
assert data['name'] == 'TAG'
assert data['ownerId'] == default_player_id()
tag = fake_session.query(Tag).first()
assert tag.name == 'TAG'
assert tag.owner == default_player_id()
assert tag.private_id is None
r = Request('PUT', LOCAL_URL + '/api/tag/TAG/private_key/fake_private_id')
response = test_client.send(r)
assert(response.status_code == 204)
fake_session.close()
fake_session = get_current_session()
tag = fake_session.query(Tag).first()
assert tag.name == 'TAG'
assert tag.owner == default_player_id()
assert tag.private_id == 'fake_private_id'
r = Request('GET', LOCAL_URL + '/api/tag/TAG/private_key')
response = test_client.send(r)
assert(response.status_code == 200)
assert response.json == ServiceTag.encode_tag(tag.id, 'fake_private_id')
def test_tag_creation_private_id(self, test_client, mock_user):
fake_private_id = 'fake_private_id'
fake_session = get_current_session()
params = {'private_id': fake_private_id}
r = Request('PUT', LOCAL_URL + '/api/tag/TAG',
params=params)
response = test_client.send(r)
assert(response.status_code == 201)
data = response.json
assert data['name'] == 'TAG'
assert data['ownerId'] == default_player_id()
tag = fake_session.query(Tag).first()
assert tag.name == 'TAG'
assert tag.owner == default_player_id()
assert tag.private_id == fake_private_id
r = Request('GET', LOCAL_URL + '/api/tag/TAG/private_key')
response = test_client.send(r)
assert(response.status_code == 200)
assert response.json == ServiceTag.encode_tag(tag.id, fake_private_id)
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 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 create_from_game(game: Game) -> 'Replay':
return Replay(id_=game.hash,
name=game.name,
date=game.match_date.isoformat(),
map=game.map,
game_mode=get_playlist(game.playlist, game.teamsize),
game_score=GameScore.create_from_game(game),
players=[
ReplayPlayer.create_from_player_game(player_game)
for player_game in sort_player_games_by_team_then_id(
cast(List[PlayerGame], game.playergames))
],
tags=[
JsonTag.create_from_dbtag(tag) for tag in game.tags
if tag.owner == get_current_user_id()
],
visibility=game.visibility,
ranks=game.ranks,
mmrs=game.mmrs)
def test_replay_basic_server_upload_with_private_tags(self, test_client, mock_user):
fake_session = get_current_session()
game = fake_session.query(Game).first()
assert game is None
params = {'private_id': 'fake_private_id'}
r = Request('PUT', LOCAL_URL + '/api/tag/' + TAG_NAME,
params=params)
response = test_client.send(r)
assert(response.status_code == 201)
tag = fake_session.query(Tag).first()
r = Request('GET', LOCAL_URL + '/api/tag/' + TAG_NAME + '/private_key')
response = test_client.send(r)
encoded_key = ServiceTag.encode_tag(tag.id, tag.private_id)
assert response.json == encoded_key
params = {'private_tag_keys': [encoded_key]}
r = Request('POST', LOCAL_URL + '/api/upload', files={'replays': ('fake_file.replay', self.stream)},
params=params)
response = test_client.send(r)
assert(response.status_code == 202)
fake_session = get_current_session()
game = fake_session.query(Game).first()
assert(game.hash == '70DDECEA4653AC55EA77DBA0DB497995')
assert(game.name == '3 kickoffs 4 shots')
assert(len(game.tags) == 1)
assert(game.tags[0].name == TAG_NAME)
assert(game.tags[0].owner == default_player_id())
assert(game.tags[0].games[0] == game)
assert(game.tags[0].private_id == 'fake_private_id')
player = fake_session.query(Player.platformid == '76561198018756583').first()
assert(player is not None)
def api_rename_tag(current_name: str):
accepted_query_params = [QueryParam(name='new_name')]
query_params = get_query_params(accepted_query_params, request)
tag = JsonTag.rename(current_name, query_params['new_name'])
return better_jsonify(tag), 200
def api_delete_tag(name: str):
JsonTag.delete(name)
return '', 204
def api_create_tag(name: str, query_params=None):
private_id = None
if 'private_id' in query_params:
private_id = query_params['private_id']
tag = JsonTag.create(name, private_id=private_id)
return better_jsonify(tag), 201
def api_remove_tag_from_game(name: str, id_: str):
JsonTag.remove_tag_from_game(name, id_)
return '', 204
def api_add_tag_to_game(name: str, id_: str):
JsonTag.add_tag_to_game(name, id_)
return '', 204
def api_add_tag_key(name: str, private_id: str):
JsonTag.add_private_key(name, private_id)
return better_jsonify(private_id), 204
def api_get_tag_key(name: str):
return better_jsonify(JsonTag.get_encoded_private_key(name))
def api_get_tags(query_params=None):
tags = JsonTag.get_all()
with_id = False
if 'with_id' in query_params:
with_id = query_params['with_id']
return better_jsonify([tag.to_JSON(with_id=with_id) for tag in tags])
