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.run_client(self.client.country("1.2.3.10"))
    def test_request(self):
        httpretty.register_uri(
            httpretty.GET,
            self.base_uri + "country/" + "1.2.3.4",
            body=json.dumps(self.country),
            status=200,
            content_type=self._content_type("country"),
        )
        self.run_client(self.client.country("1.2.3.4"))
        request = httpretty.last_request

        self.assertEqual(request.path, "/geoip/v2.1/country/1.2.3.4",
                         "correct URI is used")
        self.assertEqual(request.headers["Accept"], "application/json",
                         "correct Accept header")
        self.assertRegex(
            request.headers["User-Agent"],
            "^GeoIP2-Python-Client/",
            "Correct User-Agent",
        )
        self.assertEqual(
            request.headers["Authorization"],
            "Basic NDI6YWJjZGVmMTIzNDU2",
            "correct auth",
        )
def test_httpretty_should_mock_a_simple_get_with_requests_read():
    """HTTPretty should mock a simple GET with requests.get"""
    httpretty.register_uri(httpretty.GET,
                           "http://yipit.com/",
                           body="Find the best daily deals")

    response = requests.get("http://yipit.com")
    expect(response.text).to.equal("Find the best daily deals")
    expect(httpretty.last_request.method).to.equal("GET")
    expect(httpretty.last_request.path).to.equal("/")
 def test_bad_body_error(self):
     httpretty.register_uri(
         httpretty.GET,
         self.base_uri + "country/" + "1.2.3.9",
         body="bad body",
         status=400,
         content_type=self._content_type("country"),
     )
     with self.assertRaisesRegex(
             HTTPError, "it did not include the expected JSON body"):
         self.run_client(self.client.country("1.2.3.9"))
 def test_no_body_error(self):
     httpretty.register_uri(
         httpretty.GET,
         self.base_uri + "country/" + "1.2.3.7",
         body="",
         status=400,
         content_type=self._content_type("country"),
     )
     with self.assertRaisesRegex(
             HTTPError, "Received a 400 error for .* with no body"):
         self.run_client(self.client.country("1.2.3.7"))
 def test_200_error(self):
     httpretty.register_uri(
         httpretty.GET,
         self.base_uri + "country/1.1.1.1",
         body="",
         status=200,
         content_type=self._content_type("country"),
     )
     with self.assertRaisesRegex(GeoIP2Error,
                                 "could not decode the response as JSON"):
         self.run_client(self.client.country("1.1.1.1"))
 def _test_error(self, status, error_code, error_class):
     msg = "Some error message"
     body = {"error": msg, "code": error_code}
     httpretty.register_uri(
         httpretty.GET,
         self.base_uri + "country/1.2.3.18",
         body=json.dumps(body),
         status=status,
         content_type=self._content_type("country"),
     )
     with self.assertRaisesRegex(error_class, msg):
         self.run_client(self.client.country("1.2.3.18"))
    def test_300_error(self):
        httpretty.register_uri(
            httpretty.GET,
            self.base_uri + "country/" + "1.2.3.11",
            status=300,
            content_type=self._content_type("country"),
        )
        with self.assertRaisesRegex(
                HTTPError,
                r"Received a very surprising HTTP status \(300\) for"):

            self.run_client(self.client.country("1.2.3.11"))
 def test_city_ok(self):
     httpretty.register_uri(
         httpretty.GET,
         self.base_uri + "city/" + "1.2.3.4",
         body=json.dumps(self.country),
         status=200,
         content_type=self._content_type("city"),
     )
     city = self.run_client(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")
 def test_unknown_error(self):
     msg = "Unknown error type"
     ip = "1.2.3.19"
     body = {"error": msg, "code": "UNKNOWN_TYPE"}
     httpretty.register_uri(
         httpretty.GET,
         self.base_uri + "country/" + ip,
         body=json.dumps(body),
         status=400,
         content_type=self._content_type("country"),
     )
     with self.assertRaisesRegex(InvalidRequestError, msg):
         self.run_client(self.client.country(ip))
 def test_weird_body_error(self):
     httpretty.register_uri(
         httpretty.GET,
         self.base_uri + "country/" + "1.2.3.8",
         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.run_client(self.client.country("1.2.3.8"))
 def test_insights_ok(self):
     httpretty.register_uri(
         httpretty.GET,
         self.base_uri + "insights/1.2.3.4",
         body=json.dumps(self.insights),
         status=200,
         content_type=self._content_type("country"),
     )
     insights = self.run_client(self.client.insights("1.2.3.4"))
     self.assertEqual(type(insights), geoip2.models.Insights,
                      "return value of client.insights")
     self.assertEqual(insights.traits.network,
                      ipaddress.ip_network("1.2.3.0/24"), "network")
     self.assertEqual(insights.traits.static_ip_score, 1.3,
                      "static_ip_score is 1.3")
     self.assertEqual(insights.traits.user_count, 2, "user_count is 2")
 def test_me(self):
     httpretty.register_uri(
         httpretty.GET,
         self.base_uri + "country/me",
         body=json.dumps(self.country),
         status=200,
         content_type=self._content_type("country"),
     )
     implicit_me = self.run_client(self.client.country())
     self.assertEqual(type(implicit_me), geoip2.models.Country,
                      "country() returns Country object")
     explicit_me = self.run_client(self.client.country())
     self.assertEqual(
         type(explicit_me),
         geoip2.models.Country,
         "country('me') returns Country object",
     )
 def test_country_ok(self):
     httpretty.register_uri(
         httpretty.GET,
         self.base_uri + "country/1.2.3.4",
         body=json.dumps(self.country),
         status=200,
         content_type=self._content_type("country"),
     )
     country = self.run_client(self.client.country("1.2.3.4"))
     self.assertEqual(type(country), geoip2.models.Country,
                      "return value of client.country")
     self.assertEqual(country.continent.geoname_id, 42,
                      "continent geoname_id is 42")
     self.assertEqual(country.continent.code, "NA", "continent code is NA")
     self.assertEqual(country.continent.name, "North America",
                      "continent name is North America")
     self.assertEqual(country.country.geoname_id, 1,
                      "country geoname_id is 1")
     self.assertIs(
         country.country.is_in_european_union,
         False,
         "country is_in_european_union is False",
     )
     self.assertEqual(country.country.iso_code, "US",
                      "country iso_code is US")
     self.assertEqual(country.country.names,
                      {"en": "United States of America"}, "country names")
     self.assertEqual(
         country.country.name,
         "United States of America",
         "country name is United States of America",
     )
     self.assertEqual(country.maxmind.queries_remaining, 11,
                      "queries_remaining is 11")
     self.assertIs(
         country.registered_country.is_in_european_union,
         True,
         "registered_country is_in_european_union is True",
     )
     self.assertEqual(country.traits.network,
                      ipaddress.ip_network("1.2.3.0/24"), "network")
     self.assertEqual(country.raw, self.country, "raw response is correct")