don't keep state in OAuth1Service

rauth/service.py

@@ -379,47 +379,25 @@ 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.
 
         :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.
 
         :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,

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
 

tests/test_service.py

@@ -328,25 +328,26 @@ 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')
     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):