Don't make the test implementations nodes

Author: civerachb-cpr

clearpath_tests/clearpath_tests/all_tests.py

@@ -77,13 +77,14 @@ def __init__(self, node_name='clearpath_production_test_node'):
         self.platform = self.clearpath_config.get_platform_model()
 
         self.common_tests = [
-            mcu_test.McuTestNode(setup_path=self.setup_path),
-            diagnostic_test.DiagnosticTestNode(self.setup_path),
-            wifi_test.WifiTestNode(self.setup_path),
+            mcu_test.McuTestNode(self, setup_path=self.setup_path),
+            diagnostic_test.DiagnosticTestNode(self, self.setup_path),
+            wifi_test.WifiTestNode(self, self.setup_path),
         ]
 
         self.driving_tests = [
             drive_test.DriveTestNode(
+                self,
                 setup_path=self.setup_path,
                 default_speed_x=0.1,
                 direction='Forwards',
@@ -93,62 +94,71 @@ def __init__(self, node_name='clearpath_production_test_node'):
         # Add any platform-specific tests here
         self.tests_for_platform = []
         if self.platform == Platform.A200:
-            self.tests_for_platform.append(estop_test.EstopTestNode('Rear', self.setup_path))
+            self.tests_for_platform.append(estop_test.EstopTestNode(self, 'Rear', self.setup_path))
         elif self.platform == Platform.A300:
-            self.tests_for_platform.append(fan_test.FanTestNode(4, self.setup_path))
-            self.tests_for_platform.append(light_test.LightTestNode(4, self.setup_path))
+            self.tests_for_platform.append(fan_test.FanTestNode(self, 4, self.setup_path))
+            self.tests_for_platform.append(light_test.LightTestNode(self, 4, self.setup_path))
 
-            self.tests_for_platform.append(estop_test.EstopTestNode('Front', self.setup_path))
-            self.tests_for_platform.append(estop_test.EstopTestNode('Rear', self.setup_path))
+            self.tests_for_platform.append(
+                estop_test.EstopTestNode(self, 'Front', self.setup_path)
+            )
+            self.tests_for_platform.append(
+                estop_test.EstopTestNode(self, 'Rear', self.setup_path)
+            )
             self.tests_for_platform.append(
                 # rear access hatch should also act as an e-stop
-                estop_test.EstopTestNode('Access Panel', self.setup_path)
+                estop_test.EstopTestNode(self, 'Access Panel', self.setup_path)
             )
             self.tests_for_platform.append(
                 # wireless e-stop is optional on A300
                 estop_test.EstopTestNode('Wireless', self.setup_path, optional=True)
             )
 
-            self.tests_for_platform.append(imu_test.ImuTestNode(0, self.setup_path))
+            self.tests_for_platform.append(imu_test.ImuTestNode(self, 0, self.setup_path))
 
             # vcan0 has the 4 motor drivers
             # check for status messages, which are length 5 and more numerous
-            self.tests_for_platform.append(canbus_test.CanbusTestNode('vcan0', 4, 5, self.setup_path))  # noqa: E501
+            self.tests_for_platform.append(canbus_test.CanbusTestNode(self, 'vcan0', 4, 5, self.setup_path))  # noqa: E501
 
             # vcan1 has batteries, optional e-stop, optional wireless charger
             # so just allow anything here
-            self.tests_for_platform.append(canbus_test.CanbusTestNode('vcan1', 0, 0, self.setup_path))  # noqa: E501
+            self.tests_for_platform.append(canbus_test.CanbusTestNode(self, 'vcan1', 0, 0, self.setup_path))  # noqa: E501
 
             # Dynamic IMU tests
             self.driving_tests.insert(0, rotation_test.RotationTestNode(
+                self,
                 setup_path=self.setup_path
             ))
             self.driving_tests.insert(0, linear_acceleration_test.LinearAccelerationTestNode(
+                self,
                 setup_path=self.setup_path
             ))
         elif (
             self.platform == Platform.DD100 or
             self.platform == Platform.DD150
         ):
-            self.tests_for_platform.append(light_test.LightTestNode(4, self.setup_path))
+            self.tests_for_platform.append(light_test.LightTestNode(self, 4, self.setup_path))
 
             # Dingo doesn't use CANopen, so the ID counter won't work correctly
-            self.tests_for_platform.append(canbus_test.CanbusTestNode('vcan0', 0, 4, self.setup_path))  # noqa: E501
+            self.tests_for_platform.append(canbus_test.CanbusTestNode(self, 'vcan0', 0, 4, self.setup_path))  # noqa: E501
 
             self.tests_for_platform.append(estop_test.EstopTestNode(
+                self,
                 'Rear',
                 setup_path=self.setup_path,
                 estop_type='Motor Cutoff',
             ))
 
             # Dingo has an integral IMU
-            self.tests_for_platform.append(imu_test.ImuTestNode(setup_path=self.setup_path))
+            self.tests_for_platform.append(imu_test.ImuTestNode(self, setup_path=self.setup_path))
 
             # Dynamic IMU tests
             self.driving_tests.insert(0, rotation_test.RotationTestNode(
+                self,
                 setup_path=self.setup_path
             ))
             self.driving_tests.insert(0, linear_acceleration_test.LinearAccelerationTestNode(
+                self,
                 setup_path=self.setup_path
             ))
         elif (
@@ -158,27 +168,31 @@ def __init__(self, node_name='clearpath_production_test_node'):
             self.tests_for_platform.append(light_test.LightTestNode(4, self.setup_path))
 
             # Dingo doesn't use CANopen, so the ID counter won't work correctly
-            self.tests_for_platform.append(canbus_test.CanbusTestNode('vcan0', 0, 4, self.setup_path))  # noqa: E501
+            self.tests_for_platform.append(canbus_test.CanbusTestNode(self, 'vcan0', 0, 4, self.setup_path))  # noqa: E501
 
             self.tests_for_platform.append(estop_test.EstopTestNode(
+                self,
                 'Rear',
                 setup_path=self.setup_path,
                 estop_type='Motor Cutoff',
             ))
 
             # Dingo has an integral IMU
-            self.tests_for_platform.append(imu_test.ImuTestNode(setup_path=self.setup_path))
+            self.tests_for_platform.append(imu_test.ImuTestNode(self, setup_path=self.setup_path))
 
             # Dynamic IMU tests
             self.driving_tests.insert(0, rotation_test.RotationTestNode(
+                self,
                 setup_path=self.setup_path
             ))
             self.driving_tests.insert(0, linear_acceleration_test.LinearAccelerationTestNode(
+                self,
                 setup_path=self.setup_path
             ))
 
             self.driving_tests.append(
                 drive_test.DriveTestNode(
+                    self,
                     setup_path=self.setup_path,
                     default_speed_x=0.0,
                     default_speed_y=0.2,
@@ -189,42 +203,53 @@ def __init__(self, node_name='clearpath_production_test_node'):
         elif self.platform == Platform.GENERIC:
             pass
         elif self.platform == Platform.J100:
-            self.tests_for_platform.append(imu_test.ImuTestNode(0, self.setup_path))
+            self.tests_for_platform.append(imu_test.ImuTestNode(self, 0, self.setup_path))
 
             self.tests_for_platform.append(estop_test.EstopTestNode(
+                self,
                 'Rear',
                 setup_path=self.setup_path,
                 estop_type='Motor Cutoff',
             ))
 
             # Dynamic IMU tests
             self.driving_tests.insert(0, rotation_test.RotationTestNode(
+                self,
                 setup_path=self.setup_path
             ))
             self.driving_tests.insert(0, linear_acceleration_test.LinearAccelerationTestNode(
+                self,
                 setup_path=self.setup_path
             ))
         elif self.platform == Platform.R100:
-            self.tests_for_platform.append(light_test.LightTestNode(8))
+            self.tests_for_platform.append(light_test.LightTestNode(self, 8))
 
             # Ridgeback doesn't use CANopen, so the ID counter won't work correctly
-            self.tests_for_platform.append(canbus_test.CanbusTestNode('vcan0', 0, 4, self.setup_path))  # noqa: E501
+            self.tests_for_platform.append(
+                canbus_test.CanbusTestNode(self, 'vcan0', 0, 4, self.setup_path))
 
-            self.tests_for_platform.append(estop_test.EstopTestNode('Front Left', self.setup_path))
-            self.tests_for_platform.append(estop_test.EstopTestNode('Front Right', self.setup_path))  # noqa: E501
-            self.tests_for_platform.append(estop_test.EstopTestNode('Rear Left', self.setup_path))
-            self.tests_for_platform.append(estop_test.EstopTestNode('Rear Right', self.setup_path))
+            self.tests_for_platform.append(
+                estop_test.EstopTestNode(self, 'Front Left', self.setup_path))
+            self.tests_for_platform.append(
+                estop_test.EstopTestNode(self, 'Front Right', self.setup_path))
+            self.tests_for_platform.append(
+                estop_test.EstopTestNode(self, 'Rear Left', self.setup_path))
+            self.tests_for_platform.append(
+                estop_test.EstopTestNode(self, 'Rear Right', self.setup_path))
 
             # Dynamic IMU tests
             self.driving_tests.insert(0, rotation_test.RotationTestNode(
+                self,
                 setup_path=self.setup_path
             ))
             self.driving_tests.insert(0, linear_acceleration_test.LinearAccelerationTestNode(
+                self,
                 setup_path=self.setup_path
             ))
 
             self.driving_tests.append(
                 drive_test.DriveTestNode(
+                    self,
                     setup_path=self.setup_path,
                     default_speed_x=0.0,
                     default_speed_y=0.2,
@@ -233,19 +258,25 @@ def __init__(self, node_name='clearpath_production_test_node'):
                 )
             )
         elif self.platform == Platform.W200:
-            self.tests_for_platform.append(light_test.LightTestNode(4))
-            self.tests_for_platform.append(canbus_test.CanbusTestNode('can0', 4, 0, self.setup_path))  # noqa: E501
+            self.tests_for_platform.append(light_test.LightTestNode(self, ))
+            self.tests_for_platform.append(canbus_test.CanbusTestNode(self, 'can0', 4, 0, self.setup_path))  # noqa: E501
 
-            self.tests_for_platform.append(estop_test.EstopTestNode('Front Left', self.setup_path))
-            self.tests_for_platform.append(estop_test.EstopTestNode('Front Right', self.setup_path))  # noqa: E501
-            self.tests_for_platform.append(estop_test.EstopTestNode('Rear Left', self.setup_path))
-            self.tests_for_platform.append(estop_test.EstopTestNode('Rear Right', self.setup_path))
+            self.tests_for_platform.append(
+                estop_test.EstopTestNode(self, 'Front Left', self.setup_path))
+            self.tests_for_platform.append(
+                estop_test.EstopTestNode(self, 'Front Right', self.setup_path))
+            self.tests_for_platform.append(
+                estop_test.EstopTestNode(self, 'Rear Left', self.setup_path))
+            self.tests_for_platform.append(
+                estop_test.EstopTestNode(self, 'Rear Right', self.setup_path))
 
             # Dynamic IMU tests
             self.driving_tests.insert(0, rotation_test.RotationTestNode(
+                self,
                 setup_path=self.setup_path
             ))
             self.driving_tests.insert(0, linear_acceleration_test.LinearAccelerationTestNode(
+                self,
                 setup_path=self.setup_path
             ))
         else:

clearpath_tests/clearpath_tests/canbus_test.py

@@ -40,15 +40,16 @@ class CanbusTestNode(ClearpathTestNode):
 
     def __init__(
         self,
+        node,
         can_interface='',
         n_devices=0,
         expected_msg_length=0,
         setup_path='/etc/clearpath'
     ):
         super().__init__(
-            'CAN',
-            f'canbus_test_{can_interface}',
-            setup_path
+            node=node,
+            test_name='CAN',
+            setup_path=setup_path,
         )
 
         self.can_interface = self.get_parameter_or('can_interface', can_interface)

clearpath_tests/clearpath_tests/diagnostic_test.py

@@ -139,8 +139,8 @@
 class DiagnosticTestNode(ClearpathTestNode):
     """Monitors diagnostic topics to make sure there aren't any warnings."""
 
-    def __init__(self, setup_path='/etc/clearpath'):
-        super().__init__('Diagnostics', 'diagnostic_test', setup_path)
+    def __init__(self, node=None, setup_path='/etc/clearpath'):
+        super().__init__(node, 'Diagnostics', setup_path)
         self.test_in_progress = False
         self.warnings = {}
         self.errors = {}

clearpath_tests/clearpath_tests/drive_test.py

@@ -50,15 +50,16 @@ class DriveTestNode(MobilityTestNode):
 
     def __init__(
         self,
+        node=None,
         setup_path='/etc/clearpath',
         direction='Forwards',
         default_speed_x=0.1,  # 10cm/s; nice and safe
         default_speed_y=0.0,
         default_distance=5.0,
     ):
         super().__init__(
+            node,
             f'Drive Fixed Distance ({direction})',
-            f'drive_test_{direction.lower()}',
             setup_path,
         )
 

clearpath_tests/clearpath_tests/estop_test.py

@@ -44,14 +44,15 @@ class EstopTestNode(ClearpathTestNode):
 
     def __init__(
         self,
+        node,
         estop_location,
         setup_path='/etc/clearpath',
         optional=False,
         estop_type='E-Stop',
     ):
         super().__init__(
+            node,
             f'{estop_type} ({estop_location})',
-            f'estop_test_{estop_location.strip().lower().replace(" ", "_").replace("-", "_")}',
             setup_path
         )
         self.optional = optional

clearpath_tests/clearpath_tests/fan_test.py

@@ -37,8 +37,8 @@
 
 class FanTestNode(ClearpathTestNode):
 
-    def __init__(self, n_fans=4, setup_path='/etc/clearpath'):
-        super().__init__('Fans', 'fan_test', setup_path)
+    def __init__(self, node, n_fans=4, setup_path='/etc/clearpath'):
+        super().__init__(node, 'Fans', setup_path)
 
         # Params
         self.n_fans = self.get_parameter_or('num_fans', n_fans)

clearpath_tests/clearpath_tests/imu_test.py

@@ -52,8 +52,8 @@ class ImuTestNode(ClearpathTestNode):
     Will fail of any of the above is not correct
     """
 
-    def __init__(self, imu_num=0, setup_path='/etc/clearpath'):
-        super().__init__(f'IMU (imu_{imu_num})', f'imu_{imu_num}_test', setup_path)
+    def __init__(self, node, imu_num=0, setup_path='/etc/clearpath'):
+        super().__init__(node, f'IMU (imu_{imu_num})', setup_path)
         self.test_in_progress = False
         self.record_data = False
         self.accel_samples = []

clearpath_tests/clearpath_tests/light_test.py

@@ -39,8 +39,8 @@
 
 class LightTestNode(ClearpathTestNode):
 
-    def __init__(self, light_zones=4, setup_path='/etc/clearpath'):
-        super().__init__('Lights', 'light_test', setup_path)
+    def __init__(self, node, light_zones=4, setup_path='/etc/clearpath'):
+        super().__init__(node, 'Lights', setup_path)
 
         self.light_zones = self.get_parameter_or('n_lights', light_zones)
 

clearpath_tests/clearpath_tests/linear_acceleration_test.py

@@ -48,8 +48,8 @@ class LinearAccelerationTestNode(MobilityTestNode):
     The IMU should read X acceleration of +/- 0.2m/s/s
     """
 
-    def __init__(self, imu_num=0, setup_path='/etc/clearpath'):
-        super().__init__('Linear acceleration', 'linear_acceleration_test', setup_path)
+    def __init__(self, node, imu_num=0, setup_path='/etc/clearpath'):
+        super().__init__(node, 'Linear acceleration', setup_path)
 
         self.acceleration = self.get_parameter_or('acceleration', 0.2)
         self.acceleration_time = self.get_parameter_or('acceleration_time', 5.0)

clearpath_tests/clearpath_tests/mcu_test.py

@@ -53,6 +53,7 @@ class McuTestNode(ClearpathTestNode):
 
     def __init__(
         self,
+        node,
         mode=None,
         address=None,
         setup_path='/etc/clearpath'
@@ -68,8 +69,8 @@ def __init__(
                    or of the specified mode is not from the given list
         """
         super().__init__(
+            node,
             'MCU',
-            'mcu_test',
             setup_path
         )
 

clearpath_tests/clearpath_tests/mobility_test.py

@@ -43,8 +43,8 @@
 class MobilityTestNode(ClearpathTestNode):
     """Generic class for all tests that involve driving the robot with odometry feedback."""
 
-    def __init__(self, test_name, node_name, setup_path='/etc/clearpath'):
-        super().__init__(test_name, node_name, setup_path)
+    def __init__(self, node, test_name, setup_path='/etc/clearpath'):
+        super().__init__(node, test_name, setup_path)
 
         # The velocity command to output
         self.cmd_vel = TwistStamped()

clearpath_tests/clearpath_tests/rotation_test.py

@@ -49,8 +49,8 @@ class RotationTestNode(MobilityTestNode):
     The IMU should read positive angular velocity around the Z axis.
     """
 
-    def __init__(self, imu_num=0, setup_path='/etc/clearpath'):
-        super().__init__('Rotation in place', 'rotation_test', setup_path)
+    def __init__(self, node, imu_num=0, setup_path='/etc/clearpath'):
+        super().__init__(node, 'Rotation in place', setup_path)
 
         self.max_speed = self.get_parameter_or(
             'max_speed',