SDK-1076: Update SignedRequest and SignedRequestBuilder with payload function, and write unit tests

MrBurtyyy · MrBurtyyy · commit 6cdbfa2dc19b · 2019-09-10T10:42:43.000+01:00
diff --git a/yoti_python_sdk/http.py b/yoti_python_sdk/http.py
@@ -14,9 +14,9 @@
 import uuid
 import time
 
-try:
+try:  # pragma: no cover
     from urllib.parse import urlencode
-except ImportError:
+except ImportError:  # pragma: no cover
     from urlparse import urlencode
 
 HTTP_POST = "POST"
@@ -70,11 +70,11 @@ def prepare(self):
 
     def execute(self):
         """
-        Creates and sends a PreparedRequest in a requests Session, returning the requests Response object
+        Send the signed request, returning the requests Response object
         """
-        prepared = self.prepare()
-        with requests.Session() as s:
-            return s.send(prepared)
+        return requests.request(
+            url=self.url, method=self.method, data=self.data, headers=self.headers
+        )
 
     @staticmethod
     def builder():
@@ -120,6 +120,13 @@ def with_endpoint(self, endpoint):
         self.__endpoint = endpoint
         return self
 
+    def with_payload(self, payload):
+        """
+        Sets the payload for the signed request.  Must be a valid JSON string
+        """
+        self.__payload = payload
+        return self
+
     def with_param(self, name, value):
         """
         Sets a query param to be used with the endpoint
@@ -144,6 +151,9 @@ def with_http_method(self, http_method):
         """
         Sets the HTTP method to be used in the request
         """
+        if http_method not in HTTP_SUPPORTED_METHODS:
+            raise ValueError("{} is an unsupported HTTP method".format(http_method))
+
         self.__http_method = http_method
         return self
 
@@ -158,7 +168,7 @@ def with_get(self):
         """
         Sets the HTTP method for a GET request
         """
-        self.__http_method = HTTP_GET
+        self.with_http_method(HTTP_GET)
         return self
 
     def __append_query_params(self, query_params=None):
@@ -216,12 +226,6 @@ def __create_request(http_method, path, content):
         :param content:
         :return:
         """
-        if http_method not in HTTP_SUPPORTED_METHODS:
-            raise ValueError(
-                "{} is not in the list of supported methods: {}".format(
-                    http_method, HTTP_SUPPORTED_METHODS
-                )
-            )
 
         request = "{}&{}".format(http_method, path)
 
diff --git a/yoti_python_sdk/tests/test_http.py b/yoti_python_sdk/tests/test_http.py
@@ -0,0 +1,249 @@
+try:
+    from unittest import mock
+except ImportError:
+    import mock
+
+from yoti_python_sdk.http import SignedRequest
+from yoti_python_sdk.crypto import Crypto
+from yoti_python_sdk.tests import conftest
+from requests import PreparedRequest
+
+from yoti_python_sdk.tests.mocks import mocked_requests_get
+
+import pytest
+import json
+
+
+@pytest.fixture(scope="module")
+def json_payload():
+    payload = {"Hello": "World"}
+    return json.dumps(payload).encode()
+
+
+@pytest.fixture(scope="module")
+def valid_base_url():
+    return "https://localhost:8443/api/v1"
+
+
+@pytest.fixture(scope="module")
+def valid_endpoint():
+    return "/profile"
+
+
+@pytest.fixture(scope="module")
+def expected_request_headers():
+    return ["X-Yoti-Auth-Key", "X-Yoti-Auth-Digest", "X-Yoti-SDK", "X-Yoti-SDK-Version"]
+
+
+def test_create_signed_request_get_required_properties(
+    valid_base_url, valid_endpoint, expected_request_headers
+):
+    http_method = "GET"
+
+    signed_request = (
+        SignedRequest.builder()
+        .with_pem_file(conftest.PEM_FILE_PATH)
+        .with_base_url(valid_base_url)
+        .with_endpoint(valid_endpoint)
+        .with_http_method(http_method)
+        .build()
+    )
+
+    assert (valid_base_url + valid_endpoint) in signed_request.url
+    assert signed_request.method == http_method
+    assert signed_request.data is None
+
+    header_keys = signed_request.headers.keys()
+    for header in expected_request_headers:
+        assert header in header_keys
+
+
+def test_create_signed_request_missing_pem_file(valid_base_url, valid_endpoint):
+    http_method = "GET"
+
+    with pytest.raises(ValueError) as ex:
+        (
+            SignedRequest.builder()
+            .with_base_url(valid_base_url)
+            .with_endpoint(valid_endpoint)
+            .with_http_method(http_method)
+            .build()
+        )
+
+    assert "PEM file" in str(ex.value)
+
+
+def test_create_signed_request_missing_base_url(valid_endpoint):
+    http_method = "GET"
+
+    with pytest.raises(ValueError) as ex:
+        (
+            SignedRequest.builder()
+            .with_pem_file(conftest.PEM_FILE_PATH)
+            .with_endpoint(valid_endpoint)
+            .with_http_method(http_method)
+            .build()
+        )
+
+    assert "Base URL" in str(ex.value)
+
+
+def test_create_signed_request_missing_endpoint(valid_base_url):
+    http_method = "GET"
+
+    with pytest.raises(ValueError) as ex:
+        (
+            SignedRequest.builder()
+            .with_pem_file(conftest.PEM_FILE_PATH)
+            .with_base_url(valid_base_url)
+            .with_http_method(http_method)
+            .build()
+        )
+
+    assert "Endpoint" in str(ex.value)
+
+
+def test_create_signed_request_missing_http_method(valid_base_url, valid_endpoint):
+    with pytest.raises(ValueError) as ex:
+        (
+            SignedRequest.builder()
+            .with_pem_file(conftest.PEM_FILE_PATH)
+            .with_base_url(valid_base_url)
+            .with_endpoint(valid_endpoint)
+            .build()
+        )
+
+    assert "HTTP method" in str(ex.value)
+
+
+def test_create_signed_request_with_invalid_http_method():
+
+    with pytest.raises(ValueError) as ex:
+        SignedRequest.builder().with_http_method("INVALID").build()
+
+    assert str(ex.value) == "INVALID is an unsupported HTTP method"
+
+
+def test_create_signed_request_with_payload(
+    valid_base_url, valid_endpoint, json_payload
+):
+    http_method = "POST"
+
+    signed_request = (
+        SignedRequest.builder()
+        .with_pem_file(conftest.PEM_FILE_PATH)
+        .with_base_url(valid_base_url)
+        .with_endpoint(valid_endpoint)
+        .with_http_method(http_method)
+        .with_payload(json_payload)
+        .build()
+    )
+
+    assert signed_request.data == json_payload
+
+
+def test_create_signed_request_with_header(valid_base_url, valid_endpoint):
+    http_method = "POST"
+
+    signed_request = (
+        SignedRequest.builder()
+        .with_pem_file(conftest.PEM_FILE_PATH)
+        .with_base_url(valid_base_url)
+        .with_endpoint(valid_endpoint)
+        .with_http_method(http_method)
+        .with_header("My-Http-Header", "someValue")
+        .build()
+    )
+
+    headers = signed_request.headers
+
+    assert "My-Http-Header" in headers
+    assert headers["My-Http-Header"] == "someValue"
+
+
+def test_create_signed_request_with_query_param(valid_base_url, valid_endpoint):
+    http_method = "POST"
+
+    signed_request = (
+        SignedRequest.builder()
+        .with_pem_file(conftest.PEM_FILE_PATH)
+        .with_base_url(valid_base_url)
+        .with_endpoint(valid_endpoint)
+        .with_http_method(http_method)
+        .with_param("sdkId", "mySdkId")
+        .build()
+    )
+
+    assert "sdkId=mySdkId" in signed_request.url
+
+
+def test_create_signed_request_with_crypto_object(valid_base_url, valid_endpoint):
+    http_method = "GET"
+    crypto = Crypto.read_pem_file(conftest.PEM_FILE_PATH)
+
+    (
+        SignedRequest.builder()
+        .with_pem_file(crypto)
+        .with_base_url(valid_base_url)
+        .with_endpoint(valid_endpoint)
+        .with_http_method(http_method)
+        .build()
+    )
+
+
+def test_create_signed_request_with_get_convenience_method(
+    valid_base_url, valid_endpoint
+):
+    (
+        SignedRequest.builder()
+        .with_pem_file(conftest.PEM_FILE_PATH)
+        .with_base_url(valid_base_url)
+        .with_endpoint(valid_endpoint)
+        .with_get()
+        .build()
+    )
+
+
+def test_create_signed_request_with_post_convenience_method(
+    valid_base_url, valid_endpoint, json_payload
+):
+    (
+        SignedRequest.builder()
+        .with_pem_file(conftest.PEM_FILE_PATH)
+        .with_base_url(valid_base_url)
+        .with_endpoint(valid_endpoint)
+        .with_post()
+        .with_payload(json_payload)
+        .build()
+    )
+
+
+def test_create_prepared_request_from_signed_request(valid_base_url, valid_endpoint):
+    signed_request = (
+        SignedRequest.builder()
+        .with_pem_file(conftest.PEM_FILE_PATH)
+        .with_base_url(valid_base_url)
+        .with_endpoint(valid_endpoint)
+        .with_post()
+        .build()
+    )
+
+    prepared_request = signed_request.prepare()
+    assert isinstance(prepared_request, PreparedRequest)
+
+
+@mock.patch("requests.request", side_effect=mocked_requests_get)
+def test_execute_signed_request(valid_base_url, valid_endpoint):
+    signed_request = (
+        SignedRequest.builder()
+        .with_pem_file(conftest.PEM_FILE_PATH)
+        .with_base_url(valid_base_url)
+        .with_endpoint(valid_endpoint)
+        .with_post()
+        .build()
+    )
+
+    response = signed_request.execute()
+
+    assert response.status_code == 200
+    assert response.text is not None
