Example #1
0
    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'))
Example #2
0
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')
Example #3
0
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())
Example #4
0
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())
Example #5
0
    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)
Example #6
0
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})
Example #7
0
    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'))
Example #8
0
    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'))
Example #9
0
    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'))
Example #10
0
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())
Example #11
0
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})
Example #12
0
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})