test: shave register/shutdown/TC waits on loopback

bluetoothbot · bluetoothbot · commit a22d0682c84c · 2026-05-18T00:29:31.000Z
`async_check_service` paid an inline `random.randint(150, 250)` ms wait
on every `register_service` &mdash; RFC 6762 &sect;8.1 thundering-herd avoidance
for real networks, pure overhead on 127.0.0.1. Extracted as a module
constant `_REGISTER_RANDOM_INTERVAL` and patched in the `quick_timing`
fixture to (1, 5)ms alongside the existing _CHECK_TIME / _REGISTER_TIME
/ _UNREGISTER_TIME shaves.

Also:
- `test_shutdown_loop`: drop `.result(1)` &rarr; `.result(0.1)` and patch
  `_TASK_AWAIT_TIMEOUT` to 0.1s. The 1s waits were `shutdown_loop`'s
  outer timeout on a never-completing `asyncio.sleep(5)` &mdash; the test only
  needs the loop to be stoppable while a task is pending.
- `test_tc_bit_defers_last_response_missing`: patch
  `_TC_DELAY_RANDOM_INTERVAL` (400-500ms, RFC 6762 &sect;7.2 TC-bit deferral)
  to (10, 20)ms and tighten the cleanup poll loop.
- `test_integration`: wait for the browser's first startup query to
  fire (with empty cache) before registering. Previously the test
  relied on the register's 150-250ms random wait being longer than the
  browser's 20-120ms first-query delay; with the new fast register that
  race flipped and the first query started seeing the known PTR via
  &sect;7.1 known-answer suppression.

Speedups on loopback (CPython 3.12):

| test                                                  | before | after |
| ----------------------------------------------------- | ------ | ----- |
| test_shutdown_loop                                    | 1.16s  | 0.26s |
| test_tc_bit_defers_last_response_missing              | 0.79s  | 0.32s |
| test_async_service_registration_name_conflict        | 0.72s  | 0.10s |
| test_name_conflicts                                   | 0.50s  | 0.10s |

Plus a smaller transparent shave on every other `quick_timing`
register-based test. Full suite: 338 passed, 2 skipped. No production
behavior change &mdash; `_REGISTER_RANDOM_INTERVAL` still defaults to the
RFC 6762 &sect;8.1 value on real networks.
diff --git a/src/zeroconf/_core.py b/src/zeroconf/_core.py
@@ -104,6 +104,10 @@
 
 _REGISTER_BROADCASTS = 3
 
+# Random delay before probing (RFC 6762 &sect;8.1) to avoid a thundering
+# herd when multiple services start at once.
+_REGISTER_RANDOM_INTERVAL = (150, 250)  # ms
+
 
 def async_send_with_transport(
     log_debug: bool,
@@ -561,7 +565,7 @@ async def async_check_service(
 
         # Wait a random amount of time up avoid collisions and avoid
         # a thundering herd when multiple services are started on the network
-        await self.async_wait(random.randint(150, 250))  # noqa: S311
+        await self.async_wait(random.randint(*_REGISTER_RANDOM_INTERVAL))  # noqa: S311
 
         next_instance_number = 2
         next_time = now = current_time_millis()
diff --git a/tests/conftest.py b/tests/conftest.py
@@ -49,15 +49,17 @@ def quick_timing() -> Generator[None]:
     """Shorten the probe/announce/goodbye intervals for tests on loopback.
 
     The production values (_CHECK_TIME=500ms, _REGISTER_TIME=225ms,
-    _UNREGISTER_TIME=125ms) exist for RFC 6762 interop on real
-    networks. Tests on 127.0.0.1 do not need them and pay 1-2s per
-    register/unregister cycle without this fixture. Opt in by adding
-    `quick_timing` to a test's argument list.
+    _UNREGISTER_TIME=125ms, _REGISTER_RANDOM_INTERVAL=(150, 250)ms)
+    exist for RFC 6762 interop on real networks. Tests on 127.0.0.1
+    do not need them and pay 1-2s per register/unregister cycle
+    without this fixture. Opt in by adding `quick_timing` to a
+    test's argument list.
     """
     with (
         patch.object(_core, "_CHECK_TIME", 10),
         patch.object(_core, "_REGISTER_TIME", 10),
         patch.object(_core, "_UNREGISTER_TIME", 10),
+        patch.object(_core, "_REGISTER_RANDOM_INTERVAL", (1, 5)),
     ):
         yield
 
diff --git a/tests/test_asyncio.py b/tests/test_asyncio.py
@@ -1060,6 +1060,12 @@ def send(out, addr=const._MDNS_ADDR, port=const._MDNS_PORT, v6_flow_scope=()):
             "ash-2.local.",
             addresses=[socket.inet_aton("10.0.1.2")],
         )
+        # Wait for the browser's first startup query to land (with an empty
+        # cache) before registering &mdash; otherwise on fast loopback the register
+        # may finish before the first query fires, and answers[0] picks up
+        # the known PTR via &sect;7.1 suppression.
+        await asyncio.wait_for(got_query.wait(), 1)
+        got_query.clear()
         task = await aio_zeroconf_registrar.async_register_service(info)
         await task
         loop = asyncio.get_running_loop()
diff --git a/tests/test_core.py b/tests/test_core.py
@@ -19,7 +19,7 @@
 import pytest
 
 import zeroconf as r
-from zeroconf import NotRunningException, Zeroconf, const, current_time_millis
+from zeroconf import NotRunningException, Zeroconf, _listener, const, current_time_millis
 from zeroconf._listener import AsyncListener, _WrappedTransport
 from zeroconf._protocol.incoming import DNSIncoming
 from zeroconf.asyncio import AsyncZeroconf
@@ -631,6 +631,7 @@ def test_tc_bit_defers():
     zc.close()
 
 
+@patch.object(_listener, "_TC_DELAY_RANDOM_INTERVAL", (10, 20))
 def test_tc_bit_defers_last_response_missing():
     zc = Zeroconf(interfaces=["127.0.0.1"])
     _wait_for_start(zc)
@@ -730,8 +731,8 @@ def test_tc_bit_defers_last_response_missing():
     assert timer3.cancelled()
     assert timer4 != timer3
 
-    for _ in range(8):
-        time.sleep(0.1)
+    for _ in range(20):
+        time.sleep(0.02)
         if source_ip not in protocol._timers and source_ip not in protocol._deferred:
             break
 
diff --git a/tests/utils/test_asyncio.py b/tests/utils/test_asyncio.py
@@ -65,6 +65,7 @@ async def _async_wait_or_timeout():
         await task
 
 
+@patch.object(aioutils, "_TASK_AWAIT_TIMEOUT", 0.1)
 def test_shutdown_loop() -> None:
     """Test shutting down an event loop."""
     loop = None
@@ -89,7 +90,7 @@ def _run_coro() -> None:
         runcoro_thread_ready.set()
         assert loop is not None
         with contextlib.suppress(concurrent.futures.TimeoutError):
-            asyncio.run_coroutine_threadsafe(_still_running(), loop).result(1)
+            asyncio.run_coroutine_threadsafe(_still_running(), loop).result(0.1)
 
     runcoro_thread = threading.Thread(target=_run_coro, daemon=True)
     runcoro_thread.start()
