feat(python): Test python timeout (generated)

algolia/api-clients-automation#5883

Co-authored-by: algolia-bot <accounts+algolia-api-client-bot@algolia.com>
Co-authored-by: Eric Zaharia <94015633+eric-zaharia@users.noreply.github.com>

Author: algolia-bot

algoliasearch/http/transporter.py

@@ -3,7 +3,6 @@
 from typing import List, Optional
 
 from aiohttp import ClientSession, ClientTimeout, TCPConnector
-from async_timeout import timeout
 
 from algoliasearch.http.api_response import ApiResponse
 from algoliasearch.http.base_config import BaseConfig
@@ -60,33 +59,32 @@ async def request(
                     request_options.timeouts["connect"] * (host.retry_count + 1)
                 ) / 1000
                 request_timeout = self._timeout / 1000
-                total_timeout = connect_timeout + request_timeout
 
-                async with timeout(total_timeout):
-                    timeout_config = ClientTimeout(connect=connect_timeout)
-
-                    resp = await self._session.request(
-                        method=verb,
-                        url=url,
-                        headers=request_options.headers,
-                        data=request_options.data,
-                        proxy=proxy,
-                        timeout=timeout_config,
-                    )
+                timeout_config = ClientTimeout(
+                    connect=connect_timeout, sock_read=request_timeout
+                )
 
+                async with self._session.request(
+                    method=verb,
+                    url=url,
+                    headers=request_options.headers,
+                    data=request_options.data,
+                    proxy=proxy,
+                    timeout=timeout_config,
+                ) as resp:
                     _raw_data = await resp.text()
 
-                response = ApiResponse(
-                    verb=verb,
-                    path=path,
-                    url=url,
-                    host=host.url,
-                    status_code=resp.status,
-                    headers=resp.headers,  # pyright: ignore # insensitive dict is still a dict
-                    data=_raw_data,
-                    raw_data=_raw_data,
-                    error_message=str(resp.reason),
-                )
+                    response = ApiResponse(
+                        verb=verb,
+                        path=path,
+                        url=url,
+                        host=host.url,
+                        status_code=resp.status,
+                        headers=resp.headers,  # pyright: ignore # insensitive dict is still a dict
+                        data=_raw_data,
+                        raw_data=_raw_data,
+                        error_message=str(resp.reason),
+                    )
 
             except TimeoutError as e:
                 response = ApiResponse(

algoliasearch/tests/test_timeout_integration.py

@@ -0,0 +1,195 @@
+import asyncio
+import time
+from os import environ
+from typing import Tuple
+
+from algoliasearch.http.base_config import BaseConfig
+from algoliasearch.http.hosts import CallType, Host, HostsCollection
+from algoliasearch.http.request_options import RequestOptions
+from algoliasearch.http.transporter import Transporter
+from algoliasearch.http.transporter_sync import TransporterSync
+from algoliasearch.http.verb import Verb
+
+TEST_SERVER = (
+    "localhost" if environ.get("CI") == "true" else "host.docker.internal"
+) + ":6676"
+
+
+def create_config_with_host(host_url: str) -> Tuple[BaseConfig, Host]:
+    config = BaseConfig("test-app", "test-key")
+    host = Host(host_url, accept=CallType.READ | CallType.WRITE)
+    config.hosts = HostsCollection([host])
+    return config, host
+
+
+def create_server_host() -> Host:
+    return Host(TEST_SERVER, scheme="http", accept=CallType.READ | CallType.WRITE)
+
+
+def test_sync_retry_count_stateful():
+    """connect timeout increases across failed requests: 2s -> 4s -> 6s."""
+    config, _ = create_config_with_host("10.255.255.1")
+    transporter = TransporterSync(config)
+    request_options = RequestOptions(config).merge()
+
+    times = []
+    for _ in range(3):
+        start = time.time()
+        try:
+            transporter.request(
+                verb=Verb.GET,
+                path="/test",
+                request_options=request_options,
+                use_read_transporter=True,
+            )
+        except Exception:
+            times.append(time.time() - start)
+
+    assert 1.5 < times[0] < 2.5, f"Request 1 should be ~2s, got {times[0]:.2f}s"
+    assert 3.5 < times[1] < 4.5, f"Request 2 should be ~4s, got {times[1]:.2f}s"
+    assert 5.5 < times[2] < 7.0, f"Request 3 should be ~6s, got {times[2]:.2f}s"
+
+
+def test_sync_retry_count_resets():
+    """retry_count resets to 0 after successful request."""
+    config, bad_host = create_config_with_host("10.255.255.1")
+    good_host = create_server_host()
+
+    transporter = TransporterSync(config)
+    request_options = RequestOptions(config).merge()
+
+    # fail twice to increment retry_count
+    for _ in range(2):
+        try:
+            transporter.request(
+                verb=Verb.GET,
+                path="/test",
+                request_options=request_options,
+                use_read_transporter=True,
+            )
+        except Exception:
+            pass
+
+    # switch to good host and succeed
+    config.hosts = HostsCollection([good_host])
+    transporter._hosts = [good_host]
+    good_host.retry_count = bad_host.retry_count
+
+    response = transporter.request(
+        verb=Verb.GET,
+        path="/1/test/instant",
+        request_options=request_options,
+        use_read_transporter=True,
+    )
+    assert response.status_code == 200
+    assert good_host.retry_count == 0, (
+        f"retry_count should reset to 0, got {good_host.retry_count}"
+    )
+
+    # point to bad host again, should timeout at 2s (not 6s)
+    good_host.url = "10.255.255.1"
+    good_host.scheme = "https"
+
+    start = time.time()
+    try:
+        transporter.request(
+            verb=Verb.GET,
+            path="/test",
+            request_options=request_options,
+            use_read_transporter=True,
+        )
+        assert False, "Request should have timed out"
+    except Exception:
+        elapsed = time.time() - start
+        assert 1.5 < elapsed < 2.5, f"After reset should be ~2s, got {elapsed:.2f}s"
+
+
+async def test_async_retry_count_stateful():
+    """async connect timeout increases across failed requests: 2s -> 4s -> 6s."""
+    config, _ = create_config_with_host("10.255.255.1")
+    transporter = Transporter(config)
+    request_options = RequestOptions(config).merge()
+
+    times = []
+    for _ in range(3):
+        start = time.time()
+        try:
+            await transporter.request(
+                verb=Verb.GET,
+                path="/test",
+                request_options=request_options,
+                use_read_transporter=True,
+            )
+        except Exception:
+            times.append(time.time() - start)
+
+    await transporter.close()
+
+    assert 1.5 < times[0] < 2.5, f"Request 1 should be ~2s, got {times[0]:.2f}s"
+    assert 3.5 < times[1] < 4.5, f"Request 2 should be ~4s, got {times[1]:.2f}s"
+    assert 5.5 < times[2] < 7.0, f"Request 3 should be ~6s, got {times[2]:.2f}s"
+
+
+async def test_async_retry_count_resets():
+    """async retry_count resets to 0 after successful request."""
+    config, bad_host = create_config_with_host("10.255.255.1")
+    good_host = create_server_host()
+
+    transporter = Transporter(config)
+    request_options = RequestOptions(config).merge()
+
+    # fail twice to increment retry_count
+    for _ in range(2):
+        try:
+            await transporter.request(
+                verb=Verb.GET,
+                path="/test",
+                request_options=request_options,
+                use_read_transporter=True,
+            )
+        except Exception:
+            pass
+
+    # switch to good host and succeed
+    config.hosts = HostsCollection([good_host])
+    transporter._hosts = [good_host]
+    good_host.retry_count = bad_host.retry_count
+
+    response = await transporter.request(
+        verb=Verb.GET,
+        path="/1/test/instant",
+        request_options=request_options,
+        use_read_transporter=True,
+    )
+    assert response.status_code == 200
+    assert good_host.retry_count == 0, (
+        f"retry_count should reset to 0, got {good_host.retry_count}"
+    )
+
+    # point to bad host again, should timeout at 2s (not 6s)
+    good_host.url = "10.255.255.1"
+    good_host.scheme = "https"
+
+    start = time.time()
+    try:
+        await transporter.request(
+            verb=Verb.GET,
+            path="/test",
+            request_options=request_options,
+            use_read_transporter=True,
+        )
+        assert False, "Request should have timed out"
+    except Exception:
+        elapsed = time.time() - start
+        assert 1.5 < elapsed < 2.5, f"After reset should be ~2s, got {elapsed:.2f}s"
+    finally:
+        await transporter.close()
+
+
+# pytest integration for async tests
+def test_async_retry_count_stateful_sync():
+    asyncio.run(test_async_retry_count_stateful())
+
+
+def test_async_retry_count_resets_sync():
+    asyncio.run(test_async_retry_count_resets())