Merge branch 'reduce_main_loop' into integration

tests/integration/fixtures/defer_fifo_simple.yaml

@@ -0,0 +1,93 @@
+esphome:
+  name: defer-fifo-simple
+  on_boot:
+    - lambda: |-
+        // Test 1: Test set_timeout with 0 delay (direct scheduler call)
+        static int set_timeout_order = 0;
+        static bool set_timeout_passed = true;
+
+        ESP_LOGD("defer_test", "Test 1: Testing set_timeout(0) for FIFO order...");
+        for (int i = 0; i < 10; i++) {
+          int expected = i;
+          App.scheduler.set_timeout((Component*)nullptr, nullptr, 0, [expected]() {
+            ESP_LOGD("defer_test", "set_timeout(0) item %d executed, order %d", expected, set_timeout_order);
+            if (set_timeout_order != expected) {
+              ESP_LOGE("defer_test", "FIFO violation in set_timeout: expected %d but got execution order %d", expected, set_timeout_order);
+              set_timeout_passed = false;
+            }
+            set_timeout_order++;
+
+            if (set_timeout_order == 10) {
+              if (set_timeout_passed) {
+                ESP_LOGI("defer_test", "✓ Test 1 PASSED - set_timeout(0) maintains FIFO order");
+              } else {
+                ESP_LOGE("defer_test", "✗ Test 1 FAILED - set_timeout(0) executed out of order");
+              }
+
+              // Start Test 2 after Test 1 completes
+              App.scheduler.set_timeout((Component*)nullptr, nullptr, 100, []() {
+                // Test 2: Test defer() method (component method)
+                static int defer_order = 0;
+                static bool defer_passed = true;
+
+                ESP_LOGD("defer_test", "Test 2: Testing defer() for FIFO order...");
+
+                // Create a test component class that exposes defer()
+                class TestComponent : public Component {
+                public:
+                  void test_defer() {
+                    for (int i = 0; i < 10; i++) {
+                      int expected = i;
+                      this->defer([expected]() {
+                        ESP_LOGD("defer_test", "defer() item %d executed, order %d", expected, defer_order);
+                        if (defer_order != expected) {
+                          ESP_LOGE("defer_test", "FIFO violation in defer: expected %d but got execution order %d", expected, defer_order);
+                          defer_passed = false;
+                        }
+                        defer_order++;
+
+                        if (defer_order == 10) {
+                          bool all_passed = set_timeout_passed && defer_passed;
+                          if (defer_passed) {
+                            ESP_LOGI("defer_test", "✓ Test 2 PASSED - defer() maintains FIFO order");
+                            if (all_passed) {
+                              ESP_LOGI("defer_test", "✓ ALL TESTS PASSED - Both set_timeout(0) and defer() maintain FIFO order");
+                            }
+                          } else {
+                            ESP_LOGE("defer_test", "✗ Test 2 FAILED - defer() executed out of order");
+                          }
+
+                          // Publish test results
+                          id(test_complete)->publish_state(true);
+                          id(test_passed)->publish_state(all_passed);
+                        }
+                      });
+                    }
+                  }
+                };
+
+                TestComponent test_component;
+                test_component.test_defer();
+
+                ESP_LOGD("defer_test", "Deferred 10 items using defer(), waiting for execution...");
+              });
+            }
+          });
+        }
+
+        ESP_LOGD("defer_test", "Deferred 10 items using set_timeout(0), waiting for execution...");
+
+host:
+
+logger:
+  level: DEBUG
+
+api:
+
+binary_sensor:
+  - platform: template
+    name: "Test Complete"
+    id: test_complete
+  - platform: template
+    name: "Test Passed"
+    id: test_passed

tests/integration/test_defer_fifo_simple.py

@@ -0,0 +1,78 @@
+"""Simple test that defer() maintains FIFO order."""
+
+import asyncio
+
+from aioesphomeapi import BinarySensorInfo, BinarySensorState, EntityState
+import pytest
+
+from .types import APIClientConnectedFactory, RunCompiledFunction
+
+
+@pytest.mark.asyncio
+async def test_defer_fifo_simple(
+    yaml_config: str,
+    run_compiled: RunCompiledFunction,
+    api_client_connected: APIClientConnectedFactory,
+) -> None:
+    """Test that defer() maintains FIFO order with a simple test."""
+
+    async with run_compiled(yaml_config), api_client_connected() as client:
+        # Verify we can connect
+        device_info = await client.device_info()
+        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(
+            client.list_entities_services(), timeout=5.0
+        )
+
+        # Find our test entities
+        test_complete_entity: BinarySensorInfo | None = None
+        test_passed_entity: BinarySensorInfo | None = None
+
+        for entity in entity_info:
+            if isinstance(entity, BinarySensorInfo):
+                if entity.object_id == "test_complete":
+                    test_complete_entity = entity
+                elif entity.object_id == "test_passed":
+                    test_passed_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"
+
+        # 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()
+
+        def on_state(state: EntityState) -> None:
+            states[state.key] = state
+            # Check if this is our test_complete binary sensor
+            if isinstance(state, BinarySensorState):
+                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)
+
+        client.subscribe_states(on_state)
+
+        # 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)
+        except asyncio.TimeoutError:
+            pytest.fail(
+                f"Test did not complete within 10 seconds. "
+                f"Received states: {list(states.values())}"
+            )
+
+        # Verify the test passed
+        assert test_passed_state.state is True, (
+            "FIFO test failed - items executed out of order"
+        )