artefacts-cli 0.7.1__tar.gz → 0.7.3__tar.gz

{artefacts_cli-0.7.1 → artefacts_cli-0.7.3}/CHANGELOG.md

@@ -16,6 +16,22 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 - New logging messages and format.
 
+## [0.7.3] - 2025-03-26
+
+### Fixed
+
+- Handle nested ROS params in the configuration file.
+
+## [0.7.2] - 2025-03-19
+
+### Fixed
+
+- Fixed error handling (bug from misuse of Click's `ClickException`).
+
+### Changed
+
+- Improved error handling and messages.
+
 
 ## [0.7.1] - 2025-03-14
 

{artefacts_cli-0.7.1/artefacts_cli.egg-info → artefacts_cli-0.7.3}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: artefacts_cli
-Version: 0.7.1
+Version: 0.7.3
 Author-email: FD <fabian@artefacts.com>, AGC <alejandro@artefacts.com>, TN <tomo@artefacts.com>, EP <eric@artefacts.com>
 Project-URL: Homepage, https://github.com/art-e-fact/artefacts-client
 Project-URL: Bug Tracker, https://github.com/art-e-fact/artefacts-client/issues

{artefacts_cli-0.7.1 → artefacts_cli-0.7.3}/artefacts/cli/app.py

@@ -309,8 +309,8 @@ def run(
     api_conf = APIConf(project_id, jobname)
     click.echo(f"[{jobname}] Starting tests")
     if jobname not in warpconfig["jobs"]:
-        click.echo(f"[{jobname}] Error: Job name not defined")
-        raise click.ClickException()
+        click.secho(f"[{jobname}] Error: Job name not defined", err=True, bold=True)
+        raise click.Abort()
     jobconf = warpconfig["jobs"][jobname]
     job_type = jobconf.get("type", "test")
     if job_type not in ["test"]:
@@ -358,10 +358,12 @@ def run(
             first,
         )
     except AuthenticationError:
-        click.echo(
-            f"[{jobname}] Unable to authenticate (Stage: Job initialisation), please check your project name and API key"
+        click.secho(
+            f"[{jobname}] Unable to authenticate (Stage: Job initialisation), please check your project name and API key",
+            err=True,
+            bold=True,
         )
-        raise click.ClickException()
+        raise click.Abort()
 
     job_success = True
     for scenario_n, scenario in enumerate(scenarios):
@@ -371,18 +373,29 @@ def run(
         try:
             run = warpjob.new_run(scenario)
         except AuthenticationError:
-            click.echo(
-                f"[{jobname}] Unable to authenticate (Stage: Job run), please check your project name and API key"
+            click.secho(
+                f"[{jobname}] Unable to authenticate (Stage: Job run), please check your project name and API key",
+                err=True,
+                bold=True,
             )
-            raise click.ClickException()
+            raise click.Abort()
         if framework is not None and framework.startswith("ros2:"):
             from artefacts.cli.ros2 import run_ros2_tests
+            from artefacts.cli.utils_ros import get_TestSuite_error_result
 
             if "ros_testfile" not in run.params:
-                click.echo(
-                    f"[{jobname}] Test launch file not specified for ros2 project"
+                click.secho(
+                    f"[{jobname}] Test launch file not specified for ros2 project",
+                    err=True,
+                    bold=True,
+                )
+                result = get_TestSuite_error_result(
+                    scenario["name"],
+                    "launch_test file not specified error",
+                    f"Please specify a `ros_testfile` in the artefacts.yaml scenario configuration.",
                 )
-                raise click.ClickException()
+                run.log_tests_results([result], False)
+                run.stop()
             if dryrun:
                 click.echo(f"[{jobname}] Performing dry run")
                 results, success = {}, True
@@ -393,26 +406,34 @@ def run(
                     warpjob.stop()
                     warpjob.log_tests_result(False)
                     click.secho(e, bold=True, err=True)
-                    click.echo(f"[{jobname}] artefacts failed to execute the tests")
-                    raise click.ClickException()
+                    click.secho(
+                        f"[{jobname}] artefacts failed to execute the tests",
+                        err=True,
+                        bold=True,
+                    )
+                    raise click.Abort()
             if success is None:
                 run.stop()
                 warpjob.stop()
                 warpjob.log_tests_result(job_success)
-                click.echo(
-                    f"[{jobname}] Not able to execute tests. Make sure that ROS2 is sourced and that your launch file syntax is correct."
+                click.secho(
+                    f"[{jobname}] Not able to execute tests. Make sure that ROS2 is sourced and that your launch file syntax is correct.",
+                    err=True,
+                    bold=True,
                 )
-                raise click.ClickException()
+                raise click.Abort()
             if not success:
                 job_success = False
         elif framework is not None and framework.startswith("ros1:"):
             from artefacts.cli.ros1 import run_ros1_tests
 
             if "ros_testfile" not in run.params:
-                click.echo(
-                    f"[{jobname}] Test launch file not specified for ros1 project"
+                click.secho(
+                    f"[{jobname}] Test launch file not specified for ros1 project",
+                    err=True,
+                    bold=True,
                 )
-                raise click.ClickException()
+                raise click.Abort()
             if dryrun:
                 click.echo(f"[{jobname}] Performing dry run")
                 results, success = {}, True
@@ -424,8 +445,12 @@ def run(
             from artefacts.cli.other import run_other_tests
 
             if "run" not in run.params:
-                click.echo(f"[{jobname}] run command not specified for scenario")
-                raise click.ClickException()
+                click.secho(
+                    f"[{jobname}] run command not specified for scenario",
+                    err=True,
+                    bold=True,
+                )
+                raise click.Abort()
             if dryrun:
                 click.echo(f"[{jobname}] Performing dry run")
                 results, success = {}, True
@@ -562,17 +587,23 @@ def run_remote(config, description, jobname, skip_validation=False):
                     f"Missing access! Please make sure your API key is added at {dashboard_url}/settings"
                 )
 
-            if (
-                upload_urls_response.status_code == 401
-                and result["message"] == "no linked repository"
-            ):
+            if upload_urls_response.status_code == 402:
                 raise click.ClickException(
-                    f"Missing linked GitHub repository. Please link a GitHub repository at {dashboard_url}/settings"
+                    f"Billing issue, please go to {dashboard_url}/settings to correct: {result['error']}"
                 )
 
-            raise click.ClickException(
-                f"Error getting project info: {upload_urls_response.status_code} {upload_urls_response.reason}. Response text: {upload_urls_response.text}."
-            )
+            if "message" in result:
+                raise click.ClickException(
+                    f"Error getting project info: {result['message']}"
+                )
+            elif "error" in result:
+                raise click.ClickException(
+                    f"Error getting project info: {result['error']}"
+                )
+            else:
+                raise click.ClickException(
+                    f"Error getting project info: {upload_urls_response.status_code} {upload_urls_response.reason}. Response text: {upload_urls_response.text}."
+                )
 
         upload_urls = upload_urls_response.json()["upload_urls"]
         url = ""

{artefacts_cli-0.7.1 → artefacts_cli-0.7.3}/artefacts/cli/ros2.py

@@ -4,10 +4,58 @@ import os
 import shutil
 
 from .utils import run_and_save_logs
-from .utils_ros import parse_tests_results
+from .utils_ros import parse_tests_results, get_TestSuite_error_result
 from .parameters import TMP_SCENARIO_PARAMS_YAML
 
 
+# custom exceptions raised when trying to run ros2 tests
+class Launch_test_CmdNotFoundError(FileNotFoundError):
+    pass
+
+
+class LaunchTestFileNotFoundError(FileNotFoundError):
+    pass
+
+
+class BadLaunchTestFileError(Exception):
+    pass
+
+
+def ros2_run_and_save_logs(
+    args, output_path, shell=False, executable=None, env=None, cwd=None
+):
+    try:
+        return_code, stdout, stderr = run_and_save_logs(
+            args,
+            output_path,
+            shell=shell,
+            executable=executable,
+            env=env,
+            cwd=cwd,
+            with_output=True,
+        )
+    except FileNotFoundError:
+        raise Launch_test_CmdNotFoundError(
+            f"Running {args} failed. Please check that `launch_test` is installed and in the path."
+        )
+    if return_code == 2:
+        # check the proc stderr for `launch_test: error: Test file '[filename]' does not exist`
+
+        if "does not exist" in stderr:
+            raise LaunchTestFileNotFoundError(
+                f"Running {args} failed. Please check that the launch file exists."
+            )
+        if "launch_test: error: " in stderr:
+            # example errors:
+            # "has no attribute 'generate_test_description'"
+            # "error: name 'xxx' is not defined"
+            raise BadLaunchTestFileError(
+                f"Running {args} failed. Check that the launch_test file syntax is correct."
+            )
+
+    return return_code
+
+
 def generate_scenario_parameter_output(params: dict, param_file: str):
     """
     Store `params` in `param_file` and convert to ros2 param file nested format,
@@ -22,7 +70,14 @@ def generate_scenario_parameter_output(params: dict, param_file: str):
             return
         if node not in content:
             content[node] = {"ros__parameters": {}}
-        content[node]["ros__parameters"][pname] = v
+        # handles nested keys for params in the form of dot notation
+        current_level = content[node]["ros__parameters"]
+        keys = pname.split(".")
+        for key in keys[:-1]:
+            if key not in current_level:
+                current_level[key] = {}
+            current_level = current_level[key]
+        current_level[keys[-1]] = v
     with open(param_file, "w") as f:
         yaml.dump(content, f)
 
@@ -57,19 +112,54 @@ def run_ros2_tests(run):
     # Main: test execution
     # shell=True required to support command list items that are strings with spaces
     # (this way, scenario["ros_testfile"] can be either a path to the launch file or '<package_name> <launch_name>')
-    return_code = run_and_save_logs(
-        " ".join(command),
-        shell=True,
-        executable="/bin/bash",
-        env={
-            **os.environ,
-            **{
-                "ROS_LOG_DIR": ros_log_dir,
-                "ARTEFACTS_SCENARIO_PARAMS_FILE": TMP_SCENARIO_PARAMS_YAML,
+    try:
+        return_code = ros2_run_and_save_logs(
+            " ".join(command),
+            shell=True,
+            executable="/bin/bash",
+            env={
+                **os.environ,
+                **{
+                    "ROS_LOG_DIR": ros_log_dir,
+                    "ARTEFACTS_SCENARIO_PARAMS_FILE": TMP_SCENARIO_PARAMS_YAML,
+                },
             },
-        },
-        output_path=os.path.join(run.output_path, "test_process_log.txt"),
-    )
+            output_path=os.path.join(run.output_path, "test_process_log.txt"),
+        )
+    except Launch_test_CmdNotFoundError as e:
+        # raise Exception(
+        #    f"Running {scenario['ros_testfile']} failed. Please check that the launch file exists."
+        # )
+        # closes the run properly and mark as errored
+        # dict matching junit xml format for test execution error
+        result = get_TestSuite_error_result(
+            scenario["ros_testfile"],
+            "launch_test command not found",
+            "Please check that launch_test is installed and in the path. Exception: {e}",
+        )
+        results = [result]
+        run.log_tests_results(results, False)
+        return results, False
+    except LaunchTestFileNotFoundError as e:
+        result = get_TestSuite_error_result(
+            scenario["ros_testfile"],
+            "launch_test file not found",
+            f"Please check that the `ros_testfile` config is correct. Exception: {e}",
+        )
+        results = [result]
+        run.log_tests_results(results, False)
+        return results, False
+    except BadLaunchTestFileError as e:
+        launch_test_file = scenario["ros_testfile"]
+        result = get_TestSuite_error_result(
+            scenario["ros_testfile"],
+            "launch_test file syntax error",
+            f"Please check that the file specified in  `ros_testfile` config is a valid ros_test file. You may be able to identify issues by doing `launch_test {launch_test_file}`. Exception: {e}",
+        )
+        results = [result]
+        run.log_tests_results(results, False)
+        return results, False
+
     if return_code == 2:
         raise Exception(
             f"Running {scenario['ros_testfile']} failed. Please check that the launch file exists."
@@ -82,10 +172,11 @@ def run_ros2_tests(run):
 
     # parse xml generated by launch_test
     results, success = parse_tests_results(test_result_file_path)
+    # upload logs anyway to help user debug
+    run.log_artifacts(run.output_path)
     if success is None:
         run.log_tests_results(results, False)
         return results, success
-    run.log_artifacts(run.output_path)
 
     # upload any additional files in the folders specified by the user in artefacts.yaml
     for output in scenario.get("output_dirs", []):

{artefacts_cli-0.7.1 → artefacts_cli-0.7.3}/artefacts/cli/utils.py

@@ -12,7 +12,13 @@ from artefacts.cli import WarpRun
 
 
 def run_and_save_logs(
-    args, output_path, shell=False, executable=None, env=None, cwd=None
+    args,
+    output_path,
+    shell=False,
+    executable=None,
+    env=None,
+    cwd=None,
+    with_output=False,
 ):
     """
     Run a command and save stdout and stderr to a file in output_path
@@ -20,6 +26,7 @@ def run_and_save_logs(
     Note: explicitly list used named params instead of using **kwargs to avoid typing issue: https://github.com/microsoft/pyright/issues/455#issuecomment-780076232
     """
     output_file = open(output_path, "wb")
+
     proc = subprocess.Popen(
         args,
         stdout=subprocess.PIPE,  # Capture stdout
@@ -30,17 +37,24 @@ def run_and_save_logs(
         cwd=cwd,
     )
     # write test-process stdout and stderr into file and stdout
+    stderr_content = ""
+    stdout_content = ""
     if proc.stdout:
         for line in proc.stdout:
             decoded_line = line.decode()
             sys.stdout.write(decoded_line)
             output_file.write(line)
+            stdout_content += decoded_line
     if proc.stderr:
+        output_file.write("[STDERR]\n".encode())
         for line in proc.stderr:
             decoded_line = line.decode()
             sys.stderr.write(decoded_line)
             output_file.write(line)
+            stderr_content += decoded_line
     proc.wait()
+    if with_output:
+        return proc.returncode, stdout_content, stderr_content
     return proc.returncode
 
 

{artefacts_cli-0.7.1 → artefacts_cli-0.7.3}/artefacts/cli/utils_ros.py

@@ -6,6 +6,22 @@ class FailureElement(Element):
     message = Attr()
 
 
+def get_TestSuite_error_result(test_suite_name, name, error_msg):
+    return {
+        "suite": test_suite_name,
+        "errors": 1,
+        "failures": 0,
+        "tests": 1,
+        "details": [
+            {
+                "name": name,
+                "failure_message": error_msg,
+                "result": "failure",
+            }
+        ],
+    }
+
+
 def parse_tests_results(file):
     def parse_suite(suite):
         nonlocal success, results
@@ -50,19 +66,9 @@ def parse_tests_results(file):
     except Exception as e:
         print(f"[Exception in parse_tests_results] {e}")
         print("Test result xml could not be loaded, marking success as False")
-        results = [
-            {
-                "suite": "unittest.suite.TestSuite",
-                "errors": 1,
-                "failures": 0,
-                "tests": 1,
-                "details": [
-                    {
-                        "name": "Error parsing XML test results",
-                        "failure_message": f"The test may have timed out. Exception: {e}",
-                        "result": "failure",
-                    }
-                ],
-            }
-        ]
+        results = get_TestSuite_error_result(
+            "unittest.suite.TestSuite",
+            "Error parsing XML test results",
+            f"The test may have timed out. Exception: {e}",
+        )
         return results, None

{artefacts_cli-0.7.1 → artefacts_cli-0.7.3}/artefacts/cli/version.py

@@ -17,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.7.1'
-__version_tuple__ = version_tuple = (0, 7, 1)
+__version__ = version = '0.7.3'
+__version_tuple__ = version_tuple = (0, 7, 3)

{artefacts_cli-0.7.1 → artefacts_cli-0.7.3/artefacts_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: artefacts_cli
-Version: 0.7.1
+Version: 0.7.3
 Author-email: FD <fabian@artefacts.com>, AGC <alejandro@artefacts.com>, TN <tomo@artefacts.com>, EP <eric@artefacts.com>
 Project-URL: Homepage, https://github.com/art-e-fact/artefacts-client
 Project-URL: Bug Tracker, https://github.com/art-e-fact/artefacts-client/issues

{artefacts_cli-0.7.1 → artefacts_cli-0.7.3}/artefacts_cli.egg-info/SOURCES.txt

@@ -62,6 +62,7 @@ tests/cli/containers/__init__.py
 tests/cli/containers/test_utils.py
 tests/fixtures/artefacts_deprecated.yaml
 tests/fixtures/artefacts_ros1.yaml
+tests/fixtures/bad_launch_test.py
 tests/fixtures/warp-env-param.yaml
 tests/fixtures/warp.yaml
 tests/utils/docker_mock.py

{artefacts_cli-0.7.1 → artefacts_cli-0.7.3}/tests/cli/test_cli.py

@@ -47,14 +47,14 @@ def test_run(cli_runner):
 
 
 def test_run_with_conf_invalid_jobname(cli_runner, project_with_key):
-    result = cli_runner.invoke(
-        run, ["invalid_job_name", "--config", "tests/fixtures/warp.yaml"]
-    )
+    job_name = "invalid_job_name"
+    result = cli_runner.invoke(run, [job_name, "--config", "tests/fixtures/warp.yaml"])
     assert result.exit_code == 1
     assert result.output == (
-        "[invalid_job_name] Connecting to https://app.artefacts.com/api using ApiKey\n"
-        f"[invalid_job_name] Starting tests\n"
-        "[invalid_job_name] Error: Job name not defined\n"
+        f"[{job_name}] Connecting to https://app.artefacts.com/api using ApiKey\n"
+        f"[{job_name}] Starting tests\n"
+        f"[{job_name}] Error: Job name not defined\n"
+        "Aborted!\n"
     )
 
 

artefacts_cli-0.7.3/tests/cli/test_ros2.py

@@ -0,0 +1,100 @@
+import os
+import yaml
+from unittest.mock import patch
+import pytest
+
+from artefacts.cli import WarpJob, WarpRun
+from artefacts.cli.app import APIConf
+from artefacts.cli.ros2 import (
+    generate_scenario_parameter_output,
+    run_ros2_tests,
+    ros2_run_and_save_logs,
+)
+from artefacts.cli.ros2 import (
+    Launch_test_CmdNotFoundError,
+    LaunchTestFileNotFoundError,
+    BadLaunchTestFileError,
+)
+
+
+def test_generate_parameter_output(tmp_path):
+    params = {
+        "turtle/speed": 5,
+        "turtle/color.rgb.r": 255,
+        "controller_server/FollowPath.critics": ["RotateToGoal", "Oscillation"],
+    }
+    file_path = tmp_path / "params.yaml"
+    generate_scenario_parameter_output(params, file_path)
+    with open(file_path) as f:
+        ros2_params = yaml.load(f, Loader=yaml.Loader)
+    assert ros2_params == {
+        "turtle": {
+            "ros__parameters": {
+                "speed": 5,
+                "color": {"rgb": {"r": 255}},
+            }
+        },
+        "controller_server": {
+            "ros__parameters": {
+                "FollowPath": {"critics": ["RotateToGoal", "Oscillation"]}
+            }
+        },
+    }
+
+
+@patch("os.path.exists", return_value=False)
+@patch("artefacts.cli.ros2.ros2_run_and_save_logs")
+@pytest.mark.ros2
+def test_passing_launch_arguments(mock_ros2_run_and_save_logs, _mock_exists):
+    os.environ["ARTEFACTS_JOB_ID"] = "test_job_id"
+    os.environ["ARTEFACTS_KEY"] = "test_key"
+    job = WarpJob("test_project_id", APIConf("sdfs"), "test_jobname", {}, dryrun=True)
+    scenario = {
+        "ros_testfile": "test.launch.py",
+        "launch_arguments": {"arg1": "val1", "arg2": "val2"},
+    }
+    run = WarpRun(job, scenario, 0)
+
+    run_ros2_tests(run)
+
+    mock_ros2_run_and_save_logs.assert_called_once()
+    assert (
+        " test.launch.py arg1:=val1 arg2:=val2"
+        in mock_ros2_run_and_save_logs.call_args[0][0]
+    ), (
+        "Launch arguments should be passed to the test command after the launch file path"
+    )
+
+
+@pytest.mark.ros2
+def test_run_and_save_logs_missing_ros2_launchtest():
+    filename = "missing_launchtest.test.py"
+    command = [
+        "launch_test",
+        filename,
+    ]
+    with pytest.raises(LaunchTestFileNotFoundError):
+        return_code = ros2_run_and_save_logs(
+            " ".join(command),
+            shell=True,
+            executable="/bin/bash",
+            env=os.environ,
+            output_path="/tmp/test_log.txt",
+        )
+
+
+@pytest.mark.ros2
+def test_run_and_save_logs_bad_ros2_launchtest():
+    filename = "bad_launch_test.py"
+    command = [
+        "launch_test",
+        f"tests/fixtures/{filename}",
+    ]
+    with pytest.raises(BadLaunchTestFileError):
+        return_code = ros2_run_and_save_logs(
+            " ".join(command),
+            shell=True,
+            executable="/bin/bash",
+            env=os.environ,
+            output_path="/tmp/test_log.txt",
+        )

{artefacts_cli-0.7.1 → artefacts_cli-0.7.3}/tests/cli/test_utils.py

@@ -1,8 +1,10 @@
 import pytest
+import subprocess
+import os
 
 from artefacts.cli import WarpJob, WarpRun
 from artefacts.cli.app import APIConf
-from artefacts.cli.utils import add_output_from_default
+from artefacts.cli.utils import add_output_from_default, run_and_save_logs
 
 
 @pytest.fixture
@@ -22,3 +24,15 @@ def test_adds_nothing_on_missing_default_output(new_run, mocker, project_with_ke
     path.configure_mock(**mocked)
     add_output_from_default(new_run)
     assert len(new_run.uploads) == 0
+
+
+@pytest.mark.ros2
+def test_run_and_save_logs_missing_launch_test_command():
+    filename = "launchtest.test.py"
+    command = [
+        "launch_test",
+        filename,
+    ]
+    # launch_test won't be in the path, and an error will be raised
+    with pytest.raises(FileNotFoundError):
+        run_and_save_logs(" ".join(command), output_path="/tmp/test_log.txt")

{artefacts_cli-0.7.1 → artefacts_cli-0.7.3}/tests/fixtures/warp.yaml

@@ -1,6 +1,25 @@
 version: 0.1.0
 project: _pytest-project_
 jobs:
+  missing_launchtest:
+    type: test
+    runtime:
+      simulator: turtlesim
+      framework: ros2:humble
+    scenarios:
+      settings:
+        - name: missing_launchtest
+          ros_testfile: missing_launchtests.py
+  bad_launchtest:
+    type: test
+    runtime:
+      simulator: turtlesim
+      framework: ros2:humble
+    scenarios:
+      settings:
+        - name: bad_launchtest
+          ros_testfile: bad_launch_test.py
+
   simple_job:
     type: test
     runtime:

artefacts_cli-0.7.1/tests/cli/test_ros2.py

@@ -1,41 +0,0 @@
-import os
-import yaml
-from unittest.mock import patch
-import pytest
-
-from artefacts.cli import WarpJob, WarpRun
-from artefacts.cli.app import APIConf
-from artefacts.cli.ros2 import generate_scenario_parameter_output, run_ros2_tests
-
-
-def test_generate_parameter_output(tmp_path):
-    params = {"turtle/speed": 5}
-    file_path = tmp_path / "params.yaml"
-    generate_scenario_parameter_output(params, file_path)
-    with open(file_path) as f:
-        ros2_params = yaml.load(f, Loader=yaml.Loader)
-    assert ros2_params == {"turtle": {"ros__parameters": {"speed": 5}}}
-
-
-@patch("os.path.exists", return_value=False)
-@patch("artefacts.cli.ros2.run_and_save_logs")
-@pytest.mark.ros2
-def test_passing_launch_arguments(mock_run_and_save_logs, _mock_exists):
-    os.environ["ARTEFACTS_JOB_ID"] = "test_job_id"
-    os.environ["ARTEFACTS_KEY"] = "test_key"
-    job = WarpJob("test_project_id", APIConf("sdfs"), "test_jobname", {}, dryrun=True)
-    scenario = {
-        "ros_testfile": "test.launch.py",
-        "launch_arguments": {"arg1": "val1", "arg2": "val2"},
-    }
-    run = WarpRun(job, scenario, 0)
-
-    run_ros2_tests(run)
-
-    mock_run_and_save_logs.assert_called_once()
-    assert (
-        " test.launch.py arg1:=val1 arg2:=val2"
-        in mock_run_and_save_logs.call_args[0][0]
-    ), (
-        "Launch arguments should be passed to the test command after the launch file path"
-    )