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