Пример #1
0
class TokenEndpointTest(TestCase):
    def setUp(self):
        def set_user(request):
            request.user = mock.MagicMock()
            request.client = mock.MagicMock()
            request.client.client_id = 'mocked_client_id'
            return True

        self.mock_validator = mock.MagicMock()
        self.mock_validator.authenticate_client.side_effect = set_user
        self.mock_validator.get_code_challenge.return_value = None
        self.addCleanup(setattr, self, 'mock_validator', mock.MagicMock())
        auth_code = AuthorizationCodeGrant(
            request_validator=self.mock_validator)
        supported_types = {
            'authorization_code': auth_code,
        }
        self.expires_in = 1800
        token = BearerToken(self.mock_validator, expires_in=self.expires_in)
        self.endpoint = TokenEndpoint('authorization_code',
                                      default_token_type=token,
                                      grant_types=supported_types)

    @mock.patch('oauthlib.common.generate_token', new=lambda: 'abc')
    def test_authorization_grant(self):
        body = 'grant_type=authorization_code&code=abc&scope=all+of+them&state=xyz'
        headers, body, status_code = self.endpoint.create_token_response(
            '', body=body)
        token = {
            'token_type': 'Bearer',
            'expires_in': self.expires_in,
            'access_token': 'abc',
            'refresh_token': 'abc',
            'scope': 'all of them',
            'state': 'xyz'
        }
        self.assertEqual(json.loads(body), token)

        body = 'grant_type=authorization_code&code=abc&state=xyz'
        headers, body, status_code = self.endpoint.create_token_response(
            '', body=body)
        token = {
            'token_type': 'Bearer',
            'expires_in': self.expires_in,
            'access_token': 'abc',
            'refresh_token': 'abc',
            'state': 'xyz'
        }
        self.assertEqual(json.loads(body), token)

    def test_missing_type(self):
        _, body, _ = self.endpoint.create_token_response('', body='')
        token = {'error': 'unsupported_grant_type'}
        self.assertEqual(json.loads(body), token)

    def test_invalid_type(self):
        body = 'grant_type=invalid'
        _, body, _ = self.endpoint.create_token_response('', body=body)
        token = {'error': 'unsupported_grant_type'}
        self.assertEqual(json.loads(body), token)
Пример #2
0
class TokenEndpointTest(TestCase):
    def setUp(self):
        def set_user(request):
            request.user = mock.MagicMock()
            request.client = mock.MagicMock()
            request.client.client_id = "mocked_client_id"
            return True

        self.mock_validator = mock.MagicMock()
        self.mock_validator.authenticate_client.side_effect = set_user
        self.addCleanup(setattr, self, "mock_validator", mock.MagicMock())
        auth_code = AuthorizationCodeGrant(request_validator=self.mock_validator)
        password = ResourceOwnerPasswordCredentialsGrant(request_validator=self.mock_validator)
        client = ClientCredentialsGrant(request_validator=self.mock_validator)
        supported_types = {"authorization_code": auth_code, "password": password, "client_credentials": client}
        self.expires_in = 1800
        token = tokens.BearerToken(self.mock_validator, expires_in=self.expires_in)
        self.endpoint = TokenEndpoint("authorization_code", default_token_type=token, grant_types=supported_types)

    @mock.patch("oauthlib.common.generate_token", new=lambda: "abc")
    def test_authorization_grant(self):
        body = "grant_type=authorization_code&code=abc&scope=all+of+them&state=xyz"
        headers, body, status_code = self.endpoint.create_token_response("", body=body)
        token = {
            "token_type": "Bearer",
            "expires_in": self.expires_in,
            "access_token": "abc",
            "refresh_token": "abc",
            "state": "xyz",
        }
        self.assertEqual(json.loads(body), token)

    @mock.patch("oauthlib.common.generate_token", new=lambda: "abc")
    def test_password_grant(self):
        body = "grant_type=password&username=a&password=hello&scope=all+of+them"
        headers, body, status_code = self.endpoint.create_token_response("", body=body)
        token = {
            "token_type": "Bearer",
            "expires_in": self.expires_in,
            "access_token": "abc",
            "refresh_token": "abc",
            "scope": "all of them",
        }
        self.assertEqual(json.loads(body), token)

    @mock.patch("oauthlib.common.generate_token", new=lambda: "abc")
    def test_client_grant(self):
        body = "grant_type=client_credentials&scope=all+of+them"
        headers, body, status_code = self.endpoint.create_token_response("", body=body)
        token = {"token_type": "Bearer", "expires_in": self.expires_in, "access_token": "abc", "scope": "all of them"}
        self.assertEqual(json.loads(body), token)

    def test_missing_type(self):
        _, body, _ = self.endpoint.create_token_response("", body="")
        token = {"error": "unsupported_grant_type"}
        self.assertEqual(json.loads(body), token)

    def test_invalid_type(self):
        body = "grant_type=invalid"
        _, body, _ = self.endpoint.create_token_response("", body=body)
        token = {"error": "unsupported_grant_type"}
        self.assertEqual(json.loads(body), token)
class TokenEndpointTest(TestCase):

    def setUp(self):
        def set_user(request):
            request.user = mock.MagicMock()
            request.client = mock.MagicMock()
            request.client.client_id = 'mocked_client_id'
            return True

        self.mock_validator = mock.MagicMock()
        self.mock_validator.authenticate_client.side_effect = set_user
        self.mock_validator.get_code_challenge.return_value = None
        self.addCleanup(setattr, self, 'mock_validator', mock.MagicMock())
        auth_code = AuthorizationCodeGrant(
            request_validator=self.mock_validator)
        password = ResourceOwnerPasswordCredentialsGrant(
            request_validator=self.mock_validator)
        client = ClientCredentialsGrant(
            request_validator=self.mock_validator)
        supported_types = {
            'authorization_code': auth_code,
            'password': password,
            'client_credentials': client,
        }
        self.expires_in = 1800
        token = tokens.BearerToken(
            self.mock_validator,
            expires_in=self.expires_in
        )
        self.endpoint = TokenEndpoint(
            'authorization_code',
            default_token_type=token,
            grant_types=supported_types
        )

    @mock.patch('oauthlib.common.generate_token', new=lambda: 'abc')
    def test_authorization_grant(self):
        body = 'grant_type=authorization_code&code=abc&scope=all+of+them'
        headers, body, status_code = self.endpoint.create_token_response(
            '', body=body)
        token = {
            'token_type': 'Bearer',
            'expires_in': self.expires_in,
            'access_token': 'abc',
            'refresh_token': 'abc',
            'scope': 'all of them'
        }
        self.assertEqual(json.loads(body), token)

        body = 'grant_type=authorization_code&code=abc'
        headers, body, status_code = self.endpoint.create_token_response(
            '', body=body)
        token = {
            'token_type': 'Bearer',
            'expires_in': self.expires_in,
            'access_token': 'abc',
            'refresh_token': 'abc'
        }
        self.assertEqual(json.loads(body), token)

        # try with additional custom variables
        body = 'grant_type=authorization_code&code=abc&state=foobar'
        headers, body, status_code = self.endpoint.create_token_response(
            '', body=body)
        self.assertEqual(json.loads(body), token)

    @mock.patch('oauthlib.common.generate_token', new=lambda: 'abc')
    def test_password_grant(self):
        body = 'grant_type=password&username=a&password=hello&scope=all+of+them'
        headers, body, status_code = self.endpoint.create_token_response(
            '', body=body)
        token = {
            'token_type': 'Bearer',
            'expires_in': self.expires_in,
            'access_token': 'abc',
            'refresh_token': 'abc',
            'scope': 'all of them',
        }
        self.assertEqual(json.loads(body), token)

    @mock.patch('oauthlib.common.generate_token', new=lambda: 'abc')
    def test_client_grant(self):
        body = 'grant_type=client_credentials&scope=all+of+them'
        headers, body, status_code = self.endpoint.create_token_response(
            '', body=body)
        token = {
            'token_type': 'Bearer',
            'expires_in': self.expires_in,
            'access_token': 'abc',
            'scope': 'all of them',
        }
        self.assertEqual(json.loads(body), token)

    def test_missing_type(self):
        _, body, _ = self.endpoint.create_token_response('', body='')
        token = {'error': 'unsupported_grant_type'}
        self.assertEqual(json.loads(body), token)

    def test_invalid_type(self):
        body = 'grant_type=invalid'
        _, body, _ = self.endpoint.create_token_response('', body=body)
        token = {'error': 'unsupported_grant_type'}
        self.assertEqual(json.loads(body), token)