Merge pull request #15 from ShipChain/feature/assertion-helper

Pytest assertion fixture

Author: ajhodges

.bandit

@@ -1,3 +1,3 @@
 [bandit]
 targets: src/
-exclude: src/shipchain_common/test_utils.py
+exclude: src/shipchain_common/test_utils/

README.md

@@ -1,2 +1,186 @@
-# python-common
+# Shipchain Common Python Library
+
 A PyPI package containing shared code for ShipChain's Python/Django projects
+
+
+## Pytest Fixtures
+
+When shipchain-common is installed, a pytest plugin named `json_asserter` is automatically registered.  This plugin is
+ designed for writing concise pytest cases that make json_asserter about responses from a Django Rest Framework API. Most 
+ of the functionality is tailored to the `application/vnd.api+json` response type, but should still be usable for
+ plain `application/json` responses.
+ 
+### json_asserter Fixture
+
+The `json_asserter` fixture exposes several methods for testing specific HTTP Status codes as well as a class for
+ building consistent entity references that must be found within the responses.
+ 
+#### Usage with application/vnd.api+json
+
+This is the default when utilizing the `json_asserter`.  If the response does not conform to the 
+[JSON Api standard](https://jsonapi.org/), the assertions will fail.
+ 
+##### Asserting Error Responses
+
+To assert that a given response must have an error status, there are several 400-level response methods.  With the
+ exception of the HTTP_400 method, each of these include the default error message for ease of use.
+ 
+The following will assert that the response status was 403 and that the default error message ("You do not have
+ permission to perform this action") is present.
+ 
+```python
+response = api_client.get(self.detail_url)
+json_asserter.HTTP_403(response)
+```
+ 
+If a different error message should exist, or when checking the error of a 400 response, the specific error may
+ be provided as an argument.
+ 
+```python
+response = api_client.get(self.detail_url)
+json_asserter.HTTP_400(response, error='Specific error message that should be in the respose')
+```
+
+##### Asserting Successful Responses
+
+To assert that a given response must have status 200, call the HTTP_200 method with only the Response object:
+
+```python
+response = api_client.get(self.detail_url)
+json_asserter.HTTP_200(response)
+```
+ 
+While this is valid, it is **very strongly** recommended to include additional details about the data present in the
+ response. There are two ways to provide the data; however only one way can be used at a time in a given invocation.
+ 
+###### Simple Usage
+ 
+For simple responses, the easiest way to specify required data in the responses is by directly specifying the
+ Resource Type `resource`, the Resource Identifier `pk`, as well as any specific Attributes of the resource
+  `attributes`. 
+  
+```python
+response = api_client.get(self.detail_url)
+json_asserter.HTTP_200(response, 
+                    resource='User', 
+                    pk='4b56399d-3155-4fe5-ba4a-9718289a78b7', 
+                    attributes={'username': 'example_user'})
+```
+
+This will throw an assertion if the response is not for the resource type `User` with id 
+`4b56399d-3155-4fe5-ba4a-9718289a78b7` and with _at least_ the attribute username `example_user`.  If the response
+ includes _additional_ attributes that are not listed in the call to the json_asserter method, they are ignored.  The
+ methods check partial objects and do not require that every attribute in the response must be defined in the
+ assertion.
+   
+It is also possible to assert only on the resource type and id without providing attributes.  This is useful if you
+ are testing a response that generates content for the fields that may not be known prior to obtaining the response. 
+ Additionally, providing only the attributes and not the type and id will check only that an object in the response
+ has those attributes, regardless of resource type or id.
+
+###### Advanced Usage
+ 
+For responses where the associated Relationship and any extra Included resources are important, those can be included
+ in the assertion.
+  
+```python
+response = api_client.get(self.detail_url)
+json_asserter.HTTP_200(response,
+                    entity_refs=json_asserter.EntityRef(
+                        resource='User', 
+                        pk='4b56399d-3155-4fe5-ba4a-9718289a78b7', 
+                        attributes={'username': 'example_user'},
+                        relationships={
+                            'manager': json_asserter.EntityRef( 
+                                resource='User', 
+                                pk='88e38305-9775-4b34-95d0-4e935bb7156c')}),
+                    included=json_asserter.EntityRef(
+                        resource='User', 
+                        pk='88e38305-9775-4b34-95d0-4e935bb7156c', 
+                        attributes={'username': 'manager_user'}))
+```
+
+This requires the same original record in the response, but now also requires that there be _at least_ one relationship
+ named `manager` with the associated User and that User must be present (with at least the one attribute) in the
+ `included` property of the response.
+ 
+The above example utilizes the `EntityRef` exposed via the `json_asserter` fixture.  This is a reference to a single
+ entity defined by a combination of: ResourceType, ResourceID, Attributes, and Relationships. When providing the
+ `entity_refs` argument to an assertion, you cannot provide any of the following arguments to the assertion directly:
+ `resource`, `pk`, `attributes`, or `relationships`.
+ 
+When providing `included` json_asserter, you can provide either a single EntityRef or a list of EntityRef instances.  If
+ a list is provided, _all_ referenced entities must be present in the `included` property of the response. As they do
+ for the simple usage above, The same assertion rules apply here regarding providing a combination of `resource`, 
+ `pk`, and `attributes`.
+ 
+The `entity_refs` parameter can be a list of EntityRef instances as well. However, this is only valid for List
+ responses.  If a list of entity_refs is provided for a non-list response, an assertion will occur.  To assert that a
+ response is a list, the parameter `is_list=True` must be provided. You can provide either a single EntityRef or a
+ list of EntityRef instances.  If a list is provided, _all_ referenced entities must be present in the list of
+ returned data.
+
+#### Usage with application/json
+
+Support is included for making assertions on plain JSON responses with `json_asserter`. To ignore the JSON API specific 
+ assertions, you must provide the `vnd=False` parameter.  Only the `attributes` parameter is valid as there are no
+ relationships or included properties in a plain json response.
+ 
+Given this response:
+
+```json
+{
+    "id": "07b374c3-ed9b-4811-901a-d0c5d746f16a",
+    "name": "example 1",
+    "field_1": 1,
+    "owner": {
+        "username": "user1"
+    }
+}
+```
+
+Asserting the top level attributes as well as nested attributes is possible using the following call:
+
+```python
+response = api_client.get(self.detail_url)
+json_asserter.HTTP_200(response, 
+                    vnd=False,
+                    attributes={
+                        'id': '07b374c3-ed9b-4811-901a-d0c5d746f16a',
+                        'owner': {
+                            'username': 'user1'
+                        }
+                    })
+```
+
+For a list response:
+
+```json
+[{
+    "username": "user1",
+    "is_active": False
+},
+{
+    "username": "user2",
+    "is_active": False
+},
+{
+    "username": "user3",
+    "is_active": False
+}]
+```
+
+It is possible to assert that one or many sets of attributes exist in the response:
+```python
+response = api_client.get(self.detail_url)
+json_asserter.HTTP_200(response, 
+                    vnd=False,
+                    is_list=True,
+                    attributes=[{
+                        "username": "user1",
+                        "is_active": False
+                    }, {
+                        "username": "user3",
+                        "is_active": False
+                    }])
+```

pyproject.toml

@@ -43,3 +43,6 @@ pytest-cov = "^2.6"
 pytest-django = "^3.6"
 pytest-mock = "^1.10"
 safety = "^1.8"
+
+[tool.poetry.plugins."pytest11"]
+"json_asserter" = "shipchain_common.test_utils.json_asserter"

src/shipchain_common/renderers.py

@@ -21,6 +21,11 @@ def _get_resource_name(context, expand_polymorphic_types=False):
         if original_view_resource_name:
             raise AttributeError
 
+        # If view is not a ConfigurableGenericViewSet, don't try to get configurable serializer
+        from .viewsets import ConfigurableGenericViewSet
+        if not isinstance(view, ConfigurableGenericViewSet):
+            raise AttributeError
+
         serializer = view.get_serializer_class(
             serialization_type=SerializationType.RESPONSE if is_response else SerializationType.REQUEST)
 

src/shipchain_common/test_utils/__init__.py

@@ -0,0 +1,42 @@
+# flake8: noqa
+"""
+Copyright 2019 ShipChain, Inc.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+"""
+
+from .json_asserter import \
+    json_asserter, \
+    AssertionHelper
+
+from .helpers import\
+    create_form_content, \
+    datetimeAlmostEqual, \
+    get_jwt, \
+    generate_vnd_json, \
+    random_location,\
+    random_timestamp, \
+    replace_variables_in_string, \
+    GeoCoderResponse
+
+from .mocked_rpc_responses import \
+    mocked_rpc_response, \
+    mocked_wallet_error_creation,\
+    mocked_wallet_invalid_creation, \
+    mocked_wallet_valid_creation, \
+    second_mocked_wallet_valid_creation,\
+    invalid_eth_amount, \
+    invalid_ship_amount, \
+    valid_eth_amount
+
+from ..utils import validate_uuid4  # Imported for backwards compatibility usage of `from shipchain_common.test_utils`

src/shipchain_common/test_utils.py renamed to src/shipchain_common/test_utils/helpers.py

@@ -18,17 +18,13 @@
 import re
 import random
 from datetime import datetime, timedelta
-from unittest.mock import Mock
 from uuid import uuid4
 
 import jwt
 from django.conf import settings
 from django.test.client import encode_multipart
-from requests.models import Response
 from rest_framework_simplejwt.utils import aware_utcnow, datetime_to_epoch
 
-from .utils import validate_uuid4  # Imported for backwards compatibility usage of `from shipchain_common.test_utils`...
-
 
 def create_form_content(data):
     boundary_string = 'BoUnDaRyStRiNg'
@@ -91,77 +87,6 @@ def generate_vnd_json(attributes, object_type, object_id=None):
     return data
 
 
-def mocked_rpc_response(json, content=None, code=200):
-    response = Mock(spec=Response)
-    response.status_code = code
-    response.content = content
-    response.json.return_value = json
-    return response
-
-
-def invalid_eth_amount():
-    return mocked_rpc_response({
-        "jsonrpc": "2.0",
-        "result": {
-            "success": True,
-            "ether": "1000000",
-            "ship": "1000000000000000000"
-        },
-        "id": 0
-    })
-
-
-def invalid_ship_amount():
-    return mocked_rpc_response({
-        "jsonrpc": "2.0",
-        "result": {
-            "success": True,
-            "ether": "1000000000000000000",
-            "ship": "1000000"
-        },
-        "id": 0
-    })
-
-
-def mocked_wallet_valid_creation():
-    return mocked_rpc_response({
-        "jsonrpc": "2.0",
-        "result": {
-            "success": True,
-            "wallet": {
-                "id": "d5563423-f040-4e0d-8d87-5e941c748d91",
-                "public_key": "a07d45389b1a3b40c6784f749a1d616b4c6f0dba195c0348aef81e9b4c8a7f5c13c0d9b8c360cd2307683a2"
-                              "d8f20bd7d801c7a11f4681440f11372f2de465942",
-                "address": "0x94Fad76b5Be2b746598BCe12e7b45D7C06D8DA1F"
-            }
-        },
-        "id": 0
-    })
-
-
-def mocked_wallet_invalid_creation():
-    return mocked_rpc_response({
-        "jsonrpc": "2.0",
-        "result": {
-            "success": True,
-            "wallet": {
-                "public_key": "a07d45389b1a3b40c6784f749a1d616b4c6f0dba195c0348aef81e9b4c8a7f5c13c0d9b8c360cd2307683a2"
-                              "d8f20bd7d801c7a11f4681440f11372f2de465942",
-                "address": "0x94Fad76b5Be2b746598BCe12e7b45D7C06D8DA1F"
-            }
-        },
-        "id": 0
-    })
-
-
-def mocked_wallet_error_creation():
-    return mocked_rpc_response({
-        "jsonrpc": "2.0",
-        "result": {},
-        "id": 0
-    })
-
-
 def random_location():
     """
     :return: Randomly generated location geo point.
@@ -202,34 +127,6 @@ def replace_variables_in_string(string, parameters):
     return string
 
 
-def second_mocked_wallet_valid_creation():
-    return mocked_rpc_response({
-        "jsonrpc": "2.0",
-        "result": {
-            "success": True,
-            "wallet": {
-                "id": "256e621b-2d42-4bf2-ac76-27336d4bf770",
-                "public_key": "234111c81a928562e114b9b137dac3c36d7fac5fb6551042608a69c4838335646a641059995510793d9be5f"
-                              "c9ea4dd0c5180aafff831462319b3c6878812f987",
-                "address": "0x3fB9Ff55672084f3A34E4C77dACF5f3a8D71037a"
-            }
-        },
-        "id": 0
-    })
-
-
-def valid_eth_amount():
-    return mocked_rpc_response({
-        "jsonrpc": "2.0",
-        "result": {
-            "success": True,
-            "ether": "1000000000000000000",
-            "ship": "1000000000000000000"
-        },
-        "id": 0
-    })
-
-
 class GeoCoderResponse:
     def __init__(self, status, point=None):
         self.ok = status