Python utils.jwt_encode_handler函数代码示例

    def test_post_form_failing_jwt_auth_changed_user_secret_key(self):
        """
        Ensure changin secret key on USER level makes tokens invalid
        """
        # fine tune settings
        api_settings.JWT_GET_USER_SECRET_KEY = get_jwt_secret

        tmp_user = CustomUser.objects.create(email='[email protected]')
        payload = utils.jwt_payload_handler(tmp_user)
        token = utils.jwt_encode_handler(payload)

        auth = 'JWT {0}'.format(token)
        response = self.csrf_client.post(
            '/jwt/', {'example': 'example'}, HTTP_AUTHORIZATION=auth, format='json')

        self.assertEqual(response.status_code, status.HTTP_200_OK)

        # change token, verify
        tmp_user.jwt_secret = uuid.uuid4()
        tmp_user.save()

        response = self.csrf_client.post(
            '/jwt/', {'example': 'example'}, HTTP_AUTHORIZATION=auth)

        self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED)

        # revert api settings
        api_settings.JWT_GET_USER_SECRET_KEY = DEFAULTS['JWT_GET_USER_SECRET_KEY']

    def get_token(self, obj):
        #jwt_payload_handler = jwt_payload_handler
        #jwt_encode_handler = settings.JWT_ENCODE_HANDLER

        payload = jwt_payload_handler(obj)
        token = jwt_encode_handler(payload)
        return token

    def post(self, request):
        access_token_url = 'https://accounts.google.com/o/oauth2/token'
        people_api_url = 'https://www.googleapis.com/plus/v1/people/me/openIdConnect'

        payload = dict(client_id=request.data['clientId'],
                       redirect_uri=request.data['redirectUri'],
                       client_secret=settings.SOCIAL_AUTH_GOOGLE_OAUTH2_SECRET,
                       code=request.data['code'],
                       grant_type='authorization_code')

        # Step 1. Exchange authorization code for access token.
        r = requests.post(access_token_url, data=payload)
        token = json.loads(r.text)
        headers = {'Authorization': 'Bearer {0}'.format(token['access_token'])}

        # Step 2. Retrieve information about the current user.
        r = requests.get(people_api_url, headers=headers)
        profile = json.loads(r.text)

        user = None
        if 'email' in profile:
            try:
                user = User.objects.get(email=profile['email'])
            except User.DoesNotExist:
                pass

        if not user:
            user = User.objects.create(username=profile['email'], first_name=profile['given_name'],
                                       last_name=profile['family_name'], email=profile['email'])
            Better.objects.create(user=user)

        payload = jwt_payload_handler(user)
        token = jwt_encode_handler(payload)
        return Response({'token': token.decode('unicode_escape')},
                        status=status.HTTP_200_OK)

    def test_jwt_encode(self):
        payload = utils.jwt_payload_handler(self.user)
        token = utils.jwt_encode_handler(payload)

        payload_data = base64url_decode(token.split('.')[1].encode('utf-8'))
        payload_from_token = json.loads(payload_data.decode('utf-8'))

        self.assertEqual(payload_from_token, payload)

    def test_jwt_decode_verify_exp(self):
        api_settings.JWT_VERIFY_EXPIRATION = False

        payload = utils.jwt_payload_handler(self.user)
        payload['exp'] = 1
        token = utils.jwt_encode_handler(payload)
        utils.jwt_decode_handler(token)

        api_settings.JWT_VERIFY_EXPIRATION = True

 def setUp(self):
     self.client = APIClient()
     self.username = 'buildingblocks'
     self.email = '[email protected]'
     self.password='buildingblocks'
     self.user = User.objects.create_user(self.email, self.password, username=self.username)
     payload = utils.jwt_payload_handler(self.user)
     token = utils.jwt_encode_handler(payload)
     self.auth = 'Token {0}'.format(token)

def test_authjwt_method(subscription, expect):
    if expect is True:
        payload = jwt_payload_handler(user=subscription.subscriber)
        token = jwt_encode_handler(payload)
    else:
        token = "fdksal;j"

    value = auth.authjwt_method(token)
    assert bool(value) is expect

    def create_token(self, user, exp=None, orig_iat=None):
        payload = utils.jwt_payload_handler(user)
        if exp:
            payload['exp'] = exp

        if orig_iat:
            payload['orig_iat'] = timegm(orig_iat.utctimetuple())

        token = utils.jwt_encode_handler(payload)
        return token

    def test_post_json_passing_jwt_auth(self):
        """
        Ensure POSTing JSON over JWT auth with correct credentials
        passes and does not require CSRF
        """
        payload = utils.jwt_payload_handler(self.user)
        token = utils.jwt_encode_handler(payload)

        auth = "JWT {0}".format(token)
        response = self.csrf_client.post("/jwt/", {"example": "example"}, HTTP_AUTHORIZATION=auth, format="json")

        self.assertEqual(response.status_code, status.HTTP_200_OK)

    def create(self, request, *args, **kwargs):
        serializer = self.get_serializer(data=request.data)

        serializer.is_valid(raise_exception=True)
        user = serializer.save()
        re_dict = serializer.data
        payload = jwt_payload_handler(user)
        re_dict["token"] = jwt_encode_handler(payload)
        re_dict["user"] = user
        headers = self.get_success_headers(serializer.data)

        return Response(re_dict, status=status.HTTP_201_CREATED, headers=headers)

 def post(self, request):
     from lazysignup.models import LazyUser
     user, username = LazyUser.objects.create_lazy_user()
     user.first_name = 'Guest' + str(random.randint(1, 200))
     user.save()
     betting_funds = random.randint(10, 60)
     Better.objects.create(user=user, points=betting_funds)
     payload = jwt_payload_handler(user)
     token = jwt_encode_handler(payload)
     return Response({'token': token, 'name': user.first_name,
                      'betting_funds': betting_funds },
                     status=status.HTTP_200_OK)

    def test_post_passing_jwt_auth_with_oauth2_priority(self):
        """
        Ensure POSTing over JWT auth with correct credentials
        passes and does not require CSRF when OAuth2Authentication
        has priority on authentication_classes
        """
        payload = utils.jwt_payload_handler(self.user)
        token = utils.jwt_encode_handler(payload)

        auth = "JWT {0}".format(token)
        response = self.csrf_client.post("/oauth2-jwt/", {"example": "example"}, HTTP_AUTHORIZATION=auth, format="json")

        self.assertEqual(response.status_code, status.HTTP_200_OK, response)

    def test_post_form_passing_jwt_invalid_payload(self):
        """
        Ensure POSTing json over JWT auth with invalid payload fails
        """
        payload = dict(email=None)
        token = utils.jwt_encode_handler(payload)

        auth = "JWT {0}".format(token)
        response = self.csrf_client.post("/jwt/", {"example": "example"}, HTTP_AUTHORIZATION=auth)

        msg = "Invalid payload."

        self.assertEqual(response.data["detail"], msg)
        self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED)

    def test_jwt_login_with_expired_token(self):
        """
        Ensure JWT login view works even if expired token is provided
        """
        payload = utils.jwt_payload_handler(self.user)
        payload['exp'] = 1
        token = utils.jwt_encode_handler(payload)

        auth = 'JWT {0}'.format(token)
        client = APIClient(enforce_csrf_checks=True)
        response = client.post(
            '/auth-token/', self.data,
            HTTP_AUTHORIZATION=auth, format='json')

        self.assertTrue(response.status_code, status.HTTP_200_OK)

 def test_create_refresth_token(self):
     data = {
         'app': 'gandolf'
     }
     self.client.credentials(
         HTTP_AUTHORIZATION='JWT ' + utils.jwt_encode_handler(
             utils.jwt_payload_handler(self.user)))
     response = self.client.post(self.list_url, data, format='json')
     self.assertEqual(
         response.status_code,
         status.HTTP_201_CREATED,
         (response.status_code, response.content)
     )
     self.assertEqual(response.data['user'], self.user.pk)
     self.assertEqual(response.data['app'], data['app'])