client put & put_returning_json functions

mahewitt · mahewitt · commit 8d41ffcc1288 · 2021-10-07T13:32:24.000+02:00
diff --git a/README.rst b/README.rst
@@ -10,7 +10,12 @@ Note: This is currently a WIP so will be subject to breaking changes.
 
 Change Log
 ==========
-       
+         
+0.0.7
+-----
+
+- client put & put_returning_json functions
+  
 0.0.6
 -----
 
diff --git a/src/osdu/__init__.py b/src/osdu/__init__.py
@@ -4,4 +4,4 @@
 # license information.
 # -----------------------------------------------------------------------------
 
-__VERSION__ = "0.0.6"
+__VERSION__ = "0.0.7"
diff --git a/src/osdu/client.py b/src/osdu/client.py
@@ -106,6 +106,9 @@ def get(self, url: str) -> requests.Response:
     def get_returning_json(self, url: str, ok_status_codes: list = None) -> dict:
         """Get data from the specified url in json format.
 
+        To be able to do a conversion to json we typically need a valid http response so
+        pass this in ok_status_codes.
+
         Args:
             url (str): url to GET from to
             ok_status_codes (list, optional): Status codes for successful call. Defaults to [200].
@@ -134,8 +137,6 @@ def post(self, url: str, data: Union[str, dict]) -> requests.Response:
             [requests.Response]: response object
         """
         headers = self.get_headers()
-        # logger.debug(url)
-        # logger.debug(data)
 
         # determine whether to send to requests as data or json
         _json = None
@@ -144,14 +145,16 @@ def post(self, url: str, data: Union[str, dict]) -> requests.Response:
             data = None
 
         response = requests.post(url, data=data, json=_json, headers=headers)
-        # logger.debug(response.text)
         return response
 
     def post_returning_json(
         self, url: str, data: Union[str, dict], ok_status_codes: list = None
     ) -> dict:
         """Post data to the specified url and get the result in json format.
 
+        To be able to do a conversion to json we typically need a valid http response so
+        pass this in ok_status_codes.
+
         Args:
             url (str): url to POST to
             data (Union[str, dict]): json data as string or dict to send as the body
@@ -170,21 +173,53 @@ def post_returning_json(
             raise HTTPError(response=response)
         return response.json()
 
-    def put(self, url: str, filepath: str) -> requests.Response:
-        """PUT from the file at the given path to a url
+    def put(self, url: str, data: Union[str, dict]) -> requests.Response:
+        """PUT data to the specified url
 
         Args:
-            url (str): url to PUT to
-            filepath (str): path to a file to PUT
+            url (str): url to POST to
+            data (Union[str, dict]): json data as string or dict to send as the body
 
         Returns:
-            requests.Response: response object
+            [requests.Response]: response object
         """
         headers = self.get_headers()
-        headers.update({"Content-Type": "application/octet-stream", "x-ms-blob-type": "BlockBlob"})
-        with open(filepath, "rb") as file_handle:
-            response = requests.put(url, data=file_handle, headers=headers)
-            return response
+
+        # determine whether to send to requests as data or json
+        _json = None
+        if isinstance(data, dict):
+            _json = data
+            data = None
+
+        response = requests.put(url, data=data, json=_json, headers=headers)
+        # logger.debug(response.text)
+        return response
+
+    def put_returning_json(
+        self, url: str, data: Union[str, dict], ok_status_codes: list = None
+    ) -> dict:
+        """Post data to the specified url and get the result in json format.
+
+        To be able to do a conversion to json we typically need a valid http response so
+        pass this in ok_status_codes.
+
+        Args:
+            url (str): url to POST to
+            data (Union[str, dict]): json data as string or dict to send as the body
+            ok_status_codes (list, optional): Status codes indicating successful call. Defaults to [200].
+
+        Raises:
+            HTTPError: Raised if the get returns a status other than those in ok_status_codes
+
+        Returns:
+            dict: response json
+        """
+        if ok_status_codes is None:
+            ok_status_codes = [200]
+        response = self.put(url, data)
+        if response.status_code not in ok_status_codes:
+            raise HTTPError(response=response)
+        return response.json()
 
     def delete(self, url: str, ok_status_codes: list = None) -> requests.Response:
         """GET to a url
diff --git a/tests/test_client.py b/tests/test_client.py
@@ -10,6 +10,7 @@
 from unittest.case import TestCase
 
 import mock
+import requests
 from mock import patch
 from nose2.tools import params
 from requests.models import HTTPError
@@ -31,6 +32,11 @@ def create_dummy_client(server_url="http://www.test.com"):
 class TestOsduClient(TestCase):
     """Test cases for base OSDU client"""
 
+    dummy_headers = {"headers": "value"}
+    sample_json = {
+        "name": "value",
+    }
+
     def test_init(self):
         """Test the init method"""
         server_url = "http://www.test.com"
@@ -65,6 +71,26 @@ def test_get_headers(self, mock_get_token):  # pylint: disable=W0613
 
         self.assertDictEqual(expected_headers, headers)
 
+    # region test get
+    @params(
+        "http://www.test.com/",
+        "http://www.test.com/test2/",
+    )
+    @patch.object(OsduClient, "get_headers", return_value=dummy_headers)
+    def test_get(self, url, _):
+        """Test valid get returns expected values"""
+        response_mock = mock.Mock()
+        with mock.patch.object(requests, "get", return_value=response_mock) as mock_get:
+            client = create_dummy_client()
+
+            response = client.get(url)
+
+            mock_get.assert_called_once()
+            mock_get.assert_called_with(url, headers=self.dummy_headers)
+            self.assertEqual(response_mock, response)
+
+    # endregion test get
+
     # region test get_returning_json
     @params((None, 200), ([200], 200), ([200, 202], 202), ([202], 202))
     def test_get_returning_json(self, expected_status_codes, actual_status_code):
@@ -104,9 +130,56 @@ def test_get_returning_json_http_error_throws_exception(
 
     # endregion test get_returning_json
 
+    # region test post
+    @params(
+        "string1",
+        "string2",
+    )
+    @patch.object(OsduClient, "get_headers", return_value=dummy_headers)
+    def test_post_string(self, string_data, _):
+        """Test valid post with string returns expected values"""
+        response_mock = mock.Mock()
+        with mock.patch.object(requests, "post", return_value=response_mock) as mock_post:
+            client = create_dummy_client()
+
+            response = client.post("http://www.test.com/", string_data)
+
+            mock_post.assert_called_once()
+            mock_post.assert_called_with(
+                "http://www.test.com/", data=string_data, json=None, headers=self.dummy_headers
+            )
+            self.assertEqual(response_mock, response)
+
+    @params(
+        {"name": "value"},
+        {"name2": "value2"},
+    )
+    @patch.object(OsduClient, "get_headers", return_value=dummy_headers)
+    def test_post_json(self, json, _):
+        """Test valid post with json returns expected values"""
+        response_mock = mock.Mock()
+        with mock.patch.object(requests, "post", return_value=response_mock) as mock_post:
+            client = create_dummy_client()
+
+            response = client.post("http://www.test.com/", json)
+
+            mock_post.assert_called_once()
+            mock_post.assert_called_with(
+                "http://www.test.com/", data=None, json=json, headers=self.dummy_headers
+            )
+            self.assertEqual(response_mock, response)
+
+    # endregion test post
+
     # region test post_returning_json
-    @params((None, 200), ([200], 200), ([200, 202], 202), ([202], 202))
-    def test_post_returning_json(self, expected_status_codes, actual_status_code):
+
+    @params(
+        (None, 200),
+        ([200], 200),
+        ([200, 202], 202),
+        ([202], 202),
+    )
+    def test_post_returning_json_status_codes(self, expected_status_codes, actual_status_code):
         """Test valid post returns expected values"""
         input_data = {
             "name": "value",
@@ -151,6 +224,100 @@ def test_post_returning_json_http_error_throws_exception(
 
     # endregion test post_returning_json
 
+    # region test put
+    @params(
+        "string1",
+        "string2",
+    )
+    @patch.object(OsduClient, "get_headers", return_value=dummy_headers)
+    def test_put_string(self, string_data, _):
+        """Test valid put with string returns expected values"""
+        response_mock = mock.Mock()
+        with mock.patch.object(requests, "put", return_value=response_mock) as mock_put:
+            client = create_dummy_client()
+
+            response = client.put("http://www.test.com/", string_data)
+
+            mock_put.assert_called_once()
+            mock_put.assert_called_with(
+                "http://www.test.com/", data=string_data, json=None, headers=self.dummy_headers
+            )
+            self.assertEqual(response_mock, response)
+
+    @params(
+        {"name": "value"},
+        {"name2": "value2"},
+    )
+    @patch.object(OsduClient, "get_headers", return_value=dummy_headers)
+    def test_put_json(self, json, _):
+        """Test valid put with json returns expected values"""
+        response_mock = mock.Mock()
+        with mock.patch.object(requests, "put", return_value=response_mock) as mock_put:
+            client = create_dummy_client()
+
+            response = client.put("http://www.test.com/", json)
+
+            mock_put.assert_called_once()
+            mock_put.assert_called_with(
+                "http://www.test.com/", data=None, json=json, headers=self.dummy_headers
+            )
+            self.assertEqual(response_mock, response)
+
+    # endregion test put
+
+    # region test put_returning_json
+
+    @params(
+        (None, 200),
+        ([200], 200),
+        ([200, 202], 202),
+        ([202], 202),
+    )
+    def test_put_returning_json_status_codes(self, expected_status_codes, actual_status_code):
+        """Test valid put returns expected values"""
+        input_data = {
+            "name": "value",
+        }
+        expected_response_data = input_data
+        ok_response_mock = mock.Mock()
+        type(ok_response_mock).status_code = mock.PropertyMock(return_value=actual_status_code)
+        ok_response_mock.json.return_value = expected_response_data
+        with mock.patch("osdu.client.OsduClient.put", return_value=ok_response_mock) as mock_get:
+            client = create_dummy_client()
+
+            if expected_status_codes:
+                response = client.put_returning_json(
+                    "http://www.test.com/", input_data, expected_status_codes
+                )
+            else:
+                response = client.put_returning_json("http://www.test.com/", input_data)
+
+            mock_get.assert_called_once()
+            mock_get.assert_called_with("http://www.test.com/", input_data)
+            self.assertDictEqual(expected_response_data, response)
+
+    @params((None, 404), (None, 201), ([200], 404), ([200, 202], 500))
+    def test_put_returning_json_http_error_throws_exception(
+        self, expected_status_codes, actual_status_code
+    ):
+        """Test put error returns expected values"""
+        input_data = {
+            "name": "value",
+        }
+        error_response_mock = mock.MagicMock()
+        type(error_response_mock).status_code = mock.PropertyMock(return_value=actual_status_code)
+        with mock.patch("osdu.client.OsduClient.put", return_value=error_response_mock):
+            with self.assertRaises(HTTPError):
+                client = create_dummy_client()
+                if expected_status_codes:
+                    _ = client.put_returning_json(
+                        "http://www.test.com/", input_data, expected_status_codes
+                    )
+                else:
+                    _ = client.put_returning_json("http://www.test.com/", input_data)
+
+    # endregion test put_returning_json
+
     # region test delete
     @params((None, 200), ([200], 200), ([200, 202], 202), ([202], 202))
     @patch.object(OsduClient, "get_headers", return_value=(None))
