Add tests for nested YAML and don't specify the topics parameter every time

Signed-off-by: Blake McHale <bmchale@nvidia.com>

Author: bmchalenv

greenwave_monitor/examples/example.launch.py

@@ -53,9 +53,9 @@ def generate_launch_description():
             parameters=[
                 {
                     'topics': {
-                        '/imu_topic': {'expected_frequency': 100.0},
-                        '/image_topic': {'expected_frequency': 30.0},
-                        '/string_topic': {'expected_frequency': 1000.0}
+                        '/imu_topic': {'expected_frequency': 100.0, 'tolerance': 5.0},
+                        '/image_topic': {'expected_frequency': 30.0, 'tolerance': 5.0},
+                        '/string_topic': {'expected_frequency': 1000.0, 'tolerance': 5.0}
                     },
                 }
             ]

greenwave_monitor/greenwave_monitor/test_utils.py

@@ -73,14 +73,15 @@ def create_monitor_node(namespace: str = MONITOR_NODE_NAMESPACE,
                         topics: List[str] = None,
                         topic_configs: dict = None):
     """Create a greenwave_monitor node for testing."""
-    if topics is None:
-        topics = ['/test_topic']
-
-    # Ensure topics list has at least one element (even if empty string)
-    if not topics:
-        topics = ['']
-
-    params = {'topics': topics}
+    params = {}
+
+    # Only add topics param if explicitly provided or no topic_configs
+    if topics is not None:
+        if not topics:
+            topics = ['']
+        params['topics'] = topics
+    elif not topic_configs:
+        params['topics'] = ['/test_topic']
 
     if topic_configs:
         for topic, config in topic_configs.items():

greenwave_monitor/test/parameters/test_param_dynamic.py

@@ -43,6 +43,7 @@
 
 
 TEST_TOPIC = '/dynamic_param_topic'
+NEW_TOPIC = '/new_param_topic'
 TEST_FREQUENCY = 30.0
 
 
@@ -89,20 +90,23 @@ def make_tol_param(topic: str) -> str:
 def generate_test_description():
     """Test dynamic parameter changes via ros2 param set."""
     ros2_monitor_node = create_monitor_node(
-        namespace=MONITOR_NODE_NAMESPACE,
-        node_name=MONITOR_NODE_NAME,
-        topics=[TEST_TOPIC],  # Topic exists but no expected frequency
-        topic_configs={}
+        topics=[TEST_TOPIC]  # Topic exists but no expected frequency
     )
 
     publisher = create_minimal_publisher(
         TEST_TOPIC, TEST_FREQUENCY, 'imu', '_dynamic'
     )
 
+    # Publisher for topic not initially monitored
+    new_topic_publisher = create_minimal_publisher(
+        NEW_TOPIC, TEST_FREQUENCY, 'imu', '_new_dynamic'
+    )
+
     return (
         launch.LaunchDescription([
             ros2_monitor_node,
             publisher,
+            new_topic_publisher,
             launch_testing.actions.ReadyToTest()
         ]), {}
     )
@@ -194,6 +198,36 @@ def test_verify_params_with_get(self):
             msg=f'Tolerance mismatch: expected {expected_tol}, got {actual_tol}'
         )
 
+    def test_add_new_topic_via_param(self):
+        """Test that setting frequency param for unmonitored topic starts monitoring."""
+        time.sleep(1.0)
+
+        # Verify topic is not initially monitored
+        initial_diagnostics = collect_diagnostics_for_topic(
+            self.test_node, NEW_TOPIC, expected_count=1, timeout_sec=2.0
+        )
+        self.assertEqual(
+            len(initial_diagnostics), 0,
+            f'{NEW_TOPIC} should not be monitored initially'
+        )
+
+        # Set expected frequency for the new topic
+        freq_param = make_freq_param(NEW_TOPIC)
+        success = run_ros2_param_set(MONITOR_NODE_NAME, freq_param, TEST_FREQUENCY)
+        self.assertTrue(success, f'Failed to set {freq_param}')
+
+        time.sleep(2.0)
+
+        # Verify topic is now monitored
+        received_diagnostics = collect_diagnostics_for_topic(
+            self.test_node, NEW_TOPIC, expected_count=3, timeout_sec=10.0
+        )
+
+        self.assertGreaterEqual(
+            len(received_diagnostics), 3,
+            f'{NEW_TOPIC} should be monitored after setting frequency param'
+        )
+
 
 if __name__ == '__main__':
     unittest.main()

greenwave_monitor/test/parameters/test_param_freq_only.py

@@ -26,7 +26,6 @@
     collect_diagnostics_for_topic,
     create_minimal_publisher,
     create_monitor_node,
-    MONITOR_NODE_NAME,
     MONITOR_NODE_NAMESPACE
 )
 import launch
@@ -51,9 +50,6 @@ def generate_test_description():
     }
 
     ros2_monitor_node = create_monitor_node(
-        namespace=MONITOR_NODE_NAMESPACE,
-        node_name=MONITOR_NODE_NAME,
-        topics=[],
         topic_configs=topic_configs
     )
 

greenwave_monitor/test/parameters/test_param_new_topic.py

@@ -64,12 +64,7 @@ def make_freq_param(topic: str) -> str:
 @pytest.mark.launch_test
 def generate_test_description():
     """Test adding a new topic via ros2 param set."""
-    ros2_monitor_node = create_monitor_node(
-        namespace=MONITOR_NODE_NAMESPACE,
-        node_name=MONITOR_NODE_NAME,
-        topics=[''],  # Empty - no initial topics
-        topic_configs={}
-    )
+    ros2_monitor_node = create_monitor_node()
 
     publisher = create_minimal_publisher(
         NEW_TOPIC, TEST_FREQUENCY, 'imu', '_new_dynamic'

greenwave_monitor/test/parameters/test_param_tol_only.py

@@ -48,7 +48,6 @@
 def generate_test_description():
     """Test with only tolerance specified (should not monitor)."""
     params = {
-        'topics': [''],
         f'{TOPIC_PARAM_PREFIX}{TEST_TOPIC}{TOL_SUFFIX}': 15.0
     }
 

greenwave_monitor/test/parameters/test_param_yaml.py

@@ -39,22 +39,28 @@
 
 
 YAML_TOPIC = '/yaml_config_topic'
+NESTED_TOPIC = '/nested_yaml_topic'
 TEST_FREQUENCY = 50.0
+NESTED_FREQUENCY = 25.0
 TEST_TOLERANCE = 10.0
 
 
 @pytest.mark.launch_test
 def generate_test_description():
     """Test loading parameters from a YAML file."""
-    # Write YAML manually with proper quoting (yaml.dump doesn't quote keys with dots)
-    # Use /** to apply to all nodes, or use full namespace path
+    # Write YAML manually - demonstrates both flat dotted keys and nested dict formats
+    # Use full namespace path for node parameters
     yaml_content = (
         f'/{MONITOR_NODE_NAMESPACE}/{MONITOR_NODE_NAME}:\n'
         f'  ros__parameters:\n'
-        f'    topics:\n'
-        f"      - ''\n"
+        f'    # Flat dotted key format (requires quotes)\n'
         f'    "topics.{YAML_TOPIC}.expected_frequency": {TEST_FREQUENCY}\n'
         f'    "topics.{YAML_TOPIC}.tolerance": {TEST_TOLERANCE}\n'
+        f'    # Nested dictionary format\n'
+        f'    topics:\n'
+        f'      {NESTED_TOPIC}:\n'
+        f'        expected_frequency: {NESTED_FREQUENCY}\n'
+        f'        tolerance: {TEST_TOLERANCE}\n'
     )
 
     yaml_dir = tempfile.mkdtemp()
@@ -75,10 +81,15 @@ def generate_test_description():
         YAML_TOPIC, TEST_FREQUENCY, 'imu', '_yaml'
     )
 
+    nested_publisher = create_minimal_publisher(
+        NESTED_TOPIC, NESTED_FREQUENCY, 'imu', '_nested_yaml'
+    )
+
     return (
         launch.LaunchDescription([
             ros2_monitor_node,
             publisher,
+            nested_publisher,
             launch_testing.actions.ReadyToTest()
         ]), {}
     )
@@ -127,6 +138,34 @@ def test_topic_configured_via_yaml(self):
 
         self.assertTrue(has_valid_rate, 'Should have valid frame rate from YAML config')
 
+    def test_nested_dict_topic_configured_via_yaml(self):
+        """Test that topic configured via nested YAML dict is monitored."""
+        time.sleep(2.0)
+
+        received_diagnostics = collect_diagnostics_for_topic(
+            self.test_node, NESTED_TOPIC, expected_count=3, timeout_sec=10.0
+        )
+
+        self.assertGreaterEqual(
+            len(received_diagnostics), 3,
+            'Expected diagnostics from nested YAML-configured topic'
+        )
+
+        has_valid_rate = False
+        for status in received_diagnostics:
+            for kv in status.values:
+                if kv.key == 'frame_rate_node':
+                    try:
+                        if float(kv.value) > 0:
+                            has_valid_rate = True
+                            break
+                    except ValueError:
+                        continue
+            if has_valid_rate:
+                break
+
+        self.assertTrue(has_valid_rate, 'Should have valid frame rate from nested YAML config')
+
 
 if __name__ == '__main__':
     unittest.main()

greenwave_monitor/test/parameters/test_topic_parameters.py

@@ -54,9 +54,6 @@ def generate_test_description():
     }
 
     ros2_monitor_node = create_monitor_node(
-        namespace=MONITOR_NODE_NAMESPACE,
-        node_name=MONITOR_NODE_NAME,
-        topics=[],
         topic_configs=topic_configs
     )