Merge pull request #69 from bpicolo/immutable_async_client

Don't mutate clients.

Author: Ben Picolo

setup.py

@@ -10,7 +10,7 @@
 
 setup(
     name="swaggerpy",
-    version="0.7.0",
+    version="0.7.1",
     license="BSD 3-Clause License",
     description="Library for accessing Swagger-enabled API's",
     long_description=open(os.path.join(os.path.dirname(__file__),
@@ -32,7 +32,8 @@
         "tissue",
         "coverage",
         "ordereddict",
-        "httpretty"
+        "httpretty",
+        "bottle"
     ],
     install_requires=[
         "requests",

swaggerpy/async_http_client.py

@@ -33,15 +33,17 @@ class AsynchronousHttpClient(http_client.HttpClient):
     """Asynchronous HTTP client implementation.
     """
 
-    def setup(self, request_params):
+    def start_request(self, request_params):
         """Sets up the request params as per Twisted Agent needs.
         Sets up crochet and triggers the API request in background
 
         :param request_params: request parameters for API call
         :type request_params: dict
+
+        :return: crochet EventualResult
         """
         # request_params has mandatory: method, url, params, headers
-        self.request_params = {
+        request_params = {
             'method': str(request_params['method']),
             'bodyProducer': stringify_body(request_params),
             'headers': listify_headers(request_params['headers']),
@@ -50,42 +52,46 @@ def setup(self, request_params):
         }
 
         crochet.setup()
-        self.eventual = self.fetch_deferred()
+        return self.fetch_deferred(request_params)
 
-    def cancel(self):
+    def cancel(self, eventual):
         """Try to cancel the API call using crochet's cancel() API
+
+        :param eventual: Crochet EventualResult
         """
-        self.eventual.cancel()
+        eventual.cancel()
 
-    def wait(self, timeout):
+    def wait(self, timeout, eventual):
         """Requests based implemention with timeout
 
         :param timeout: time in seconds to wait for response
+        :param eventual: Crochet EventualResult
+
         :return: Requests response
         :rtype:  requests.Response
         """
-        log.info(u"%s %s", self.request_params.get('method'),
-                 self.request_params.get('uri'))
         # finished_resp is returned here
         # TODO(#44): catch known exceptions and raise common exceptions
-        return self.eventual.wait(timeout)
+        return eventual.wait(timeout)
 
     @crochet.run_in_reactor
-    def fetch_deferred(self):
+    def fetch_deferred(self, request_params):
         """The main core to start the reacter and run the API
         in the background. Also the callbacks are registered here
+
+        :return: crochet EventualResult
         """
         finished_resp = Deferred()
         agent = Agent(reactor)
-        deferred = agent.request(**self.request_params)
+        deferred = agent.request(**request_params)
 
         def response_callback(response):
             """Callback for response received from server, even 4XX, 5XX possible
             response param stores the headers and status code.
             It needs a callback method to be registered to store the response
             body which is provided using deliverBody
             """
-            response.deliverBody(_HTTPBodyFetcher(self.request_params,
+            response.deliverBody(_HTTPBodyFetcher(request_params,
                                                   response, finished_resp))
         deferred.addCallback(response_callback)
 
@@ -101,10 +107,8 @@ def response_errback(reason):
         return finished_resp
 
 
-class AsyncResponse():
-    """AsyncResponse inherits from requests.Response
-    to inherit methods like json(), raise_for_status()
-
+class AsyncResponse(object):
+    """
     Remove the property text and content and make them as overridable attrs
     """
     def __init__(self, req, resp, data):

swaggerpy/http_client.py

@@ -71,27 +71,35 @@ def set_api_key(self, host, api_key, param_name=u'api_key'):
         raise NotImplementedError(
             u"%s: Method not implemented", self.__class__.__name__)
 
-    def setup(self, request_params):
-        """Store the request params for calling later.
-
+    def start_request(self, request_params):
+        """
         :param request_params: Complete request data.
         :type request_params: dict
+
+        :returns: The client's request object
         """
         raise NotImplementedError(
             u"%s: Method not implemented", self.__class__.__name__)
 
-    def wait(self, timeout):
+    def wait(self, timeout, request):
         """Calls the API with request_params and waits till timeout.
 
         :param timeout: time in seconds to wait for response.
         :type timeout: float
+        :param request: request object from the client
+            In the Sync client this is a requests.Request
+            In the Async client this is a crochet.EventualResult
         :return: Implementation specific response
         """
         raise NotImplementedError(
             u"%s: Method not implemented", self.__class__.__name__)
 
-    def cancel(self):
+    def cancel(self, request):
         """Cancels the API call
+
+        :param request: request object from the client
+            In the Sync client this is a requests.Request
+            In the Async client this is a crochet.EventualResult
         """
         raise NotImplementedError(
             u"%s: Method not implemented", self.__class__.__name__)
@@ -143,6 +151,8 @@ def __init__(self, host, username, password):
     def apply(self, request):
         request.auth = self.auth
 
+        return request
+
 
 # noinspection PyDocstring
 class ApiKeyAuthenticator(Authenticator):
@@ -162,6 +172,7 @@ def __init__(self, host, api_key, param_name=u'api_key'):
 
     def apply(self, request):
         request.params[self.param_name] = self.api_key
+        return request
 
 
 class SynchronousHttpClient(HttpClient):
@@ -175,14 +186,21 @@ def __init__(self):
     def close(self):
         self.session.close()
 
-    def setup(self, request_params):
+    def start_request(self, request_params):
+        """
+        :return: request
+        :rtype: requests.Request
+        """
         # if files in request_params OR
         # if content-type is x-www-form-urlencoded, no need to stringify
         if ('files' not in request_params and
                 request_params['headers'].get('content-type') != APP_FORM):
             stringify_body(request_params)
-        self.request_params = request_params
-        self.purge_content_types_if_file_present()
+        request_params = self.purge_content_types_if_file_present(
+            request_params,
+        )
+
+        return self.authenticated_request(request_params)
 
     def set_basic_auth(self, host, username, password):
         self.authenticator = BasicAuthenticator(
@@ -192,31 +210,35 @@ def set_api_key(self, host, api_key, param_name=u'api_key'):
         self.authenticator = ApiKeyAuthenticator(
             host=host, api_key=api_key, param_name=param_name)
 
-    def wait(self, timeout):
+    def wait(self, timeout, request):
         """Requests based implemention with timeout.
 
         :param timeout: time in seconds to wait for response
+        :param request: requests.Request
+
         :return: Requests response
         :rtype:  requests.Response
         """
-        log.info(u"%s %s(%r)", self.request_params['method'],
-                 self.request_params['url'],
-                 self.request_params['params'])
-        req = requests.Request(**self.request_params)
-        self.apply_authentication(req)
-        return self.session.send(self.session.prepare_request(req),
-                                 timeout=timeout)
+        log.info(u"%s %s(%r)", request.method, request.url, request.params)
+        return self.session.send(
+            self.session.prepare_request(request),
+            timeout=timeout,
+        )
 
-    def purge_content_types_if_file_present(self):
+    def purge_content_types_if_file_present(self, request_params):
         """'Requests' adds 'multipart/form-data' to content-type if
         files are in the request. Hence, any existing content-type
         like application/x-www-form... should be removed
         """
-        if 'files' in self.request_params:
-            self.request_params['headers'].pop('content-type', '')
+        if 'files' in request_params:
+            request_params['headers'].pop('content-type', '')
 
-    def cancel(self):
+        return request_params
+
+    def cancel(self, request):
         """Nothing to be done for Synchronous client
+
+        :param request: requests.Request
         """
 
     def request(self, method, url, params=None, data=None, headers=None):
@@ -227,16 +249,20 @@ def request(self, method, url, params=None, data=None, headers=None):
         """
         if not headers:
             headers = {}
-        kwargs = {}
+        request_params = {}
         for i in ('method', 'url', 'params', 'data', 'headers'):
-            kwargs[i] = locals()[i]
-        req = requests.Request(**kwargs)
-        self.apply_authentication(req)
-        return self.session.send(self.session.prepare_request(req))
-
-    def apply_authentication(self, req):
-        if self.authenticator and self.authenticator.matches(req.url):
-            self.authenticator.apply(req)
+            request_params[i] = locals()[i]
+        request = self.authenticated_request(request_params)
+        return self.session.send(self.session.prepare_request(request))
+
+    def authenticated_request(self, request_params):
+        return self.apply_authentication(requests.Request(**request_params))
+
+    def apply_authentication(self, request):
+        if self.authenticator and self.authenticator.matches(request.url):
+            return self.authenticator.apply(request)
+
+        return request
 
 
 def stringify_body(request_params):

swaggerpy/response.py

@@ -29,17 +29,20 @@ def handle_response_errors(e, CustomError):
 
 
 class HTTPFuture(object):
+
     """A future which inputs HTTP params"""
     def __init__(self, http_client, request_params, postHTTP_callback):
         """Kicks API call for Asynchronous client
 
-        :param http_client: instance with public methods: setup(), wait()
+        :param http_client: instance with public methods:
+            start_request(), wait(), cancel()
         :param request_params: dict containing API request parameters
         :param postHTTP_callback: function to callback on finish
         """
         self._http_client = http_client
         self._postHTTP_callback = postHTTP_callback
-        self._http_client.setup(request_params)
+        # A request is an EventualResult in the async client
+        self._request = self._http_client.start_request(request_params)
         self._cancelled = False
 
     def cancelled(self):
@@ -52,7 +55,7 @@ def cancel(self):
         """Try to cancel the API (meaningful for Asynchronous client)
         """
         self._cancelled = True
-        self._http_client.cancel()
+        self._http_client.cancel(self._request)
 
     def result(self, **kwargs):
         """Blocking call to wait for API response
@@ -70,7 +73,7 @@ def result(self, **kwargs):
 
         if self.cancelled():
             raise CancelledError()
-        response = self._http_client.wait(timeout)
+        response = self._http_client.wait(timeout, self._request)
         try:
             response.raise_for_status()
         except Exception as e:

tests/async_http_client_test.py

@@ -16,6 +16,9 @@
 from mock import patch, Mock
 from ordereddict import OrderedDict
 
+from crochet._eventloop import EventualResult
+from twisted.internet.defer import Deferred
+
 import swaggerpy.async_http_client
 import swaggerpy.exception
 import swaggerpy.http_client
@@ -107,21 +110,26 @@ def test_listify_headers(self):
     def test_success_AsyncHTTP_response(self):
         Response = namedtuple("MyResponse",
                               "version code phrase headers length deliverBody")
-        with patch.object(swaggerpy.async_http_client.AsynchronousHttpClient,
-                          'fetch_deferred') as mock_Async:
+        with patch.object(
+            swaggerpy.async_http_client.AsynchronousHttpClient,
+            'fetch_deferred',
+            return_value=Mock(
+                autospec=EventualResult,
+                _deferred=Mock(autospec=Deferred),
+            ),
+        ) as mock_Async:
             req = {
                 'method': 'GET',
                 'url': 'foo',
                 'data': None,
                 'headers': {'foo': 'bar'},
-                'params': ''}
+                'params': ''
+            }
             mock_Async.return_value.wait.return_value = Response(
                 1, 2, 3, 4, 5, 6)
             async_client = swaggerpy.async_http_client.AsynchronousHttpClient()
-            async_client.setup(req)
-            resp = async_client.wait(5)
-            headers = async_client.request_params['headers']
-            self.assertTrue(headers.hasHeader('foo'))
+            eventual = async_client.start_request(req)
+            resp = async_client.wait(5, eventual)
             self.assertEqual(2, resp.code)