Merge pull request #79 from maxmind/greg/wrong-body-fix

Test #78 and prepare for release

Author: horgh

HISTORY.rst

@@ -3,6 +3,14 @@
 History
 -------
 
+2.3.1 (2021-02-12)
+++++++++++++++++++
+
+* In 2.2.0 and 2.3.0, a ``KeyError`` would be thrown if the response from the
+  web service did not have the ``ip_address`` key but did contain the text
+  "ip_address" in the JSON body. Reported and fixed by Justas-iDenfy. GitHub
+  #78.
+
 2.3.0 (2021-02-02)
 ++++++++++++++++++
 

minfraud/webservice.py

@@ -65,25 +65,25 @@ def __init__(
 
     def _handle_success(
         self,
-        body: str,
+        raw_body: str,
         uri: str,
         model_class: Union[Type[Factors], Type[Score], Type[Insights]],
     ) -> Union[Score, Factors, Insights]:
         """Handle successful response."""
         try:
-            decoded_body = json.loads(body)
+            decoded_body = json.loads(raw_body)
         except ValueError as ex:
             raise MinFraudError(
-                f"Received a 200 response but could not decode the response as JSON: {body}",
+                f"Received a 200 response but could not decode the response as JSON: {raw_body}",
                 200,
                 uri,
             ) from ex
-        if "ip_address" in body:
+        if "ip_address" in decoded_body:
             decoded_body["ip_address"]["_locales"] = self._locales
         return model_class(decoded_body)  # type: ignore
 
     def _exception_for_error(
-        self, status: int, content_type: str, body: str, uri: str
+        self, status: int, content_type: str, raw_body: str, uri: str
     ) -> Union[
         AuthenticationError,
         InsufficientFundsError,
@@ -94,13 +94,13 @@ def _exception_for_error(
         """Returns the exception for the error responses."""
 
         if 400 <= status < 500:
-            return self._exception_for_4xx_status(status, content_type, body, uri)
+            return self._exception_for_4xx_status(status, content_type, raw_body, uri)
         if 500 <= status < 600:
-            return self._exception_for_5xx_status(status, body, uri)
-        return self._exception_for_unexpected_status(status, body, uri)
+            return self._exception_for_5xx_status(status, raw_body, uri)
+        return self._exception_for_unexpected_status(status, raw_body, uri)
 
     def _exception_for_4xx_status(
-        self, status: int, content_type: str, body: str, uri: str
+        self, status: int, content_type: str, raw_body: str, uri: str
     ) -> Union[
         AuthenticationError,
         InsufficientFundsError,
@@ -109,36 +109,38 @@ def _exception_for_4xx_status(
         PermissionRequiredError,
     ]:
         """Returns exception for error responses with 4xx status codes."""
-        if not body:
+        if not raw_body:
             return HTTPError(
-                f"Received a {status} error with no body", status, uri, body
+                f"Received a {status} error with no body", status, uri, raw_body
             )
         if content_type.find("json") == -1:
             return HTTPError(
-                f"Received a {status} with the following body: {body}",
+                f"Received a {status} with the following body: {raw_body}",
                 status,
                 uri,
-                body,
+                raw_body,
             )
         try:
-            decoded_body = json.loads(body)
+            decoded_body = json.loads(raw_body)
         except ValueError:
             return HTTPError(
-                f"Received a {status} error but it did not include the expected JSON body: {body}",
+                f"Received a {status} error but it did not "
+                + f"include the expected JSON body: {raw_body}",
                 status,
                 uri,
-                body,
+                raw_body,
             )
         else:
             if "code" in decoded_body and "error" in decoded_body:
                 return self._exception_for_web_service_error(
                     decoded_body.get("error"), decoded_body.get("code"), status, uri
                 )
             return HTTPError(
-                f"Error response contains JSON but it does not specify code or error keys: {body}",
+                "Error response contains JSON but it does not "
+                + f"specify code or error keys: {raw_body}",
                 status,
                 uri,
-                body,
+                raw_body,
             )
 
     @staticmethod
@@ -168,29 +170,29 @@ def _exception_for_web_service_error(
     @staticmethod
     def _exception_for_5xx_status(
         status: int,
-        body: Optional[str],
+        raw_body: Optional[str],
         uri: str,
     ) -> HTTPError:
         """Returns exception for error response with 5xx status codes."""
         return HTTPError(
             f"Received a server error ({status}) for {uri}",
             status,
             uri,
-            body,
+            raw_body,
         )
 
     @staticmethod
     def _exception_for_unexpected_status(
         status: int,
-        body: Optional[str],
+        raw_body: Optional[str],
         uri: str,
     ) -> HTTPError:
         """Returns exception for responses with unexpected status codes."""
         return HTTPError(
             f"Received an unexpected HTTP status ({status}) for {uri}",
             status,
             uri,
-            body,
+            raw_body,
         )
 
 
@@ -374,10 +376,10 @@ async def report(
         async with await self._do_request(uri, prepared_request) as response:
             status = response.status
             content_type = response.content_type
-            body = await response.text()
+            raw_body = await response.text()
 
             if status != 204:
-                raise self._exception_for_error(status, content_type, body, uri)
+                raise self._exception_for_error(status, content_type, raw_body, uri)
 
     async def _response_for(
         self,
@@ -392,11 +394,11 @@ async def _response_for(
         async with await self._do_request(uri, prepared_request) as response:
             status = response.status
             content_type = response.content_type
-            body = await response.text()
+            raw_body = await response.text()
 
             if status != 200:
-                raise self._exception_for_error(status, content_type, body, uri)
-            return self._handle_success(body, uri, model_class)
+                raise self._exception_for_error(status, content_type, raw_body, uri)
+            return self._handle_success(raw_body, uri, model_class)
 
     async def _do_request(
         self, uri: str, data: Dict[str, Any]
@@ -617,9 +619,9 @@ def report(self, report: Dict[str, Optional[str]], validate: bool = True) -> Non
         response = self._do_request(uri, prepared_request)
         status = response.status_code
         content_type = response.headers["Content-Type"]
-        body = response.text
+        raw_body = response.text
         if status != 204:
-            raise self._exception_for_error(status, content_type, body, uri)
+            raise self._exception_for_error(status, content_type, raw_body, uri)
 
     def _response_for(
         self,
@@ -635,10 +637,10 @@ def _response_for(
         response = self._do_request(uri, prepared_request)
         status = response.status_code
         content_type = response.headers["Content-Type"]
-        body = response.text
+        raw_body = response.text
         if status != 200:
-            raise self._exception_for_error(status, content_type, body, uri)
-        return self._handle_success(body, uri, model_class)
+            raise self._exception_for_error(status, content_type, raw_body, uri)
+        return self._handle_success(raw_body, uri, model_class)
 
     def _do_request(self, uri: str, data: Dict[str, Any]) -> Response:
         return self._session.post(

tests/test_webservice.py

@@ -239,6 +239,7 @@ def test_200_with_email_hashing(self):
             json.loads(httpretty.last_request.body),
         )
 
+    # This was fixed in https://github.com/maxmind/minfraud-api-python/pull/78
     @httprettified
     def test_200_with_locales(self):
         locales = ("fr",)
@@ -252,6 +253,27 @@ def test_200_with_locales(self):
             self.assertEqual("Royaume-Uni", model.ip_address.country.name)
             self.assertEqual("Londres", model.ip_address.city.name)
 
+    @httprettified
+    def test_200_with_reserved_ip_warning(self):
+        model = self.create_success(
+            """
+                {
+                    "risk_score": 12,
+                    "id": "0e52f5ac-7690-4780-a939-173cb13ecd75",
+                    "warnings": [
+                        {
+                            "code": "IP_ADDRESS_RESERVED",
+                            "warning":
+                                "The IP address supplied is in a reserved network.",
+                            "input_pointer": "/device/ip_address"
+                        }
+                    ]
+                }
+            """
+        )
+
+        self.assertEqual(12, model.risk_score)
+
     @httprettified
     def test_200_with_no_body(self):
         with self.assertRaisesRegex(