[script][wait_until] Fix FIFO ordering and reentrancy bugs (#12049)

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

tests/integration/test_script_delay_params.py

@@ -0,0 +1,121 @@
+"""Integration test for script.wait FIFO ordering (issues #12043, #12044).
+
+This test verifies that ScriptWaitAction processes queued items in FIFO order.
+
+PR #7972 introduced bugs in ScriptWaitAction:
+- Used emplace_front() causing LIFO ordering instead of FIFO
+- Called loop() synchronously causing reentrancy issues
+- Used while loop processing entire queue causing infinite loops
+
+These bugs manifested as:
+- Scripts becoming "zombies" (stuck in running state)
+- script.wait hanging forever
+- Incorrect execution order
+"""
+
+from __future__ import annotations
+
+import asyncio
+import re
+
+import pytest
+
+from .types import APIClientConnectedFactory, RunCompiledFunction
+
+
+@pytest.mark.asyncio
+async def test_script_delay_with_params(
+    yaml_config: str,
+    run_compiled: RunCompiledFunction,
+    api_client_connected: APIClientConnectedFactory,
+) -> None:
+    """Test that script.wait processes queued items in FIFO order.
+
+    This reproduces issues #12043 and #12044 where scripts would hang or become
+    zombies due to LIFO ordering bugs in ScriptWaitAction from PR #7972.
+    """
+    test_complete = asyncio.Event()
+
+    # Patterns to match in logs
+    father_calling_pattern = re.compile(r"Father iteration (\d+): calling son")
+    son_started_pattern = re.compile(r"Son script started with iteration (\d+)")
+    son_delaying_pattern = re.compile(r"Son script delaying for iteration (\d+)")
+    son_finished_pattern = re.compile(r"Son script finished with iteration (\d+)")
+    father_wait_returned_pattern = re.compile(
+        r"Father iteration (\d+): son finished, wait returned"
+    )
+
+    # Track which iterations completed
+    father_calling = set()
+    son_started = set()
+    son_delaying = set()
+    son_finished = set()
+    wait_returned = set()
+
+    def check_output(line: str) -> None:
+        """Check log output for expected messages."""
+        if test_complete.is_set():
+            return
+
+        if mo := father_calling_pattern.search(line):
+            father_calling.add(int(mo.group(1)))
+        elif mo := son_started_pattern.search(line):
+            son_started.add(int(mo.group(1)))
+        elif mo := son_delaying_pattern.search(line):
+            son_delaying.add(int(mo.group(1)))
+        elif mo := son_finished_pattern.search(line):
+            son_finished.add(int(mo.group(1)))
+        elif mo := father_wait_returned_pattern.search(line):
+            iteration = int(mo.group(1))
+            wait_returned.add(iteration)
+            # Test completes when iteration 9 finishes
+            if iteration == 9:
+                test_complete.set()
+
+    # Run with log monitoring
+    async with (
+        run_compiled(yaml_config, line_callback=check_output),
+        api_client_connected() as client,
+    ):
+        # Verify device info
+        device_info = await client.device_info()
+        assert device_info is not None
+        assert device_info.name == "test-script-delay-params"
+
+        # Get services
+        _, services = await client.list_entities_services()
+        test_service = next(
+            (s for s in services if s.name == "test_repeat_with_delay"), None
+        )
+        assert test_service is not None, "test_repeat_with_delay service not found"
+
+        # Execute the test
+        client.execute_service(test_service, {})
+
+        # Wait for test to complete (10 iterations * ~100ms each + margin)
+        try:
+            await asyncio.wait_for(test_complete.wait(), timeout=5.0)
+        except TimeoutError:
+            pytest.fail(
+                f"Test timed out. Completed iterations: {sorted(wait_returned)}. "
+                f"This likely indicates the script became a zombie (issue #12044)."
+            )
+
+        # Verify all 10 iterations completed successfully
+        expected_iterations = set(range(10))
+        assert father_calling == expected_iterations, "Not all iterations started"
+        assert son_started == expected_iterations, (
+            "Son script not started for all iterations"
+        )
+        assert son_finished == expected_iterations, (
+            "Son script not finished for all iterations"
+        )
+        assert wait_returned == expected_iterations, (
+            "script.wait did not return for all iterations"
+        )
+
+        # Verify delays were triggered for iterations >= 5
+        expected_delays = set(range(5, 10))
+        assert son_delaying == expected_delays, (
+            "Delays not triggered for iterations >= 5"
+        )