blob: 8c7ce0b1496596d93dc7f289dc0827548622bc4f [file]
# 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 unittest
from unittest.mock import AsyncMock, Mock, patch
from daemon.daemon import Daemon
from daemon.tests.helpers import DaemonTestCase
from pydap.client import DapError
from shared.protocol.continue_request import ContinueRequest
from shared.protocol.finish import FinishRequest
from shared.protocol.next_request import NextRequest
from shared.protocol.step_in import StepInRequest
class TestExecutionHandlers(DaemonTestCase):
@patch("daemon.daemon.ZxdbDapClient")
async def test_handle_continue(self, mock_dap_client_class: Mock) -> None:
mock_dap_client = mock_dap_client_class.return_value
mock_continue_resp = Mock()
mock_continue_resp.body = Mock()
mock_continue_resp.body.all_threads_continued = True
mock_continue_resp.dump_dap.return_value = {"allThreadsContinued": True}
mock_dap_client.continue_thread = AsyncMock(
return_value=mock_continue_resp
)
daemon = Daemon(port=15678)
daemon.zxdb_writer = Mock()
thread = daemon.get_or_create_thread(1, process_id=1234)
thread.is_stopped = True
resp = await daemon.registry.handle(
"continue", ContinueRequest(thread_id=1)
)
self.assertTrue(resp.success)
mock_dap_client.continue_thread.assert_called_once()
self.assertFalse(thread.is_stopped)
@patch("daemon.daemon.ZxdbDapClient")
async def test_handle_continue_single_thread(
self, mock_dap_client_class: Mock
) -> None:
mock_dap_client = mock_dap_client_class.return_value
mock_continue_resp = Mock()
mock_continue_resp.body = Mock()
mock_continue_resp.body.all_threads_continued = False
mock_continue_resp.dump_dap.return_value = {
"allThreadsContinued": False
}
mock_dap_client.continue_thread = AsyncMock(
return_value=mock_continue_resp
)
daemon = Daemon(port=15678)
daemon.zxdb_writer = Mock()
thread1 = daemon.get_or_create_thread(1, process_id=1234)
thread2 = daemon.get_or_create_thread(2, process_id=1234)
thread1.is_stopped = True
thread2.is_stopped = True
resp = await daemon.registry.handle(
"continue", ContinueRequest(thread_id=1, single_thread=True)
)
self.assertTrue(resp.success)
mock_dap_client.continue_thread.assert_called_once()
self.assertFalse(thread1.is_stopped)
self.assertTrue(thread2.is_stopped)
@patch("daemon.daemon.ZxdbDapClient")
async def test_handle_finish(self, mock_dap_client_class: Mock) -> None:
mock_dap_client = mock_dap_client_class.return_value
mock_finish_resp = Mock()
mock_finish_resp.dump_dap.return_value = {"success": True}
mock_dap_client.step_out = AsyncMock(return_value=mock_finish_resp)
daemon = Daemon(port=15678)
daemon.zxdb_writer = Mock()
thread1 = daemon.get_or_create_thread(1, process_id=1234)
thread2 = daemon.get_or_create_thread(2, process_id=1234)
thread1.is_stopped = True
thread2.is_stopped = True
resp = await daemon.registry.handle(
"finish",
FinishRequest(command="finish", thread_id=1),
)
self.assertTrue(resp.success, resp.message)
mock_dap_client.step_out.assert_called_once()
args = mock_dap_client.step_out.call_args[0][0]
self.assertEqual(args.thread_id, 1)
self.assertTrue(args.single_thread)
self.assertFalse(thread1.is_stopped)
self.assertTrue(thread2.is_stopped)
@patch("daemon.daemon.ZxdbDapClient")
async def test_handle_finish_all_threads(
self, mock_dap_client_class: Mock
) -> None:
mock_dap_client = mock_dap_client_class.return_value
mock_finish_resp = Mock()
mock_finish_resp.dump_dap.return_value = {"success": True}
mock_dap_client.step_out = AsyncMock(return_value=mock_finish_resp)
daemon = Daemon(port=15678)
daemon.zxdb_writer = Mock()
thread1 = daemon.get_or_create_thread(1, process_id=1234)
thread2 = daemon.get_or_create_thread(2, process_id=1234)
thread1.is_stopped = True
thread2.is_stopped = True
resp = await daemon.registry.handle(
"finish",
FinishRequest(command="finish", thread_id=1, single_thread=False),
)
self.assertTrue(resp.success, resp.message)
mock_dap_client.step_out.assert_called_once()
args = mock_dap_client.step_out.call_args[0][0]
self.assertEqual(args.thread_id, 1)
self.assertFalse(args.single_thread)
self.assertFalse(thread1.is_stopped)
self.assertFalse(thread2.is_stopped)
@patch("daemon.daemon.ZxdbDapClient")
async def test_handle_next(self, mock_dap_client_class: Mock) -> None:
mock_dap_client = mock_dap_client_class.return_value
mock_next_resp = Mock()
mock_next_resp.success = True
mock_next_resp.dump_dap.return_value = {"success": True}
mock_dap_client.next = AsyncMock(return_value=mock_next_resp)
daemon = Daemon(port=15678)
daemon.zxdb_writer = Mock()
thread1 = daemon.get_or_create_thread(1, process_id=1234)
thread2 = daemon.get_or_create_thread(2, process_id=1234)
thread1.is_stopped = True
thread2.is_stopped = True
resp = await daemon.registry.handle(
"next",
NextRequest(
command="next",
thread_id=1,
granularity="line",
),
)
self.assertTrue(resp.success, resp.message)
mock_dap_client.next.assert_called_once()
args = mock_dap_client.next.call_args[0][0]
self.assertEqual(args.thread_id, 1)
self.assertTrue(args.single_thread)
self.assertFalse(thread1.is_stopped)
self.assertTrue(thread2.is_stopped)
@patch("daemon.daemon.ZxdbDapClient")
async def test_handle_next_all_threads(
self, mock_dap_client_class: Mock
) -> None:
mock_dap_client = mock_dap_client_class.return_value
mock_next_resp = Mock()
mock_next_resp.success = True
mock_next_resp.dump_dap.return_value = {"success": True}
mock_dap_client.next = AsyncMock(return_value=mock_next_resp)
daemon = Daemon(port=15678)
daemon.zxdb_writer = Mock()
thread1 = daemon.get_or_create_thread(1, process_id=1234)
thread2 = daemon.get_or_create_thread(2, process_id=1234)
thread1.is_stopped = True
thread2.is_stopped = True
resp = await daemon.registry.handle(
"next",
NextRequest(
command="next",
thread_id=1,
single_thread=False,
),
)
self.assertTrue(resp.success, resp.message)
mock_dap_client.next.assert_called_once()
args = mock_dap_client.next.call_args[0][0]
self.assertEqual(args.thread_id, 1)
self.assertFalse(args.single_thread)
self.assertFalse(thread1.is_stopped)
self.assertFalse(thread2.is_stopped)
@patch("daemon.daemon.ZxdbDapClient")
async def test_handle_next_dap_error(
self, mock_dap_client_class: Mock
) -> None:
mock_dap_client = mock_dap_client_class.return_value
mock_dap_client.next = AsyncMock(
side_effect=DapError("Thread not stopped")
)
daemon = Daemon(port=15678)
daemon.zxdb_writer = Mock()
resp = await daemon.registry.handle(
"next", NextRequest(command="next", thread_id=1)
)
self.assertFalse(resp.success)
self.assertIn("Thread not stopped", resp.message or "")
@patch("daemon.daemon.ZxdbDapClient")
async def test_handle_step_in(self, mock_dap_client_class: Mock) -> None:
mock_dap_client = mock_dap_client_class.return_value
mock_dap_response = Mock()
mock_dap_response.success = True
mock_dap_response.dump_dap.return_value = {"success": True}
mock_dap_client.step_in = AsyncMock(return_value=mock_dap_response)
daemon = Daemon(port=15678)
daemon.zxdb_writer = Mock()
thread1 = daemon.get_or_create_thread(1, process_id=1234)
thread2 = daemon.get_or_create_thread(2, process_id=1234)
thread1.is_stopped = True
thread2.is_stopped = True
resp = await daemon.registry.handle(
"step-in",
StepInRequest(command="step-in", thread_id=1),
)
self.assertTrue(resp.success)
mock_dap_client.step_in.assert_called_once()
args = mock_dap_client.step_in.call_args[0][0]
self.assertEqual(args.thread_id, 1)
self.assertTrue(args.single_thread)
self.assertFalse(thread1.is_stopped)
self.assertTrue(thread2.is_stopped)
@patch("daemon.daemon.ZxdbDapClient")
async def test_handle_step_in_all_threads(
self, mock_dap_client_class: Mock
) -> None:
mock_dap_client = mock_dap_client_class.return_value
mock_dap_response = Mock()
mock_dap_response.success = True
mock_dap_response.dump_dap.return_value = {"success": True}
mock_dap_client.step_in = AsyncMock(return_value=mock_dap_response)
daemon = Daemon(port=15678)
daemon.zxdb_writer = Mock()
thread1 = daemon.get_or_create_thread(1, process_id=1234)
thread2 = daemon.get_or_create_thread(2, process_id=1234)
thread1.is_stopped = True
thread2.is_stopped = True
resp = await daemon.registry.handle(
"step-in",
StepInRequest(command="step-in", thread_id=1, single_thread=False),
)
self.assertTrue(resp.success)
mock_dap_client.step_in.assert_called_once()
args = mock_dap_client.step_in.call_args[0][0]
self.assertEqual(args.thread_id, 1)
self.assertFalse(args.single_thread)
self.assertFalse(thread1.is_stopped)
self.assertFalse(thread2.is_stopped)
@patch("daemon.daemon.ZxdbDapClient")
async def test_handle_step_in_dap_error(
self, mock_dap_client_class: Mock
) -> None:
mock_dap_client = mock_dap_client_class.return_value
mock_dap_client.step_in = AsyncMock(
side_effect=DapError("Thread not stopped")
)
daemon = Daemon(port=15678)
daemon.zxdb_writer = Mock()
resp = await daemon.registry.handle(
"step-in", StepInRequest(command="step-in", thread_id=1)
)
self.assertFalse(resp.success)
self.assertIn("Thread not stopped", resp.message or "")
if __name__ == "__main__":
unittest.main()