Switch to mocket via httpretty API

Author: oschwald

tests/test_webservice.py

@@ -1,8 +1,12 @@
 import os
 
 import json
-import requests_mock  # type: ignore
 from io import open
+
+# httpretty currently doesn't work, but mocket with the compat interface
+# does.
+from mocket.plugins.httpretty import HTTPretty as httpretty, httprettified  # type: ignore
+
 from minfraud.errors import (
     HTTPError,
     InvalidRequestError,
@@ -31,6 +35,7 @@ def setUp(self):
 
     base_uri = "https://minfraud.maxmind.com/minfraud/v2.0"
 
+    @httprettified
     def test_invalid_auth(self):
         for error in (
             "ACCOUNT_ID_REQUIRED",
@@ -44,23 +49,27 @@ def test_invalid_auth(self):
                     status_code=401,
                 )
 
+    @httprettified
     def test_invalid_request(self):
         with self.assertRaisesRegex(InvalidRequestError, "IP invalid"):
             self.create_error(text='{"code":"IP_ADDRESS_INVALID","error":"IP invalid"}')
 
+    @httprettified
     def test_300_error(self):
         with self.assertRaisesRegex(
             HTTPError, "Received an unexpected HTTP status \(300\) for"
         ):
             self.create_error(status_code=300)
 
+    @httprettified
     def test_permission_required(self):
         with self.assertRaisesRegex(PermissionRequiredError, "permission"):
             self.create_error(
                 text='{"code":"PERMISSION_REQUIRED","error":"permission required"}',
                 status_code=403,
             )
 
+    @httprettified
     def test_400_with_invalid_json(self):
         with self.assertRaisesRegex(
             HTTPError,
@@ -69,16 +78,19 @@ def test_400_with_invalid_json(self):
         ):
             self.create_error(text="{blah}")
 
+    @httprettified
     def test_400_with_no_body(self):
         with self.assertRaisesRegex(HTTPError, "Received a 400 error with no body"):
             self.create_error()
 
+    @httprettified
     def test_400_with_unexpected_content_type(self):
         with self.assertRaisesRegex(
             HTTPError, "Received a 400 with the following body: b?'?plain'?"
         ):
-            self.create_error(headers={"Content-Type": "text/plain"}, text="plain")
+            self.create_error(content_type="text/plain", text="plain")
 
+    @httprettified
     def test_400_without_json_body(self):
         with self.assertRaisesRegex(
             HTTPError,
@@ -87,6 +99,7 @@ def test_400_without_json_body(self):
         ):
             self.create_error(text="plain")
 
+    @httprettified
     def test_400_with_unexpected_json(self):
         with self.assertRaisesRegex(
             HTTPError,
@@ -95,50 +108,55 @@ def test_400_with_unexpected_json(self):
         ):
             self.create_error(text='{"not":"expected"}')
 
+    @httprettified
     def test_500_error(self):
         with self.assertRaisesRegex(HTTPError, "Received a server error \(500\) for"):
             self.create_error(status_code=500)
 
-    @requests_mock.mock()
-    def create_error(self, mock, status_code=400, text="", headers=None):
+    def create_error(self, status_code=400, text="", content_type=None):
         uri = "/".join(
             [self.base_uri, "transactions", "report"]
             if self.type == "report"
             else [self.base_uri, self.type]
         )
-        if headers is None:
-            headers = {
-                "Content-Type": "application/json"
+        if content_type is None:
+            content_type = (
+                "application/json"
                 if self.type == "report"
-                else "application/vnd.maxmind.com-error+json; charset=UTF-8;"
-                " version=2.0"
-            }
-        mock.post(uri, status_code=status_code, text=text, headers=headers)
+                else "application/vnd.maxmind.com-error+json; charset=UTF-8; version=2.0"
+            )
+        httpretty.register_uri(
+            httpretty.POST,
+            uri=uri,
+            status=status_code,
+            body=text,
+            content_type=content_type,
+        )
         return getattr(self.client, self.type)(self.full_request)
 
-    @requests_mock.mock()
-    def create_success(self, mock, text=None, headers=None, client=None, request=None):
+    def create_success(self, text=None, client=None, request=None):
         uri = "/".join(
             [self.base_uri, "transactions", "report"]
             if self.type == "report"
             else [self.base_uri, self.type]
         )
-        params = {
-            "status_code": 204 if self.type == "report" else 200,
-            "text": self.response if text is None else text,
-        }
-        if headers is None:
-            params["headers"] = {
-                "Content-Type": "application/vnd.maxmind.com-minfraud-{0}+json;"
-                " charset=UTF-8; version=2.0".format(self.type)
-            }
-        mock.post(uri, **params)
+        httpretty.register_uri(
+            httpretty.POST,
+            uri=uri,
+            status=204 if self.type == "report" else 200,
+            body=self.response if text is None else text,
+            content_type="application/vnd.maxmind.com-minfraud-{0}+json; charset=UTF-8; version=2.0".format(
+                self.type
+            ),
+        )
         if client is None:
             client = self.client
         if request is None:
             request = self.full_request
+        print(client)
         return getattr(client, self.type)(request)
 
+    @httprettified
     def test_named_constructor_args(self):
         id = "47"
         key = "1234567890ab"
@@ -149,6 +167,7 @@ def test_named_constructor_args(self):
             self.assertEqual(client._account_id, id)
             self.assertEqual(client._license_key, key)
 
+    @httprettified
     def test_missing_constructor_args(self):
         with self.assertRaises(TypeError):
             Client(license_key="1234567890ab")
@@ -161,6 +180,7 @@ class BaseTransactionTest(BaseTest):
     def has_ip_location(self):
         return self.type in ["factors", "insights"]
 
+    @httprettified
     def test_200(self):
         model = self.create_success()
         response = json.loads(self.response)
@@ -170,6 +190,7 @@ def test_200(self):
         if self.has_ip_location():
             self.assertEqual("United Kingdom", model.ip_address.country.name)
 
+    @httprettified
     def test_200_on_request_with_nones(self):
         model = self.create_success(
             request={
@@ -181,6 +202,7 @@ def test_200_on_request_with_nones(self):
         response = self.response
         self.assertEqual(0.01, model.risk_score)
 
+    @httprettified
     def test_200_with_locales(self):
         locales = ("fr",)
         client = Client(42, "abcdef123456", locales=locales)
@@ -193,6 +215,7 @@ 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_no_body(self):
         with self.assertRaisesRegex(
             MinFraudError,
@@ -201,6 +224,7 @@ def test_200_with_no_body(self):
         ):
             self.create_success(text="")
 
+    @httprettified
     def test_200_with_invalid_json(self):
         with self.assertRaisesRegex(
             MinFraudError,
@@ -209,6 +233,7 @@ def test_200_with_invalid_json(self):
         ):
             self.create_success(text="{")
 
+    @httprettified
     def test_insufficient_funds(self):
         with self.assertRaisesRegex(InsufficientFundsError, "out of funds"):
             self.create_error(
@@ -247,9 +272,11 @@ class TestReportTransaction(BaseTest):
     request_file = "full-report-request.json"
     response_file = "report-response.json"
 
+    @httprettified
     def test_204(self):
         self.create_success()
 
+    @httprettified
     def test_204_on_request_with_nones(self):
         self.create_success(
             request={