async def test_time_limit(event_loop):
command = Command(command_string="new-command", time_limit=0.5)
await asyncio.sleep(0.6)
assert command.status == CommandStatus.TIMEDOUT
assert command.done()
def mock_send_command(mocker):
command = Command()
command.set_status("done")
HALHelper._send_command = mocker.AsyncMock(return_value=command)
Macro.send_command = mocker.AsyncMock(return_value=command)
async def _send_command(
self,
command: HALCommandType,
target: str,
cmd_str: str,
raise_on_fail: bool = True,
**kwargs,
):
"""Sends a command to a target."""
bypasses = self.actor.helpers.bypasses
# If the helper is bypassed, just returns a fake done command.
if (self.name and self.name in bypasses) or ("all" in bypasses):
command.warning(f"Bypassing command '{target} {cmd_str}'")
cmd = Command()
cmd.set_status(CommandStatus.DONE)
return cmd
if self.actor.tron is None or self.actor.tron.connected() is False:
raise HALError("Not connected to Tron. Cannot send commands.")
cmd = await command.send_command(target, cmd_str, **kwargs)
if raise_on_fail and cmd.status.did_fail:
if cmd.status == CommandStatus.TIMEDOUT:
raise HALError(f"Command '{target} {cmd_str}' timed out.")
else:
raise HALError(f"Command '{target} {cmd_str}' failed.")
return cast(Command, cmd)
def test_child_command_write(command):
command.command_id = 666
child = Command(command_string="new-command", parent=command)
child.write("i", "hello")
command.actor.write.assert_called_with(
"i",
message={"text": "hello"},
command=command,
broadcast=False,
silent=False,
**{},
)
async def test_unique(json_actor, click_parser):
cmd = Command("unique-command", actor=json_actor)
click_parser.parse_command(cmd)
await asyncio.sleep(0.01)
cmd2 = Command("unique-command", actor=json_actor)
click_parser.parse_command(cmd2)
await cmd2
assert cmd2.status.did_fail
assert (
"Another command with name my-parser-command-parser_unique-command"
in cmd2.replies[-1].message["error"]
)
async def test_cancellable(json_actor, click_parser):
cmd = Command("cancellable-command", actor=json_actor)
click_parser.parse_command(cmd)
await asyncio.sleep(0.01)
cmd2 = Command("cancellable-command --stop", actor=json_actor)
click_parser.parse_command(cmd2)
await cmd2
await cmd
assert cmd.status.did_fail
assert cmd2.status.did_succeed
assert "has been cancelled." in cmd.replies[-1].message["error"]
assert "has been scheduled for cancellation" in cmd2.replies[-1].message["text"]
async def test_cancellable_duplicate(json_actor, click_parser):
cmd = Command("cancellable-command", actor=json_actor)
click_parser.parse_command(cmd)
await asyncio.sleep(0.01)
cmd2 = Command("cancellable-command", actor=json_actor)
click_parser.parse_command(cmd2)
await cmd2
assert cmd2.status.did_fail
assert (
"Another command my-parser-command-parser_cancellable-command"
in cmd2.replies[-1].message["error"]
)
def test_child_command_finished(command):
child = Command(command_string="new-command", parent=command)
child.finish(text="Finished")
command.actor.write.assert_called_with(
"i",
message={},
text="Finished",
command=command,
broadcast=False,
silent=False,
**{},
)
assert child.status.did_succeed
def test_child_command_failed(command):
child = Command(command_string="new-command", parent=command)
child.fail(error="Failed")
command.actor.write.assert_called_with(
"e",
message={},
error="Failed",
command=command,
broadcast=False,
silent=False,
**{},
)
assert child.status.did_fail
async def test_help(json_actor, click_parser):
cmd = Command(command_string="ping --help", actor=json_actor)
click_parser.parse_command(cmd)
await cmd
assert cmd.status.is_done
async def test_help_not_found(json_actor, click_parser):
cmd = Command(command_string="png --help", actor=json_actor)
click_parser.parse_command(cmd)
await cmd
assert cmd.status.did_fail
async def test_abort(json_actor, click_parser):
cmd = Command(command_string="command-abort", actor=json_actor)
click_parser.parse_command(cmd)
await cmd
assert cmd.status.did_fail
assert "Command 'command-abort' was aborted" in json_actor.mock_replies[-1]["error"]
async def test_parser_full_help(json_actor, click_parser, cmd_str):
cmd = Command(command_string=cmd_str, actor=json_actor)
click_parser.parse_command(cmd)
await cmd
assert cmd.status.is_done
assert "Usage: json_actor" in cmd.replies[-1].message["help"][0]
async def test_string_with_spaces(json_actor, click_parser):
cmd = Command(command_string='mygroup neg-number-command --text "A test" -1')
click_parser.parse_command(cmd)
await cmd
assert cmd.status.did_succeed
assert cmd.replies[-1]["text"] == "A test"
async def test_keyword_bad_parameter(json_actor, click_parser):
cmd = Command(command_string="keyword bad_param", actor=json_actor)
click_parser.parse_command(cmd)
await cmd
assert cmd.status.did_fail
assert len(json_actor.mock_replies) == 2
assert "is not part of the data model" in json_actor.mock_replies[1]["error"]
async def test_keyword(json_actor, click_parser):
cmd = Command(command_string="keyword version", actor=json_actor)
click_parser.parse_command(cmd)
await cmd
assert cmd.status.did_succeed
assert len(json_actor.mock_replies) == 5
assert json_actor.mock_replies[1]["text"].strip() == "version = {"
async def test_cancellable_cannot_find(json_actor, click_parser, mocker):
mocker.patch.object(clu.parsers.click, "get_running_tasks", return_value=None)
cmd = Command("cancellable-command --stop", actor=json_actor)
click_parser.parse_command(cmd)
await cmd
assert cmd.status.did_fail
assert "Cannot find running command" in cmd.replies[-1].message["error"]
async def test_exit_finish(json_actor, click_parser):
cmd = Command(command_string="command-exit --finish", actor=json_actor)
click_parser.parse_command(cmd)
await cmd
# Wait a bit more to allow for extra messages to arrive.
await asyncio.sleep(0.1)
assert cmd.status.is_done
async def test_keyword_no_model(json_actor, click_parser):
json_actor.model = None
cmd = Command(command_string="keyword version", actor=json_actor)
click_parser.parse_command(cmd)
await cmd
assert cmd.status.did_fail
assert len(json_actor.mock_replies) == 2
assert "Actor does not have a data model" in json_actor.mock_replies[1]["error"]
async def test_uncaught_exception(json_actor, click_parser, caplog):
cmd = Command(command_string="bad-command", actor=json_actor)
click_parser.parse_command(cmd)
await cmd
assert cmd.status.did_fail
assert "uncaught error" in json_actor.mock_replies[-1]["error"]
last_log = caplog.record_tuples[-1]
assert last_log[1] == logging.ERROR
assert "Command 'bad-command' failed with error:" in last_log[2]
# Confirm the traceback was logged.
log_filename = click_parser.log.log_filename
assert os.path.exists(log_filename)
log_data = open(log_filename).read()
assert "This is an exception in the command." in log_data
async def test_command_neg_number(json_actor, click_parser, command_string):
cmd = Command(command_string="mygroup " + command_string, actor=json_actor)
click_parser.parse_command(cmd)
await cmd
assert cmd.status.did_succeed
# This is a different test. We are testing that mygroup got called
# with the parser_obj "object" and its value was passed.
assert cmd.replies[-3]["object"] == "my_object"
if "-15" in command_string:
assert cmd.replies[-2]["value"] == -15
else:
assert cmd.replies[-2]["value"] == 15
if "-r" in command_string or "--recursive" in command_string:
assert cmd.replies[-2]["recursive"] is True
else:
assert cmd.replies[-2]["recursive"] is False
def send_message(
self,
parent_command: Command,
message: str,
command_id: Optional[int] = None,
) -> Command:
"""Sends a message to the device."""
if not self.is_connected():
raise OSError("Device is not connected")
command_id = command_id or self.id_pool.get()
dev_command = Command(message,
command_id=command_id,
parent=parent_command)
self.running_commands[command_id] = dev_command
self.write(f"{command_id} {message}")
return dev_command
def test_child_command_running(command):
child = Command(command_string="new-command", parent=command)
child.set_status("RUNNING")
command.actor.write.assert_not_called()
def command(mocker):
yield Command(command_string="say-hello",
command_id=100,
actor=mocker.MagicMock())
def test_child_command(command):
child = Command(command_string="new-command", parent=command)
assert child.parent == command
def command(actor):
yield Command(actor=actor)
