Add last_response attr to WaiterError

The rationale behind just adding a last_response instead of exposing some sort
of error_code and error_message is that a WaiterError can also be thrown in
non-error states (transitioning to a failure state, hitting max-attempts), and
while we can always guarantee a last response, we can't necessarily guarantee
that response is a "error" response.

Closes #957

botocore/exceptions.py

@@ -295,6 +295,10 @@ class WaiterError(BotoCoreError):
     """Waiter failed to reach desired state."""
     fmt = 'Waiter {name} failed: {reason}'
 
+    def __init__(self, name, reason, last_response):
+        super(WaiterError, self).__init__(name=name, reason=reason)
+        self.last_response = last_response
+
 
 class IncompleteReadError(BotoCoreError):
     """HTTP response did not return expected number of bytes."""

botocore/waiter.py

@@ -303,20 +303,27 @@ def wait(self, **kwargs):
                 # transition to the failure state if an error
                 # response was received.
                 if 'Error' in response:
-                    # This was a ClientError that was not handled in an
-                    # acceptor. Raise a ClientError again
-                    raise ClientError(
-                        error_response=response,
-                        operation_name=self.config.operation)
+                    # Transition to a failure state, which we
+                    # can just handle here by raising an exception.
+                    raise WaiterError(
+                        name=self.name,
+                        reason=response['Error'].get('Message', 'Unknown'),
+                        last_response=response
+                    )
             if current_state == 'success':
                 logger.debug("Waiting complete, waiter matched the "
                              "success state.")
                 return
             if current_state == 'failure':
                 raise WaiterError(
                     name=self.name,
-                    reason='Waiter encountered a terminal failure state')
+                    reason='Waiter encountered a terminal failure state',
+                    last_response=response,
+                )
             if num_attempts >= max_attempts:
-                raise WaiterError(name=self.name,
-                                  reason='Max attempts exceeded')
+                raise WaiterError(
+                    name=self.name,
+                    reason='Max attempts exceeded',
+                    last_response=response
+                )
             time.sleep(sleep_amount)

tests/unit/test_waiters.py

@@ -358,8 +358,19 @@ def test_unspecified_errors_stops_waiter(self):
             for_operation=operation_method
         )
         waiter = Waiter('MyWaiter', config, operation_method)
-        with self.assertRaises(ClientError):
+        with self.assertRaises(WaiterError):
+            waiter.wait()
+
+    def test_last_response_available_on_waiter_error(self):
+        last_response = {'Error': {'Code': 'UnknownError', 'Message': 'bad error'}}
+        config = self.create_waiter_config()
+        operation_method = mock.Mock()
+        self.client_responses_are(last_response,
+                                  for_operation=operation_method)
+        waiter = Waiter('MyWaiter', config, operation_method)
+        with self.assertRaises(WaiterError) as e:
             waiter.wait()
+        self.assertEqual(e.exception.last_response, last_response)
 
     def test_unspecified_errors_propagate_error_code(self):
         # If a waiter receives an error response, then the
@@ -378,7 +389,7 @@ def test_unspecified_errors_propagate_error_code(self):
         )
         waiter = Waiter('MyWaiter', config, operation_method)
 
-        with self.assertRaisesRegexp(ClientError, error_message):
+        with self.assertRaisesRegexp(WaiterError, error_message):
             waiter.wait()
 
     def test_waiter_transitions_to_failure_state(self):