fix tests

Signed-off-by: Brian Chen <[email protected]>

Author: ihasdapie

ros2param/ros2param/api/__init__.py

@@ -13,6 +13,7 @@
 # limitations under the License.
 
 import sys
+import time
 import warnings
 
 from rcl_interfaces.msg import ParameterType
@@ -40,13 +41,20 @@ def get_value(*, parameter_value):
     return value
 
 
-def load_parameter_file(*, node, node_name, parameter_file, use_wildcard):
-    # Remove leading slash and namespaces
-    client = AsyncParameterClient(node, node_name)
-    client.wait_for_services(timeout_sec=5.0)
+def busy_wait_client(client, node):
+    timeout_sec = 5
+    prev = time.time()
+    while not (client.services_are_ready() or timeout_sec < 0):
+        client.wait_for_services(timeout_sec=0.1)
+        rclpy.spin_once(node)
+        timeout_sec -= prev - time.time()
     if not client.services_are_ready():
         raise RuntimeError('Could not reach parameter services')
 
+
+def load_parameter_file(*, node, node_name, parameter_file, use_wildcard):
+    client = AsyncParameterClient(node, node_name)
+    busy_wait_client(client, node)
     future = client.load_parameter_file(parameter_file, use_wildcard)
     parameters = list(parameter_dict_from_yaml_file(parameter_file, use_wildcard).values())
     rclpy.spin_until_future_complete(node, future)
@@ -69,45 +77,53 @@ def load_parameter_file(*, node, node_name, parameter_file, use_wildcard):
 
 def call_describe_parameters(*, node, node_name, parameter_names=None):
     client = AsyncParameterClient(node, node_name)
-    client.wait_for_services(timeout_sec=5.0)
-    if not client.services_are_ready():
-        raise RuntimeError('Could not reach parameter services')
+    busy_wait_client(client, node)
+
     future = client.describe_parameters(parameter_names)
     rclpy.spin_until_future_complete(node, future)
     response = future.result()
+    if response is None:
+        raise RuntimeError('Exception while calling service of node '
+                           f'{node_name}: {future.exception()}')
     return response
 
 
 def call_get_parameters(*, node, node_name, parameter_names):
     client = AsyncParameterClient(node, node_name)
-    client.wait_for_services(timeout_sec=5.0)
-    if not client.services_are_ready():
-        raise RuntimeError('Could not reach parameter services')
+    busy_wait_client(client, node)
+
     future = client.get_parameters(parameter_names)
     rclpy.spin_until_future_complete(node, future)
     response = future.result()
+    if response is None:
+        raise RuntimeError('Exception while calling service of node '
+                           f'{node_name}: {future.exception()}')
     return response
 
 
 def call_set_parameters(*, node, node_name, parameters):
     client = AsyncParameterClient(node, node_name)
-    client.wait_for_services(timeout_sec=5.0)
-    if not client.services_are_ready():
-        raise RuntimeError('Could not reach parameter services')
+    busy_wait_client(client, node)
+
     future = client.set_parameters(parameters)
     rclpy.spin_until_future_complete(node, future)
     response = future.result()
+    if response is None:
+        raise RuntimeError('Exception while calling service of node '
+                           f'{node_name}: {future.exception()}')
     return response
 
 
-def call_list_parameters(*, node, node_name):
+def call_list_parameters(*, node, node_name, prefixes=None):
     client = AsyncParameterClient(node, node_name)
-    client.wait_for_services(timeout_sec=5.0)
-    if not client.services_are_ready():
-        raise RuntimeError('Could not reach parameter services')
-    future = client.list_parameters()
-    rclpy.spin_until_future_complete(node, future)  # This is hanging..
+    busy_wait_client(client, node)
+
+    future = client.list_parameters(prefixes=prefixes)
+    rclpy.spin_until_future_complete(node, future)
     response = future.result()
+    if response is None:
+        raise RuntimeError('Exception while calling service of node '
+                           f'{node_name}: {future.exception()}')
     return response.result.names
 
 

ros2param/ros2param/verb/dump.py

@@ -15,8 +15,6 @@
 import os
 import sys
 
-from rcl_interfaces.srv import ListParameters
-import rclpy
 from rclpy.parameter import PARAMETER_SEPARATOR_STRING
 from ros2cli.node.direct import DirectNode
 from ros2cli.node.strategy import add_arguments
@@ -96,16 +94,10 @@ def main(self, *, args):  # noqa: D102
             # retrieve values
             response = call_list_parameters(node=node, node_name=absolute_node_name)
 
-            if response is not None:
-                for param_name in sorted(response):
-                    pval = self.get_parameter_value(node, absolute_node_name, param_name)
-                    self.insert_dict(
-                        yaml_output[node_name.full_name]['ros__parameters'], param_name, pval)
-            else:
-                e = future.exception()
-                raise RuntimeError(
-                    'Exception while calling service of node '
-                    f"'{node_name.full_name}': {e}")
+            for param_name in sorted(response):
+                pval = self.get_parameter_value(node, absolute_node_name, param_name)
+                self.insert_dict(
+                    yaml_output[node_name.full_name]['ros__parameters'], param_name, pval)
 
             if args.print:
                 print(

ros2param/ros2param/verb/list.py

@@ -15,22 +15,18 @@
 import re
 import sys
 
-import rclpy
 from ros2cli.node.direct import DirectNode
 from ros2cli.node.strategy import add_arguments
 from ros2cli.node.strategy import NodeStrategy
 from ros2node.api import get_absolute_node_name
 from ros2node.api import get_node_names
 from ros2node.api import NodeNameCompleter
 
-from rcl_interfaces.srv import ListParameters
-
 from ros2param.api import call_describe_parameters
 from ros2param.api import call_list_parameters
 from ros2param.api import get_parameter_type_string
 from ros2param.verb import VerbExtension
 
-from ros2service.api import get_service_names
 
 class ListVerb(VerbExtension):
     """Output a list of available parameters."""
@@ -75,7 +71,9 @@ def main(self, *, args):  # noqa: D102
         with DirectNode(args) as node:
             responses = {}
             for node_name in node_names:
-                responses[node_name] = call_list_parameters(node=node, node_name=node_name.name)
+                responses[node_name] = call_list_parameters(node=node,
+                                                            node_name=node_name.full_name,
+                                                            prefixes=args.param_prefixes)
             # print responses
             for node_name in sorted(responses.keys()):
                 response = responses[node_name]

ros2param/test/test_verb_load.py

@@ -129,7 +129,7 @@ def generate_test_description(rmw_implementation):
     ])
 
 
-class TestVerbDump(unittest.TestCase):
+class TestVerbLoad(unittest.TestCase):
 
     @classmethod
     def setUpClass(
@@ -305,8 +305,7 @@ def test_verb_load_wildcard(self):
                 assert param_load_command.wait_for_shutdown(timeout=TEST_TIMEOUT)
             assert param_load_command.exit_code != launch_testing.asserts.EXIT_OK
             assert launch_testing.tools.expect_output(
-                expected_lines=['Param file does not contain parameters for '
-                                f'{TEST_NAMESPACE}/{TEST_NODE}'],
+                expected_lines=['Param file does not contain selected parameters'],
                 text=param_load_command.output,
                 strict=False
             )