def test_signin_signs_in_player(self): signin_url = '/players/signin' username = self.player.get_username() password = self.PLAYER_PASSWORD player_data = { 'username': username, 'password': password } response = self.post(signin_url, data=player_data) self.assertEqual(200, response.status_code) player = json.loads(response.data) self.assertEqual(self.player.get_id(), player.get('id')) self.assertEqual(Player.dump_datetime(self.player.get_date_created()), player.get('date_created')) self.assertIsNotNone(player.get('date_modified')) self.assertEqual(username, player.get('username')) self.assertEqual(self.player.get_email(), player.get('email')) self.assertIsNone(player.get('password')) self.assertEqual(self.player.get_avatar_url(), player.get('avatar_url')) self.assertEqual(self.player.get_is_active(), player.get('is_active')) # Make sure the player was actually updated in the database saved_player = PlayersService.get_instance().get(int(player.get('id'))) self.assertEqual(saved_player.get_id(), player.get('id')) self.assertEqual(Player.dump_datetime(saved_player.get_date_created()), player.get('date_created')) self.assertEqual(Player.dump_datetime(saved_player.get_date_modified()), player.get('date_modified')) self.assertEqual(saved_player.get_username(), player.get('username')) self.assertEqual(saved_player.get_email(), player.get('email')) self.assertEqual(saved_player.get_avatar_url(), player.get('avatar_url')) self.assertEqual(saved_player.get_is_active(), player.get('is_active'))
def before_request(): params = get_inputs() if params.get('auth_token'): player = PlayersService.get_instance().get_from_auth(params.get('auth_token')) if player: set_current_user(player) set_user_logged_in(True) unset_input('auth_token')
def index(): """ Request: { "offset": "offset", "limit": "limit" } Response [422] (invalid parameters): { "errors": { "name of parameter that failed validation": [ "Reason for validation failure" ], "name of another parameter that failed validation": [ "Reason for validation failure" ], }, "inputs": { "offset": "value passed in. empty string if missing", "limit": "value passed in. empty string if missing" } } Response [200] (success): [ { "id": "current value", "date_created": "current value", "date_modified": "current value", "username": "******", "email": "current value", "avatar_url": "current value", "is_active": "current value" }, { "id": "current value", "date_created": "current value", "date_modified": "current value", "username": "******", "email": "current value", "avatar_url": "current value", "is_active": "current value" }, ... ] """ # Get the input validator inputs = ListInputs(get_inputs()) # Verify the list inputs if inputs.validate(): players = PlayersService.get_instance().get_list(inputs.limit.data, inputs.offset.data) return render_view('players/index', 200, players={player.get_id(): player.serialized for player in players}) return render_view('422', 422, errors=inputs.errors, inputs=inputs.obfuscated())
def create(): # Get the input validator inputs = CreateInputs(get_inputs()) # Verify the match creation inputs if inputs.validate_on_submit(): # Ensure we have a valid game game = GamesService.get_instance().get(inputs.game_id.data) if game: # If an opponent is specified, match with that opponent if inputs.opponent_id.data: # Ensure that the opponent is a valid user opponent = PlayersService.get_instance().get(inputs.opponent_id.data) if not opponent: return render_view('422', 422, errors=OPPONENT_NOT_FOUND_ERROR, inputs=inputs.serialized()) # First attempt to find a match already requested by the desired opponent match = MatchesService.get_instance().get_opponent_match( game.get_id(), get_current_user(), opponent.get_id() ) # If the match is found, add the player to it and start the match if it's full if match: match.add_player(get_current_user()) # If no match is found, create one that is assigned to the desired opponent, # but leave it in the waiting state else: match = Match(game, get_current_user()) match.add_player(opponent, should_start=False) # Otherwise, match with a random opponent else: # First, attempt to find a match that is looking for an opponent match = MatchesService.get_instance().get_random_match(game.get_id(), get_current_user()) # If the match is found, add the player to it and start the match if it's full if match: match.add_player(get_current_user()) # If no match is found, create one that is waiting for an opponent else: match = Match(game, get_current_user()) try: match.save() return render_view('matches/show', 201, match=match.serialized) except Exception as e: return render_view('422', 422, errors={e.__class__.__name__: [e.message]}, inputs=inputs.serialized()) return render_view('422', 422, errors=GAME_NOT_FOUND_ERROR, inputs=inputs.serialized()) return render_view('422', 422, errors=inputs.errors, inputs=inputs.serialized())
def test_signout_signs_out_player(self): player_id = self.player.get_id() self.assertEqual(True, self.player.get_is_active()) signout_url = '/players/signout' response = self.post(signout_url) self.assertEqual(200, response.status_code) player = json.loads(response.data) self.assertIsNotNone(player.get('Success')) # Make sure the player was actually updated in the database saved_player = PlayersService.get_instance().get(player_id) self.assertEqual(saved_player.get_auth_token(), None)
def show(player_id): """ Request: { "auth_token": "auth_token" } Response [422] (unauthenticated): { "errors": { "UnauthorizedAccess": [ "Attempted to access data without an authenticated player" ] } } Response [422] (player with player_id doesn't exist): { "errors": { "PlayerNotFound": [ "Unable to find Player" ] }, "inputs": { "id": "player_id" } } Response [200] (success): { "id": "current value", "date_created": "current value", "date_modified": "current value", "username": "******", "email": "current value", "avatar_url": "current value", "is_active": "current value" } """ # Get the player player = PlayersService.get_instance().get(player_id) if player: return render_view('players/show', 200, player=player.serialized) return render_view('422', 422, errors=NOT_FOUND_ERROR, inputs={'id': player_id})
def test_delete_deletes_player(self): delete_url = '/players/{}'.format(self.player.get_id()) self.assertEqual(True, self.player.get_is_active()) response = self.delete(delete_url) self.assertEqual(200, response.status_code) player = json.loads(response.data) self.assertIsNotNone(player.get('id')) self.assertIsNotNone(player.get('date_created')) self.assertIsNotNone(player.get('date_modified')) self.assertIsNotNone(player.get('username')) self.assertIsNotNone(player.get('email')) self.assertIsNone(player.get('password')) self.assertEqual(False, player.get('is_active')) # Make sure the player was actually updated in the database saved_player = PlayersService.get_instance().get(int(player.get('id'))) self.assertEqual(saved_player.get_id(), player.get('id')) self.assertEqual(Player.dump_datetime(saved_player.get_date_created()), player.get('date_created')) self.assertEqual(Player.dump_datetime(saved_player.get_date_modified()), player.get('date_modified')) self.assertEqual(saved_player.get_username(), player.get('username')) self.assertEqual(saved_player.get_email(), player.get('email')) self.assertEqual(saved_player.get_avatar_url(), player.get('avatar_url')) self.assertEqual(saved_player.get_is_active(), player.get('is_active'))
def test_update_updates_player(self): update_url = '/players/{}'.format(self.player.get_id()) player_number = self.player.get_id() * 100 username = get_incremental_username(player_number) email = get_incremental_email(player_number) password = '******'.format(player_number) avatar_url = get_incremental_avatar_url(player_number) player_data = { 'username': username, 'password': password, 'confirm': password, 'email': email, 'avatar_url': avatar_url, 'is_active': False } response = self.put(update_url, data=player_data) self.assertEqual(200, response.status_code) player = json.loads(response.data) self.assertIsNotNone(player.get('id')) self.assertIsNotNone(player.get('date_created')) self.assertIsNotNone(player.get('date_modified')) self.assertEqual(username, player.get('username')) self.assertEqual(email, player.get('email')) self.assertIsNone(player.get('password')) self.assertEqual(avatar_url, player.get('avatar_url')) self.assertEqual(False, player.get('is_active')) # Make sure the player was actually updated in the database saved_player = PlayersService.get_instance().get(int(player.get('id'))) self.assertEqual(saved_player.get_id(), player.get('id')) self.assertEqual(Player.dump_datetime(saved_player.get_date_created()), player.get('date_created')) self.assertEqual(Player.dump_datetime(saved_player.get_date_modified()), player.get('date_modified')) self.assertEqual(saved_player.get_username(), player.get('username')) self.assertEqual(saved_player.get_email(), player.get('email')) self.assertEqual(saved_player.get_avatar_url(), player.get('avatar_url')) self.assertEqual(saved_player.get_is_active(), player.get('is_active'))
def test_create_returns_created_status(self): player_id = self.NUM_PLAYERS + 1 create_url = '/players' username = get_incremental_username(player_id) email = get_incremental_email(player_id) avatar_url = get_incremental_avatar_url(player_id) player_data = { 'username': username, 'password': self.PLAYER_PASSWORD, 'confirm': self.PLAYER_PASSWORD, 'email': email, 'avatar_url': avatar_url } response = self.post(create_url, data=player_data) self.assertEqual(201, response.status_code) player = json.loads(response.data) self.assertIsNotNone(player.get('id')) self.assertIsNotNone(player.get('date_created')) self.assertIsNotNone(player.get('date_modified')) self.assertEqual(username, player.get('username')) self.assertEqual(email, player.get('email')) self.assertIsNone(player.get('password')) self.assertEqual(avatar_url, player.get('avatar_url')) self.assertEqual(True, player.get('is_active')) self.assertIsNotNone(player.get('auth_token')) # Make sure the player was actually saved to the database saved_player = PlayersService.get_instance().get(int(player.get('id'))) self.assertEqual(saved_player.get_id(), player.get('id')) self.assertEqual(Player.dump_datetime(saved_player.get_date_created()), player.get('date_created')) self.assertEqual(Player.dump_datetime(saved_player.get_date_modified()), player.get('date_modified')) self.assertEqual(saved_player.get_username(), player.get('username')) self.assertEqual(saved_player.get_email(), player.get('email')) self.assertEqual(saved_player.get_avatar_url(), player.get('avatar_url')) self.assertEqual(saved_player.get_is_active(), player.get('is_active')) self.assertEqual(saved_player.get_auth_token(), player.get('auth_token'))
def signin(): """ Request: { "username": "******", "password": "******" } Response [422] (invalid parameters): { "errors": { "name of parameter that failed validation": [ "Reason for validation failure" ], "name of another parameter that failed validation": [ "Reason for validation failure" ], }, "inputs": { "username": "******", "password": NULL } } Response [422] (login failure - username doesn't return user or password is invalid): { "errors": { "InvalidUsernamePassword": [ "Wrong username or password" ] }, "inputs": { "username": "******", "password": NULL } } Response [422] (signin failure - inactive user or save error): { "errors": { "SigninError": [ "Unable to sign in an inactive player" ] }, "inputs": { "username": "******", "password": NULL } } Response [200] (success): { "id": "current value", "date_created": "current value", "date_modified": "current value", "username": "******", "email": "current value", "avatar_url": "current value", "is_active": "current value", "auth_token": "current value" } """ # Get the input validator inputs = SignInInputs(get_inputs()) # Verify the sign in inputs if inputs.validate_on_submit(): player = PlayersService.get_instance().get_from_username(inputs.username.data) if player and check_password_hash(player.get_password(), inputs.password.data): if player.login(): player_data = dict(player.serialized.items() + {'auth_token': player.get_auth_token()}.items()) return render_view('players/show', 200, player=player_data) else: return render_view('422', 422, errors=UNABLE_TO_SIGNIN_ERROR, inputs=inputs.obfuscated()) return render_view('422', 422, errors=INVALID_USERNAME_PASSWORD_ERROR, inputs=inputs.obfuscated()) return render_view('422', 422, errors=inputs.errors, inputs=inputs.obfuscated())
def delete(player_id): """ Request: { "auth_token": "auth_token" } Response [422] (unauthenticated): { "errors": { "UnauthorizedAccess": [ "Attempted to access data without an authenticated player" ] } } Response [422] (player with player_id doesn't exist): { "errors": { "PlayerNotFound": [ "Unable to find Player" ] }, "inputs": { "id": "player_id" } } Response [422] (save failure - unable to set user as inactive): { "errors": { "IntegrityError": [ "Reason saving to the db failed" ] }, "inputs": { "id": "player_id" } } Response [200] (success): { "id": "current value", "date_created": "current value", "date_modified": "current value", "username": "******", "email": "current value", "avatar_url": "current value", "is_active": "current value" } """ # Get the player player = PlayersService.get_instance().get(player_id) # Verify the player creation inputs if player: try: player.update(**{'is_active': False}) return render_view('players/show', 200, player=player.serialized) except Exception as e: return render_view('422', 422, errors={e.__class__.__name__: [e.message]}, inputs={'id': player_id}) return render_view('422', 422, errors=NOT_FOUND_ERROR, inputs={'id': player_id})
def update(player_id): """ Request: { "auth_token": "auth_token", "username": "******", "password": "******", "email": "email", "avatar_url": "avatar_url", "is_active": "is_active" } Response [422] (unauthenticated): { "errors": { "UnauthorizedAccess": [ "Attempted to access data without an authenticated player" ] } } Response [422] (player with player_id doesn't exist): { "errors": { "PlayerNotFound": [ "Unable to find Player" ] }, "inputs": { "id": "player_id" } } Response [422] (invalid parameters): { "errors": { "name of parameter that failed validation": [ "Reason for validation failure" ], "name of another parameter that failed validation": [ "Reason for validation failure" ], }, "inputs": { "id": "player_id", "username": "******", "password": NULL, "email": "value passed in. empty string if missing", "avatar_url": "value passed in. empty string if missing", "is_active": "value passed in. empty string if missing" } } Response [422] (save failure): { "errors": { "IntegrityError": [ "Reason saving to the db failed, such as username/email uniqueness" ] }, "inputs": { "id": "player_id", "username": "******", "password": NULL, "email": "value passed in. empty string if missing", "avatar_url": "value passed in. empty string if missing", "is_active": "value passed in. empty string if missing" } } Response [200] (success): { "id": "current value", "date_created": "current value", "date_modified": "current value", "username": "******", "email": "current value", "avatar_url": "current value", "is_active": "current value" } """ # Get the player player = PlayersService.get_instance().get(player_id) # Verify the player creation inputs if player: # Get the input validator inputs = UpdateInputs(get_inputs()) combined_inputs = dict(inputs.obfuscated().items() + {'id': player_id}.items()) if inputs.validate_on_submit(): try: player.update(**get_mixed_dict_from_multidict(get_inputs(), inputs)) return render_view('players/show', 200, player=player.serialized) except Exception as e: return render_view('422', 422, errors={e.__class__.__name__: [e.message]}, inputs=combined_inputs) return render_view('422', 422, errors=inputs.errors, inputs=combined_inputs) return render_view('422', 422, errors=NOT_FOUND_ERROR, inputs={'id': player_id})