SDK-1076: Update tests for SignedRequest and SignedRequestBuilder, as well as updating the rest of the SDK to make use of the new builders

Author: MrBurtyyy

yoti_python_sdk/client.py

@@ -4,8 +4,6 @@
 import json
 from os import environ
 
-import requests
-
 import yoti_python_sdk
 from yoti_python_sdk import aml
 from yoti_python_sdk.activity_details import ActivityDetails
@@ -26,12 +24,36 @@
 
 
 class Client(object):
-    def __init__(self, sdk_id=None, pem_file_path=None):
+    def __init__(self, sdk_id=None, pem_file_path=None, request_handler=None):
         self.sdk_id = sdk_id or environ.get("YOTI_CLIENT_SDK_ID")
         pem_file_path_env = environ.get("YOTI_KEY_FILE_PATH", pem_file_path)
 
-        self.__crypto = Crypto.read_pem_file(pem_file_path_env)
+        if pem_file_path is not None:
+            error_source = "argument specified in Client()"
+            self.__crypto = Crypto.read_pem_file(pem_file_path, error_source)
+        elif pem_file_path_env is not None:
+            error_source = "specified by the YOTI_KEY_FILE_PATH env variable"
+            self.__crypto = Crypto.read_pem_file(pem_file_path_env, error_source)
+        else:
+            raise RuntimeError(NO_KEY_FILE_SPECIFIED_ERROR)
+
         self.__endpoint = Endpoint(sdk_id)
+        self.__request_handler = request_handler
+
+    def make_request(self, http_method, endpoint, body):
+        signed_request = (
+            SignedRequest.builder()
+            .with_pem_file(self.__crypto)
+            .with_base_url(yoti_python_sdk.YOTI_API_ENDPOINT)
+            .with_endpoint(endpoint)
+            .with_http_method(http_method)
+            .with_payload(body)
+            .with_request_handler(self.__request_handler)
+            .build()
+        )
+
+        response = signed_request.execute()
+        return response
 
     def get_activity_details(self, encrypted_request_token):
         response = self.__make_activity_details_request(encrypted_request_token)
@@ -70,24 +92,10 @@ def perform_aml_check(self, aml_profile):
         if aml_profile is None:
             raise TypeError("aml_profile not set")
 
-        http_method = "POST"
-
-        response = self.__make_aml_check_request(http_method, aml_profile)
+        response = self.__make_aml_check_request(aml_profile)
 
         return aml.AmlResult(response.text)
 
-    def make_request(self, http_method, endpoint, body):
-        url = yoti_python_sdk.YOTI_API_ENDPOINT + endpoint
-        headers = self.__get_request_headers(endpoint, http_method, body)
-        response = requests.request(
-            http_method,
-            url,
-            headers=headers,
-            data=body,
-            verify=yoti_python_sdk.YOTI_API_VERIFY_SSL,
-        )
-        return response
-
     @property
     def endpoints(self):
         return self.__endpoint
@@ -123,6 +131,7 @@ def __make_activity_details_request(self, encrypted_request_token):
             .with_base_url(yoti_python_sdk.YOTI_API_ENDPOINT)
             .with_endpoint(path)
             .with_param("appId", self.sdk_id)
+            .with_request_handler(self.__request_handler)
             .build()
         )
 
@@ -134,20 +143,25 @@ def __make_activity_details_request(self, encrypted_request_token):
 
         return response
 
-    def __make_aml_check_request(self, http_method, aml_profile):
+    def __make_aml_check_request(self, aml_profile):
         aml_profile_json = json.dumps(aml_profile.__dict__, sort_keys=True)
         aml_profile_bytes = aml_profile_json.encode()
-        path = self.__endpoint.get_aml_request_url()
-        url = yoti_python_sdk.YOTI_API_ENDPOINT + path
-        headers = self.__get_request_headers(path, http_method, aml_profile_bytes)
-
-        response = requests.post(
-            url=url,
-            headers=headers,
-            data=aml_profile_bytes,
-            verify=yoti_python_sdk.YOTI_API_VERIFY_SSL,
+        path = self.__endpoint.get_aml_request_url(no_params=True)
+
+        signed_request = (
+            SignedRequest.builder()
+            .with_pem_file(self.__crypto)
+            .with_base_url(yoti_python_sdk.YOTI_API_ENDPOINT)
+            .with_endpoint(path)
+            .with_payload(aml_profile_bytes)
+            .with_param("appId", self.sdk_id)
+            .with_post()
+            .with_request_handler(self.__request_handler)
+            .build()
         )
 
+        response = signed_request.execute()
+
         self.http_error_handler(
             response, {"default": "Unsuccessful Yoti API call: {} {}"}
         )

yoti_python_sdk/dynamic_sharing_service/share_url.py

@@ -19,7 +19,7 @@
 def create_share_url(yoti_client, dynamic_scenario):
     http_method = "POST"
     payload = json.dumps(dynamic_scenario, sort_keys=True).encode()
-    endpoint = yoti_client.endpoints.get_dynamic_share_request_url()
+    endpoint = yoti_client.endpoints.get_dynamic_share_request_url(no_params=True)
     response = yoti_client.make_request(http_method, endpoint, payload)
 
     client.Client.http_error_handler(response, SHARE_URL_ERRORS)

yoti_python_sdk/http.py

@@ -8,6 +8,7 @@
     JSON_CONTENT_TYPE,
 )
 from cryptography.fernet import base64
+from abc import ABCMeta, abstractmethod
 
 import yoti_python_sdk
 import requests
@@ -17,19 +18,52 @@
 try:  # pragma: no cover
     from urllib.parse import urlencode
 except ImportError:  # pragma: no cover
-    from urlparse import urlencode
+    from urllib import urlencode
 
 HTTP_POST = "POST"
 HTTP_GET = "GET"
 HTTP_SUPPORTED_METHODS = ["POST", "PUT", "PATCH", "GET", "DELETE"]
 
 
+class RequestHandler:
+    """
+    Default request handler for signing requests using the requests library.
+    This type can be inherited and the execute method overridden to use any
+    preferred HTTP library.
+    """
+
+    __metaclass__ = ABCMeta  # Python 2 compatability
+
+    @staticmethod
+    @abstractmethod
+    def execute(request):
+        return NotImplemented
+
+
+class DefaultRequestHandler(RequestHandler):
+    @staticmethod
+    def execute(request):
+        """
+        Execute the HTTP request supplied
+        """
+        if not isinstance(request, SignedRequest):
+            raise TypeError("RequestHandler expects instance of SignedRequest")
+
+        return requests.request(
+            url=request.url,
+            method=request.method,
+            data=request.data,
+            headers=request.headers,
+        )
+
+
 class SignedRequest(object):
-    def __init__(self, url, http_method, payload, headers):
+    def __init__(self, url, http_method, payload, headers, request_handler=None):
         self.__url = url
         self.__http_method = http_method
         self.__payload = payload
         self.__headers = headers
+        self.__request_handler = request_handler
 
     @property
     def url(self):
@@ -59,22 +93,15 @@ def headers(self):
         """
         return self.__headers
 
-    def prepare(self):
-        """
-        Creates a PreparedRequest object for use in a requests Session
-        """
-        r = requests.Request(
-            method=self.method, url=self.url, headers=self.headers, data=self.data
-        )
-        return r.prepare()
-
     def execute(self):
         """
-        Send the signed request, returning the requests Response object
+        Send the signed request, using the default RequestHandler if one has not be supplied
         """
-        return requests.request(
-            url=self.url, method=self.method, data=self.data, headers=self.headers
-        )
+        if self.__request_handler is None:
+            print("Using default request handler")
+            return DefaultRequestHandler.execute(self)
+
+        return self.__request_handler.execute(self)
 
     @staticmethod
     def builder():
@@ -93,6 +120,7 @@ def __init__(self):
         self.__params = None
         self.__headers = None
         self.__payload = None
+        self.__request_handler = None
 
     def with_pem_file(self, pem_file):
         """
@@ -157,6 +185,25 @@ def with_http_method(self, http_method):
         self.__http_method = http_method
         return self
 
+    def with_request_handler(self, handler):
+        # If no handler is passed, just return as the default will be used
+        if handler is None:
+            return self
+
+        try:
+            if not issubclass(handler, RequestHandler):
+                raise TypeError(
+                    "Handler must be instance of yoti_python_sdk.http.RequestHandler"
+                )
+        except Exception:
+            # ABC
+            raise TypeError(
+                "Handler must be instance of yoti_python_sdk.http.RequestHandler"
+            )
+
+        self.__request_handler = handler
+        return self
+
     def with_post(self):
         """
         Sets the HTTP method for a POST request
@@ -270,4 +317,6 @@ def build(self):
         )
         url = self.__base_url + endpoint
 
-        return SignedRequest(url, self.__http_method, self.__payload, headers)
+        return SignedRequest(
+            url, self.__http_method, self.__payload, headers, self.__request_handler
+        )

yoti_python_sdk/tests/conftest.py

@@ -6,6 +6,7 @@
 
 from yoti_python_sdk import Client
 from yoti_python_sdk.crypto import Crypto
+from yoti_python_sdk.tests.mocks import MockRequestHandler
 
 FIXTURES_DIR = join(dirname(abspath(__file__)), "fixtures")
 PEM_FILE_PATH = join(FIXTURES_DIR, "sdk-test.pem")
@@ -17,6 +18,11 @@
 YOTI_CLIENT_SDK_ID = "737204aa-d54e-49a4-8bde-26ddbe6d880c"
 
 
+@pytest.fixture(scope="module")
+def mock_request_handler():
+    return MockRequestHandler
+
+
 @pytest.fixture(scope="module")
 def client():
     return Client(YOTI_CLIENT_SDK_ID, PEM_FILE_PATH)

yoti_python_sdk/tests/mocks.py

@@ -1,4 +1,5 @@
 from uuid import UUID
+from yoti_python_sdk.http import RequestHandler, SignedRequest
 
 
 class MockResponse:
@@ -7,6 +8,18 @@ def __init__(self, status_code, text):
         self.text = text
 
 
+class MockRequestHandler(RequestHandler):
+    @staticmethod
+    def execute(request):
+        """
+        Execute the HTTP request supplied
+        """
+        if not isinstance(request, SignedRequest):
+            raise RuntimeError("RequestHandler expects instance of SignedRequest")
+
+        return mocked_requests_get()
+
+
 def mocked_requests_get(*args, **kwargs):
     with open("yoti_python_sdk/tests/fixtures/response.txt", "r") as f:
         response = f.read()