test(query_namespaces): de-flake parallel-vs-serial perf assertion

With ~35 ms queries and http2=False, the first parallel fan-out has to
open ~N concurrent TCP+TLS connections — handshake overhead, plus any
single tail-latency outlier blowing out max(times), regularly inverts
serial-sum vs parallel-max. Warm the pool with a throwaway
query_namespaces() call, take the min of 3 sample pairs, and loosen
the ratio threshold from 0.60 to 0.75. Parallelism is still
meaningfully proven; CI variance no longer masquerades as a regression.

Author: jhamon

tests/integration/test_query_namespaces.py

@@ -754,23 +754,37 @@ def test_query_namespaces_parallel_faster_than_serial_rest(client: Pinecone) ->
                 description=f"{ns} vectors queryable before parallel test",
             )
 
-        # Serial baseline: loop over each namespace individually
-        serial_start = time.monotonic()
-        for ns in namespaces:
-            index.query(vector=[0.5, 0.5], top_k=5, namespace=ns)
-        serial_elapsed = time.monotonic() - serial_start
-
-        # Parallel call: single query_namespaces fan-out
-        parallel_start = time.monotonic()
-        results = index.query_namespaces(
-            vector=[0.5, 0.5],
-            namespaces=namespaces,
-            metric="cosine",
-            top_k=5,
-        )
-        parallel_elapsed = time.monotonic() - parallel_start
+        # Warm up the HTTP connection pool before measuring. The first
+        # parallel fan-out has to open ~N concurrent TCP+TLS connections
+        # (http2=False, so each query needs its own connection); without
+        # this warmup, parallel-vs-serial comparisons capture handshake
+        # overhead rather than query overlap.
+        index.query_namespaces(vector=[0.5, 0.5], namespaces=namespaces, metric="cosine", top_k=5)
+
+        # Take the best (min) of multiple samples to reject CI noise — a
+        # single tail-latency outlier on one parallel query inflates
+        # max(times), so any cleaner sample is a more honest signal.
+        samples = 3
+        serial_elapsed = float("inf")
+        parallel_elapsed = float("inf")
+        results: QueryNamespacesResults | None = None
+        for _ in range(samples):
+            serial_start = time.monotonic()
+            for ns in namespaces:
+                index.query(vector=[0.5, 0.5], top_k=5, namespace=ns)
+            serial_elapsed = min(serial_elapsed, time.monotonic() - serial_start)
+
+            parallel_start = time.monotonic()
+            results = index.query_namespaces(
+                vector=[0.5, 0.5],
+                namespaces=namespaces,
+                metric="cosine",
+                top_k=5,
+            )
+            parallel_elapsed = min(parallel_elapsed, time.monotonic() - parallel_start)
 
         # Correctness assertions
+        assert results is not None
         assert isinstance(results, QueryNamespacesResults)
         assert isinstance(results.matches, list)
         assert 1 <= len(results.matches) <= 5
@@ -787,11 +801,13 @@ def test_query_namespaces_parallel_faster_than_serial_rest(client: Pinecone) ->
         if serial_elapsed < 0.1:
             pytest.skip(f"serial baseline too fast to be meaningful: {serial_elapsed:.3f}s")
 
-        # Parallelism assertion: parallel must be substantially faster
-        assert parallel_elapsed < serial_elapsed * 0.6, (
+        # Parallelism assertion: parallel must be substantially faster.
+        # Threshold is generous (0.75) to absorb residual CI variance —
+        # even a small parallel benefit proves fan-out is happening.
+        assert parallel_elapsed < serial_elapsed * 0.75, (
             f"query_namespaces must fan out queries in parallel. "
             f"serial={serial_elapsed:.3f}s parallel={parallel_elapsed:.3f}s "
-            f"ratio={parallel_elapsed / serial_elapsed:.2f} (expected < 0.60)"
+            f"ratio={parallel_elapsed / serial_elapsed:.2f} (expected < 0.75)"
         )
     finally:
         ensure_index_deleted(client, name)

tests/integration/test_query_namespaces_async.py

@@ -832,23 +832,39 @@ async def test_query_namespaces_parallel_faster_than_serial_rest_async(
                 description=f"{ns} vectors queryable (async) before parallel test",
             )
 
-        # Serial baseline: loop over each namespace sequentially
-        serial_start = time.monotonic()
-        for ns in namespaces:
-            await idx.query(vector=[0.5, 0.5], top_k=5, namespace=ns)
-        serial_elapsed = time.monotonic() - serial_start
-
-        # Parallel call: single query_namespaces fan-out via asyncio.gather
-        parallel_start = time.monotonic()
-        results = await idx.query_namespaces(
-            vector=[0.5, 0.5],
-            namespaces=namespaces,
-            metric="cosine",
-            top_k=5,
-        )
-        parallel_elapsed = time.monotonic() - parallel_start
+        # Warm up the HTTP connection pool before measuring. The first
+        # parallel fan-out has to open ~N concurrent TCP+TLS connections
+        # (http2=False, so each query needs its own connection); without
+        # this warmup, parallel-vs-serial comparisons capture handshake
+        # overhead rather than query overlap.
+        await idx.query_namespaces(
+            vector=[0.5, 0.5], namespaces=namespaces, metric="cosine", top_k=5
+        )
+
+        # Take the best (min) of multiple samples to reject CI noise — a
+        # single tail-latency outlier on one parallel query inflates
+        # max(times), so any cleaner sample is a more honest signal.
+        samples = 3
+        serial_elapsed = float("inf")
+        parallel_elapsed = float("inf")
+        results: QueryNamespacesResults | None = None
+        for _ in range(samples):
+            serial_start = time.monotonic()
+            for ns in namespaces:
+                await idx.query(vector=[0.5, 0.5], top_k=5, namespace=ns)
+            serial_elapsed = min(serial_elapsed, time.monotonic() - serial_start)
+
+            parallel_start = time.monotonic()
+            results = await idx.query_namespaces(
+                vector=[0.5, 0.5],
+                namespaces=namespaces,
+                metric="cosine",
+                top_k=5,
+            )
+            parallel_elapsed = min(parallel_elapsed, time.monotonic() - parallel_start)
 
         # Correctness assertions
+        assert results is not None
         assert isinstance(results, QueryNamespacesResults)
         assert isinstance(results.matches, list)
         assert 1 <= len(results.matches) <= 5
@@ -865,11 +881,13 @@ async def test_query_namespaces_parallel_faster_than_serial_rest_async(
         if serial_elapsed < 0.1:
             pytest.skip(f"serial baseline too fast to be meaningful: {serial_elapsed:.3f}s")
 
-        # Parallelism assertion: parallel must be substantially faster
-        assert parallel_elapsed < serial_elapsed * 0.6, (
+        # Parallelism assertion: parallel must be substantially faster.
+        # Threshold is generous (0.75) to absorb residual CI variance —
+        # even a small parallel benefit proves fan-out is happening.
+        assert parallel_elapsed < serial_elapsed * 0.75, (
             f"query_namespaces must fan out queries in parallel. "
             f"serial={serial_elapsed:.3f}s parallel={parallel_elapsed:.3f}s "
-            f"ratio={parallel_elapsed / serial_elapsed:.2f} (expected < 0.60)"
+            f"ratio={parallel_elapsed / serial_elapsed:.2f} (expected < 0.75)"
         )
     finally:
         if idx is not None: