blob: 55840caf995747f088d9cd2fa3270c7f9622996c [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 shared.protocol.async_backtrace import (
AsyncBacktraceRequest,
AsyncBacktraceResponse,
)
from zxdb_dap import AsyncTaskNode
class TestAsyncBacktraceHandler(DaemonTestCase):
def test_async_backtrace_registration(self) -> None:
daemon = Daemon(port=15678)
self.assertIn("async-backtrace", daemon.registry.handlers)
async def test_handle_async_backtrace_not_connected(self) -> None:
daemon = Daemon(port=15678)
daemon.zxdb_writer = None
resp = await daemon.registry.handle(
"async-backtrace", AsyncBacktraceRequest()
)
self.assertFalse(resp.success)
self.assertIn("Not connected to zxdb DAP server", resp.message or "")
async def test_handle_async_backtrace_no_processes(self) -> None:
daemon = Daemon(port=15678)
daemon.zxdb_writer = Mock()
resp = await daemon.registry.handle(
"async-backtrace", AsyncBacktraceRequest()
)
self.assertFalse(resp.success)
self.assertIn("No active processes found", resp.message or "")
async def test_handle_async_backtrace_ambiguous_processes(self) -> None:
daemon = Daemon(port=15678)
daemon.zxdb_writer = Mock()
daemon.get_or_create_process(1001, name="proc1")
daemon.get_or_create_process(1002, name="proc2")
resp = await daemon.registry.handle(
"async-backtrace", AsyncBacktraceRequest()
)
self.assertFalse(resp.success)
self.assertIn(
"Multiple processes active; please specify a PID with --pid / -p",
resp.message or "",
)
async def test_handle_async_backtrace_pid_not_found(self) -> None:
daemon = Daemon(port=15678)
daemon.zxdb_writer = Mock()
daemon.get_or_create_process(1001, name="proc1")
resp = await daemon.registry.handle(
"async-backtrace", AsyncBacktraceRequest(pid=9999)
)
self.assertFalse(resp.success)
self.assertIn("Process 9999 not found", resp.message or "")
@patch("daemon.daemon.ZxdbDapClient")
async def test_handle_async_backtrace_no_threads(
self, mock_dap_client_class: Mock
) -> None:
mock_dap_client = mock_dap_client_class.return_value
mock_threads_resp = Mock(body=Mock(threads=[]))
mock_dap_client.zxdb_threads = AsyncMock(return_value=mock_threads_resp)
daemon = Daemon(port=15678)
daemon.zxdb_writer = Mock()
daemon.get_or_create_process(1001, name="proc1")
with patch.object(
daemon, "ensure_process_stopped", new_callable=AsyncMock
):
resp = await daemon.registry.handle(
"async-backtrace", AsyncBacktraceRequest(pid=1001)
)
self.assertTrue(resp.success)
assert isinstance(resp.body, AsyncBacktraceResponse)
self.assertEqual(resp.body.process_id, 1001)
self.assertEqual(resp.body.tasks, [])
@patch("daemon.daemon.ZxdbDapClient")
async def test_handle_async_backtrace_syncs_threads_when_empty(
self, mock_dap_client_class: Mock
) -> None:
mock_dap_client = mock_dap_client_class.return_value
daemon = Daemon(port=15678)
daemon.zxdb_writer = Mock()
daemon.get_or_create_process(1001, name="proc1")
mock_thread = Mock()
mock_thread.id = 3001
mock_thread.name = "initial-thread"
mock_thread.process_id = 1001
mock_threads_resp = Mock()
mock_threads_resp.body = Mock()
mock_threads_resp.body.threads = [mock_thread]
mock_dap_client.zxdb_threads = AsyncMock(return_value=mock_threads_resp)
mock_abt_resp = Mock()
mock_abt_resp.success = True
mock_abt_resp.body = Mock()
mock_abt_resp.body.tasks = [
AsyncTaskNode(
id="t_synced",
name="synced_task",
file="main.rs",
line=10,
children=[],
)
]
mock_dap_client.zxdb_async_backtrace = AsyncMock(
return_value=mock_abt_resp
)
with patch.object(
daemon, "ensure_process_stopped", new_callable=AsyncMock
) as mock_ensure_stopped:
resp = await daemon.registry.handle(
"async-backtrace", AsyncBacktraceRequest(pid=1001)
)
self.assertTrue(resp.success)
mock_ensure_stopped.assert_called_once_with(1001)
mock_dap_client.zxdb_threads.assert_called_once()
mock_dap_client.zxdb_async_backtrace.assert_called_once()
self.assertIsNotNone(resp.body)
assert isinstance(resp.body, AsyncBacktraceResponse)
self.assertEqual(resp.body.process_id, 1001)
self.assertEqual(len(resp.body.tasks), 1)
self.assertEqual(resp.body.tasks[0].id, "t_synced")
@patch("daemon.daemon.ZxdbDapClient")
async def test_handle_async_backtrace_success_explicit_pid(
self, mock_dap_client_class: Mock
) -> None:
mock_dap_client = mock_dap_client_class.return_value
daemon = Daemon(port=15678)
daemon.zxdb_writer = Mock()
daemon.get_or_create_process(1001, name="proc1")
daemon.get_or_create_thread(2001, name="thread1", process_id=1001)
mock_abt_resp = Mock()
mock_abt_resp.success = True
mock_abt_resp.body = Mock()
mock_abt_resp.body.tasks = [
AsyncTaskNode(
id="t1",
name="root_task",
file="main.rs",
line=42,
children=[],
)
]
mock_dap_client.zxdb_async_backtrace = AsyncMock(
return_value=mock_abt_resp
)
with patch.object(
daemon, "ensure_process_stopped", new_callable=AsyncMock
) as mock_ensure_stopped:
resp = await daemon.registry.handle(
"async-backtrace", AsyncBacktraceRequest(pid=1001)
)
self.assertTrue(resp.success)
mock_ensure_stopped.assert_called_once_with(1001)
mock_dap_client.zxdb_async_backtrace.assert_called_once()
self.assertIsNotNone(resp.body)
assert isinstance(resp.body, AsyncBacktraceResponse)
self.assertEqual(resp.body.process_id, 1001)
self.assertEqual(len(resp.body.tasks), 1)
self.assertEqual(resp.body.tasks[0].id, "t1")
self.assertEqual(resp.body.tasks[0].name, "root_task")
@patch("daemon.daemon.ZxdbDapClient")
async def test_handle_async_backtrace_success_default_single_process(
self, mock_dap_client_class: Mock
) -> None:
mock_dap_client = mock_dap_client_class.return_value
daemon = Daemon(port=15678)
daemon.zxdb_writer = Mock()
daemon.get_or_create_process(1001, name="proc1")
daemon.get_or_create_thread(2001, name="thread1", process_id=1001)
mock_abt_resp = Mock()
mock_abt_resp.success = True
mock_abt_resp.body = Mock()
mock_abt_resp.body.tasks = []
mock_dap_client.zxdb_async_backtrace = AsyncMock(
return_value=mock_abt_resp
)
with patch.object(
daemon, "ensure_process_stopped", new_callable=AsyncMock
):
resp = await daemon.registry.handle(
"async-backtrace", AsyncBacktraceRequest()
)
self.assertTrue(resp.success)
assert isinstance(resp.body, AsyncBacktraceResponse)
self.assertEqual(resp.body.process_id, 1001)
self.assertEqual(resp.body.tasks, [])
@patch("daemon.daemon.ZxdbDapClient")
async def test_handle_async_backtrace_returns_first_successful_thread(
self, mock_dap_client_class: Mock
) -> None:
mock_dap_client = mock_dap_client_class.return_value
daemon = Daemon(port=15678)
daemon.zxdb_writer = Mock()
daemon.get_or_create_process(1001, name="proc1")
daemon.get_or_create_thread(2001, name="thread1", process_id=1001)
daemon.get_or_create_thread(2002, name="thread2", process_id=1001)
mock_resp_1 = Mock()
mock_resp_1.success = True
mock_resp_1.body = Mock()
mock_resp_1.body.tasks = [
AsyncTaskNode(
id="t1",
name="parent_task",
file="foo.rs",
line=10,
children=[
AsyncTaskNode(
id="t2",
name="child_task",
file="bar.rs",
line=20,
children=[],
)
],
)
]
mock_dap_client.zxdb_async_backtrace = AsyncMock(
return_value=mock_resp_1
)
with patch.object(
daemon, "ensure_process_stopped", new_callable=AsyncMock
):
resp = await daemon.registry.handle(
"async-backtrace", AsyncBacktraceRequest(pid=1001)
)
self.assertTrue(resp.success)
assert isinstance(resp.body, AsyncBacktraceResponse)
self.assertEqual(mock_dap_client.zxdb_async_backtrace.call_count, 1)
self.assertEqual(len(resp.body.tasks), 1)
parent = resp.body.tasks[0]
self.assertIsInstance(parent, AsyncTaskNode)
self.assertEqual(parent.name, "parent_task")
self.assertEqual(len(parent.children), 1)
child = parent.children[0]
self.assertIsInstance(child, AsyncTaskNode)
self.assertEqual(child.name, "child_task")
@patch("daemon.daemon.ZxdbDapClient")
async def test_handle_async_backtrace_fallback_to_second_thread_when_first_empty(
self, mock_dap_client_class: Mock
) -> None:
mock_dap_client = mock_dap_client_class.return_value
daemon = Daemon(port=15678)
daemon.zxdb_writer = Mock()
daemon.get_or_create_process(1001, name="proc1")
daemon.get_or_create_thread(2001, name="thread1", process_id=1001)
daemon.get_or_create_thread(2002, name="thread2", process_id=1001)
mock_resp_1 = Mock()
mock_resp_1.success = True
mock_resp_1.body = Mock()
mock_resp_1.body.tasks = []
mock_resp_2 = Mock()
mock_resp_2.success = True
mock_resp_2.body = Mock()
mock_resp_2.body.tasks = [
AsyncTaskNode(
id="t3",
name="thread2_task",
file="baz.rs",
line=30,
children=[],
)
]
mock_dap_client.zxdb_async_backtrace = AsyncMock(
side_effect=[mock_resp_1, mock_resp_2]
)
with patch.object(
daemon, "ensure_process_stopped", new_callable=AsyncMock
):
resp = await daemon.registry.handle(
"async-backtrace", AsyncBacktraceRequest(pid=1001)
)
self.assertTrue(resp.success)
assert isinstance(resp.body, AsyncBacktraceResponse)
self.assertEqual(mock_dap_client.zxdb_async_backtrace.call_count, 2)
self.assertEqual(len(resp.body.tasks), 1)
task = resp.body.tasks[0]
self.assertEqual(task.name, "thread2_task")
if __name__ == "__main__":
unittest.main()