def test_get_and_undo_merge(self):
dao = self.norcal_dao
dao.insert_player(self.merge_player_1)
all_players = dao.get_all_players()
player_one = all_players[0]
player_two = all_players[2]
user = dao.get_all_users()[0]
now = datetime.today()
orig_id = ObjectId()
the_merge = Merge(requester_user_id=user.id,
source_player_obj_id=player_one.id,
target_player_obj_id=player_two.id,
time=now,
id=orig_id)
merge_id = dao.insert_merge(the_merge)
the_merge_redux = dao.get_merge(merge_id)
# try to undo merge
dao.undo_merge(the_merge_redux)
new_player_one = dao.get_player_by_id(player_one.id)
new_player_two = dao.get_player_by_id(player_two.id)
self.assertFalse(new_player_one.merged)
self.assertIsNone(new_player_one.merge_parent)
self.assertTrue(new_player_one.id not in new_player_two.merge_children)
all_tournaments = dao.get_all_tournaments()
self.assertTrue(
all([new_player_one.id not in t.players for t in all_tournaments]))
# test that merge was removed from list of merges
self.assertIsNone(dao.get_merge(merge_id))
def post(self, region):
dao = Dao(region, mongo_client=mongo_client)
requesting_user = get_user_from_access_token(request.headers, dao)
if not requesting_user.admin_regions: #wow, such auth
return "user is not an admin", 403
args = merges_put_parser.parse_args() #parse args
try:
base_player_id = ObjectId(args['base_player_id'])
to_be_merged_player_id = ObjectId(args['to_be_merged_player_id'])
except:
return "invalid ids, that wasn't an ObjectID", 400
# the above should validate that we have real objectIDs
# now lets validate that both of those players exist
if not dao.get_player_by_id(base_player_id):
return "base_player not found", 400
if not dao.get_player_by_id(to_be_merged_player_id):
return "to_be_merged_player not found", 400
#get curr time
now = datetime.now()
#create a new merge object
the_merge = Merge(requesting_user.id, base_player_id,
to_be_merged_player_id, now)
#store it in the dao
merge_id = dao.insert_pending_merge(the_merge)
string_rep = str(merge_id)
return_dict = {'id': string_rep}
return return_dict, 200
def test_get_and_insert_merge(self):
dao = self.norcal_dao
dao.insert_player(self.merge_player_1)
all_players = dao.get_all_players()
self.assertEqual([p.name for p in all_players],
[u'CLGsFaT', u'gaR', u'sfat'])
player_one = all_players[0]
player_two = all_players[2]
users = dao.get_all_users()
user = users[0]
now = datetime.today()
orig_id = ObjectId()
the_merge = Merge(requester_user_id=user.id,
source_player_obj_id=player_one.id,
target_player_obj_id=player_two.id,
time=now,
id=orig_id)
merge_id = dao.insert_merge(the_merge)
self.assertTrue(merge_id)
self.assertIsInstance(merge_id, ObjectId)
self.assertEqual(merge_id, orig_id)
# check if merge actually merged players
new_player_one = dao.get_player_by_id(player_one.id)
new_player_two = dao.get_player_by_id(player_two.id)
self.assertTrue(new_player_one.merged)
self.assertEqual(new_player_one.merge_parent, new_player_two.id)
self.assertTrue(new_player_one.id in new_player_two.merge_children)
self.assertEqual(set(new_player_two.aliases),
set([u'sfat', u'miom | sfat', u'clg | sfat']))
the_merge_redux = dao.get_merge(merge_id)
self.assertEqual(the_merge.source_player_obj_id,
the_merge_redux.source_player_obj_id,
msg=the_merge_redux)
self.assertEqual(the_merge.target_player_obj_id,
the_merge_redux.target_player_obj_id)
self.assertEqual(the_merge.id, the_merge_redux.id)
self.assertEqual(the_merge.requester_user_id,
the_merge_redux.requester_user_id)
# changed to account for mongo driver losing sub-second accuracy on
# datetimes
self.assertTrue(
abs(the_merge.time - the_merge_redux.time).total_seconds() < 1)
def test_merge_players_same_player(self):
dao = self.norcal_dao
all_players = dao.get_all_players()
player_one = all_players[0]
user = dao.get_all_users()[0]
now = datetime.today()
the_merge = Merge(requester_user_id=user.id,
source_player_obj_id=player_one.id,
target_player_obj_id=player_one.id,
time=now,
id=ObjectId())
with self.assertRaises(ValueError):
self.norcal_dao.merge_players(the_merge)
def test_merge_players_in_same_tourney(self):
dao = self.norcal_dao
all_players = dao.get_all_players()
player_one = all_players[0]
player_two = all_players[1]
self.assertEqual(player_one.name, u'gaR')
self.assertEqual(player_two.name, u'sfat')
user = dao.get_all_users()[0]
now = datetime.today()
orig_id = ObjectId()
the_merge = Merge(requester_user_id=user.id,
source_player_obj_id=player_one.id,
target_player_obj_id=player_one.id,
time=now,
id=orig_id)
with self.assertRaises(ValueError):
self.norcal_dao.merge_players(the_merge)
def post(self, region):
dao = Dao(region, mongo_client=mongo_client)
user = get_user_from_request(request, dao)
if not user:
return 'Permission denied', 403
if not user.admin_regions: #wow, such auth -- fixed, now we actually do more auth checking later
return "user is not an admin", 403
args = merges_put_parser.parse_args() #parse args
try:
base_player_id = ObjectId(args['base_player_id'])
to_be_merged_player_id = ObjectId(args['to_be_merged_player_id'])
except:
return "invalid ids, that wasn't an ObjectID", 400
# the above should validate that we have real objectIDs
# now lets validate that both of those players exist
player1 = dao.get_player_by_id(base_player_id)
if not player1:
return "base_player not found", 400
player2 = dao.get_player_by_id(to_be_merged_player_id)
if not player2:
return "to_be_merged_player not found", 400
if not is_user_admin_for_regions(user, player1.regions):
return "Permission denied", 403
if not is_user_admin_for_regions(user, player2.regions):
return "Permission denied", 403
#get curr time
now = datetime.now()
base_player = dao.get_player_by_id(base_player_id)
to_be_merged_player = dao.get_player_by_id(to_be_merged_player_id)
the_merge = Merge(user.id,
base_player_id,
to_be_merged_player_id,
now,
id=ObjectId())
dao.insert_pending_merge(the_merge)
return_dict = {'status': "success", 'id': str(the_merge.id)}
return return_dict, 200