http-api-tool 1.1.0__tar.gz → 1.1.1__tar.gz

{http_api_tool-1.1.0 → http_api_tool-1.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: http-api-tool
-Version: 1.1.0
+Version: 1.1.1
 Summary: A Python HTTP/HTTPS API testing tool for GitHub Actions and CLI usage
 Project-URL: Homepage, https://github.com/lfreleng-actions/http-api-tool-docker
 Project-URL: Repository, https://github.com/lfreleng-actions/http-api-tool-docker
@@ -153,7 +153,7 @@ docker run --rm --entrypoint=/usr/local/bin/uv \
 - **Supported HTTP Methods**: Supports GET, POST, PUT, PATCH, DELETE, HEAD, OPTIONS
 - **Authentication**: Basic Auth via auth_string and custom headers support
 - **Response Validation**: Status code, regex pattern matching, response time limits
-- **Retry Logic**: Configurable exponential backoff with jitter
+- **Retry Logic**: Exponential backoff, doubling up to a configurable cap
 - **Dual Usage**: Works as both a CLI tool and GitHub Action
 - **Robust Error Handling**: Detailed error messages and proper exit codes
 - **JSON Safety**: Uses pycurl instead of shell commands to avoid escaping issues
@@ -271,7 +271,7 @@ uv run python -m http_api_tool test \
 | `url`                   | URL of API server/interface to check                                 | Yes      | -                  |
 | `auth_string`           | Authentication string, colon separated username/password             | No       | -                  |
 | `service_name`          | Name of HTTP/HTTPS API service tested                                | No       | `API Service`      |
-| `initial_sleep_time`    | Time in seconds between API service connection attempts              | No       | `1`                |
+| `initial_sleep_time`    | Delay in seconds before the first retry, doubling thereafter         | No       | `1`                |
 | `max_delay`             | Max delay in seconds between retries                                 | No       | `30`               |
 | `retries`               | Number of retries before declaring service unavailable               | No       | `3`                |
 | `expected_http_code`    | HTTP response code to accept from the API service                    | No       | `200`              |

{http_api_tool-1.1.0 → http_api_tool-1.1.1}/README.md

@@ -100,7 +100,7 @@ docker run --rm --entrypoint=/usr/local/bin/uv \
 - **Supported HTTP Methods**: Supports GET, POST, PUT, PATCH, DELETE, HEAD, OPTIONS
 - **Authentication**: Basic Auth via auth_string and custom headers support
 - **Response Validation**: Status code, regex pattern matching, response time limits
-- **Retry Logic**: Configurable exponential backoff with jitter
+- **Retry Logic**: Exponential backoff, doubling up to a configurable cap
 - **Dual Usage**: Works as both a CLI tool and GitHub Action
 - **Robust Error Handling**: Detailed error messages and proper exit codes
 - **JSON Safety**: Uses pycurl instead of shell commands to avoid escaping issues
@@ -218,7 +218,7 @@ uv run python -m http_api_tool test \
 | `url`                   | URL of API server/interface to check                                 | Yes      | -                  |
 | `auth_string`           | Authentication string, colon separated username/password             | No       | -                  |
 | `service_name`          | Name of HTTP/HTTPS API service tested                                | No       | `API Service`      |
-| `initial_sleep_time`    | Time in seconds between API service connection attempts              | No       | `1`                |
+| `initial_sleep_time`    | Delay in seconds before the first retry, doubling thereafter         | No       | `1`                |
 | `max_delay`             | Max delay in seconds between retries                                 | No       | `30`               |
 | `retries`               | Number of retries before declaring service unavailable               | No       | `3`                |
 | `expected_http_code`    | HTTP response code to accept from the API service                    | No       | `200`              |

{http_api_tool-1.1.0 → http_api_tool-1.1.1}/action.yaml

@@ -39,9 +39,9 @@ inputs:
     required: false
     default: 'API Service'
   initial_sleep_time:
-    description: 'Time in seconds between API service connection attempts'
+    description: 'Delay in seconds before the first retry, doubling thereafter'
     required: false
-    # Try once every second
+    # Wait a second before the first retry
     default: '1'
   max_delay:
     description: 'Maximum delay in seconds between retries'

{http_api_tool-1.1.0 → http_api_tool-1.1.1}/src/http_api_tool/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '1.1.0'
-__version_tuple__ = version_tuple = (1, 1, 0)
+__version__ = version = '1.1.1'
+__version_tuple__ = version_tuple = (1, 1, 1)
 
 __commit_id__ = commit_id = None

{http_api_tool-1.1.0 → http_api_tool-1.1.1}/src/http_api_tool/cli.py

@@ -113,7 +113,7 @@ def verify(
         "API Service", help="Name of HTTP/HTTPS API service tested"
     ),
     initial_sleep_time: int = typer.Option(
-        1, help="Time in seconds between API service connection attempts"
+        1, help="Delay in seconds before the first retry, doubling thereafter"
     ),
     max_delay: int = typer.Option(30, help="Maximum delay in seconds between retries"),
     retries: int = typer.Option(

{http_api_tool-1.1.0 → http_api_tool-1.1.1}/src/http_api_tool/verifier.py

@@ -235,7 +235,7 @@ class HTTPAPITester:
         result = _initial_result()
         counter = 0
         time_delay = 0
-        sleep_time = config["initial_sleep_time"]
+        sleep_time = min(config["initial_sleep_time"], config["max_delay"])
 
         while True:
             counter += 1
@@ -267,5 +267,5 @@ class HTTPAPITester:
             self.reporter.log(f"Waiting for {sleep_time} seconds before retrying...")
             time.sleep(sleep_time)
             time_delay += sleep_time
-            sleep_time = min(sleep_time * (2 ** (counter - 1)), config["max_delay"])
+            sleep_time = min(sleep_time * 2, config["max_delay"])
             self.reporter.log(f"Sleep/wait time for next attempt: {sleep_time} seconds")

{http_api_tool-1.1.0 → http_api_tool-1.1.1}/tests/test_http_api_tool.py

@@ -625,6 +625,50 @@ X-Custom-Header: test-value
             assert result["curl_error"] == (7, "Failed to connect to host")
 
 
+def failed_response() -> dict[str, Any]:
+    """Build a perform_request result representing a connection failure."""
+    return {
+        "success": False,
+        "http_code": 0,
+        "total_time": 0,
+        "connect_time": 0,
+        "body_size": 0,
+        "header_size": 0,
+        "response_body": b"",
+        "response_headers": "",
+        "header_json": "{}",
+        "curl_error": (7, "Failed to connect"),
+    }
+
+
+def retry_config(**overrides: Any) -> dict[str, Any]:
+    """Build a test_api config, applying any per-test overrides."""
+    config: dict[str, Any] = {
+        "url": "https://example.com",
+        "service_name": "Test API",
+        "retries": 2,
+        "expected_http_code": 200,
+        "initial_sleep_time": 1,
+        "max_delay": 30,
+        "curl_timeout": 5,
+        "http_method": "GET",
+        "verify_ssl": True,
+        "connection_reuse": True,
+        "follow_redirects": True,
+        "debug": False,
+        "include_response_body": False,
+        "max_response_time": 0,
+        "fail_on_timeout": False,
+    }
+    config.update(overrides)
+    return config
+
+
+def recorded_sleeps(mock_sleep: Mock) -> list[float]:
+    """Extract the interval passed to each time.sleep call, in order."""
+    return [call.args[0] for call in mock_sleep.call_args_list]
+
+
 @pytest.mark.integration
 class TestIntegration:
     """Integration tests for the complete verification flow.
@@ -857,45 +901,83 @@ class TestIntegration:
         self, _mock_sleep: Mock, mock_perform: Mock, mock_create_handle: Mock
     ) -> None:
         """Test API verification with exhausted retries."""
-        # Mock curl handle
-        mock_curl = Mock()
-        mock_create_handle.return_value = mock_curl
+        mock_create_handle.return_value = Mock()
+        mock_perform.return_value = failed_response()
 
-        # Mock consistent failures
-        mock_perform.return_value = {
-            "success": False,
-            "http_code": 0,
-            "total_time": 0,
-            "connect_time": 0,
-            "body_size": 0,
-            "header_size": 0,
-            "response_body": b"",
-            "response_headers": "",
-            "header_json": "{}",
-            "curl_error": (7, "Failed to connect"),
-        }
+        with pytest.raises(SystemExit):
+            _ = self.verifier.test_api(**retry_config(retries=2))
 
-        config = {
-            "url": "https://example.com",
-            "service_name": "Test API",
-            "retries": 2,
-            "expected_http_code": 200,
-            "initial_sleep_time": 1,
-            "max_delay": 30,
-            "curl_timeout": 5,
-            "http_method": "GET",
-            "verify_ssl": True,
-            "connection_reuse": True,
-            "follow_redirects": True,
-            "debug": False,
-            "include_response_body": False,
-            "max_response_time": 0,
-            "fail_on_timeout": False,
-        }
+    @patch("http_api_tool.verifier.create_curl_handle")
+    @patch("http_api_tool.verifier.perform_request")
+    @patch("time.sleep")
+    def test_test_api_backoff_doubles_each_attempt(
+        self, mock_sleep: Mock, mock_perform: Mock, mock_create_handle: Mock
+    ) -> None:
+        """Test that the retry interval doubles between attempts."""
+        mock_create_handle.return_value = Mock()
+        mock_perform.return_value = failed_response()
 
+        config = retry_config(retries=5, initial_sleep_time=1, max_delay=30)
         with pytest.raises(SystemExit):
             _ = self.verifier.test_api(**config)
 
+        # Five attempts means four waits, each twice the one before it.
+        assert recorded_sleeps(mock_sleep) == [1, 2, 4, 8]
+
+    @patch("http_api_tool.verifier.create_curl_handle")
+    @patch("http_api_tool.verifier.perform_request")
+    @patch("time.sleep")
+    def test_test_api_backoff_stops_at_max_delay(
+        self, mock_sleep: Mock, mock_perform: Mock, mock_create_handle: Mock
+    ) -> None:
+        """Test that the retry interval never exceeds max_delay."""
+        mock_create_handle.return_value = Mock()
+        mock_perform.return_value = failed_response()
+
+        config = retry_config(retries=4, initial_sleep_time=10, max_delay=15)
+        with pytest.raises(SystemExit):
+            _ = self.verifier.test_api(**config)
+
+        assert recorded_sleeps(mock_sleep) == [10, 15, 15]
+
+    @patch("http_api_tool.verifier.create_curl_handle")
+    @patch("http_api_tool.verifier.perform_request")
+    @patch("time.sleep")
+    def test_test_api_backoff_caps_the_first_wait(
+        self, mock_sleep: Mock, mock_perform: Mock, mock_create_handle: Mock
+    ) -> None:
+        """Test that max_delay caps initial_sleep_time as well."""
+        mock_create_handle.return_value = Mock()
+        mock_perform.return_value = failed_response()
+
+        config = retry_config(retries=3, initial_sleep_time=60, max_delay=30)
+        with pytest.raises(SystemExit):
+            _ = self.verifier.test_api(**config)
+
+        assert recorded_sleeps(mock_sleep) == [30, 30]
+
+    @patch("http_api_tool.verifier.create_curl_handle")
+    @patch("http_api_tool.verifier.perform_request")
+    @patch("time.sleep")
+    def test_test_api_reports_total_delay_on_failure(
+        self, _mock_sleep: Mock, mock_perform: Mock, mock_create_handle: Mock
+    ) -> None:
+        """Test that time_delay accumulates every backoff interval."""
+        mock_create_handle.return_value = Mock()
+        mock_perform.return_value = failed_response()
+        recorded: dict[str, Any] = {}
+
+        def capture(result: dict[str, Any], *_args: Any) -> None:
+            recorded.update(result)
+
+        config = retry_config(retries=4, initial_sleep_time=1, max_delay=30)
+        with patch.object(HTTPAPITester, "_report_exhausted", side_effect=capture):
+            with pytest.raises(SystemExit):
+                _ = self.verifier.test_api(**config)
+
+        # Waits of 1, 2, and 4 seconds precede the fourth and final attempt.
+        assert recorded["time_delay"] == 7
+
     # NOTE: Response time testing is now covered by the testing.yaml workflow
     # using a local go-httpbin service to avoid external dependencies in unit tests.