blob: 7f9e1f9f371035f32b7461cbc561331129a8161c [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 contextlib
import unittest
from io import StringIO
from unittest.mock import AsyncMock, Mock, patch
from cli.cli import main
from cli.commands.location_utils import resolve_path
from cli.tests.helpers import CLITestCase
from shared.protocol.break_request import BreakRequest
from shared.protocol.tracepoint import TracepointRequest
from shared.protocol.watch_request import WatchRequest
class TestBreakpointCommands(CLITestCase):
@patch("cli.commands.location_utils.resolve_path", autospec=True)
@patch("cli.cli.send_command")
async def test_break_command(
self, mock_send: Mock, mock_resolve: Mock
) -> None:
mock_send.return_value = 0
mock_resolve.return_value = "/path/to/fuchsia/src/main.rs"
exit_code = await main(["break", "src/main.rs:12"])
self.assertEqual(exit_code, 0)
mock_resolve.assert_called_once_with("src/main.rs")
mock_send.assert_called_once_with(
BreakRequest(file="/path/to/fuchsia/src/main.rs", line=12)
)
@patch("cli.commands.location_utils.resolve_path", autospec=True)
@patch("cli.cli.send_command")
async def test_break_command_aliases(
self, mock_send: Mock, mock_resolve: Mock
) -> None:
mock_send.return_value = 0
mock_resolve.return_value = "/path/to/fuchsia/src/main.rs"
for alias in [
"breakpoint",
"b",
"setBreakpoints",
"set-breakpoints",
"set_breakpoints",
]:
mock_send.reset_mock()
mock_resolve.reset_mock()
exit_code = await main([alias, "src/main.rs:12"])
self.assertEqual(exit_code, 0, f"Failed for alias: {alias}")
mock_resolve.assert_called_once_with("src/main.rs")
mock_send.assert_called_once_with(
BreakRequest(file="/path/to/fuchsia/src/main.rs", line=12)
)
@patch("cli.cli.send_command")
async def test_json_option_break(self, mock_send: Mock) -> None:
mock_send.return_value = 0
exit_code = await main(
[
"--json",
'{"command": "break", "file": "/path/to/file.rs", "line": 12}',
]
)
self.assertEqual(exit_code, 0)
mock_send.assert_called_once_with(
BreakRequest(file="/path/to/file.rs", line=12)
)
@patch("cli.commands.location_utils.resolve_path", autospec=True)
async def test_break_command_invalid_format(
self, mock_resolve: Mock
) -> None:
# Rejects target missing colon delimiter.
exit_code = await main(["break", "src/main.rs"])
self.assertEqual(exit_code, 1)
mock_resolve.assert_not_called()
# Rejects non-integer line number suffix.
exit_code = await main(["break", "src/main.rs:abc"])
self.assertEqual(exit_code, 1)
mock_resolve.assert_not_called()
# Rejects negative line number.
exit_code = await main(["break", "src/main.rs:-5"])
self.assertEqual(exit_code, 1)
mock_resolve.assert_not_called()
# Fails when path cannot be resolved in source tree.
mock_resolve.return_value = None
exit_code = await main(["break", "src/missing.rs:10"])
self.assertEqual(exit_code, 1)
mock_resolve.assert_called_once_with("src/missing.rs")
@patch("os.path.isfile")
@patch.dict("os.environ", {"FUCHSIA_DIR": "/workspace/fuchsia"})
def test_resolve_path_fuchsia_dir(self, mock_isfile: Mock) -> None:
mock_isfile.side_effect = lambda p: p == "/workspace/fuchsia/src/foo.rs"
res = resolve_path("src/foo.rs")
self.assertEqual(res, "/workspace/fuchsia/src/foo.rs")
@patch("os.path.isfile")
@patch.dict("os.environ", {"FUCHSIA_DIR": "/workspace/fuchsia"})
def test_resolve_path_directory(self, mock_isfile: Mock) -> None:
mock_isfile.return_value = False
res = resolve_path("src")
self.assertIsNone(res)
@patch("os.path.isfile")
@patch.dict("os.environ", {"FUCHSIA_DIR": "/workspace/fuchsia"})
def test_resolve_path_unresolved(self, mock_isfile: Mock) -> None:
mock_isfile.return_value = False
res = resolve_path("missing/foo.rs")
self.assertIsNone(res)
@patch("cli.commands.location_utils.resolve_path", autospec=True)
@patch("cli.cli.send_command")
async def test_break_command_delete(
self, mock_send: Mock, mock_resolve: Mock
) -> None:
mock_send.return_value = 0
mock_resolve.return_value = "/path/to/fuchsia/src/main.rs"
exit_code = await main(["break", "-d", "src/main.rs:12"])
self.assertEqual(exit_code, 0)
mock_resolve.assert_called_once_with("src/main.rs")
mock_send.assert_called_once_with(
BreakRequest(
file="/path/to/fuchsia/src/main.rs", line=12, delete=True
)
)
@patch("cli.cli.send_command")
async def test_watch_command(self, mock_send: Mock) -> None:
mock_send.return_value = 0
exit_code = await main(
[
"watch",
"-t",
"1",
"--frame-index",
"2",
"-a",
"readWrite",
"my_var",
]
)
self.assertEqual(exit_code, 0)
mock_send.assert_called_once_with(
WatchRequest(
name="my_var",
thread_id=1,
frame_index=2,
access_type="readWrite",
)
)
@patch("cli.cli.send_command")
async def test_watch_aliases(self, mock_send: Mock) -> None:
mock_send.return_value = 0
for alias in [
"watchpoint",
"data-breakpoint",
"setDataBreakpoints",
"set-data-breakpoints",
"set_data_breakpoints",
]:
mock_send.reset_mock()
exit_code = await main([alias, "-t", "1", "-a", "write", "my_var"])
self.assertEqual(exit_code, 0, f"Failed for alias: {alias}")
mock_send.assert_called_once_with(
WatchRequest(name="my_var", thread_id=1, access_type="write")
)
@patch("cli.cli.send_command")
async def test_watch_delete(self, mock_send: Mock) -> None:
mock_send.return_value = 0
exit_code = await main(["watch", "-d", "1001:0x1234:4"])
self.assertEqual(exit_code, 0)
mock_send.assert_called_once_with(
WatchRequest(
name="1001:0x1234:4",
delete=True,
)
)
@patch("cli.cli.send_command")
async def test_watch_clear(self, mock_send: Mock) -> None:
mock_send.return_value = 0
exit_code = await main(["watch", "--clear"])
self.assertEqual(exit_code, 0)
mock_send.assert_called_once_with(WatchRequest(name="", clear=True))
@patch("cli.cli.send_command")
async def test_watch_invalid_args(self, mock_send: Mock) -> None:
mock_send.return_value = 0
cases = [
(["watch"], "expression is required"),
(["watch", "-d"], "data_id is required"),
(["watch", "-a", "write", "my_var"], "-t/--thread-id"),
(["watch", "-t", "1", "my_var"], "-a/--access-type"),
]
for argv, expected in cases:
mock_send.reset_mock()
stderr = StringIO()
with contextlib.redirect_stderr(stderr):
exit_code = await main(argv)
self.assertEqual(exit_code, 2, f"Failed for: {argv}")
self.assertIn(expected, stderr.getvalue())
mock_send.assert_not_called()
async def test_watch_rejects_read_access_type(self) -> None:
with contextlib.redirect_stderr(StringIO()):
with self.assertRaises(SystemExit):
await main(["watch", "-t", "1", "-a", "read", "my_var"])
@patch("cli.cli.send_command")
async def test_json_option_watch(self, mock_send: Mock) -> None:
mock_send.return_value = 0
exit_code = await main(
[
"--json",
'{"command": "watch", "name": "my_var", "thread_id": 1,'
' "frame_index": 2, "access_type": "write"}',
]
)
self.assertEqual(exit_code, 0)
mock_send.assert_called_once_with(
WatchRequest(
name="my_var",
thread_id=1,
frame_index=2,
access_type="write",
)
)
@patch("cli.cli.send_command")
async def test_json_option_watch_delete_and_clear(
self, mock_send: Mock
) -> None:
mock_send.return_value = 0
exit_code = await main(
[
"--json",
'{"command": "watch", "name": "1001:0x1234:4", "delete": true}',
]
)
self.assertEqual(exit_code, 0)
mock_send.assert_called_once_with(
WatchRequest(name="1001:0x1234:4", delete=True)
)
mock_send.reset_mock()
exit_code = await main(
["--json", '{"command": "watch", "clear": true}']
)
self.assertEqual(exit_code, 0)
mock_send.assert_called_once_with(WatchRequest(clear=True))
@patch("cli.cli.send_command")
async def test_json_option_watch_invalid(self, mock_send: Mock) -> None:
mock_send.return_value = 0
cases = [
('{"command": "watch", "name": "my_var", "thread_id": 1}', 2),
(
'{"command": "watch", "name": "my_var", "access_type": "write"}',
2,
),
(
'{"command": "watch", "name": "my_var", "thread_id": 1,'
' "access_type": "read"}',
1,
),
]
for payload, expected_code in cases:
mock_send.reset_mock()
with contextlib.redirect_stderr(StringIO()):
exit_code = await main(["--json", payload])
self.assertEqual(exit_code, expected_code, f"Failed for: {payload}")
mock_send.assert_not_called()
@patch("cli.cli.send_command")
async def test_extended_break_commands(self, mock_send: Mock) -> None:
mock_send.return_value = 0
exit_code = await main(
["break", "-f", "usb_xhci::UsbXhci::Init", "-c", "status != 0"]
)
self.assertEqual(exit_code, 0)
mock_send.assert_called_once_with(
BreakRequest(
function="usb_xhci::UsbXhci::Init", condition="status != 0"
)
)
@patch("cli.cli.send_command")
async def test_tracepoint_function_command(
self, mock_send: AsyncMock
) -> None:
mock_send.return_value = 0
exit_code = await main(
[
"tracepoint",
"my_func",
"-e",
"x",
"--locals",
"--max-hits",
"10",
"--max-frames",
"5",
]
)
self.assertEqual(exit_code, 0)
mock_send.assert_called_once()
req = mock_send.call_args[0][0]
self.assertIsInstance(req, TracepointRequest)
self.assertEqual(req.function, "my_func")
self.assertEqual(req.expressions, ["x"])
self.assertIn("locals", req.capture)
self.assertEqual(req.max_hits, 10)
self.assertEqual(req.max_matching_frames, 5)
@patch("cli.cli.send_command")
async def test_tracepoint_list_command(self, mock_send: AsyncMock) -> None:
mock_send.return_value = 0
exit_code = await main(["tracepoint", "--list"])
self.assertEqual(exit_code, 0)
mock_send.assert_called_once()
req = mock_send.call_args[0][0]
self.assertIsInstance(req, TracepointRequest)
self.assertTrue(req.list_all)
@patch("cli.cli.send_command")
async def test_tracepoint_delete_command(
self, mock_send: AsyncMock
) -> None:
mock_send.return_value = 0
exit_code = await main(["tracepoint", "-d", "--id", "1"])
self.assertEqual(exit_code, 0)
mock_send.assert_called_once()
req = mock_send.call_args[0][0]
self.assertIsInstance(req, TracepointRequest)
self.assertTrue(req.delete)
self.assertEqual(req.tracepoint_id, 1)
@patch("cli.cli.send_command")
async def test_tracepoint_raw_backtrace_implies_backtrace(
self, mock_send: AsyncMock
) -> None:
mock_send.return_value = 0
exit_code = await main(["tracepoint", "my_func", "-r"])
self.assertEqual(exit_code, 0)
mock_send.assert_called_once()
req = mock_send.call_args[0][0]
self.assertIsInstance(req, TracepointRequest)
self.assertTrue(req.raw_backtrace)
self.assertIn("backtrace", req.capture)
@patch("cli.cli.send_command")
async def test_tracepoint_expr_flag(self, mock_send: AsyncMock) -> None:
mock_send.return_value = 0
exit_code = await main(["tracepoint", "my_func", "--expr", "x"])
self.assertEqual(exit_code, 0)
mock_send.assert_called_once()
req = mock_send.call_args[0][0]
self.assertIsInstance(req, TracepointRequest)
self.assertEqual(req.expressions, ["x"])
@patch("cli.cli.send_command")
async def test_tracepoint_delete_positional_id(
self, mock_send: AsyncMock
) -> None:
mock_send.return_value = 0
exit_code = await main(["tracepoint", "1", "-d"])
self.assertEqual(exit_code, 0)
mock_send.assert_called_once()
req = mock_send.call_args[0][0]
self.assertIsInstance(req, TracepointRequest)
self.assertTrue(req.delete)
self.assertEqual(req.tracepoint_id, 1)
@patch("cli.commands.location_utils.resolve_path", autospec=True)
@patch("cli.cli.send_command")
async def test_tracepoint_file_line_and_cpp_symbol(
self, mock_send: AsyncMock, mock_resolve: Mock
) -> None:
mock_send.return_value = 0
mock_resolve.return_value = "/workspace/src/main.cc"
exit_code = await main(["tp", "src/main.cc:42"])
self.assertEqual(exit_code, 0)
mock_resolve.assert_called_once_with("src/main.cc")
self.assertEqual(
mock_send.call_args[0][0],
TracepointRequest(file="/workspace/src/main.cc", line=42),
)
mock_send.reset_mock()
mock_resolve.reset_mock()
exit_code = await main(["trace", "foo::Bar::Baz"])
self.assertEqual(exit_code, 0)
mock_resolve.assert_not_called()
self.assertEqual(
mock_send.call_args[0][0],
TracepointRequest(function="foo::Bar::Baz"),
)
@patch("cli.cli.send_command")
async def test_tracepoint_watch_and_management_commands(
self, mock_send: AsyncMock
) -> None:
mock_send.return_value = 0
exit_code = await main(
["tp", "-w", "my_var", "-t", "2", "-a", "readWrite", "--size", "4"]
)
self.assertEqual(exit_code, 0)
self.assertEqual(
mock_send.call_args[0][0],
TracepointRequest(
watch="my_var", thread_id=2, access_type="readWrite", size=4
),
)
for argv, expected in (
(["tp", "--clear"], TracepointRequest(clear=True)),
(
["tp", "--enable", "3"],
TracepointRequest(tracepoint_id=3, enabled=True),
),
(
["tp", "--disable", "--id", "4"],
TracepointRequest(tracepoint_id=4, enabled=False),
),
):
mock_send.reset_mock()
exit_code = await main(argv)
self.assertEqual(exit_code, 0)
self.assertEqual(mock_send.call_args[0][0], expected)
@patch("cli.cli.send_command")
async def test_tracepoint_conflicting_cli_flags(
self, mock_send: AsyncMock
) -> None:
invalid_cases = [
["tracepoint", "--list", "--delete"],
["tracepoint", "--list", "my_func"],
["tracepoint", "--clear", "--locals"],
["tracepoint", "-d", "--id", "1", "other_func"],
["tracepoint", "-d"],
["tracepoint", "--enable", "--disable", "--id", "1"],
["tracepoint", "--enable"],
["tracepoint", "--disable", "1", "--locals"],
]
for argv in invalid_cases:
mock_send.reset_mock()
with contextlib.redirect_stderr(StringIO()):
exit_code = await main(argv)
self.assertEqual(exit_code, 1, f"Expected failure for {argv}")
mock_send.assert_not_called()
if __name__ == "__main__":
unittest.main()