Merge "Add the resp to RestClientExceptions"

3 files changed, 62 insertions, 76 deletions

diff --git a/tempest_lib/common/rest_client.py b/tempest_lib/common/rest_client.py
index ca0afbe..8aa1325 100644
--- a/tempest_lib/common/rest_client.py
+++ b/tempest_lib/common/rest_client.py
@@ -677,50 +677,51 @@ class RestClient(object):
         elif ctype.lower() in TXT_ENC:
             parse_resp = False
         else:
-            raise exceptions.UnexpectedContentType(str(resp.status))
+            raise exceptions.UnexpectedContentType(str(resp.status),
+                                                   resp=resp)
 
         if resp.status == 401:
             if parse_resp:
                 resp_body = self._parse_resp(resp_body)
-            raise exceptions.Unauthorized(resp_body)
+            raise exceptions.Unauthorized(resp_body, resp=resp)
 
         if resp.status == 403:
             if parse_resp:
                 resp_body = self._parse_resp(resp_body)
-            raise exceptions.Forbidden(resp_body)
+            raise exceptions.Forbidden(resp_body, resp=resp)
 
         if resp.status == 404:
             if parse_resp:
                 resp_body = self._parse_resp(resp_body)
-            raise exceptions.NotFound(resp_body)
+            raise exceptions.NotFound(resp_body, resp=resp)
 
         if resp.status == 400:
             if parse_resp:
                 resp_body = self._parse_resp(resp_body)
-            raise exceptions.BadRequest(resp_body)
+            raise exceptions.BadRequest(resp_body, resp=resp)
 
         if resp.status == 409:
             if parse_resp:
                 resp_body = self._parse_resp(resp_body)
-            raise exceptions.Conflict(resp_body)
+            raise exceptions.Conflict(resp_body, resp=resp)
 
         if resp.status == 413:
             if parse_resp:
                 resp_body = self._parse_resp(resp_body)
             if self.is_absolute_limit(resp, resp_body):
-                raise exceptions.OverLimit(resp_body)
+                raise exceptions.OverLimit(resp_body, resp=resp)
             else:
-                raise exceptions.RateLimitExceeded(resp_body)
+                raise exceptions.RateLimitExceeded(resp_body, resp=resp)
 
         if resp.status == 415:
             if parse_resp:
                 resp_body = self._parse_resp(resp_body)
-            raise exceptions.InvalidContentType(resp_body)
+            raise exceptions.InvalidContentType(resp_body, resp=resp)
 
         if resp.status == 422:
             if parse_resp:
                 resp_body = self._parse_resp(resp_body)
-            raise exceptions.UnprocessableEntity(resp_body)
+            raise exceptions.UnprocessableEntity(resp_body, resp=resp)
 
         if resp.status in (500, 501):
             message = resp_body
@@ -749,12 +750,15 @@ class RestClient(object):
                         message = resp_body
 
             if resp.status == 501:
-                raise exceptions.NotImplemented(message)
+                raise exceptions.NotImplemented(resp_body, resp=resp,
+                                                message=message)
             else:
-                raise exceptions.ServerFault(resp_body, message=message)
+                raise exceptions.ServerFault(resp_body, resp=resp,
+                                             message=message)
 
         if resp.status >= 400:
-            raise exceptions.UnexpectedResponseCode(str(resp.status))
+            raise exceptions.UnexpectedResponseCode(str(resp.status),
+                                                    resp=resp)
 
     def is_absolute_limit(self, resp, resp_body):
         if (not isinstance(resp_body, collections.Mapping) or
diff --git a/tempest_lib/exceptions.py b/tempest_lib/exceptions.py
index 52df4d3..050ccc6 100644
--- a/tempest_lib/exceptions.py
+++ b/tempest_lib/exceptions.py
@@ -48,6 +48,8 @@ class TempestException(Exception):
 class RestClientException(TempestException,
                           testtools.TestCase.failureException):
     def __init__(self, resp_body=None, *args, **kwargs):
+        if 'resp' in kwargs:
+            self.resp = kwargs.get('resp')
         self.resp_body = resp_body
         message = kwargs.get("message", resp_body)
         super(RestClientException, self).__init__(message, *args, **kwargs)
diff --git a/tempest_lib/tests/test_rest_client.py b/tempest_lib/tests/test_rest_client.py
index b71555c..25bf161 100644
--- a/tempest_lib/tests/test_rest_client.py
+++ b/tempest_lib/tests/test_rest_client.py
@@ -306,67 +306,56 @@ class TestRestClientErrorCheckerJSON(base.TestCase):
     def test_response_less_than_400(self):
         self.rest_client._error_checker(**self.set_data("399"))
 
+    def _test_error_checker(self, exception_type, data):
+        e = self.assertRaises(exception_type,
+                              self.rest_client._error_checker,
+                              **data)
+        self.assertEqual(e.resp, data['resp'])
+        self.assertTrue(hasattr(e, 'resp_body'))
+        return e
+
     def test_response_400(self):
-        self.assertRaises(exceptions.BadRequest,
-                          self.rest_client._error_checker,
-                          **self.set_data("400"))
+        self._test_error_checker(exceptions.BadRequest, self.set_data("400"))
 
     def test_response_401(self):
-        self.assertRaises(exceptions.Unauthorized,
-                          self.rest_client._error_checker,
-                          **self.set_data("401"))
+        self._test_error_checker(exceptions.Unauthorized, self.set_data("401"))
 
     def test_response_403(self):
-        self.assertRaises(exceptions.Forbidden,
-                          self.rest_client._error_checker,
-                          **self.set_data("403"))
+        self._test_error_checker(exceptions.Forbidden, self.set_data("403"))
 
     def test_response_404(self):
-        self.assertRaises(exceptions.NotFound,
-                          self.rest_client._error_checker,
-                          **self.set_data("404"))
+        self._test_error_checker(exceptions.NotFound, self.set_data("404"))
 
     def test_response_409(self):
-        self.assertRaises(exceptions.Conflict,
-                          self.rest_client._error_checker,
-                          **self.set_data("409"))
+        self._test_error_checker(exceptions.Conflict, self.set_data("409"))
 
     def test_response_413(self):
-        self.assertRaises(exceptions.OverLimit,
-                          self.rest_client._error_checker,
-                          **self.set_data("413"))
+        self._test_error_checker(exceptions.OverLimit, self.set_data("413"))
 
     def test_response_413_without_absolute_limit(self):
-        self.assertRaises(exceptions.RateLimitExceeded,
-                          self.rest_client._error_checker,
-                          **self.set_data("413", absolute_limit=False))
+        self._test_error_checker(exceptions.RateLimitExceeded,
+                                 self.set_data("413", absolute_limit=False))
 
     def test_response_415(self):
-        self.assertRaises(exceptions.InvalidContentType,
-                          self.rest_client._error_checker,
-                          **self.set_data("415"))
+        self._test_error_checker(exceptions.InvalidContentType,
+                                 self.set_data("415"))
 
     def test_response_422(self):
-        self.assertRaises(exceptions.UnprocessableEntity,
-                          self.rest_client._error_checker,
-                          **self.set_data("422"))
+        self._test_error_checker(exceptions.UnprocessableEntity,
+                                 self.set_data("422"))
 
     def test_response_500_with_text(self):
         # _parse_resp is expected to return 'str'
-        self.assertRaises(exceptions.ServerFault,
-                          self.rest_client._error_checker,
-                          **self.set_data("500"))
+        self._test_error_checker(exceptions.ServerFault, self.set_data("500"))
 
     def test_response_501_with_text(self):
-        self.assertRaises(exceptions.NotImplemented,
-                          self.rest_client._error_checker,
-                          **self.set_data("501"))
+        self._test_error_checker(exceptions.NotImplemented,
+                                 self.set_data("501"))
 
     def test_response_400_with_dict(self):
         r_body = '{"resp_body": {"err": "fake_resp_body"}}'
-        e = self.assertRaises(exceptions.BadRequest,
-                              self.rest_client._error_checker,
-                              **self.set_data("400", r_body=r_body))
+        e = self._test_error_checker(exceptions.BadRequest,
+                                     self.set_data("400", r_body=r_body))
 
         if self.c_type == 'application/json':
             expected = {"err": "fake_resp_body"}
@@ -376,9 +365,8 @@ class TestRestClientErrorCheckerJSON(base.TestCase):
 
     def test_response_401_with_dict(self):
         r_body = '{"resp_body": {"err": "fake_resp_body"}}'
-        e = self.assertRaises(exceptions.Unauthorized,
-                              self.rest_client._error_checker,
-                              **self.set_data("401", r_body=r_body))
+        e = self._test_error_checker(exceptions.Unauthorized,
+                                     self.set_data("401", r_body=r_body))
 
         if self.c_type == 'application/json':
             expected = {"err": "fake_resp_body"}
@@ -388,9 +376,8 @@ class TestRestClientErrorCheckerJSON(base.TestCase):
 
     def test_response_403_with_dict(self):
         r_body = '{"resp_body": {"err": "fake_resp_body"}}'
-        e = self.assertRaises(exceptions.Forbidden,
-                              self.rest_client._error_checker,
-                              **self.set_data("403", r_body=r_body))
+        e = self._test_error_checker(exceptions.Forbidden,
+                                     self.set_data("403", r_body=r_body))
 
         if self.c_type == 'application/json':
             expected = {"err": "fake_resp_body"}
@@ -400,9 +387,8 @@ class TestRestClientErrorCheckerJSON(base.TestCase):
 
     def test_response_404_with_dict(self):
         r_body = '{"resp_body": {"err": "fake_resp_body"}}'
-        e = self.assertRaises(exceptions.NotFound,
-                              self.rest_client._error_checker,
-                              **self.set_data("404", r_body=r_body))
+        e = self._test_error_checker(exceptions.NotFound,
+                                     self.set_data("404", r_body=r_body))
 
         if self.c_type == 'application/json':
             expected = {"err": "fake_resp_body"}
@@ -412,18 +398,16 @@ class TestRestClientErrorCheckerJSON(base.TestCase):
 
     def test_response_404_with_invalid_dict(self):
         r_body = '{"foo": "bar"]'
-        e = self.assertRaises(exceptions.NotFound,
-                              self.rest_client._error_checker,
-                              **self.set_data("404", r_body=r_body))
+        e = self._test_error_checker(exceptions.NotFound,
+                                     self.set_data("404", r_body=r_body))
 
         expected = r_body
         self.assertEqual(expected, e.resp_body)
 
     def test_response_409_with_dict(self):
         r_body = '{"resp_body": {"err": "fake_resp_body"}}'
-        e = self.assertRaises(exceptions.Conflict,
-                              self.rest_client._error_checker,
-                              **self.set_data("409", r_body=r_body))
+        e = self._test_error_checker(exceptions.Conflict,
+                                     self.set_data("409", r_body=r_body))
 
         if self.c_type == 'application/json':
             expected = {"err": "fake_resp_body"}
@@ -433,9 +417,8 @@ class TestRestClientErrorCheckerJSON(base.TestCase):
 
     def test_response_500_with_dict(self):
         r_body = '{"resp_body": {"err": "fake_resp_body"}}'
-        e = self.assertRaises(exceptions.ServerFault,
-                              self.rest_client._error_checker,
-                              **self.set_data("500", r_body=r_body))
+        e = self._test_error_checker(exceptions.ServerFault,
+                                     self.set_data("500", r_body=r_body))
 
         if self.c_type == 'application/json':
             expected = {"err": "fake_resp_body"}
@@ -445,16 +428,14 @@ class TestRestClientErrorCheckerJSON(base.TestCase):
 
     def test_response_501_with_dict(self):
         r_body = '{"resp_body": {"err": "fake_resp_body"}}'
-        self.assertRaises(exceptions.NotImplemented,
-                          self.rest_client._error_checker,
-                          **self.set_data("501", r_body=r_body))
+        self._test_error_checker(exceptions.NotImplemented,
+                                 self.set_data("501", r_body=r_body))
 
     def test_response_bigger_than_400(self):
         # Any response code, that bigger than 400, and not in
         # (401, 403, 404, 409, 413, 422, 500, 501)
-        self.assertRaises(exceptions.UnexpectedResponseCode,
-                          self.rest_client._error_checker,
-                          **self.set_data("402"))
+        self._test_error_checker(exceptions.UnexpectedResponseCode,
+                                 self.set_data("402"))
 
 
 class TestRestClientErrorCheckerTEXT(TestRestClientErrorCheckerJSON):
@@ -464,9 +445,8 @@ class TestRestClientErrorCheckerTEXT(TestRestClientErrorCheckerJSON):
         # This test is required only in one exemplar
         # Any response code, that bigger than 400, and not in
         # (401, 403, 404, 409, 413, 422, 500, 501)
-        self.assertRaises(exceptions.UnexpectedContentType,
-                          self.rest_client._error_checker,
-                          **self.set_data("405", enc="fake_enc"))
+        self._test_error_checker(exceptions.UnexpectedContentType,
+                                 self.set_data("405", enc="fake_enc"))
 
     def test_response_413_without_absolute_limit(self):
         # Skip this test because rest_client cannot get overLimit message