chore(#82): Consistent Error Presentation

app/api/routes/helpers.py

@@ -11,7 +11,7 @@
 def unauthorized_response():
     message = "The email or password you submitted is incorrect " \
               "or your account is not allowed api access"
-    payload = {'errors': {"unauthorized": {"message": message}}}
+    payload = {'errors': [{"unauthorized": {"message": message}}]}
     return utils.standardize_response(payload=payload, status_code=401)
 
 

app/api/routes/resource_retrieval.py

@@ -74,7 +74,7 @@ def get_resources():
         except Exception as e:
             logger.exception(e)
             message = 'The value for "updated_after" is invalid'
-            res = {"errors": {"unprocessable-entity": {"message": message}}}
+            res = {"errors": [{"unprocessable-entity": {"message": message}}]}
             return utils.standardize_response(payload=res, status_code=422)
 
         q = q.filter(

app/api/validations.py

@@ -10,23 +10,19 @@
 
 def requires_body(func):
     def wrapper(*args, **kwargs):
-        try:
-            # JSON body is {} or []
-            if not request.get_json():
-                return missing_json_error()
-        except Exception as e:
-            # JSON body is completely missing
-            if "Expecting value: line 1 column 1" in str(e):
-                return missing_json_error()
-
+        # JSON body is {} or []
+        # This will throw a 400 if the JSON is malformed
+        # and drop into handlers.bad_request()
+        if not request.get_json():
+            return missing_json_error()
         return func(*args, **kwargs)
     return wrapper
 
 
 def missing_json_error():
     message = "You must provide a valid JSON body to use this endpoint"
     error = {'errors': [{MISSING_BODY: {"message": message}}]}
-    return standardize_response(error, status_code=422)
+    return standardize_response(payload=error, status_code=422)
 
 
 def validate_resource_list(method, rlist):
@@ -38,18 +34,19 @@ def validate_resource_list(method, rlist):
         return {"errors": [{"too-long": {"message": msg}}]}
 
     for i, r in enumerate(rlist):
-        validation = validate_resource(method, r)
-        if validation:
-            validation['index'] = i
-            errors['errors'].append(validation)
+        validation_errors = validate_resource(method, r)
+        if validation_errors:
+            for err in validation_errors:
+                err['index'] = i
+                errors['errors'].append(err)
 
     if bool(errors['errors']):
         return errors
 
 
 def validate_resource(method, json, id=-1):
     errors = None
-    validation_errors = {}
+    validation_errors = []
     missing_params = {"params": []}
     invalid_params = {"params": []}
     required = []
@@ -115,18 +112,20 @@ def validate_resource(method, json, id=-1):
                 f"https://resources.operationcode.org/api/v1/{resource.id}"
 
     if missing_params["params"]:
-        validation_errors[MISSING_PARAMS] = missing_params
+        missing_params_error = {MISSING_PARAMS: missing_params}
         msg = " The following params were missing: "
         msg += ", ".join(missing_params.get("params")) + "."
-        validation_errors[MISSING_PARAMS]["message"] = msg
+        missing_params_error[MISSING_PARAMS]["message"] = msg
+        validation_errors.append(missing_params_error)
         errors = True
 
     if invalid_params["params"]:
-        validation_errors[INVALID_PARAMS] = invalid_params
+        invalid_params_error = {INVALID_PARAMS: invalid_params}
         msg = " The following params were invalid: "
         msg += ", ".join(invalid_params.get("params")) + ". "
         msg += invalid_params.get("message", "")
-        validation_errors[INVALID_PARAMS]["message"] = msg.strip()
+        invalid_params_error[INVALID_PARAMS]["message"] = msg.strip()
+        validation_errors.append(invalid_params_error)
         errors = True
 
     if errors:
@@ -144,6 +143,6 @@ def wrong_type(type_accepted, type_provided):
     }
     json_type = types[type_provided]
     msg = f"Expected {type_accepted}, but found {json_type}"
-    validation_errors = {"errors": {INVALID_TYPE: {"message": msg}}}
+    validation_errors = {"errors": [{INVALID_TYPE: {"message": msg}}]}
 
     return standardize_response(payload=validation_errors, status_code=422)

app/errors/handlers.py

@@ -6,7 +6,7 @@
 # Error Handlers
 @bp.app_errorhandler(400)
 def bad_request(e):
-    errors = {"errors": {"bad-request": {"message": str(e)}}}
+    errors = {"errors": [{"bad-request": {"message": str(e)}}]}
     return standardize_response(payload=errors, status_code=400)
 
 

app/utils.py

@@ -116,13 +116,13 @@ def standardize_response(
         else:
             code = get_error_code_from_status(status_code)
             message = msg_map.get(status_code)
-            resp["errors"] = {}
-            resp["errors"][code] = {"message": message}
+            resp["errors"] = []
+            resp["errors"].append({code: {"message": message}})
 
     elif not data:
         # 500 Error case -- Something went wrong.
         message = msg_map.get(500)
-        resp["errors"] = {"server-error": {"message": message}}
+        resp["errors"] = [{"server-error": {"message": message}}]
         resp["status_code"] = 500
         resp["status"] = err_map.get(500)
     else:

tests/unit/test_routes/helpers.py

@@ -79,23 +79,29 @@ def get_api_key(client):
 
 def assert_correct_response(response, code):
     assert (response.status_code == code)
-    assert (isinstance(response.json.get('errors').get(
-        get_error_code_from_status(response.status_code)), dict))
-    assert (isinstance(response.json.get('errors').get(
-        get_error_code_from_status(response.status_code)).get('message'), str))
+    assert (isinstance(
+                response.json.get('errors')[0].get(
+                    get_error_code_from_status(response.status_code)
+                ),
+                dict))
+    assert (isinstance(
+                response.json.get('errors')[0].get(
+                    get_error_code_from_status(response.status_code)
+                ).get('message'),
+                str))
 
 
 def assert_correct_validation_error(response, params):
     assert (response.status_code == 422)
-    assert (isinstance(response.json.get('errors')
+    assert (isinstance(response.json.get('errors')[0]
             .get(INVALID_PARAMS), dict))
-    assert (isinstance(response.json.get('errors')
+    assert (isinstance(response.json.get('errors')[0]
             .get(INVALID_PARAMS).get('message'), str))
 
     for param in params:
-        assert (param in response.json.get('errors')
+        assert (param in response.json.get('errors')[0]
                 .get(INVALID_PARAMS).get("params"))
-        assert (param in response.json.get('errors')
+        assert (param in response.json.get('errors')[0]
                 .get(INVALID_PARAMS).get("message"))
 
 
@@ -146,4 +152,12 @@ def assert_missing_params_create(response, params, index):
 def assert_wrong_type(response, expected_type):
     assert (response.status_code == 422)
     assert (expected_type in response.get_json()
-            .get("errors").get(INVALID_TYPE).get("message"))
+            .get("errors")[0].get(INVALID_TYPE).get("message"))
+
+
+def assert_bad_request(response):
+    assert (response.status_code == 400)
+    assert (isinstance(response.json.get('errors')[0]
+                       .get('bad-request'), dict))
+    assert (isinstance(response.json.get('errors')[0]
+                       .get('bad-request').get('message'), str))

tests/unit/test_routes/test_invalid_put_post.py

@@ -1,6 +1,6 @@
 from .helpers import (
     create_resource, get_api_key, assert_correct_response,
-    assert_correct_validation_error, assert_missing_body
+    assert_correct_validation_error, assert_missing_body, assert_bad_request
 )
 
 
@@ -97,15 +97,15 @@ def test_validate_resource(module_client, module_db, fake_auth_from_oc):
                           )
     assert_missing_body(response)
 
-    # Data cannot be empty
+    # Data must be valid json
     response = client.put(
         "api/v1/resources/1",
-        data='',
+        data='this is not json',
         content_type='application/json',
         headers={'x-apikey': apikey},
         follow_redirects=True
     )
-    assert_missing_body(response)
+    assert_bad_request(response)
 
 
 def test_create_with_invalid_apikey(module_client, module_db):