| # Copyright 2026 The Fuchsia Authors. All rights reserved. | |
| # Use of this source code is governed by a BSD-style license that can be | |
| # found in the LICENSE file. | |
| import asyncio | |
| import unittest | |
| from unittest.mock import AsyncMock, Mock, patch | |
| from daemon.daemon import Daemon | |
| from daemon.tests.helpers import DaemonTestCase | |
| from pydap.client import READER_STOPPED_EVENT | |
| from shared.protocol import Response | |
| from shared.protocol.wait_for_event import WaitForEventRequest | |
| class TestDaemonEvents(DaemonTestCase): | |
| async def test_event_sequencing(self) -> None: | |
| # Port is unused in these tests. | |
| daemon = Daemon(port=None) | |
| # Put events into queue | |
| await daemon.event_queue.put( | |
| {"event": "thread", "body": {"threadId": 1}} | |
| ) | |
| await daemon.event_queue.put( | |
| {"event": "stopped", "body": {"threadId": 1}} | |
| ) | |
| # Run process events in background | |
| task = asyncio.create_task(daemon._process_events()) | |
| # Wait for events to be processed (avoiding fixed sleep) | |
| for _ in range(100): | |
| if len(daemon.all_events) == 2: | |
| break | |
| await asyncio.sleep(0.01) | |
| task.cancel() | |
| self.assertEqual(len(daemon.all_events), 2) | |
| self.assertEqual(daemon.all_events[1]["seq"], 1) | |
| self.assertEqual(daemon.all_events[2]["seq"], 2) | |
| async def test_wait_for_event_immediate(self) -> None: | |
| daemon = Daemon(port=None) | |
| daemon.all_events = { | |
| 1: {"seq": 1, "event": "thread"}, | |
| 2: {"seq": 2, "event": "stopped"}, | |
| } | |
| daemon.latest_seq = 2 | |
| resp = await daemon.registry.handle( | |
| "wait-for-event", WaitForEventRequest(last_seen_seq=1) | |
| ) | |
| self.assertTrue(resp.success) | |
| assert resp.events is not None | |
| self.assertEqual(len(resp.events), 1) | |
| self.assertEqual(resp.events[0]["seq"], 2) | |
| async def test_wait_for_event_blocking(self) -> None: | |
| daemon = Daemon(port=None) | |
| async def add_event() -> None: | |
| # Give the waiter time to start waiting | |
| await asyncio.sleep(0.05) | |
| daemon.latest_seq = 1 | |
| daemon.all_events[1] = {"seq": 1, "event": "stopped"} | |
| async with daemon.new_event_condition: | |
| daemon.new_event_condition.notify_all() | |
| asyncio.create_task(add_event()) | |
| resp = await daemon.registry.handle( | |
| "wait-for-event", WaitForEventRequest(last_seen_seq=0) | |
| ) | |
| self.assertTrue(resp.success) | |
| assert resp.events is not None | |
| self.assertEqual(len(resp.events), 1) | |
| self.assertEqual(resp.events[0]["seq"], 1) | |
| async def test_event_filtering(self) -> None: | |
| daemon = Daemon(port=None) | |
| # Put allowed and disallowed events into queue | |
| await daemon.event_queue.put( | |
| {"event": "stopped", "body": {"threadId": 1}} | |
| ) | |
| await daemon.event_queue.put( | |
| {"event": "output", "body": {"output": "stdout"}} | |
| ) | |
| await daemon.event_queue.put( | |
| {"event": "exited", "body": {"exitCode": 0}} | |
| ) | |
| # Run process events in background | |
| task = asyncio.create_task(daemon._process_events()) | |
| # Wait for events to be processed | |
| for _ in range(100): | |
| if len(daemon.all_events) == 2: | |
| break | |
| await asyncio.sleep(0.01) | |
| task.cancel() | |
| self.assertEqual(len(daemon.all_events), 2) | |
| self.assertEqual(daemon.all_events[1]["event"], "stopped") | |
| self.assertEqual(daemon.all_events[2]["event"], "exited") | |
| async def test_event_acknowledgment(self) -> None: | |
| daemon = Daemon(port=None) | |
| daemon.all_events = { | |
| 1: {"seq": 1, "event": "thread"}, | |
| 2: {"seq": 2, "event": "stopped"}, | |
| 3: {"seq": 3, "event": "exited"}, | |
| } | |
| daemon.latest_seq = 3 | |
| mock_reader = AsyncMock() | |
| mock_reader.readline.return_value = ( | |
| b'{"command": "threads", "ack_seq": 2}\n' | |
| ) | |
| mock_writer = Mock() | |
| mock_writer.write = Mock() | |
| mock_writer.drain = AsyncMock() | |
| mock_writer.wait_closed = AsyncMock() | |
| with patch.object( | |
| daemon.registry, "handle", new_callable=AsyncMock | |
| ) as mock_handle: | |
| mock_handle.return_value = Response(success=True) | |
| await daemon.handle_uds_client(mock_reader, mock_writer) | |
| self.assertEqual(len(daemon.all_events), 1) | |
| self.assertEqual(daemon.all_events[3]["seq"], 3) | |
| async def test_process_event_handling(self) -> None: | |
| daemon = Daemon(port=None) | |
| # Put process event into queue | |
| await daemon.event_queue.put( | |
| { | |
| "event": "process", | |
| "body": {"systemProcessId": 1234, "name": "test_process"}, | |
| } | |
| ) | |
| # Run process events in background | |
| task = asyncio.create_task(daemon._process_events()) | |
| # Wait for events to be processed | |
| for _ in range(100): | |
| if 1234 in daemon.processes: | |
| break | |
| await asyncio.sleep(0.01) | |
| task.cancel() | |
| self.assertIn(1234, daemon.processes) | |
| self.assertEqual(daemon.processes[1234].name, "test_process") | |
| async def test_reader_stopped_event_logs_warning(self) -> None: | |
| daemon = Daemon(port=None) | |
| err = RuntimeError("Connection forcibly closed by peer") | |
| await daemon.event_queue.put( | |
| {"type": READER_STOPPED_EVENT, "exception": err} | |
| ) | |
| with self.assertLogs("daemon.daemon", level="WARNING") as cm: | |
| await daemon._process_events() | |
| self.assertTrue( | |
| any( | |
| "DAP reader background task stopped with error" in log | |
| for log in cm.output | |
| ) | |
| ) | |
| async def test_thread_event_handling_populates_thread_and_process( | |
| self, | |
| ) -> None: | |
| daemon = Daemon(port=None) | |
| await daemon.event_queue.put( | |
| { | |
| "event": "thread", | |
| "body": {"reason": "started", "threadId": 1, "processId": 1234}, | |
| } | |
| ) | |
| await daemon.event_queue.put({"type": READER_STOPPED_EVENT}) | |
| await daemon._process_events() | |
| self.assertIn(1, daemon.threads) | |
| assert daemon.threads[1].process is not None | |
| self.assertEqual(daemon.threads[1].process.id, 1234) | |
| async def test_thread_event_is_stopped(self) -> None: | |
| daemon = Daemon(port=None) | |
| await daemon.event_queue.put( | |
| { | |
| "event": "thread", | |
| "body": { | |
| "reason": "started", | |
| "threadId": 1, | |
| "processId": 1234, | |
| "isStopped": True, | |
| }, | |
| } | |
| ) | |
| await daemon.event_queue.put( | |
| { | |
| "event": "thread", | |
| "body": { | |
| "reason": "started", | |
| "threadId": 2, | |
| "processId": 1234, | |
| "isStopped": False, | |
| }, | |
| } | |
| ) | |
| await daemon.event_queue.put( | |
| { | |
| "event": "thread", | |
| "body": { | |
| "reason": "started", | |
| "threadId": 3, | |
| "processId": 1234, | |
| }, | |
| } | |
| ) | |
| await daemon.event_queue.put({"type": READER_STOPPED_EVENT}) | |
| await daemon._process_events() | |
| self.assertIn(1, daemon.threads) | |
| self.assertTrue(daemon.threads[1].is_stopped) | |
| self.assertIn(2, daemon.threads) | |
| self.assertFalse(daemon.threads[2].is_stopped) | |
| self.assertIn(3, daemon.threads) | |
| self.assertFalse(daemon.threads[3].is_stopped) | |
| async def test_thread_event_exited_evicts_thread(self) -> None: | |
| daemon = Daemon(port=None) | |
| daemon.get_or_create_thread(1, process_id=1234).is_stopped = True | |
| daemon.get_or_create_thread(2, process_id=1234).is_stopped = True | |
| await daemon.event_queue.put( | |
| { | |
| "event": "thread", | |
| "body": {"reason": "exited", "threadId": 1}, | |
| } | |
| ) | |
| await daemon.event_queue.put({"type": READER_STOPPED_EVENT}) | |
| await daemon._process_events() | |
| self.assertNotIn(1, daemon.threads) | |
| self.assertIn(2, daemon.threads) | |
| self.assertTrue(daemon.threads[2].is_stopped) | |
| assert daemon.threads[2].process is not None | |
| self.assertEqual(daemon.threads[2].process.id, 1234) | |
| async def test_detached_event_clears_process_threads(self) -> None: | |
| daemon = Daemon(port=None) | |
| daemon.get_or_create_process(1234, name="p1") | |
| daemon.get_or_create_process(5678, name="p2") | |
| daemon.get_or_create_thread(1, process_id=1234).is_stopped = True | |
| daemon.get_or_create_thread(2, process_id=1234).is_stopped = True | |
| daemon.get_or_create_thread(3, process_id=5678).is_stopped = True | |
| await daemon.event_queue.put( | |
| { | |
| "event": "detached", | |
| "body": {"processId": 1234}, | |
| } | |
| ) | |
| await daemon.event_queue.put({"type": READER_STOPPED_EVENT}) | |
| await daemon._process_events() | |
| self.assertNotIn(1234, daemon.processes) | |
| self.assertIn(5678, daemon.processes) | |
| self.assertNotIn(1, daemon.threads) | |
| self.assertNotIn(2, daemon.threads) | |
| self.assertIn(3, daemon.threads) | |
| self.assertTrue(daemon.threads[3].is_stopped) | |
| assert daemon.threads[3].process is not None | |
| self.assertEqual(daemon.threads[3].process.id, 5678) | |
| async def test_process_stopped_event(self) -> None: | |
| daemon = Daemon(port=None) | |
| proc = daemon.get_or_create_process(1234, name="p1") | |
| daemon.get_or_create_thread(1, process_id=1234) | |
| daemon.get_or_create_thread(2, process_id=1234) | |
| self.assertFalse(proc.all_threads_stopped) | |
| self.assertFalse(daemon.threads[1].is_stopped) | |
| self.assertFalse(daemon.threads[2].is_stopped) | |
| with daemon.event_waiter.wait_for_process_stop(1234) as fut: | |
| await daemon.event_queue.put( | |
| { | |
| "event": "processStopped", | |
| "body": { | |
| "processId": 1234, | |
| "name": "p1", | |
| "threads": [1, 2], | |
| }, | |
| } | |
| ) | |
| await daemon.event_queue.put({"type": READER_STOPPED_EVENT}) | |
| await daemon._process_events() | |
| self.assertTrue(fut.done()) | |
| self.assertTrue(proc.all_threads_stopped) | |
| self.assertTrue(daemon.threads[1].is_stopped) | |
| self.assertTrue(daemon.threads[2].is_stopped) | |
| async def test_detached_event_cleans_up_process(self) -> None: | |
| daemon = Daemon(port=None) | |
| daemon.get_or_create_process(5678, name="p1") | |
| await daemon.event_queue.put( | |
| {"event": "detached", "body": {"processId": 5678}} | |
| ) | |
| await daemon.event_queue.put({"type": READER_STOPPED_EVENT}) | |
| await daemon._process_events() | |
| self.assertNotIn(5678, daemon.processes) | |
| async def test_async_backtrace_update_event_ignored(self) -> None: | |
| daemon = Daemon(port=None) | |
| daemon.get_or_create_process(5678, name="p1") | |
| await daemon.event_queue.put( | |
| { | |
| "event": "zxdb.updateAsyncBacktrace", | |
| "body": { | |
| "id": 100, | |
| "name": "main", | |
| "processId": 5678, | |
| "tasks": [{"name": "task1"}], | |
| }, | |
| } | |
| ) | |
| await daemon.event_queue.put({"type": READER_STOPPED_EVENT}) | |
| await daemon._process_events() | |
| self.assertEqual(len(daemon.all_events), 0) | |
| if __name__ == "__main__": | |
| unittest.main() |