Merge pull request #20 from QuickPay/feature/request_options

API: supporting body, headers, query as arguments

Author: dinesh

CHANGELOG.md

@@ -3,6 +3,10 @@ All notable changes to this project will be documented in this file.
 This project adheres to [Semantic Versioning](http://semver.org/).
 
 ## UNRELEASED
+
+### Breaking
+- [Sending request with body, headers, and query](https://github.com/QuickPay/quickpay-python-client/issues/16#issuecomment-474115554)
+
 ### Fixed
 - [Callback header typo fix](https://github.com/QuickPay/quickpay-python-client/issues/16)
 

README.md

@@ -73,6 +73,21 @@ else:
     print "Error", body
 ```
 
+Beyond the endpoint, the client accepts the following options (default values shown):
+
+* `body: ""` ( valid for POST, PATCH and PUT)
+* `headers: {}`
+* `query: {}`
+* `raw: false`
+
+```python
+response = client.post("/payments/1/capture",
+  body={ 'amount': 100 },
+  query={ "synchronized" : "" },
+  raw=False
+)
+```
+
 Handling API exceptions
 ----------------------
 

quickpay_api_client/api.py

@@ -10,13 +10,15 @@
 from quickpay_api_client import exceptions
 import quickpay_api_client
 
+
 class QPAdapter(HTTPAdapter):
     def init_poolmanager(self, connections, maxsize, block=False):
         self.poolmanager = PoolManager(num_pools=connections,
                                        maxsize=maxsize,
                                        block=block,
                                        ssl_version=ssl.PROTOCOL_TLSv1_1)
 
+
 class QPApi(object):
     api_version = '10'
     base_url = 'https://api.quickpay.net'
@@ -43,32 +45,43 @@ def fulfill(self, method, *args, **kwargs):
 
     def perform(self, method, path, **kwargs):
         raw = kwargs.pop('raw', False)
+        ssl_verify = kwargs.pop("verify", True)
         url = "{0}{1}".format(self.base_url, path)
 
         headers = {
             "Accept-Version": 'v%s' % self.api_version,
             "User-Agent": "quickpay-python-client, v%s" % quickpay_api_client.__version__
         }
 
-        callback_url = kwargs.pop("callback_url", None)
-        if callback_url:
-            headers["QuickPay-Callback-Url"] = callback_url
+        body = kwargs.get("body", {})
+        query = kwargs.get("query", {})
+
+        for key in kwargs.get("headers", {}):
+            headers[key] = kwargs['headers'][key]
 
         if self.secret:
-            headers["Authorization"
-                    ] = "Basic {0}".format(_base64_encode(self.secret))
+            headers["Authorization"] = "Basic {0}".format(
+                _base64_encode(self.secret))
 
         if method in ['put', 'post', 'patch']:
             headers['content-type'] = 'application/json'
+
+            # The bytes class isn't considered a string type in Python 3
+            if not isinstance(body, (str, bytes)):
+                body = json.dumps(body)
+
             response = self.fulfill(method, url,
-                                    data=json.dumps(kwargs),
+                                    data=body,
+                                    params=query,
                                     headers=headers,
-                                    timeout=self.timeout)
+                                    timeout=self.timeout,
+                                    verify=ssl_verify)
         else:
             response = self.fulfill(method, url,
-                                    params=kwargs,
+                                    params=query,
                                     headers=headers,
-                                    timeout=self.timeout)
+                                    timeout=self.timeout,
+                                    verify=ssl_verify)
 
         if response.headers.get('content-type') == 'application/json':
             body = response.json()

quickpay_api_client/tests/api_tests.py

@@ -1,4 +1,5 @@
-import base64, json
+import base64
+import json
 from nose.tools import assert_equal, assert_raises
 import requests
 from quickpay_api_client.api import QPApi
@@ -12,8 +13,8 @@ def setup(self):
 
     def setup_request(self):
         responses.add(responses.GET, self.url,
-                    json={'id': 123},
-                    headers={"x-quickpay-server" : "QP-TEST"})
+                      json={'id': 123},
+                      headers={"x-quickpay-server": "QP-TEST"})
 
     @responses.activate
     def test_perform_success(self):
@@ -24,8 +25,8 @@ def test_perform_success(self):
     @responses.activate
     def test_perform_failure(self):
         responses.add(responses.GET, self.url,
-                               status=500,
-                               json={'message': 'dummy'})
+                      status=500,
+                      json={'message': 'dummy'})
 
         try:
             self.api.perform("get", "/test")
@@ -47,11 +48,40 @@ def test_headers(self):
     def test_callback_url_headers(self):
         self.setup_request()
         callback_url = "https://foo.bar"
-        res = self.api.perform("get", "/test", callback_url=callback_url)
+        self.api.perform(
+            "get", "/test", headers={'QuickPay-Callback-Url': callback_url})
 
         req_headers = responses.calls[0].request.headers
         assert_equal(req_headers['QuickPay-Callback-Url'], callback_url)
 
+    @responses.activate
+    def test_query_params(self):
+        self.setup_request()
+        self.api.perform("get", "/test", query={'foo': 'bar'})
+
+        url = responses.calls[0].request.url
+        assert(url.endswith('?foo=bar'))
+
+    @responses.activate
+    def test_post_body(self):
+        responses.add(responses.POST, self.url,
+                      status=200,
+                      json={'message': 'dummy'})
+
+        self.api.perform("post", "/test", query={"foo": "baz"},
+                         body={'foo': 'bar'})
+
+        last_request = responses.calls[0].request
+        body = last_request.body
+        parsed_body = json.loads(body)
+        headers = last_request.headers
+
+        assert_equal(parsed_body["foo"], "bar")
+        assert(headers["Authorization"])
+        assert(headers["Accept-Version"])
+        assert(headers["User-Agent"])
+        assert(last_request.url.endswith('?foo=baz'))
+
     @responses.activate
     def test_perform_when_raw(self):
         self.setup_request()