From 13638405ed5c3525218b86ab0ec956dfcc23daf1 Mon Sep 17 00:00:00 2001
From: Sam Harrison <sharrison@twilio.com>
Date: Thu, 20 Aug 2020 15:32:16 -0500
Subject: [PATCH] fix: update request exception logging and update tests

---
 python_http_client/client.py |  4 +--
 tests/test_unit.py           | 70 ++++++++++++++++++------------------
 2 files changed, 37 insertions(+), 37 deletions(-)

diff --git a/python_http_client/client.py b/python_http_client/client.py
index d3b600a..3a56235 100644
--- a/python_http_client/client.py
+++ b/python_http_client/client.py
@@ -175,12 +175,12 @@ def _make_request(self, opener, request, timeout=None):
         try:
             return opener.open(request, timeout=timeout)
         except HTTPError as err:
+            exc = handle_error(err)
+            exc.__cause__ = None
             _logger.debug('{method} Response: {status} {body}'.format(
                 method=request.get_method(),
                 status=exc.status_code,
                 body=exc.body))
-            exc = handle_error(err)
-            exc.__cause__ = None
             raise exc
 
     def _(self, name):
diff --git a/tests/test_unit.py b/tests/test_unit.py
index 8ef5116..36b115f 100644
--- a/tests/test_unit.py
+++ b/tests/test_unit.py
@@ -1,22 +1,20 @@
 import pickle
 import unittest
 
-from python_http_client.client import Client
+from python_http_client.client import Client, HTTPError, urllib
 from python_http_client.exceptions import (
-    BadRequestsError, HTTPError,
+    HTTPError as SG_HTTPError,
+    BadRequestsError,
     NotFoundError,
     ServiceUnavailableError,
     UnsupportedMediaTypeError,
-    handle_error
 )
 
 try:
     # Python 3
-    import urllib.request as urllib
     from unittest import mock
 except ImportError:
     # Python 2
-    import urllib2 as urllib
     import mock
 
 try:
@@ -27,10 +25,10 @@
 
 class MockException(HTTPError):
 
-    def __init__(self, code):
-        self.code = code
-        self.reason = 'REASON'
-        self.hdrs = 'HEADERS'
+    def __init__(self, url, response_code):
+        super(MockException, self).__init__(
+            url, response_code, 'REASON', 'HEADERS', None
+        )
 
     def read(self):
         return 'BODY'
@@ -51,17 +49,16 @@ def read(self):
         return 'RESPONSE BODY'
 
 
-class MockClient(Client):
+class MockOpener:
 
-    def __init__(self, host, response_code, timeout=None):
+    def __init__(self):
         self.response_code = 200
-        Client.__init__(self, host)
 
-    def _make_request(self, opener, request, timeout=None):
+    def open(self, request, timeout=None):
         if 200 <= self.response_code < 299:  # if successful code
             return MockResponse(self.response_code)
         else:
-            raise handle_error(MockException(self.response_code))
+            raise MockException(request.get_full_url(), self.response_code)
 
 
 class TestClient(unittest.TestCase):
@@ -150,9 +147,12 @@ def test__(self):
         url_path = ['hello']
         self.assertEqual(client._url_path[0], url_path[0])
 
-    def test__getattr__(self):
-        mock_client = MockClient(self.host, 200)
-        client = mock_client.__getattr__('hello')
+    @mock.patch('python_http_client.client.urllib')
+    def test__getattr__(self, mock_lib):
+        mock_opener = MockOpener()
+        mock_lib.build_opener.return_value = mock_opener
+
+        client = self.client.__getattr__('hello')
         url_path = ['hello']
         self.assertEqual(client._url_path, url_path)
         self.assertEqual(client.__getattr__('get').__name__, 'http_request')
@@ -162,42 +162,42 @@ def test__getattr__(self):
         self.assertEqual(client._version, 3)
 
         # Test GET
-        mock_client._url_path += ['test']
-        r = mock_client.get()
+        client._url_path += ['test']
+        r = client.get()
         self.assertEqual(r.status_code, 200)
 
         # Test POST
-        r = mock_client.put()
+        r = client.put()
         self.assertEqual(r.status_code, 200)
 
         # Test PATCH
-        r = mock_client.patch()
+        r = client.patch()
         self.assertEqual(r.status_code, 200)
 
         # Test POST
-        mock_client.response_code = 201
-        r = mock_client.post()
+        mock_opener.response_code = 201
+        r = client.post()
         self.assertEqual(r.status_code, 201)
 
         # Test DELETE
-        mock_client.response_code = 204
-        r = mock_client.delete()
+        mock_opener.response_code = 204
+        r = client.delete()
         self.assertEqual(r.status_code, 204)
 
-        mock_client.response_code = 400
-        self.assertRaises(BadRequestsError, mock_client.get)
+        mock_opener.response_code = 400
+        self.assertRaises(BadRequestsError, client.get)
 
-        mock_client.response_code = 404
-        self.assertRaises(NotFoundError, mock_client.post)
+        mock_opener.response_code = 404
+        self.assertRaises(NotFoundError, client.post)
 
-        mock_client.response_code = 415
-        self.assertRaises(UnsupportedMediaTypeError, mock_client.patch)
+        mock_opener.response_code = 415
+        self.assertRaises(UnsupportedMediaTypeError, client.patch)
 
-        mock_client.response_code = 503
-        self.assertRaises(ServiceUnavailableError, mock_client.delete)
+        mock_opener.response_code = 503
+        self.assertRaises(ServiceUnavailableError, client.delete)
 
-        mock_client.response_code = 523
-        self.assertRaises(HTTPError, mock_client.delete)
+        mock_opener.response_code = 523
+        self.assertRaises(SG_HTTPError, client.delete)
 
     def test_client_pickle_unpickle(self):
         pickled_client = pickle.dumps(self.client)