tests: calibrate polling deadlines

Use the 100 ms prompt deadline for single-hop pipeline callbacks and a one-second eventual deadline for handler work crossing queues, event loops, and worker threads. Keep five-second bounds only for deliberate deadlock-safety orchestration.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: cartertinney

tests/unit/common/pipeline/test_pipeline_stages_base.py

@@ -27,6 +27,7 @@
 from .helpers import StageRunOpTestBase, StageHandlePipelineEventTestBase
 from .fixtures import ArbitraryOperation
 from tests.unit.common.pipeline import pipeline_stage_test
+from tests.unit.helpers import PROMPT_TIMEOUT
 
 this_module = sys.modules[__name__]
 logging.basicConfig(level=logging.DEBUG)
@@ -188,7 +189,7 @@ def test_invoke_handler(self, mocker, stage, event, poll_until):
         stage.on_connected_handler = mock_handler
         stage.handle_pipeline_event(event)
         # Wait for the handler invocation to complete
-        poll_until(lambda: mock_handler.call_count >= 1, timeout=5)
+        poll_until(lambda: mock_handler.call_count >= 1, timeout=PROMPT_TIMEOUT)
         assert mock_handler.call_count == 1
         assert mock_handler.call_args == mocker.call()
 
@@ -209,7 +210,7 @@ def test_invoke_handler(self, mocker, stage, event, poll_until):
         stage.on_disconnected_handler = mock_handler
         stage.handle_pipeline_event(event)
         # Wait for the handler invocation to complete
-        poll_until(lambda: mock_handler.call_count >= 1, timeout=5)
+        poll_until(lambda: mock_handler.call_count >= 1, timeout=PROMPT_TIMEOUT)
         assert mock_handler.call_count == 1
         assert mock_handler.call_args == mocker.call()
 
@@ -230,7 +231,7 @@ def test_invoke_handler(self, mocker, stage, event, poll_until):
         stage.on_new_sastoken_required_handler = mock_handler
         stage.handle_pipeline_event(event)
         # Wait for the handler invocation to complete
-        poll_until(lambda: mock_handler.call_count >= 1, timeout=5)
+        poll_until(lambda: mock_handler.call_count >= 1, timeout=PROMPT_TIMEOUT)
         assert mock_handler.call_count == 1
         assert mock_handler.call_args == mocker.call()
 
@@ -253,7 +254,7 @@ def test_invoke_handler(self, mocker, stage, event, poll_until):
         stage.on_background_exception_handler = mock_handler
         stage.handle_pipeline_event(event)
         # Wait for the handler invocation to complete
-        poll_until(lambda: mock_handler.call_count >= 1, timeout=5)
+        poll_until(lambda: mock_handler.call_count >= 1, timeout=PROMPT_TIMEOUT)
         assert mock_handler.call_count == 1
         assert mock_handler.call_args == mocker.call(event.e)
 
@@ -274,7 +275,7 @@ def test_invoke_handler(self, mocker, stage, event, poll_until):
         stage.on_pipeline_event_handler = mock_handler
         stage.handle_pipeline_event(event)
         # Wait for the handler invocation to complete
-        poll_until(lambda: mock_handler.call_count >= 1, timeout=5)
+        poll_until(lambda: mock_handler.call_count >= 1, timeout=PROMPT_TIMEOUT)
         assert mock_handler.call_count == 1
         assert mock_handler.call_args == mocker.call(event)
 

tests/unit/helpers.py

@@ -6,3 +6,6 @@
 
 # Maximum time allowed for an operation expected to complete promptly.
 PROMPT_TIMEOUT = 0.1
+
+# Maximum time allowed for asynchronous work crossing threads or event loops.
+EVENTUAL_TIMEOUT = 1

tests/unit/iothub/aio/test_async_handler_manager.py

@@ -18,6 +18,7 @@
 from azure.iot.device.iothub.sync_handler_manager import MESSAGE, METHOD, TWIN_DP_PATCH
 from azure.iot.device.iothub.inbox_manager import InboxManager
 from azure.iot.device.iothub.aio.async_inbox import AsyncClientInbox
+from tests.unit.helpers import EVENTUAL_TIMEOUT
 
 logging.basicConfig(level=logging.DEBUG)
 
@@ -413,7 +414,7 @@ async def test_handler_invoked(
         mock_obj = mocker.MagicMock()
         inbox.put(mock_obj)
         # Wait for the handler invocation to complete
-        await async_poll_until(lambda: handler_checker.handler_called, timeout=5)
+        await async_poll_until(lambda: handler_checker.handler_called, timeout=EVENTUAL_TIMEOUT)
 
         # Handler has been called with the item from the inbox
         assert handler_checker.handler_called is True
@@ -441,7 +442,9 @@ async def test_handler_invoked_multiple(
         for _ in range(5):
             inbox.put(mocker.MagicMock())
         # Wait for all handler invocations to complete
-        await async_poll_until(lambda: handler_checker.handler_call_count >= 5, timeout=5)
+        await async_poll_until(
+            lambda: handler_checker.handler_call_count >= 5, timeout=EVENTUAL_TIMEOUT
+        )
 
         # Handler has been called 5 times
         assert handler_checker.handler_call_count == 5
@@ -550,7 +553,7 @@ async def coro_handler(arg):
         # Add an item to corresponding inbox, triggering the handler
         inbox.put(mocker.MagicMock())
         # Wait for the background exception handler to be called
-        await async_poll_until(lambda: background_exc_spy.call_count >= 1, timeout=5)
+        await async_poll_until(lambda: background_exc_spy.call_count >= 1, timeout=EVENTUAL_TIMEOUT)
         # Background exception handler was called
         assert background_exc_spy.call_count == 1
         e = background_exc_spy.call_args[0][0]
@@ -567,7 +570,7 @@ async def coro_handler(arg):
         # Add an item to corresponding inbox, triggering the handler
         inbox.put(mocker.MagicMock())
         # Wait for the background exception handler to be called
-        await async_poll_until(lambda: background_exc_spy.call_count >= 1, timeout=5)
+        await async_poll_until(lambda: background_exc_spy.call_count >= 1, timeout=EVENTUAL_TIMEOUT)
         # Background exception handler was called
         assert background_exc_spy.call_count == 1
         e = background_exc_spy.call_args[0][0]
@@ -596,7 +599,8 @@ def handler1(arg):
         inbox.put(mocker.MagicMock())
         # Wait for handler1 to replace itself with handler2
         await async_poll_until(
-            lambda: getattr(handler_manager, handler_name) is handler2, timeout=5
+            lambda: getattr(handler_manager, handler_name) is handler2,
+            timeout=EVENTUAL_TIMEOUT,
         )
         # The set handler (handler1) has been replaced with a new handler (handler2)
         assert getattr(handler_manager, handler_name) is not handler1
@@ -605,15 +609,16 @@ def handler1(arg):
         inbox.put(mocker.MagicMock())
         # Wait for handler2 to replace itself with the mock
         await async_poll_until(
-            lambda: getattr(handler_manager, handler_name) is mock_handler, timeout=5
+            lambda: getattr(handler_manager, handler_name) is mock_handler,
+            timeout=EVENTUAL_TIMEOUT,
         )
         # The set handler (handler2) has now been replaced by a mock handler
         assert getattr(handler_manager, handler_name) is not handler2
         assert getattr(handler_manager, handler_name) is mock_handler
         # Add a new item to the inbox
         inbox.put(mocker.MagicMock())
         # Wait for the mock handler invocation to complete
-        await async_poll_until(lambda: mock_handler.call_count >= 1, timeout=5)
+        await async_poll_until(lambda: mock_handler.call_count >= 1, timeout=EVENTUAL_TIMEOUT)
         # The mock was now called
         assert getattr(handler_manager, handler_name).call_count == 1
 
@@ -706,7 +711,9 @@ async def test_handler_invoked(
         # Add the event to the client inbox
         inbox.put(event)
         # Wait for the handler invocation to complete
-        await async_poll_until(lambda: handler_checker.handler_call_count >= 1, timeout=5)
+        await async_poll_until(
+            lambda: handler_checker.handler_call_count >= 1, timeout=EVENTUAL_TIMEOUT
+        )
 
         # Handler has been called with the arguments from the event
         assert handler_checker.handler_call_count == 1
@@ -716,7 +723,7 @@ async def test_handler_invoked(
         non_matching_event = client_event.ClientEvent("NON_MATCHING_EVENT")
         inbox.put(non_matching_event)
         # Wait for the runner to consume the non-matching event
-        await async_poll_until(inbox.empty, timeout=5)
+        await async_poll_until(inbox.empty, timeout=EVENTUAL_TIMEOUT)
 
         # Handler has not been called again
         assert handler_checker.handler_call_count == 1
@@ -743,7 +750,9 @@ async def test_handler_invoked_multiple(
         for _ in range(5):
             inbox.put(event)
         # Wait for all handler invocations to complete
-        await async_poll_until(lambda: handler_checker.handler_call_count >= 5, timeout=5)
+        await async_poll_until(
+            lambda: handler_checker.handler_call_count >= 5, timeout=EVENTUAL_TIMEOUT
+        )
 
         # Handler has been called 5 times
         assert handler_checker.handler_call_count == 5
@@ -777,7 +786,7 @@ async def coro_handler(*args):
         # Add an item to corresponding inbox, triggering the handler
         inbox.put(event)
         # Wait for the background exception handler to be called
-        await async_poll_until(lambda: background_exc_spy.call_count >= 1, timeout=5)
+        await async_poll_until(lambda: background_exc_spy.call_count >= 1, timeout=EVENTUAL_TIMEOUT)
         # Background exception handler was called
         assert background_exc_spy.call_count == 1
         e = background_exc_spy.call_args[0][0]
@@ -794,7 +803,7 @@ async def coro_handler(*args):
         # Add an item to corresponding inbox, triggering the handler
         inbox.put(event)
         # Wait for the background exception handler to be called
-        await async_poll_until(lambda: background_exc_spy.call_count >= 1, timeout=5)
+        await async_poll_until(lambda: background_exc_spy.call_count >= 1, timeout=EVENTUAL_TIMEOUT)
         # Background exception handler was called
         assert background_exc_spy.call_count == 1
         e = background_exc_spy.call_args[0][0]
@@ -823,7 +832,8 @@ def handler1(*args):
         inbox.put(event)
         # Wait for handler1 to replace itself with handler2
         await async_poll_until(
-            lambda: getattr(handler_manager, handler_name) is handler2, timeout=5
+            lambda: getattr(handler_manager, handler_name) is handler2,
+            timeout=EVENTUAL_TIMEOUT,
         )
         # The set handler (handler1) has been replaced with a new handler (handler2)
         assert getattr(handler_manager, handler_name) is not handler1
@@ -832,15 +842,16 @@ def handler1(*args):
         inbox.put(event)
         # Wait for handler2 to replace itself with the mock
         await async_poll_until(
-            lambda: getattr(handler_manager, handler_name) is mock_handler, timeout=5
+            lambda: getattr(handler_manager, handler_name) is mock_handler,
+            timeout=EVENTUAL_TIMEOUT,
         )
         # The set handler (handler2) has now been replaced by a mock handler
         assert getattr(handler_manager, handler_name) is not handler2
         assert getattr(handler_manager, handler_name) is mock_handler
         # Add a new item to the inbox
         inbox.put(event)
         # Wait for the mock handler invocation to complete
-        await async_poll_until(lambda: mock_handler.call_count >= 1, timeout=5)
+        await async_poll_until(lambda: mock_handler.call_count >= 1, timeout=EVENTUAL_TIMEOUT)
         # The mock was now called
         assert getattr(handler_manager, handler_name).call_count == 1
 

tests/unit/iothub/test_sync_handler_manager.py

@@ -17,6 +17,7 @@
 from azure.iot.device.iothub.sync_handler_manager import MESSAGE, METHOD, TWIN_DP_PATCH
 from azure.iot.device.iothub.inbox_manager import InboxManager
 from azure.iot.device.iothub.sync_inbox import SyncClientInbox
+from tests.unit.helpers import EVENTUAL_TIMEOUT
 
 logging.basicConfig(level=logging.DEBUG)
 
@@ -363,7 +364,7 @@ def test_handler_invoked(self, mocker, handler_name, handler_manager, inbox, pol
         mock_obj = mocker.MagicMock()
         inbox.put(mock_obj)
         # Wait for the handler invocation to complete
-        poll_until(lambda: mock_handler.call_count >= 1, timeout=5)
+        poll_until(lambda: mock_handler.call_count >= 1, timeout=EVENTUAL_TIMEOUT)
 
         # Handler has been called with the item from the inbox
         assert mock_handler.call_count == 1
@@ -385,7 +386,7 @@ def test_handler_invoked_multiple(
         for _ in range(5):
             inbox.put(mocker.MagicMock())
         # Wait for all handler invocations to complete
-        poll_until(lambda: mock_handler.call_count >= 5, timeout=5)
+        poll_until(lambda: mock_handler.call_count >= 5, timeout=EVENTUAL_TIMEOUT)
 
         # Handler has been called 5 times
         assert mock_handler.call_count == 5
@@ -485,7 +486,7 @@ def test_exception_in_handler(
         # Add an item to corresponding inbox, triggering the handler
         inbox.put(mocker.MagicMock())
         # Wait for the background exception handler to be called
-        poll_until(lambda: background_exc_spy.call_count >= 1, timeout=5)
+        poll_until(lambda: background_exc_spy.call_count >= 1, timeout=EVENTUAL_TIMEOUT)
         # Handler has now been called
         assert mock_handler.call_count == 1
         # Background exception handler was called
@@ -506,14 +507,20 @@ def handler(arg):
 
         inbox.put(mocker.MagicMock())
         # Wait for the handler to replace itself with the mock
-        poll_until(lambda: getattr(handler_manager, handler_name) is not handler, timeout=5)
+        poll_until(
+            lambda: getattr(handler_manager, handler_name) is not handler,
+            timeout=EVENTUAL_TIMEOUT,
+        )
         # Handler has been replaced with a mock, but the mock has not been invoked
         assert getattr(handler_manager, handler_name) is not handler
         assert getattr(handler_manager, handler_name).call_count == 0
         # Add a new item to the inbox
         inbox.put(mocker.MagicMock())
         # Wait for the mock handler invocation to complete
-        poll_until(lambda: getattr(handler_manager, handler_name).call_count >= 1, timeout=5)
+        poll_until(
+            lambda: getattr(handler_manager, handler_name).call_count >= 1,
+            timeout=EVENTUAL_TIMEOUT,
+        )
         # The mock was now called
         assert getattr(handler_manager, handler_name).call_count == 1
 
@@ -597,7 +604,7 @@ def test_handler_invoked(self, mocker, handler_name, handler_manager, inbox, eve
         # Add the event to the client event inbox
         inbox.put(event)
         # Wait for the handler invocation to complete
-        poll_until(lambda: mock_handler.call_count >= 1, timeout=5)
+        poll_until(lambda: mock_handler.call_count >= 1, timeout=EVENTUAL_TIMEOUT)
 
         # Handler has been called with the arguments from the event
         assert mock_handler.call_count == 1
@@ -607,7 +614,7 @@ def test_handler_invoked(self, mocker, handler_name, handler_manager, inbox, eve
         non_matching_event = client_event.ClientEvent("NON_MATCHING_EVENT")
         inbox.put(non_matching_event)
         # Wait for the runner to consume the non-matching event
-        poll_until(inbox.empty, timeout=5)
+        poll_until(inbox.empty, timeout=EVENTUAL_TIMEOUT)
 
         # Handler has not been called again
         assert mock_handler.call_count == 1
@@ -628,7 +635,7 @@ def test_handler_invoked_multiple(
         for _ in range(5):
             inbox.put(event)
         # Wait for all handler invocations to complete
-        poll_until(lambda: mock_handler.call_count >= 5, timeout=5)
+        poll_until(lambda: mock_handler.call_count >= 5, timeout=EVENTUAL_TIMEOUT)
 
         # Handler has been called 5 times
         assert mock_handler.call_count == 5
@@ -652,7 +659,7 @@ def test_exception_in_handler(
         # Add the event to the client event inbox, triggering the handler
         inbox.put(event)
         # Wait for the background exception handler to be called
-        poll_until(lambda: background_exc_spy.call_count >= 1, timeout=5)
+        poll_until(lambda: background_exc_spy.call_count >= 1, timeout=EVENTUAL_TIMEOUT)
         # Handler has now been called
         assert mock_handler.call_count == 1
         # Background exception handler was called
@@ -673,14 +680,20 @@ def handler(*args):
 
         inbox.put(event)
         # Wait for the handler to replace itself with the mock
-        poll_until(lambda: getattr(handler_manager, handler_name) is not handler, timeout=5)
+        poll_until(
+            lambda: getattr(handler_manager, handler_name) is not handler,
+            timeout=EVENTUAL_TIMEOUT,
+        )
         # Handler has been replaced with a mock, but the mock has not been invoked
         assert getattr(handler_manager, handler_name) is not handler
         assert getattr(handler_manager, handler_name).call_count == 0
         # Add a new event to the inbox
         inbox.put(event)
         # Wait for the mock handler invocation to complete
-        poll_until(lambda: getattr(handler_manager, handler_name).call_count >= 1, timeout=5)
+        poll_until(
+            lambda: getattr(handler_manager, handler_name).call_count >= 1,
+            timeout=EVENTUAL_TIMEOUT,
+        )
         # The mock was now called
         assert getattr(handler_manager, handler_name).call_count == 1