update check using decorator (#44)

src/main/python/covata/delta/apiclient.py

@@ -95,6 +95,10 @@ def get_identity(self, requestor_id, identity_id):
         identity = response.json()
         return identity
 
+    @utils.check_arguments(
+        "page, page_size", [int, None],
+        lambda x: x > 0 if isinstance(x, int) else True,
+        "must be a non-zero positive integer")
     def get_identities_by_metadata(self, requestor_id, metadata,
                                    page=None, page_size=None):
         """
@@ -111,19 +115,12 @@ def get_identities_by_metadata(self, requestor_id, metadata,
         :return: a list of identities satisfying the request
         :rtype: list[dict[str, any]]
         """
-        if page is not None and not int(page) > 0:
-            raise ValueError("page must be an integer greater than zero")
-        if page_size is not None and not int(page_size) > 0:
-            raise ValueError("page size must be an integer greater than zero")
-
-        page_ = int(page) if page else None
-        page_size_ = int(page_size) if page_size else None
         metadata_ = dict(("metadata." + k, v) for k, v in metadata.items())
         response = requests.get(
             url="{base_url}{resource}".format(
                 base_url=self.DELTA_URL,
                 resource=self.RESOURCE_IDENTITIES),
-            params=dict(metadata_, page=page_, pageSize=page_size_),
+            params=dict(metadata_, page=page, pageSize=page_size),
             auth=self.signer(requestor_id))
         response.raise_for_status()
         return response.json()

src/main/python/covata/delta/utils.py

@@ -15,8 +15,6 @@
 import logging
 import inspect
 
-__all__ = ["LogMixin", "caller"]
-
 
 class LogMixin:
     @property
@@ -44,3 +42,25 @@ def caller():
         if 'self' in caller_frame.f_locals else None])
     del caller_frame
     return ".".join(name)
+
+
+def check_arguments(arguments, test_type, test_function, fail_message):
+    def decorator(function):
+        def _f(*args, **kwargs):
+            for arg, value in kwargs.items():
+                if arg in arguments:
+                    if not any(value is t or isinstance(value, t)
+                               for t in test_type):
+                        raise TypeError(
+                            "{arg} must be in {type}, actual {actual}".format(
+                                arg=arg,
+                                type=test_type,
+                                actual=type(value).__name__))
+                    if not test_function(value):
+                        raise ValueError("{arg}:{msg} actual:{value}".format(
+                            arg=arg,
+                            msg=fail_message,
+                            value=value))
+            return function(*args, **kwargs)
+        return _f
+    return decorator

src/test/python/test_apiclient.py

@@ -326,8 +326,8 @@ def test_get_secret_content(api_client, mock_signer):
 
 
 @responses.activate
-@pytest.mark.parametrize("page", [1, 1.0, "1"])
-@pytest.mark.parametrize("page_size", [1, 2.0, "3"])
+@pytest.mark.parametrize("page", [1, 3, None])
+@pytest.mark.parametrize("page_size", [1, 3, None])
 def test_get_identities_by_metadata_with_valid_page_parameters(
         api_client, mock_signer, page, page_size):
     requestor_id = "requestor_id"
@@ -355,30 +355,38 @@ def test_get_identities_by_metadata_with_valid_page_parameters(
     url = urllib.parse.urlparse(responses.calls[0].request.url)
     query_params = dict(urllib.parse.parse_qsl(url.query))
     expected_query_params = {
-        "metadata.name": "test123",
-        "page": str(int(page)),
-        "pageSize": str(int(page_size))
+        "metadata.name": "test123"
     }
+
+    if page is not None:
+        expected_query_params["page"] = str(page)
+
+    if page_size is not None:
+        expected_query_params["pageSize"] = str(page_size)
+
     assert query_params == expected_query_params
 
 
-@pytest.mark.parametrize("page, page_size", [
-    (0, 3),
-    (-1.0, 1.0),
-    ("1", "-30")
+@pytest.mark.parametrize("page, page_size, exception", [
+    (0, 3, ValueError),
+    (1, 0, ValueError),
+    (-1, 10, ValueError),
+    (10, -1, ValueError),
+    (1.0, -1, TypeError),
+    (1, 1.0, TypeError),
+    ("3", 7.0, TypeError),
+    ("1", 3, TypeError)
 ])
 def test_get_identities_by_metadata_with_invalid_page_parameters(
-        api_client, mock_signer, page, page_size):
+        api_client, mock_signer, page, page_size, exception):
     requestor_id = "requestor_id"
-    with pytest.raises(ValueError) as excinfo:
+    with pytest.raises(exception):
         api_client.get_identities_by_metadata(
             requestor_id=requestor_id,
             metadata=dict(name="test123"),
             page=page,
             page_size=page_size)
     mock_signer.assert_not_called()
-    assert "must be an integer greater than zero" in str(excinfo.value)
-
 
 def test_construct_signer(mocker, api_client, key_store, private_key):
     get_private_signing_key = mocker.patch.object(