test(core): drop vacuous URLError wait-strategy case (#1116)

`HttpWaitStrategy` leaks a file descriptor per failed request. A wait
strategy polls, so a container
that takes a while to become healthy leaks one descriptor per attempt,
and a suite waiting on several
containers can exhaust the limit.

`urlopen` is used in a `with`, so the success path closes. `HTTPError`
is the leak: it is both an
exception and a response file object, so raising it hands back an open
descriptor that the `except`
clause discards without closing.

`src/testcontainers/core/wait_strategies.py` now splits the handler.
`HTTPError` is handled inside
`with e:`, which closes the wrapped response on the way out, and
`URLError`, which carries no file
object, keeps the plain path.

Behaviour is otherwise unchanged: both still go to `_handle_http_error`
and the strategy retries as
before.

The test asserts no descriptors are left open across repeated failing
probes.

Fixes #1115

Author: cpruijsen

src/testcontainers/core/wait_strategies.py

@@ -418,7 +418,12 @@ def _try_http_request(self, url: str, headers: dict[str, str], ssl_context: Any)
             with urlopen(request, timeout=1, context=ssl_context) as response:
                 return self._check_response(response, url)
 
-        except (URLError, HTTPError) as e:
+        except HTTPError as e:
+            # HTTPError wraps the response file object, so it doubles as a
+            # context manager to avoid leaking the file descriptor.
+            with e:
+                return self._handle_http_error(e)
+        except URLError as e:
             return self._handle_http_error(e)
         except (ConnectionResetError, ConnectionRefusedError, BrokenPipeError, OSError) as e:
             # Handle connection-level errors that can occur during HTTP requests

tests/core/test_wait_strategies.py

@@ -1,9 +1,12 @@
+import io
 import itertools
 import logging
 import re
 import time
 from datetime import timedelta
+from email.message import Message
 from unittest.mock import Mock, patch
+from urllib.error import HTTPError
 
 import pytest
 
@@ -361,6 +364,31 @@ 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_codes,expected_result",
+        [
+            ({503}, True),
+            (set(), False),
+        ],
+        ids=[
+            "accepted_error_status_code",
+            "unaccepted_error_status_code",
+        ],
+    )
+    @patch("testcontainers.core.wait_strategies.urlopen")
+    def test_try_http_request_closes_http_error(self, mock_urlopen, status_codes, expected_result):
+        """HTTPError holds the response's file object and must be closed (issue #1115)."""
+        fp = io.BytesIO(b"error body")
+        mock_urlopen.side_effect = HTTPError("http://localhost:8080/", 503, "Service Unavailable", Message(), fp)
+        strategy = HttpWaitStrategy(8080)
+        for code in status_codes:
+            strategy.for_status_code(code)
+
+        result = strategy._try_http_request("http://localhost:8080/", {}, None)
+
+        assert result is expected_result
+        assert fp.closed
+
 
 class TestHealthcheckWaitStrategy:
     """Test the HealthcheckWaitStrategy class."""