ros2doctor: add and test node/parameter reporting

- Add and update tests: test_node.py, test_parameter.py, test_api.py, common.py

Signed-off-by: BhuvanB404<bhuvanb1408@gmail.com>
Signed-off-by: BhuvanB404 <bhuvanb1408@gmail.com>

Author: BhuvanB404

ros2doctor/package.xml

@@ -22,6 +22,8 @@
   <exec_depend>rclpy</exec_depend>
   <exec_depend>ros2action</exec_depend>
   <exec_depend>ros2cli</exec_depend>
+  <exec_depend>ros2node</exec_depend>
+  <exec_depend>ros2param</exec_depend>
   <exec_depend>ros_environment</exec_depend>
   <exec_depend>std_msgs</exec_depend>
 

ros2doctor/ros2doctor/api/node.py

@@ -4,7 +4,7 @@
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at
 #
-#    http://www.apache.org/licenses/LICENSE-2.0
+#     http://www.apache.org/licenses/LICENSE-2.0
 #
 # Unless required by applicable law or agreed to in writing, software
 # distributed under the License is distributed on an "AS IS" BASIS,
@@ -13,20 +13,21 @@
 # limitations under the License.
 
 
-from collections import defaultdict
+from collections import Counter
 
+from ros2node.api import get_node_names
 from ros2cli.node.strategy import NodeStrategy
 from ros2doctor.api import DoctorCheck
 from ros2doctor.api import DoctorReport
 from ros2doctor.api import Report
 from ros2doctor.api import Result
 from ros2doctor.api.format import doctor_warn
-from ros2node.api import get_node_names
 
 
-def has_duplicates(values):
-    """Find out if there are any exact duplicates in a list of strings."""
-    return len(set(values)) < len(values)
+def find_duplicates(values):
+    """Return values that appear more than once."""
+    counts = Counter(values)
+    return [v for v, c in counts.items() if c > 1]
 
 
 class NodeCheck(DoctorCheck):
@@ -40,15 +41,10 @@ def check(self):
         with NodeStrategy(None) as node:
             node_list = get_node_names(node=node, include_hidden_nodes=True)
             node_names = [n.full_name for n in node_list]
-            if has_duplicates(node_names):
-                name_counts = defaultdict(int)
-                for name in node_names:
-                    name_counts[name] += 1
-
-                duplicates = [name for name, count in name_counts.items() if count > 1]
-                for duplicate in duplicates:
-                    doctor_warn(f'Duplicate node name: {duplicate}')
-                    result.add_warning()
+            duplicates = find_duplicates(node_names)
+            for duplicate in duplicates:
+                doctor_warn(f'Duplicate node name: {duplicate}')
+                result.add_warning()
         return result
 
 

ros2doctor/ros2doctor/api/parameter.py

@@ -4,17 +4,19 @@
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at
 #
-#   http://www.apache.org/licenses/LICENSE-2.0
+#     http://www.apache.org/licenses/LICENSE-2.0
 #
 # Unless required by applicable law or agreed to in writing, software
 # distributed under the License is distributed on an "AS IS" BASIS,
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-
-from rcl_interfaces.srv import ListParameters
 import rclpy
+from rclpy.parameter import parameter_value_to_python
+from ros2param.api import call_get_parameters
+from ros2param.api import call_list_parameters
+
 from ros2cli.node.direct import DirectNode
 from ros2cli.node.strategy import NodeStrategy
 from ros2doctor.api import DoctorCheck
@@ -24,60 +26,6 @@
 from ros2doctor.api.format import doctor_warn
 
 
-def call_list_parameters(node, node_name, namespace='/'):
-    """Call the list_parameters service for a specific node."""
-    try:
-        # Create service name and client for the target node's list_parameters service
-        service_name = f"{namespace.rstrip('/')}/{node_name}/list_parameters"
-        if service_name.startswith('//'):
-            service_name = service_name[1:]
-
-        client = node.create_client(ListParameters, service_name)
-
-        if not client.wait_for_service(timeout_sec=1.0):
-            return None
-
-        request = ListParameters.Request()
-        future = client.call_async(request)
-
-        # Spin until the service call completes or times out
-        rclpy.spin_until_future_complete(node, future, timeout_sec=2.0)
-
-        if future.done():
-            response = future.result()
-            node.destroy_client(client)
-            return response
-        else:
-            node.destroy_client(client)
-            return None
-
-    except Exception:
-        return None
-
-
-class ParameterCheck(DoctorCheck):
-    """Check for nodes without parameter services."""
-
-    def category(self):
-        return 'parameter'
-
-    def check(self):
-        result = Result()
-        with NodeStrategy(None) as node:
-            try:
-                node_names_and_namespaces = node.get_node_names_and_namespaces()
-            except Exception:
-                node_names_and_namespaces = []
-            with DirectNode(None) as param_node:
-                for node_name, namespace in node_names_and_namespaces:
-                    response = call_list_parameters(param_node.node, node_name, namespace)
-                    if response is None:
-                        full_name = f"{namespace.rstrip('/')}/{node_name}"
-                        doctor_warn(f'Node {full_name} has no parameter services.')
-                        result.add_warning()
-        return result
-
-
 class ParameterReport(DoctorReport):
     """Report parameter related information."""
 
@@ -88,7 +36,8 @@ def report(self):
         report = Report('PARAMETER LIST')
         with NodeStrategy(None) as node:
             try:
-                node_names_and_namespaces = node.get_node_names_and_namespaces()
+                node_names_and_namespaces = \
+                    node.get_node_names_and_namespaces()
             except Exception:
                 node_names_and_namespaces = []
             if not node_names_and_namespaces:
@@ -97,24 +46,59 @@ def report(self):
                 report.add_to_report('parameter', 'none')
                 return report
 
-            total_param_count = 0
+            param_count = 0
             nodes_checked = 0
 
             with DirectNode(None) as param_node:
                 for node_name, namespace in sorted(node_names_and_namespaces):
                     nodes_checked += 1
-                    response = call_list_parameters(param_node.node, node_name, namespace)
-                    if response and hasattr(response, 'result') and response.result:
-                        result = response.result
-                        param_names = result.names if hasattr(result, 'names') else []
+                    full_name = f"{namespace.rstrip('/')}/{node_name}"
+                    try:
+                        response = call_list_parameters(
+                            node=param_node.node, node_name=full_name)
+                        if response is None:
+                            continue
+                        elif response.result() is None:
+                            continue
+
+                        param_names = response.result().result.names
                         if param_names:
-                            total_param_count += len(param_names)
-                            full_name = f"{namespace.rstrip('/')}/{node_name}"
-
+                            param_count += len(param_names)
                             report.add_to_report('node', full_name)
-                            for param_name in sorted(param_names):
-                                report.add_to_report('parameter', param_name)
+                            try:
+                                param_response = call_get_parameters(
+                                    node=param_node.node,
+                                    node_name=full_name,
+                                    parameter_names=param_names
+                                )
+                                param_values = None
+                                if param_response:
+                                    param_values = param_response.values
+                                if param_values and len(param_values) == len(
+                                    param_names
+                                ):
+                                    params_with_values = sorted(
+                                        zip(param_names, param_values)
+                                    )
+                                    for name, value_msg in params_with_values:
+                                        value = parameter_value_to_python(
+                                            value_msg
+                                        )
+                                        report.add_to_report(
+                                            'parameter', f'{name}: {value}')
+                                else:
+                                    for param_name in sorted(param_names):
+                                        report.add_to_report(
+                                            'parameter', param_name
+                                        )
+                            except RuntimeError:
+                                for param_name in sorted(param_names):
+                                    report.add_to_report(
+                                        'parameter', param_name
+                                    )
+                    except RuntimeError:
+                        pass
 
             report.add_to_report('total nodes checked', nodes_checked)
-            report.add_to_report('total parameter count', total_param_count)
+            report.add_to_report('total parameter count', param_count)
         return report

ros2doctor/test/common.py

@@ -33,3 +33,32 @@ def generate_expected_service_report(services: Iterable[str], serv_counts: Itera
         expected_report.add_to_report('service count', serv_count)
         expected_report.add_to_report('client count', cli_count)
     return expected_report
+
+
+def generate_expected_node_report(node_count: int, nodes: Iterable[str]) -> Report:
+    expected_report = Report('NODE LIST')
+    if node_count == 0:
+        expected_report.add_to_report('node count', 0)
+        expected_report.add_to_report('node', 'none')
+    else:
+        expected_report.add_to_report('node count', node_count)
+        for node in nodes:
+            expected_report.add_to_report('node', node)
+    return expected_report
+
+
+def generate_expected_parameter_report(nodes_checked: int, param_count: int,
+                                       node_params: Iterable[tuple]) -> Report:
+    expected_report = Report('PARAMETER LIST')
+    if nodes_checked == 0:
+        expected_report.add_to_report('total nodes checked', 0)
+        expected_report.add_to_report('total parameter count', 0)
+        expected_report.add_to_report('parameter', 'none')
+    else:
+        for node_name, params in node_params:
+            expected_report.add_to_report('node', node_name)
+            for param in params:
+                expected_report.add_to_report('parameter', param)
+        expected_report.add_to_report('total nodes checked', nodes_checked)
+        expected_report.add_to_report('total parameter count', param_count)
+    return expected_report

ros2doctor/test/fixtures/complex_node.py

@@ -0,0 +1,69 @@
+# Copyright 2026 Open Source Robotics Foundation, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import rclpy
+from rclpy.action import ActionServer
+from rclpy.executors import ExternalShutdownException
+from rclpy.node import Node
+from rclpy.qos import qos_profile_system_default
+
+from test_msgs.action import Fibonacci
+from test_msgs.msg import Arrays
+from test_msgs.msg import Strings
+from test_msgs.srv import BasicTypes
+
+
+class ComplexNode(Node):
+
+    def __init__(self):
+        super().__init__('complex_node')
+        self.publisher = self.create_publisher(
+            Arrays, 'arrays', qos_profile_system_default
+        )
+        self.subscription = self.create_subscription(
+            Strings, 'strings', lambda msg: None, qos_profile_system_default
+        )
+        self.server = self.create_service(BasicTypes, 'basic', lambda req, res: res)
+        self.action_server = ActionServer(
+            self, Fibonacci, 'fibonacci', self.action_callback
+        )
+        self.timer = self.create_timer(1.0, self.pub_callback)
+
+    def destroy_node(self):
+        self.timer.destroy()
+        self.publisher.destroy()
+        self.subscription.destroy()
+        self.server.destroy()
+        self.action_server.destroy()
+        super().destroy_node()
+
+    def pub_callback(self):
+        self.publisher.publish(Arrays())
+
+    def action_callback(self, goal_handle):
+        goal_handle.succeed()
+        return Fibonacci.Result()
+
+
+def main(args=None):
+    try:
+        with rclpy.init(args=args):
+            node = ComplexNode()
+            rclpy.spin(node)
+    except (KeyboardInterrupt, ExternalShutdownException):
+        print('node stopped cleanly')
+
+
+if __name__ == '__main__':
+    main()

ros2doctor/test/fixtures/parameter_fixtures_node.py

@@ -0,0 +1,44 @@
+# Copyright 2025 Open Source Robotics Foundation, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Test fixture node with parameters for ros2doctor testing."""
+
+import rclpy
+from rclpy.executors import ExternalShutdownException
+from rclpy.parameter import PARAMETER_SEPARATOR_STRING
+
+
+def main():
+    try:
+        with rclpy.init():
+            node = rclpy.create_node('parameter_node')
+            # Declare various parameter types for testing
+            node.declare_parameter('bool_param', True)
+            node.declare_parameter('int_param', 42)
+            node.declare_parameter('double_param', 3.14)
+            node.declare_parameter('str_param', 'hello')
+            node.declare_parameter('bool_array_param', [True, False])
+            node.declare_parameter('int_array_param', [1, 2, 3])
+            node.declare_parameter('double_array_param', [1.0, 2.0])
+            node.declare_parameter('str_array_param', ['foo', 'bar'])
+            node.declare_parameter(
+                'nested' + PARAMETER_SEPARATOR_STRING + 'param', 'nested_value'
+            )
+            rclpy.spin(node)
+    except (KeyboardInterrupt, ExternalShutdownException):
+        print('parameter_node stopped cleanly')
+
+
+if __name__ == '__main__':
+    main()