def test_identities_wrong_user(self):
# authenticate with gamecenter
username_gamecenter = "gamecenter:G:%s" % uuid_string()
self.auth(username=username_gamecenter)
headers_gamecenter = self.headers
user_identities_url = self.endpoints["user_identities"]
r = self.get("/").json()
gamecenter_user_id = r["current_user"]["user_id"]
gamecenter_jti = r["current_user"]["jti"]
# authenticate with device
self.auth(username="******" % uuid_string())
r = self.get("/").json()
other_user_id = r["current_user"]["user_id"]
# authenticate with device again
self.auth(username="******" % uuid_string())
r = self.get("/").json()
device_user_id = r["current_user"]["user_id"]
device_jti = r["current_user"]["jti"]
# switch to gamecenter user
self.headers = headers_gamecenter
data = {
"link_with_user_id" : other_user_id,
"link_with_user_jti" : device_jti
}
r = self.post(user_identities_url, data=data, expected_status_code=httplib.BAD_REQUEST)
self.assertIn("User does not match JWT user", r.json()['error']["description"])
def test_identities_already_claimed(self):
# authenticate with gamecenter
username_gamecenter = "gamecenter:G:%s" % uuid_string()
self.auth(username=username_gamecenter)
headers_gamecenter = self.headers
user_identities_url = self.endpoints["user_identities"]
r = self.get("/").json()
gamecenter_user_id = r["current_user"]["user_id"]
gamecenter_jti = r["current_user"]["jti"]
# authenticate with device
self.auth(username="******" % uuid_string())
r = self.get("/").json()
device_user_id = r["current_user"]["user_id"]
device_jti = r["current_user"]["jti"]
# switch to gamecenter user
self.headers = headers_gamecenter
data = {"link_with_user_id": device_user_id,
"link_with_user_jti": device_jti
}
self.post(user_identities_url, data=data)
# authenticate with a new gamecenter user
username_other_gamecenter = "gamecenter:G:%s" % uuid_string()
self.auth(username=username_other_gamecenter)
r = self.get("/").json()
other_gamecenter_user_id = r["current_user"]["user_id"]
other_gamecenter_jti = r["current_user"]["jti"]
r = self.post(user_identities_url, data=data, expected_status_code=httplib.FORBIDDEN)
self.assertEquals(r.json()['error']["code"], "linked_account_already_claimed")
def test_identities_missing_user(self):
# authenticate with gamecenter
username_gamecenter = "gamecenter:G:%s" % uuid_string()
self.auth(username=username_gamecenter)
headers_gamecenter = self.headers
user_identities_url = self.endpoints["user_identities"]
r = self.get("/").json()
gamecenter_user_id = r["current_user"]["user_id"]
gamecenter_jti = r["current_user"]["jti"]
# authenticate with device
self.auth(username="******" % uuid_string())
r = self.get("/").json()
device_user_id = r["current_user"]["user_id"]
device_jti = r["current_user"]["jti"]
# switch to gamecenter user
self.headers = headers_gamecenter
data = {
"link_with_user_id" : -1,
"link_with_user_jti" : device_jti
}
self.post(user_identities_url, data=data, expected_status_code=httplib.NOT_FOUND)
def test_active_matches(self):
self.auth(username=uuid_string())
player_id = self.player_id
team_id = 0
self.auth(username=uuid_string())
other_player_id = self.player_id
team_id = 0
self.auth_service()
match = self._create_match(max_players=3)
match_url = match["url"]
teams_url = match["teams_url"]
resp = self.get(match_url)
matchplayers_url = resp.json()["matchplayers_url"]
resp = self.post(teams_url,
data={},
expected_status_code=httplib.CREATED)
team_id = resp.json()["team_id"]
resp = self.get(teams_url)
data = {"player_id": player_id, "team_id": team_id}
self.post(matchplayers_url,
data=data,
expected_status_code=httplib.CREATED)
data = {"player_id": other_player_id, "team_id": team_id}
self.post(matchplayers_url,
data=data,
expected_status_code=httplib.CREATED)
resp = self.get(match_url)
self.assertEquals(len(resp.json()["teams"]), 1)
resp = self.get(teams_url)
team_url = resp.json()[0]["url"]
resp = self.get(team_url)
resp = self.get(matchplayers_url)
matchplayer_url = resp.json()[0]["matchplayer_url"]
self.get(matchplayer_url)
resp = self.get(self.endpoints["active_matches"])
players = resp.json()[0]["players"]
self.assertEquals(len(players), 2)
self.assertEquals(players[0]["player_id"], player_id)
resp = self.get(self.endpoints["active_matches"] +
"?player_id=9999999&player_id=9999998")
self.assertEquals(len(resp.json()), 0)
resp = self.get(self.endpoints["active_matches"] +
"?player_id=9999999&player_id=%s" % other_player_id)
self.assertEquals(len(resp.json()), 1)
players = resp.json()[0]["players"]
self.assertEquals(players[1]["player_id"], other_player_id)
def test_matchqueue_challenge(self):
# create a match
self.auth_service()
self.clear_queue()
match = self._create_match()
# add two players to the queue
self.make_player()
matchqueue_url = self.endpoints["matchqueue"]
token = uuid_string()
data = {"player_id": self.player_id, "token": token}
r = self.post(matchqueue_url, data=data, expected_status_code=httplib.CREATED)
matchqueueplayer1_url = r.json()["matchqueueplayer_url"]
r = self.get(matchqueueplayer1_url)
self.assertEquals(r.json()["status"], "waiting")
self.assertIsNone(r.json()["match_id"])
self.assertIn('match_url', r.json())
# add a new player who is using a different token
self.make_player()
data = {"player_id": self.player_id, "token": uuid_string()}
r = self.post(matchqueue_url, data=data, expected_status_code=httplib.CREATED)
matchqueueplayer_anothertoken_url = r.json()["matchqueueplayer_url"]
# add a new player who is using no token
self.make_player()
data = {"player_id": self.player_id}
r = self.post(matchqueue_url, data=data, expected_status_code=httplib.CREATED)
matchqueueplayer_notoken_url = r.json()["matchqueueplayer_url"]
self.make_player()
data = {"player_id": self.player_id, "token": token}
r = self.post(matchqueue_url, data=data, expected_status_code=httplib.CREATED)
matchqueueplayer2_url = r.json()["matchqueueplayer_url"]
r = self.get(matchqueue_url + "?status=matched")
self.assertEquals(len(r.json()), 2)
self.assertEquals(r.json()[0]["match_id"], match["match_id"])
self.assertEquals(r.json()[1]["match_id"], match["match_id"])
r = self.get(matchqueueplayer_anothertoken_url)
self.assertEquals(r.json()["status"], "waiting")
self.assertIsNone(r.json()["match_id"])
r = self.get(matchqueueplayer_notoken_url)
self.assertEquals(r.json()["status"], "waiting")
self.assertIsNone(r.json()["match_id"])
r = self.get(matchqueueplayer1_url)
self.assertEquals(r.json()["status"], "matched")
self.assertEquals(r.json()["match_id"], match["match_id"])
r = self.get(matchqueueplayer2_url)
self.assertEquals(r.json()["status"], "matched")
self.assertEquals(r.json()["match_id"], match["match_id"])
def test_counters_filters(self):
# create some counters
self.auth(username=uuid_string())
player_url = self.endpoints["my_player"]
first_player_id = self.player_id
self.patch(player_url, {"name": "Something"})
r = self.get(player_url)
counter_url = r.json()["counter_url"]
timestamp = datetime.datetime(2016, 1, 1, 10, 2, 2)
data = [
{"name": "first_counter", "value": 12, "timestamp": timestamp.isoformat()},
{"name": "second_counter", "value": 22, "timestamp": timestamp.isoformat()},
{"name": "third_counter", "value": 32, "timestamp": timestamp.isoformat()}
]
r = self.patch(counter_url, data=data)
# another player also posts counter
self.auth(username=uuid_string())
player_url = self.endpoints["my_player"]
second_player_id = self.player_id
self.patch(player_url, {"name": "Something"})
r = self.get(player_url)
counter_url = r.json()["counter_url"]
r = self.patch(counter_url, data=data)
# take a look at the counters 'leaderboard' base endpoint
url = self.endpoints["counters"]
r = self.get(url)
counter_ids = []
counter_leaderboard_url = None
for c in r.json():
if c["name"] == "first_counter":
counter_leaderboard_url = c["url"]
elif c["name"] in ("second_counter", "third_counter"):
counter_ids.append(c["counter_id"])
r = self.get(counter_leaderboard_url)
player_ids = [c["player_id"] for c in r.json()]
self.assertIn(first_player_id, player_ids)
self.assertIn(second_player_id, player_ids)
r = self.get(counter_leaderboard_url + "?player_id=9999999")
player_ids = [c["player_id"] for c in r.json()]
self.assertEquals(r.json(), [])
r = self.get(counter_leaderboard_url + "?player_id=%s" % second_player_id)
player_ids = [c["player_id"] for c in r.json()]
self.assertIn(second_player_id, player_ids)
self.assertNotIn(first_player_id, player_ids)
# Test player_group
pg_url = self.endpoints["my_player_groups"].replace('{group_name}', 'second_player')
self.put(pg_url, data={'player_ids': [second_player_id]}, expected_status_code=httplib.OK)
r = self.get(counter_leaderboard_url + "?player_group=second_player")
player_ids = [c["player_id"] for c in r.json()]
self.assertIn(second_player_id, player_ids)
self.assertNotIn(first_player_id, player_ids)
def test_identities_add_gamecenter(self):
"""
Use case #1:
Player starts the game for the first time. His Game Center id has
no user account association. The
game client will automatically associate his Game Center id with his
current device user account.
```device_jwt, device_jti = POST /auth {"username": "******"}
gamecenter_jwt, gamecenter_jti =
POST /auth {"username": "******", "provider_details": ...}
if gamecenter_jwt.user_id == 0:
# Use case 1
Authorization: JTI gamecenter_jti
POST /user-identities
{"link_with_user_jti": device_jti, "link_with_user_id": device_jwt.user_id}
"""
# authenticate with gamecenter
username_gamecenter = "gamecenter:G:%s" % uuid_string()
self.auth(username=username_gamecenter)
headers_gamecenter = self.headers
user_identities_url = self.endpoints["user_identities"]
r = self.get("/").json()
gamecenter_user_id = r["current_user"]["user_id"]
gamecenter_jti = r["current_user"]["jti"]
# authenticate with device
self.auth(username="******" % uuid_string())
r = self.get("/").json()
device_user_id = r["current_user"]["user_id"]
device_jti = r["current_user"]["jti"]
# switch to gamecenter user
self.headers = headers_gamecenter
data = {
"link_with_user_id": device_user_id,
"link_with_user_jti": device_jti
}
self.post(user_identities_url, data=data)
# I should not be able to associate the same user again
self.post(user_identities_url,
data=data,
expected_status_code=httplib.BAD_REQUEST)
# reauthenticate and ensure the user is associated with the gamecenter account
self.auth(username=username_gamecenter)
r = self.get("/").json()
new_gamecenter_user_id = r["current_user"]["user_id"]
self.assertEqual(new_gamecenter_user_id, device_user_id)
# I should not be able to associate the same user again (now with a proper jwt)
self.post(user_identities_url,
data=data,
expected_status_code=httplib.BAD_REQUEST)
def _generate_dummy_gamestate(numkeys=100):
ret = {}
for i in xrange(numkeys):
key = uuid_string()
ret[key] = []
for i in xrange(numkeys):
ret[key].append({uuid_string(): uuid_string()})
string = json.dumps(ret)
return string
def test_gamestate_history(self):
self.auth(username=uuid_string())
player_url = self.endpoints["my_player"]
resp = self.get(player_url)
gamestates_url = resp.json()["gamestates_url"]
first_data = {"first": "entry"}
data = {
"gamestate": first_data,
}
gamestate_url = gamestates_url + "/test"
r = self.put(gamestate_url, data=data)
r = self.get(gamestate_url)
history_url = r.json()["gamestatehistory_url"]
r = self.get(history_url)
self.assertEqual(len(r.json()), 1)
# add another entry
second_data = {"second": "entry"}
data = {
"gamestate": second_data,
}
r = self.put(gamestate_url, data=data)
r = self.get(gamestate_url)
history_url = r.json()["gamestatehistory_url"]
r = self.get(history_url)
history_list = r.json()
self.assertTrue(isinstance(history_list, list))
self.assertEqual(len(history_list), 2)
r = self.get(history_list[0]["gamestatehistoryentry_url"])
self.assertEqual(r.json()["data"], second_data)
r = self.get(history_list[1]["gamestatehistoryentry_url"])
self.assertEqual(r.json()["data"], first_data)
def test_gamestate_nojournal(self):
self.auth(username=uuid_string())
player_url = self.endpoints["my_player"]
resp = self.get(player_url)
gamestates_url = resp.json()["gamestates_url"]
gamestate_data = {"hello": "world"}
data = {
"gamestate": gamestate_data,
}
gamestate_url = gamestates_url + "/test"
r = self.put(gamestate_url, data=data)
r = self.get(gamestates_url)
self.assertEqual(len(r.json()), 1)
gamestate_url = r.json()[0]["gamestate_url"]
r = self.get(gamestate_url)
self.assertIsNone(r.json()["journal_id"])
# You can explicitly set journal_id to null as the caller
data = {"gamestate": gamestate_data, "journal_id": None}
gamestate_url = gamestates_url + "/test"
r = self.put(gamestate_url, data=data)
r = self.get(gamestate_url)
self.assertIsNone(r.json()["journal_id"])
# journal_id 0 is also valid for 'no journal entry'
data = {"gamestate": gamestate_data, "journal_id": 0}
gamestate_url = gamestates_url + "/test"
r = self.put(gamestate_url, data=data)
r = self.get(gamestate_url)
self.assertIsNone(r.json()["journal_id"])
def make_player(self, username=None):
username = username or uuid_string()
self.auth(username=username)
player_url = self.endpoints["my_player"]
r = self.get(player_url)
player_name = "Player #%s" % self.player_id
self.patch(player_url, data={"name": player_name})
# start by getting a client session (this should be in utils!)
clients_url = self.endpoints["clients"]
data = {
"client_type": "client_type",
"build": "build",
"platform_type": "platform_type",
"app_guid": "app_guid",
"version": "version"
}
r = self.post(clients_url,
data=data,
expected_status_code=httplib.CREATED)
new_jti = r.json()["jti"]
self.headers["Authorization"] = "JTI %s" % new_jti
r = self.get("/")
self.endpoints = r.json()["endpoints"]
return username
def test_counters_absolute(self):
self.auth(username=uuid_string())
player_url = self.endpoints["my_player"]
r = self.get(player_url)
counter_url = r.json()["counter_url"]
r = self.get(counter_url)
timestamp = datetime.datetime(2016, 1, 1, 10, 2, 2)
val = 500
data = [{"name": "my_absolute_counter",
"value": val,
"timestamp": timestamp.isoformat(),
"counter_type": "absolute"}]
r = self.patch(counter_url, data=data)
r = self.get(counter_url)
period_urls = r.json()[0]["periods"]
r = self.get(period_urls["total"])
self.assertEqual(r.json().values()[0], val)
# update the value and make sure it did not get added, but replaced
val = 1666
timestamp += datetime.timedelta(seconds=1)
data = [{"name": "my_absolute_counter",
"value": val,
"timestamp": timestamp.isoformat(),
"counter_type": "absolute"}]
r = self.patch(counter_url, data=data)
r = self.get(period_urls["total"])
self.assertEqual(r.json().values()[0], val)
r = self.get(period_urls["day"])
self.assertEqual(r.json().values()[0], val)
def test_counters_reverse(self):
counter_name = "my_reverse_counter"
# create some counters
self.auth(username=uuid_string())
player_url = self.endpoints["my_player"]
self.patch(player_url, {"name": "First Player"})
r = self.get(player_url)
counter_url = r.json()["counter_url"]
timestamp = datetime.datetime(2016, 1, 1, 10, 2, 2)
data = [{
"name": counter_name,
"value": 100,
"timestamp": timestamp.isoformat()
}]
r = self.patch(counter_url, data=data)
# another player also posts counter
self.auth(username=uuid_string())
player_url = self.endpoints["my_player"]
self.patch(player_url, {"name": "First Player"})
r = self.get(player_url)
counter_url = r.json()["counter_url"]
data = [{
"name": counter_name,
"value": 200,
"timestamp": timestamp.isoformat()
}]
r = self.patch(counter_url, data=data)
# take a look at the counters 'leaderboard' base endpoint
url = self.endpoints["counters"]
r = self.get(url)
counter_leaderboard_url = None
for c in r.json():
if c["name"] == counter_name:
counter_leaderboard_url = c["url"]
r = self.get(counter_leaderboard_url)
self.assertEquals(len(r.json()), 2)
self.assertTrue(r.json()[0]["total"] > r.json()[1]["total"])
r = self.get(counter_leaderboard_url + "?reverse=true")
self.assertEquals(len(r.json()), 2)
self.assertTrue(r.json()[0]["total"] < r.json()[1]["total"])
def test_counters_timestamp(self):
self.auth(username=uuid_string())
player_url = self.endpoints["my_player"]
r = self.get(player_url)
counter_url = r.json()["counter_url"]
r = self.get(counter_url)
self.assertTrue(len(r.json()) == 0)
timestamp = datetime.datetime(2016, 1, 1, 10, 2, 2)
data = [{"name": "my_counter", "value": 1.23,
"timestamp": timestamp.isoformat(),
"counter_type": "count"}]
r = self.patch(counter_url, data=data)
r = self.get(counter_url)
# verify that we have one value per period
period_urls = r.json()[0]["periods"]
value_per_period = {}
for period, url in period_urls.iteritems():
if period == "all":
continue
r = self.get(url)
self.assertTrue(len(r.json().values()) == 1)
value_per_period[period] = r.json().values()[0]
# Send in the same data again and verify that things have not changed
# r = self.patch(counter_url, data=data)
# for period, url in period_urls.iteritems():
# if period == "all": continue
# r = self.get(url)
# self.assertTrue(len(r.json().values()) == 1)
# self.assertTrue(value_per_period[period] == r.json().values()[0])
# Send in data for the next day and make sure we have updated correctly
timestamp += datetime.timedelta(days=1)
data[0]["timestamp"] = timestamp.isoformat()
r = self.patch(counter_url, data=data)
r = self.get(period_urls["minute"])
self.assertEqual(len(r.json().values()), 2)
r = self.get(period_urls["hour"])
self.assertEqual(len(r.json().values()), 2)
r = self.get(period_urls["day"])
self.assertEqual(len(r.json().values()), 2)
r = self.get(period_urls["month"])
self.assertEqual(len(r.json().values()), 1)
r = self.get(period_urls["total"])
self.assertEqual(len(r.json().values()), 1)
self.assertEqual(float(r.json().values()[0]), 2 * data[0]["value"])
data = [{"name": "my_counter",
"value": 1.23,
"timestamp": timestamp.isoformat(),
"counter_type": "count",
"context_id": 666}]
r = self.patch(counter_url, data=data)
def test_change_name_put(self):
# verify that the temporary put versions of the patch endpoints work
self.auth()
player_url = self.endpoints["my_player"]
r = self.get(player_url)
new_name = "new name %s" % uuid_string()
r = self.put(player_url, data={"name": new_name})
self.assertEqual(r.json()["player_name"], new_name)
self.assertEqual(self.get(player_url).json()["player_name"], new_name)
def test_counters_with_service_role(self):
# Create this player and as a different player/user make sure we can modify its counters
# with service role, but not without the service role.
self.auth(username=uuid_string())
player_url = self.endpoints["my_player"]
r = self.get(player_url)
counter_url = r.json()['counter_url']
timestamp = datetime.datetime(2016, 1, 1, 10, 2, 2)
data = [{"name": "my_counter", "value": 1.23,
"timestamp": timestamp.isoformat(),
"counter_type": "count"}]
# First fail with no service role
self.auth(username=uuid_string())
r = self.patch(counter_url, data=data, expected_status_code=httplib.UNAUTHORIZED)
self.assertIn("Role 'service' is required for updating other players counters",
r.json()["error"]["description"])
# Log on as a service and retry
self.auth_service()
r = self.patch(counter_url, data=data)
def get_journal_entry(self, action=None, journal_id=None, timestamp=None,
details=None, steps=None):
entry = {"action": action or "test.%s" % uuid_string(),
"journal_id": journal_id if journal_id is not None
else self.get_latest_journal_id() + 1,
"timestamp": timestamp or self.get_timestamp()
}
if details:
entry["details"] = json.dumps(details)
if steps:
entry["steps"] = json.dumps(steps)
return entry
def test_counters_include(self):
# create some counters
self.auth(username=uuid_string())
player_url = self.endpoints["my_player"]
self.patch(player_url, {"name": "Something"})
r = self.get(player_url)
counter_url = r.json()["counter_url"]
timestamp = datetime.datetime(2016, 1, 1, 10, 2, 2)
data = [{
"name": "first_counter",
"value": 12,
"timestamp": timestamp.isoformat()
}, {
"name": "second_counter",
"value": 22,
"timestamp": timestamp.isoformat()
}, {
"name": "third_counter",
"value": 32,
"timestamp": timestamp.isoformat()
}]
r = self.patch(counter_url, data=data)
# take a look at the counters 'leaderboard' base endpoint
url = self.endpoints["counters"]
r = self.get(url)
counter_ids = []
counter_leaderboard_url = None
for c in r.json():
if c["name"] == "first_counter":
counter_leaderboard_url = c["url"]
elif c["name"] in ("second_counter", "third_counter"):
counter_ids.append(c["counter_id"])
# look up the first counter we made and make sure we don't have any included counters
r = self.get(counter_leaderboard_url)
self.assertEqual(len(r.json()[0]["include"]), 0)
# ask for the second and third counter to be included and ensure that they are
include_string = ""
for counter_id in counter_ids:
include_string += "include=%s&" % counter_id
url = counter_leaderboard_url + "?%s" % include_string
r = self.get(url)
self.assertEqual(len(r.json()[0]["include"]), len(counter_ids))
for included_counter in r.json()[0]["include"]:
self.assertTrue(included_counter["counter_id"] in counter_ids)
def test_counters_positions(self):
name = "my_leaderboard_counter"
num_players = 5
players = []
for i in xrange(num_players):
self.auth(username=uuid_string())
player_url = self.endpoints["my_player"]
self.patch(player_url, {"name": "Player %s" % i})
r = self.get(player_url)
counter_url = r.json()["counter_url"]
countertotals_url = r.json()["countertotals_url"]
r = self.get(counter_url)
timestamp = datetime.datetime(2016, 1, 1, 10, 2, 2)
val = 500 + i
data = [{
"name": name,
"value": val,
"timestamp": timestamp.isoformat(),
"counter_type": "count"
}]
r = self.patch(counter_url, data=data)
r = self.get(countertotals_url)
self.assertEquals(len(r.json()), 1)
self.assertIn(name, r.json())
self.assertEquals(r.json()[name], val)
players.append((self.player_id, player_url, val))
url = self.endpoints["counters"]
r = self.get(url)
self.assertIn(name, [c["name"] for c in r.json()])
counter_url = None
for c in r.json():
if c["name"] == name:
counter_url = c["url"]
r = self.get(counter_url)
self.assertEqual(len(r.json()), num_players)
# verify that the leaderboard is sorted correctly with the
# player with the highest score at the top
for i, pl in enumerate(reversed(players)):
player_id, player_url, val = pl
self.assertEquals(r.json()[i]["position"], i + 1)
self.assertEquals(r.json()[i]["total"], val)
self.assertEquals(r.json()[i]["player_id"], player_id)
def test_gamestate_delete(self):
self.auth(username=uuid_string())
player_url = self.endpoints["my_player"]
resp = self.get(player_url)
gamestates_url = resp.json()["gamestates_url"]
gamestate_data = {"hello": "world"}
data = {
"gamestate": gamestate_data,
}
gamestate_url = gamestates_url + "/test"
r = self.put(gamestate_url, data=data)
r = self.get(gamestates_url)
self.assertEqual(len(r.json()), 1)
self.delete(gamestate_url)
r = self.get(gamestates_url)
self.assertEqual(len(r.json()), 0)
def test_counters_put(self):
# verify that the temporary put versions of the patch endpoints work
self.auth(username=uuid_string())
name = "my_put_counter"
player_url = self.endpoints["my_player"]
r = self.get(player_url)
counter_url = r.json()["counter_url"]
countertotals_url = r.json()["countertotals_url"]
timestamp = datetime.datetime(2016, 1, 1, 10, 2, 2)
val = 666
data = [{"name": name, "value": val, "timestamp": timestamp.isoformat(),
"counter_type": "count"}]
r = self.put(counter_url, data=data)
r = self.get(countertotals_url)
self.assertEquals(len(r.json()), 1)
self.assertIn(name, r.json())
self.assertEquals(r.json()[name], val)
def test_identities_get(self):
# authenticate with gamecenter
username = "******" % uuid_string()
self.auth(username=username)
user_identities_url = self.endpoints["user_identities"]
r = self.get(user_identities_url + "?name=bla")
self.assertEquals(len(r.json()), 0)
r = self.get(user_identities_url + "?name=%s" % username)
self.assertEquals(len(r.json()), 1)
self.assertEquals(r.json()[0]["player_id"], self.player_id)
r = self.get(user_identities_url + "?player_id=9999999")
self.assertEquals(len(r.json()), 0)
r = self.get(user_identities_url + "?player_id=%s" % self.player_id)
self.assertEquals(len(r.json()), 1)
self.assertEquals(r.json()[0]["player_id"], self.player_id)
self.assertEquals(r.json()[0]["identity_name"], username)
def test_counters_totals(self):
self.auth(username=uuid_string())
player_url = self.endpoints["my_player"]
r = self.get(player_url)
counter_url = r.json()["counter_url"]
countertotals_url = r.json()["countertotals_url"]
r = self.get(counter_url)
timestamp = datetime.datetime(2016, 1, 1, 10, 2, 2)
val = 500
name = "my_counter"
data = [{"name": name,
"value": val,
"timestamp": timestamp.isoformat(),
"counter_type": "count"}]
r = self.patch(counter_url, data=data)
r = self.get(countertotals_url)
self.assertEquals(len(r.json()), 1)
self.assertIn(name, r.json())
self.assertEquals(r.json()[name], val)
def test_gamestate_multiple(self):
self.auth(username=uuid_string())
player_url = self.endpoints["my_player"]
resp = self.get(player_url)
gamestates_url = resp.json()["gamestates_url"]
num = 5
for i in xrange(num):
gamestate_data = {"hello": "world", "number": i}
data = {
"gamestate": gamestate_data,
}
gamestate_url = gamestates_url + "/multiple:%s" % i
r = self.put(gamestate_url, data=data)
r = self.get(gamestates_url)
self.assertEqual(len(r.json()), num)
for i, entry in enumerate(r.json()):
self.assertEqual(entry["namespace"], "multiple:%s" % i)
r = self.get(entry["gamestate_url"])
d = r.json()
self.assertEqual(d["data"]["number"], i)
def test_counters_multiple(self):
# test writing to the same counter more than once. The total count should upgade
self.auth(username=uuid_string())
player_url = self.endpoints["my_player"]
r = self.get(player_url)
counter_url = r.json()["counter_url"]
countertotals_url = r.json()["countertotals_url"]
r = self.get(counter_url)
timestamp = datetime.datetime(2016, 1, 1, 10, 2, 2)
val = 500
name = "my_counter"
data = [{"name": name,
"value": val,
"timestamp": timestamp.isoformat(),
"counter_type": "count"}]
r = self.patch(counter_url, data=data)
timestamp = datetime.datetime(2016, 1, 1, 10, 2, 3)
second_val = 99
name = "my_counter"
data = [{"name": name,
"value": second_val,
"timestamp": timestamp.isoformat(),
"counter_type": "count"}]
r = self.patch(counter_url, data=data)
timestamp = datetime.datetime(2016, 1, 1, 10, 2, 2)
absolute_val = 666
absolute_name = "my_absolute_counter"
data = [{"name": absolute_name,
"value": absolute_val,
"timestamp": timestamp.isoformat(),
"counter_type": "absolute"}]
r = self.patch(counter_url, data=data)
r = self.get(countertotals_url)
self.assertEquals(len(r.json()), 2)
self.assertEquals(r.json()[name], val + second_val)
self.assertEquals(r.json()[absolute_name], absolute_val)
def test_change_name(self):
self.auth()
player_url = self.endpoints["my_player"]
r = self.get(player_url)
old_name = r.json()["player_name"]
self.patch(player_url,
data={"name": ""},
expected_status_code=httplib.METHOD_NOT_ALLOWED)
self.patch(player_url,
data={"name": "a" * 100},
expected_status_code=httplib.METHOD_NOT_ALLOWED)
self.patch(self.endpoints["players"] + "/9999999",
data={"name": "a" * 100},
expected_status_code=httplib.METHOD_NOT_ALLOWED)
self.assertEqual(self.get(player_url).json()["player_name"], old_name)
new_name = "new name %s" % uuid_string()
r = self.patch(player_url, data={"name": new_name})
self.assertEqual(r.json()["player_name"], new_name)
self.assertEqual(self.get(player_url).json()["player_name"], new_name)
def test_gamestate_basic(self):
self.auth(username=uuid_string())
player_url = self.endpoints["my_player"]
resp = self.get(player_url)
gamestates_url = resp.json()["gamestates_url"]
journal_url = resp.json()["journal_url"]
# new players should not have a gamestate
r = self.get(gamestates_url)
self.assertEqual(len(r.json()), 0)
gamestate_data = {"hello": "world"}
journal_id = self.write_journal_entry(journal_url, journal_id=1)
data = {
"gamestate": gamestate_data,
"journal_id": journal_id,
}
gamestate_url = gamestates_url + "/test"
r = self.put(gamestate_url, data=data)
self.assertEqual(r.json()["version"], 1)
self.assertEqual(r.json()["journal_id"], journal_id)
old_modify_date = r.json()["modify_date"]
# now we should have a gamestate
r = self.get(gamestates_url)
self.assertEqual(len(r.json()), 1)
# write a new gamestate
journal_id += 1
journal_id = self.write_journal_entry(journal_url,
journal_id=journal_id)
data = {
"gamestate": gamestate_data,
"journal_id": journal_id,
}
r = self.put(gamestate_url, data=data)
self.assertEqual(r.json()["version"], 2)
self.assertEqual(r.json()["journal_id"], journal_id)
self.assertGreater(r.json()["modify_date"], old_modify_date)
def test_gamestate_update(self):
self.auth(username=uuid_string())
player_url = self.endpoints["my_player"]
resp = self.get(player_url)
gamestates_url = resp.json()["gamestates_url"]
gamestate_data = {"hello": "world"}
data = {
"gamestate": gamestate_data,
}
gamestate_url = gamestates_url + "/test"
r = self.put(gamestate_url, data=data)
r = self.get(gamestate_url)
old_version = r.json()["version"]
new_gamestate_data = {"something": ["very", "different"]}
data = {
"gamestate": new_gamestate_data,
}
r = self.put(gamestate_url, data=data)
r = self.get(gamestate_url)
self.assertEqual(r.json()["data"], new_gamestate_data)
self.assertEqual(r.json()["version"], old_version + 1)
def test_counters_basic(self):
self.auth(username=uuid_string())
player_url = self.endpoints["my_player"]
r = self.get(player_url)
counter_url = r.json()["counter_url"]
r = self.get(counter_url)
self.assertTrue(len(r.json()) == 0)
timestamp = datetime.datetime(2016, 1, 1, 10, 2, 2)
data = [{"name": "my_counter", "value": 1.23,
"timestamp": timestamp.isoformat(),
"counter_type": "count"}]
r = self.patch(counter_url, data=data)
r = self.get(counter_url)
# verify that we have one value per period
period_urls = r.json()[0]["periods"]
value_per_period = {}
for period, url in period_urls.iteritems():
if period == "all":
continue
r = self.get(url)
self.assertTrue(len(r.json().values()) == 1)
value_per_period[period] = r.json().values()[0]
def init_player(self):
self.auth(username=uuid_string())
self.player_url = self.endpoints["my_player"]
resp = self.get(self.player_url)
self.gamestates_url = resp.json()["gamestates_url"]
self.journal_url = resp.json()["journal_url"]
