From 68513501ef2d885ccf5115ff583fd784e7e7547d Mon Sep 17 00:00:00 2001 From: Joe Shaw Date: Fri, 1 Jun 2012 12:09:55 -0400 Subject: [PATCH 1/2] try to fallback to unittest2 if using an older python version Python 2.6 doesn't have unittest.TestCase.assertIsNotNone, among others. If we don't have it, try to import unittest2 as unittest. --- tests/base.py | 3 +++ 1 file changed, 3 insertions(+) diff --git a/tests/base.py b/tests/base.py index 1314022..44f70b0 100644 --- a/tests/base.py +++ b/tests/base.py @@ -7,6 +7,9 @@ import unittest +if not hasattr(unittest.TestCase, 'assertIsNotNone'): + import unittest2 as unittest + from mock import Mock from requests import Request From eae023de6163055af104c77afac680880257787b Mon Sep 17 00:00:00 2001 From: Joe Shaw Date: Fri, 1 Jun 2012 13:28:19 -0400 Subject: [PATCH 2/2] always construct a new session when doing a request We can't keep state, because this service object is likely shared across many different uses (and people) -- if an access token is cached, it might be reused by another user who is trying to get a request token. --- rauth/service.py | 44 +++++++++++-------------------------------- tests/test_service.py | 17 +++++++++-------- 2 files changed, 20 insertions(+), 41 deletions(-) diff --git a/rauth/service.py b/rauth/service.py index cb04af7..d2897c7 100644 --- a/rauth/service.py +++ b/rauth/service.py @@ -379,8 +379,6 @@ def __init__(self, name, consumer_key, consumer_secret, request_token_url, # set to True to use header authentication for this service self.header_auth = header_auth - self.auth_session = None - def _construct_session(self, **kwargs): '''Construct the request session, supplying the consumer key and secret. @@ -388,30 +386,10 @@ def _construct_session(self, **kwargs): :param \*\*kwargs: Extra keyworded arguments to be passed to the OAuth1Hook constructor. ''' - self.hook = OAuth1Hook(consumer_key=self.consumer_key, - consumer_secret=self.consumer_secret, - **kwargs) - return requests.session(hooks={'pre_request': self.hook}) - - def _get_session(self, **kwargs): - '''Get the request session, update attributes on the hook instance. - - :param \*\*kwargs: Updates for access_token, access_token_secret, - header_auth.''' - access_token = kwargs.get('access_token') - access_token_secret = kwargs.get('access_token_secret') - header_auth = kwargs.get('header_auth') - - if self.auth_session is None: - self.auth_session = \ - self._construct_session(header_auth=self.header_auth) - - if access_token is not None: - self.hook.access_token = access_token - if access_token_secret is not None: - self.hook.access_token_secret = access_token_secret - self.hook.header_auth = header_auth or self.header_auth - return self.auth_session + hook = OAuth1Hook(consumer_key=self.consumer_key, + consumer_secret=self.consumer_secret, + **kwargs) + return requests.session(hooks={'pre_request': hook}) def get_request_token(self, method='GET', **kwargs): '''Gets a request token from the request token endpoint. @@ -419,7 +397,7 @@ def get_request_token(self, method='GET', **kwargs): :param method: A string representation of the HTTP method to be used. :param \*\*kwargs: Optional arguments. Same as Requests. ''' - auth_session = self._get_session() + auth_session = self._construct_session() response = auth_session.request(method, self.request_token_url, **kwargs) @@ -455,9 +433,9 @@ def get_access_token(self, method='GET', **kwargs): request_token_secret = kwargs.pop('request_token_secret') auth_session = \ - self._get_session(access_token=request_token, - access_token_secret=request_token_secret, - header_auth=self.header_auth) + self._construct_session(access_token=request_token, + access_token_secret=request_token_secret, + header_auth=self.header_auth) response = auth_session.request(method, self.access_token_url, @@ -486,9 +464,9 @@ def request(self, method, url, **kwargs): # grab session constructed on initialization auth_session = \ - self._get_session(access_token=access_token, - access_token_secret=access_token_secret, - header_auth=header_auth) + self._construct_session(access_token=access_token, + access_token_secret=access_token_secret, + header_auth=header_auth) response = auth_session.request(method, url, diff --git a/tests/test_service.py b/tests/test_service.py index 36c4b59..1c08b96 100644 --- a/tests/test_service.py +++ b/tests/test_service.py @@ -328,8 +328,8 @@ def test_get_access_token_bad_response(self, mock_request): def test_get_authenticated_session(self): auth_session = \ - self.service._get_session(access_token='123', - access_token_secret='456') + self.service._construct_session(access_token='123', + access_token_secret='456') self.assertIsNotNone(auth_session) @patch.object(requests.Session, 'request') @@ -337,16 +337,17 @@ def test_use_authenticated_session(self, mock_request): mock_request.return_value = self.response auth_session = \ - self.service._get_session(access_token='123', - access_token_secret='456') + self.service._construct_session(access_token='123', + access_token_secret='456') + hook = auth_session.hooks['pre_request'] response = auth_session.get('http://example.com/foobar').content self.assertIsNotNone(response) self.assertEqual('oauth_token=123&oauth_token_secret=456', response) - self.assertIsNotNone(self.service.hook.access_token) - self.assertIsNotNone(self.service.hook.access_token_secret) - self.assertEqual(self.service.hook.access_token, '123') - self.assertEqual(self.service.hook.access_token_secret, '456') + self.assertIsNotNone(hook.access_token) + self.assertIsNotNone(hook.access_token_secret) + self.assertEqual(hook.access_token, '123') + self.assertEqual(hook.access_token_secret, '456') @patch.object(requests.Session, 'request') def test_request(self, mock_request):