Update rate limit testing

Author: cmlccie

ciscosparkapi/restsession.py

@@ -39,7 +39,8 @@
 # Module Constants
 DEFAULT_SINGLE_REQUEST_TIMEOUT = 20.0
 DEFAULT_RATE_LIMIT_TIMEOUT = 60.0
-RATE_LIMIT_EXCEEDED_RESPONSE_CODE = 429
+RATE_LIMIT_RESPONSE_CODE = 429
+RATE_LIMIT_LOG_MESSAGE = "Received a [%s] rate-limit response code."
 
 
 # Helper Functions
@@ -251,7 +252,6 @@ def request(self, method, relative_url, erc, **kwargs):
         kwargs.setdefault('timeout', self.single_request_timeout)
 
         start_time = time.time()
-        finish_time = start_time + self.rate_limit_timeout
 
         while True:
             # Make the HTTP request to the API endpoint
@@ -264,23 +264,25 @@ def request(self, method, relative_url, erc, **kwargs):
             except SparkApiError as e:
 
                 # Catch rate-limit errors
-                if e.response_code == RATE_LIMIT_EXCEEDED_RESPONSE_CODE \
+                if e.response_code == RATE_LIMIT_RESPONSE_CODE \
                         and response.headers.get('Retry-After'):
 
-                    logger.debug("Received a [%s] rate limit response. "
-                                 "Attempting to retry.", e.response_code)
+                    logger.debug(RATE_LIMIT_LOG_MESSAGE,
+                                 e.response_code)
 
-                    rate_limit_wait = response.headers['Retry-After']
+                    rate_limit_wait = float(response.headers['Retry-After'])
 
                     if self.rate_limit_timeout is None:
                         # Retry indefinitely
-                        logger.debug("Waiting {:0.3f} seconds. "
-                                     "rate_limit_timeout is None; "
+                        logger.debug("Rate-limiting; waiting {:0.3f} seconds. "
+                                     "rate_limit_timeout is None. "
                                      "will retry indefinitely."
                                      "".format(rate_limit_wait))
                         time.sleep(rate_limit_wait)
                         continue
-                    elif time.time() + rate_limit_wait < finish_time:
+
+                    elif (time.time() + rate_limit_wait
+                            < start_time + self.rate_limit_timeout):
                         # Retry if doing so will not exceed the finish time
                         logger.debug("Waiting {:0.3f} seconds. "
                                      "rate_limit_timeout is {:0.3f} seconds, "
@@ -291,6 +293,7 @@ def request(self, method, relative_url, erc, **kwargs):
                                                finish_time - time.time()))
                         time.sleep(rate_limit_wait)
                         continue
+
                     else:
                         # Time exceeded re-raise the rate limit SparkApiError
                         raise
@@ -301,6 +304,8 @@ def request(self, method, relative_url, erc, **kwargs):
 
             else:
                 # No errors - return the response object
+                logger.debug("Response Code [%s]: %s",
+                             response.status_code, response.url)
                 return response
 
     def get(self, url, params=None, **kwargs):

tests/test_restsession.py

@@ -6,13 +6,10 @@
 
 import pytest
 
-from ciscosparkapi.exceptions import SPARK_RESPONSE_CODES
-
-# Constants
-RATE_LIMIT_RESPONSE_CODE = 429
-RATE_LIMIT_RESPONSE_TEXT = SPARK_RESPONSE_CODES[RATE_LIMIT_RESPONSE_CODE]
-RATE_LIMIT_LOG_MESSAGE = ("Received a [%s] rate limit response. "
-                          "Attempting to retry.")
+from ciscosparkapi.restsession import (
+    RATE_LIMIT_RESPONSE_CODE,
+    RATE_LIMIT_LOG_MESSAGE
+)
 
 
 # Helper Classes
@@ -39,7 +36,13 @@ class TestRestSession:
     """Test edge cases of core RestSession functionality."""
 
     @pytest.mark.ratelimit
-    def test_rate_limit_support(self, api, rooms_list, add_rooms):
+    def test_rate_limit_retry_indefinitely(self, api, rooms_list, add_rooms):
+        logger = logging.getLogger(__name__)
+
+        # Save state and initialize test setup
+        original_rate_limit_timer = api._session.rate_limit_timeout
+        api._session.rate_limit_timeout = None
+
         # Add log handler
         root_logger = logging.getLogger()
         rate_limit_detector = RateLimitDetector()
@@ -48,13 +51,19 @@ def test_rate_limit_support(self, api, rooms_list, add_rooms):
         try:
             # Try and trigger a rate-limit
             rooms = api.rooms.list(max=1)
+            request_count = 0
             while not rate_limit_detector.rate_limit_detected:
                 for room in rooms:
-                    # Do nothing
-                    pass
+                    request_count += 1
+                    if rate_limit_detector.rate_limit_detected:
+                        break
 
         finally:
-            # Remove the log handler
+            logger.info("Rate-limit reached with approximately %s requests.",
+                        request_count)
+            # Remove the log handler and restore the pre-test state
             root_logger.removeHandler(rate_limit_detector)
+            api._session.rate_limit_timeout = original_rate_limit_timer
 
+        # Assert test condition
         assert rate_limit_detector.rate_limit_detected == True