fix(wait-strategy): close HTTPError in HttpWaitStrategy to avoid fd leak

Closes #1115

Author: BrunosGits

src/testcontainers/core/wait_strategies.py

@@ -427,13 +427,19 @@ def _try_http_request(self, url: str, headers: dict[str, str], ssl_context: Any)
 
     def _handle_http_error(self, error: Union[URLError, HTTPError]) -> bool:
         """Handle HTTP errors and return True if error is acceptable."""
-        if isinstance(error, HTTPError) and (
-            error.code in self._status_codes
-            or (self._status_code_predicate and self._status_code_predicate(error.code))
-        ):
-            return True
-        logger.debug(f"HTTP request failed: {error!s}")
-        return False
+        try:
+            if isinstance(error, HTTPError) and (
+                error.code in self._status_codes
+                or (self._status_code_predicate and self._status_code_predicate(error.code))
+            ):
+                return True
+            logger.debug(f"HTTP request failed: {error!s}")
+            return False
+        finally:
+            # HTTPError wraps the response body in a temporary file: always close it
+            # to avoid leaking file descriptors (see #1115).
+            if isinstance(error, HTTPError):
+                error.close()
 
 
 class HealthcheckWaitStrategy(WaitStrategy):

tests/core/test_wait_strategies.py

@@ -1,9 +1,12 @@
 import itertools
 import logging
 import re
+import threading
 import time
 from datetime import timedelta
+from http.server import BaseHTTPRequestHandler, HTTPServer
 from unittest.mock import Mock, patch
+from urllib.error import HTTPError
 
 import pytest
 
@@ -361,6 +364,44 @@ def test_from_url(self, url, expected_port, expected_path, expected_tls):
         assert strategy._path == expected_path
         assert strategy._tls is expected_tls
 
+    @pytest.mark.parametrize(
+        "status_code,expected",
+        [(503, False), (200, True)],
+        ids=["unexpected_status", "expected_status"],
+    )
+    def test_handle_http_error_always_closes_error(self, status_code, expected):
+        # Regression test for #1115: HTTPError wraps the response fp and must be closed.
+        error = Mock(spec=HTTPError)
+        error.code = status_code
+        strategy = HttpWaitStrategy(8080, "/health").for_status_code(200)
+        assert strategy._handle_http_error(error) is expected
+        error.close.assert_called_once_with()
+
+    def test_try_http_request_unexpected_status(self):
+        # End-to-end check for #1115: 503 against an expectation of 200 returns False.
+        class _FailHandler(BaseHTTPRequestHandler):
+            def do_GET(self):
+                body = b"error"
+                self.send_response(503)
+                self.send_header("Content-Length", str(len(body)))
+                self.end_headers()
+                self.wfile.write(body)
+
+            def log_message(self, *args):
+                pass
+
+        server = HTTPServer(("127.0.0.1", 0), _FailHandler)
+        thread = threading.Thread(target=server.serve_forever, daemon=True)
+        thread.start()
+        try:
+            port = server.server_address[1]
+            url = f"http://127.0.0.1:{port}/health"
+            assert HttpWaitStrategy(port, "/health").for_status_code(200)._try_http_request(url, {}, None) is False
+            assert HttpWaitStrategy(port, "/health").for_status_code(503)._try_http_request(url, {}, None) is True
+        finally:
+            server.shutdown()
+            thread.join(timeout=5)
+
 
 class TestHealthcheckWaitStrategy:
     """Test the HealthcheckWaitStrategy class."""