Switch _back_ to httpretty

This basically reverts #24. httpretty seems well maintained these days
and it makes it easy to switch out the HTTP client libraries without
changing the tests.

Author: oschwald

.travis.yml

@@ -26,7 +26,7 @@ before_install:
   - "if [[ $RUN_SNYK && $SNYK_TOKEN ]]; then sudo apt-get install -y nodejs; npm install -g snyk; fi"
 install:
   - pip install -r requirements.txt
-  - pip install requests_mock coveralls
+  - pip install httpretty coveralls
   - |
     if [[ $RUN_LINTER ]]; then
       pip install --upgrade pylint black mypy

setup.py

@@ -26,7 +26,7 @@
     include_package_data=True,
     python_requires=">=3.6",
     install_requires=requirements,
-    tests_require=["requests_mock>=0.5"],
+    tests_require=["httpretty>=1.0.0"],
     test_suite="tests",
     license=geoip2.__license__,
     classifiers=[

tests/webservice_test.py

@@ -3,14 +3,15 @@
 
 import copy
 import ipaddress
+import json
 import sys
 from typing import cast, Dict
 import unittest
 
 sys.path.append("..")
 
+import httpretty  # type: ignore
 import geoip2
-import requests_mock  # type: ignore
 from geoip2.errors import (
     AddressNotFoundError,
     AuthenticationError,
@@ -23,6 +24,7 @@
 from geoip2.webservice import Client
 
 
+@httpretty.activate
 class TestClient(unittest.TestCase):
     def setUp(self):
         self.client = Client(42, "abcdef123456")
@@ -58,13 +60,13 @@ def _content_type(self, endpoint):
             + "+json; charset=UTF-8; version=1.0"
         )
 
-    @requests_mock.mock()
-    def test_country_ok(self, mock):
-        mock.get(
+    def test_country_ok(self):
+        httpretty.register_uri(
+            httpretty.GET,
             self.base_uri + "country/1.2.3.4",
-            json=self.country,
-            status_code=200,
-            headers={"Content-Type": self._content_type("country")},
+            body=json.dumps(self.country),
+            status=200,
+            content_type=self._content_type("country"),
         )
         country = self.client.country("1.2.3.4")
         self.assertEqual(
@@ -103,13 +105,13 @@ def test_country_ok(self, mock):
         )
         self.assertEqual(country.raw, self.country, "raw response is correct")
 
-    @requests_mock.mock()
-    def test_me(self, mock):
-        mock.get(
+    def test_me(self):
+        httpretty.register_uri(
+            httpretty.GET,
             self.base_uri + "country/me",
-            json=self.country,
-            status_code=200,
-            headers={"Content-Type": self._content_type("country")},
+            body=json.dumps(self.country),
+            status=200,
+            content_type=self._content_type("country"),
         )
         implicit_me = self.client.country()
         self.assertEqual(
@@ -122,12 +124,13 @@ def test_me(self, mock):
             "country('me') returns Country object",
         )
 
-    @requests_mock.mock()
-    def test_200_error(self, mock):
-        mock.get(
+    def test_200_error(self):
+        httpretty.register_uri(
+            httpretty.GET,
             self.base_uri + "country/1.1.1.1",
-            status_code=200,
-            headers={"Content-Type": self._content_type("country")},
+            body="",
+            status=200,
+            content_type=self._content_type("country"),
         )
         with self.assertRaisesRegex(
             GeoIP2Error, "could not decode the response as JSON"
@@ -140,145 +143,136 @@ def test_bad_ip_address(self):
         ):
             self.client.country("1.2.3")
 
-    @requests_mock.mock()
-    def test_no_body_error(self, mock):
-        mock.get(
+    def test_no_body_error(self):
+        httpretty.register_uri(
+            httpretty.GET,
             self.base_uri + "country/" + "1.2.3.7",
-            text="",
-            status_code=400,
-            headers={"Content-Type": self._content_type("country")},
+            body="",
+            status=400,
+            content_type=self._content_type("country"),
         )
         with self.assertRaisesRegex(
             HTTPError, "Received a 400 error for .* with no body"
         ):
             self.client.country("1.2.3.7")
 
-    @requests_mock.mock()
-    def test_weird_body_error(self, mock):
-        mock.get(
+    def test_weird_body_error(self):
+        httpretty.register_uri(
+            httpretty.GET,
             self.base_uri + "country/" + "1.2.3.8",
-            text='{"wierd": 42}',
-            status_code=400,
-            headers={"Content-Type": self._content_type("country")},
+            body='{"wierd": 42}',
+            status=400,
+            content_type=self._content_type("country"),
         )
         with self.assertRaisesRegex(
             HTTPError,
             "Response contains JSON but it does not " "specify code or error keys",
         ):
             self.client.country("1.2.3.8")
 
-    @requests_mock.mock()
-    def test_bad_body_error(self, mock):
-        mock.get(
+    def test_bad_body_error(self):
+        httpretty.register_uri(
+            httpretty.GET,
             self.base_uri + "country/" + "1.2.3.9",
-            text="bad body",
-            status_code=400,
-            headers={"Content-Type": self._content_type("country")},
+            body="bad body",
+            status=400,
+            content_type=self._content_type("country"),
         )
         with self.assertRaisesRegex(
             HTTPError, "it did not include the expected JSON body"
         ):
             self.client.country("1.2.3.9")
 
-    @requests_mock.mock()
-    def test_500_error(self, mock):
-        mock.get(self.base_uri + "country/" + "1.2.3.10", status_code=500)
+    def test_500_error(self):
+        httpretty.register_uri(
+            httpretty.GET, self.base_uri + "country/" + "1.2.3.10", status=500
+        )
         with self.assertRaisesRegex(HTTPError, r"Received a server error \(500\) for"):
             self.client.country("1.2.3.10")
 
-    @requests_mock.mock()
-    def test_300_error(self, mock):
-        mock.get(
+    def test_300_error(self):
+        httpretty.register_uri(
+            httpretty.GET,
             self.base_uri + "country/" + "1.2.3.11",
-            status_code=300,
-            headers={"Content-Type": self._content_type("country")},
+            status=300,
+            content_type=self._content_type("country"),
         )
         with self.assertRaisesRegex(
             HTTPError, r"Received a very surprising HTTP status \(300\) for"
         ):
 
             self.client.country("1.2.3.11")
 
-    @requests_mock.mock()
-    def test_ip_address_required(self, mock):
-        self._test_error(mock, 400, "IP_ADDRESS_REQUIRED", InvalidRequestError)
+    def test_ip_address_required(self):
+        self._test_error(400, "IP_ADDRESS_REQUIRED", InvalidRequestError)
 
-    @requests_mock.mock()
-    def test_ip_address_not_found(self, mock):
-        self._test_error(mock, 404, "IP_ADDRESS_NOT_FOUND", AddressNotFoundError)
+    def test_ip_address_not_found(self):
+        self._test_error(404, "IP_ADDRESS_NOT_FOUND", AddressNotFoundError)
 
-    @requests_mock.mock()
-    def test_ip_address_reserved(self, mock):
-        self._test_error(mock, 400, "IP_ADDRESS_RESERVED", AddressNotFoundError)
+    def test_ip_address_reserved(self):
+        self._test_error(400, "IP_ADDRESS_RESERVED", AddressNotFoundError)
 
-    @requests_mock.mock()
-    def test_permission_required(self, mock):
-        self._test_error(mock, 403, "PERMISSION_REQUIRED", PermissionRequiredError)
+    def test_permission_required(self):
+        self._test_error(403, "PERMISSION_REQUIRED", PermissionRequiredError)
 
-    @requests_mock.mock()
-    def test_auth_invalid(self, mock):
-        self._test_error(mock, 400, "AUTHORIZATION_INVALID", AuthenticationError)
+    def test_auth_invalid(self):
+        self._test_error(400, "AUTHORIZATION_INVALID", AuthenticationError)
 
-    @requests_mock.mock()
-    def test_license_key_required(self, mock):
-        self._test_error(mock, 401, "LICENSE_KEY_REQUIRED", AuthenticationError)
+    def test_license_key_required(self):
+        self._test_error(401, "LICENSE_KEY_REQUIRED", AuthenticationError)
 
-    @requests_mock.mock()
-    def test_account_id_required(self, mock):
-        self._test_error(mock, 401, "ACCOUNT_ID_REQUIRED", AuthenticationError)
+    def test_account_id_required(self):
+        self._test_error(401, "ACCOUNT_ID_REQUIRED", AuthenticationError)
 
-    @requests_mock.mock()
-    def test_user_id_required(self, mock):
-        self._test_error(mock, 401, "USER_ID_REQUIRED", AuthenticationError)
+    def test_user_id_required(self):
+        self._test_error(401, "USER_ID_REQUIRED", AuthenticationError)
 
-    @requests_mock.mock()
-    def test_account_id_unkown(self, mock):
-        self._test_error(mock, 401, "ACCOUNT_ID_UNKNOWN", AuthenticationError)
+    def test_account_id_unkown(self):
+        self._test_error(401, "ACCOUNT_ID_UNKNOWN", AuthenticationError)
 
-    @requests_mock.mock()
-    def test_user_id_unkown(self, mock):
-        self._test_error(mock, 401, "USER_ID_UNKNOWN", AuthenticationError)
+    def test_user_id_unkown(self):
+        self._test_error(401, "USER_ID_UNKNOWN", AuthenticationError)
 
-    @requests_mock.mock()
-    def test_out_of_queries_error(self, mock):
-        self._test_error(mock, 402, "OUT_OF_QUERIES", OutOfQueriesError)
+    def test_out_of_queries_error(self):
+        self._test_error(402, "OUT_OF_QUERIES", OutOfQueriesError)
 
-    def _test_error(self, mock, status, error_code, error_class):
+    def _test_error(self, status, error_code, error_class):
         msg = "Some error message"
         body = {"error": msg, "code": error_code}
-        mock.get(
+        httpretty.register_uri(
+            httpretty.GET,
             self.base_uri + "country/1.2.3.18",
-            json=body,
-            status_code=status,
-            headers={"Content-Type": self._content_type("country")},
+            body=json.dumps(body),
+            status=status,
+            content_type=self._content_type("country"),
         )
         with self.assertRaisesRegex(error_class, msg):
             self.client.country("1.2.3.18")
 
-    @requests_mock.mock()
-    def test_unknown_error(self, mock):
+    def test_unknown_error(self):
         msg = "Unknown error type"
         ip = "1.2.3.19"
         body = {"error": msg, "code": "UNKNOWN_TYPE"}
-        mock.get(
+        httpretty.register_uri(
+            httpretty.GET,
             self.base_uri + "country/" + ip,
-            json=body,
-            status_code=400,
-            headers={"Content-Type": self._content_type("country")},
+            body=json.dumps(body),
+            status=400,
+            content_type=self._content_type("country"),
         )
         with self.assertRaisesRegex(InvalidRequestError, msg):
             self.client.country(ip)
 
-    @requests_mock.mock()
-    def test_request(self, mock):
-        mock.get(
+    def test_request(self):
+        httpretty.register_uri(
+            httpretty.GET,
             self.base_uri + "country/" + "1.2.3.4",
-            json=self.country,
-            status_code=200,
-            headers={"Content-Type": self._content_type("country")},
+            body=json.dumps(self.country),
+            status=200,
+            content_type=self._content_type("country"),
         )
         self.client.country("1.2.3.4")
-        request = mock.request_history[-1]
+        request = httpretty.latest_requests()[-1]
 
         self.assertEqual(
             request.path, "/geoip/v2.1/country/1.2.3.4", "correct URI is used"
@@ -297,27 +291,27 @@ def test_request(self, mock):
             "correct auth",
         )
 
-    @requests_mock.mock()
-    def test_city_ok(self, mock):
-        mock.get(
+    def test_city_ok(self):
+        httpretty.register_uri(
+            httpretty.GET,
             self.base_uri + "city/" + "1.2.3.4",
-            json=self.country,
-            status_code=200,
-            headers={"Content-Type": self._content_type("city")},
+            body=json.dumps(self.country),
+            status=200,
+            content_type=self._content_type("city"),
         )
         city = self.client.city("1.2.3.4")
         self.assertEqual(type(city), geoip2.models.City, "return value of client.city")
         self.assertEqual(
             city.traits.network, ipaddress.ip_network("1.2.3.0/24"), "network"
         )
 
-    @requests_mock.mock()
-    def test_insights_ok(self, mock):
-        mock.get(
+    def test_insights_ok(self):
+        httpretty.register_uri(
+            httpretty.GET,
             self.base_uri + "insights/1.2.3.4",
-            json=self.insights,
-            status_code=200,
-            headers={"Content-Type": self._content_type("country")},
+            body=json.dumps(self.insights),
+            status=200,
+            content_type=self._content_type("country"),
         )
         insights = self.client.insights("1.2.3.4")
         self.assertEqual(