make test race safe

tests/integration/test_defer_fifo_simple.py

@@ -2,7 +2,7 @@
 
 import asyncio
 
-from aioesphomeapi import BinarySensorInfo, BinarySensorState, EntityState
+from aioesphomeapi import EntityState, Event, EventInfo, UserService
 import pytest
 
 from .types import APIClientConnectedFactory, RunCompiledFunction
@@ -22,57 +22,67 @@ async def test_defer_fifo_simple(
         assert device_info is not None
         assert device_info.name == "defer-fifo-simple"
 
-        # List entities to get the keys
-        entity_info, _ = await asyncio.wait_for(
+        # List entities and services
+        entity_info, services = await asyncio.wait_for(
             client.list_entities_services(), timeout=5.0
         )
 
         # Find our test entities
-        test_complete_entity: BinarySensorInfo | None = None
-        test_passed_entity: BinarySensorInfo | None = None
+        test_complete_entity: EventInfo | None = None
+        test_result_entity: EventInfo | None = None
 
         for entity in entity_info:
-            if isinstance(entity, BinarySensorInfo):
+            if isinstance(entity, EventInfo):
                 if entity.object_id == "test_complete":
                     test_complete_entity = entity
-                elif entity.object_id == "test_passed":
-                    test_passed_entity = entity
+                elif entity.object_id == "test_result":
+                    test_result_entity = entity
 
-        assert test_complete_entity is not None, "test_complete sensor not found"
-        assert test_passed_entity is not None, "test_passed sensor not found"
+        assert test_complete_entity is not None, "test_complete event not found"
+        assert test_result_entity is not None, "test_result event not found"
+
+        # Find our test service
+        run_defer_test_service: UserService | None = None
+        for service in services:
+            if service.name == "run_defer_test":
+                run_defer_test_service = service
+                break
+
+        assert run_defer_test_service is not None, "run_defer_test service not found"
 
         # Get the event loop
         loop = asyncio.get_running_loop()
 
-        # Subscribe to state changes
-        states: dict[int, EntityState] = {}
-        test_complete_future: asyncio.Future[BinarySensorState] = loop.create_future()
-        test_passed_future: asyncio.Future[BinarySensorState] = loop.create_future()
+        # Subscribe to states (events are delivered as EventStates through subscribe_states)
+        test_complete_future: asyncio.Future[bool] = loop.create_future()
+        test_result_future: asyncio.Future[bool] = loop.create_future()
 
         def on_state(state: EntityState) -> None:
-            states[state.key] = state
-            # Check if this is our test_complete binary sensor
-            if isinstance(state, BinarySensorState):
+            if isinstance(state, Event):
                 if state.key == test_complete_entity.key:
-                    if state.state and not test_complete_future.done():
-                        test_complete_future.set_result(state)
-                elif state.key == test_passed_entity.key:
-                    if not test_passed_future.done():
-                        test_passed_future.set_result(state)
+                    if (
+                        state.event_type == "test_finished"
+                        and not test_complete_future.done()
+                    ):
+                        test_complete_future.set_result(True)
+                elif state.key == test_result_entity.key:
+                    if not test_result_future.done():
+                        if state.event_type == "passed":
+                            test_result_future.set_result(True)
+                        elif state.event_type == "failed":
+                            test_result_future.set_result(False)
 
         client.subscribe_states(on_state)
 
+        # Call the run_defer_test service to start the test
+        client.execute_service(run_defer_test_service, {})
+
         # Wait for test completion with timeout
         try:
             await asyncio.wait_for(test_complete_future, timeout=10.0)
-            test_passed_state = await asyncio.wait_for(test_passed_future, timeout=1.0)
+            test_passed = await asyncio.wait_for(test_result_future, timeout=1.0)
         except asyncio.TimeoutError:
-            pytest.fail(
-                f"Test did not complete within 10 seconds. "
-                f"Received states: {list(states.values())}"
-            )
+            pytest.fail("Test did not complete within 10 seconds")
 
         # Verify the test passed
-        assert test_passed_state.state is True, (
-            "FIFO test failed - items executed out of order"
-        )
+        assert test_passed is True, "FIFO test failed - items executed out of order"