Update from Ros1 + auto format

Author: LaurieCheers-unity

ros_tcp_endpoint/service.py

@@ -24,21 +24,21 @@ class RosService(RosSender):
     """
     Class to send messages to a ROS service.
     """
+
     def __init__(self, service, service_class):
         """
         Args:
             service:        The service name in ROS
             service_class:  The service class in catkin workspace
         """
-        strippedService = re.sub('[^A-Za-z0-9_]+', '', service)
-        node_name = f'{strippedService}_RosService'
+        strippedService = re.sub("[^A-Za-z0-9_]+", "", service)
+        node_name = f"{strippedService}_RosService"
         RosSender.__init__(self, node_name)
-        
+
         self.service_topic = service
         self.cli = self.create_client(service_class, service)
         self.req = service_class.Request()
 
-
     def send(self, data):
         """
         Takes in serialized message data from source outside of the ROS network,
@@ -55,9 +55,11 @@ def send(self, data):
         message = deserialize_message(data, message_type)
 
         if not self.cli.service_is_ready():
-            self.get_logger().error('Ignoring service call to {} - service is not ready.'.format(self.service_topic))
+            self.get_logger().error(
+                "Ignoring service call to {} - service is not ready.".format(self.service_topic)
+            )
             return None
-            
+
         self.future = self.cli.call_async(message)
 
         while rclpy.ok():
@@ -66,13 +68,12 @@ def send(self, data):
                     response = self.future.result()
                     return response
                 except Exception as e:
-                    self.get_logger().info(f'Service call failed {e}')
+                    self.get_logger().info(f"Service call failed {e}")
 
                 break
 
         return None
 
-
     def unregister(self):
         """
 

ros_tcp_endpoint/subscriber.py

@@ -35,8 +35,8 @@ def __init__(self, topic, message_class, tcp_server, queue_size=10):
             message_class: The message class in catkin workspace
             queue_size:    Max number of entries to maintain in an outgoing queue
         """
-        strippedTopic = re.sub('[^A-Za-z0-9_]+', '', topic)
-        self.node_name = f'{strippedTopic}_RosSubscriber'
+        strippedTopic = re.sub("[^A-Za-z0-9_]+", "", topic)
+        self.node_name = f"{strippedTopic}_RosSubscriber"
         RosReceiver.__init__(self, self.node_name)
         self.topic = topic
         self.msg = message_class
@@ -47,10 +47,7 @@ def __init__(self, topic, message_class, tcp_server, queue_size=10):
 
         # Start Subscriber listener function
         self.subscription = self.create_subscription(
-            self.msg,
-            self.topic,
-            self.send,
-            qos_profile #queue_size
+            self.msg, self.topic, self.send, qos_profile  # queue_size
         )
         self.subscription
 
@@ -74,4 +71,4 @@ def unregister(self):
 
         """
         self.destroy_subscription(self.subscription)
-        self.destroy_node()
+        self.destroy_node()

test/test_server.py

@@ -1,7 +1,6 @@
 from unittest import mock
 from ros_tcp_endpoint import TcpServer
 from ros_tcp_endpoint.server import SysCommands
-from ros_tcp_endpoint.server import resolve_message_name
 import importlib
 import rospy
 import sys
@@ -16,14 +15,14 @@ def test_server_constructor(mock_ros, mock_socket):
     assert server.node_name == "test-tcp-server"
     assert server.tcp_ip == "127.0.0.1"
     assert server.buffer_size == 1024
-    assert server.connections == 2
+    assert server.connections == 10
 
 
 def test_start_server():
     server = TcpServer(node_name="test-tcp-server", tcp_ip="127.0.0.1", tcp_port=10000)
     assert server.tcp_ip == "127.0.0.1"
     assert server.tcp_port == 10000
-    assert server.connections == 2
+    assert server.connections == 10
     server.start()
 
 
@@ -43,13 +42,11 @@ def test_unity_service_resolve_message_name_failure():
 
 @mock.patch.object(rospy, "Service")
 @mock.patch.object(
-    ros_tcp_endpoint.server,
-    "resolve_message_name",
-    return_value="unity_interfaces.msg/RosUnitySrvMessage",
+    SysCommands, "resolve_message_name", return_value="unity_interfaces.msg/RosUnitySrvMessage"
 )
 def test_unity_service_resolve_news_service(mock_resolve_message, mock_ros_service):
     server = TcpServer(node_name="test-tcp-server", tcp_ip="127.0.0.1", tcp_port=10000)
-    assert server.ros_services == {}
+    assert server.ros_services_table == {}
     system_cmds = SysCommands(server)
     result = system_cmds.unity_service("get_pos", "unity_interfaces.msg/RosUnitySrvMessage")
     mock_ros_service.assert_called_once
@@ -58,9 +55,7 @@ def test_unity_service_resolve_news_service(mock_resolve_message, mock_ros_servi
 
 @mock.patch.object(rospy, "Service")
 @mock.patch.object(
-    ros_tcp_endpoint.server,
-    "resolve_message_name",
-    return_value="unity_interfaces.msg/RosUnitySrvMessage",
+    SysCommands, "resolve_message_name", return_value="unity_interfaces.msg/RosUnitySrvMessage"
 )
 def test_unity_service_resolve_existing_service(mock_resolve_message, mock_ros_service):
     server = TcpServer(node_name="test-tcp-server", tcp_ip="127.0.0.1", tcp_port=10000)
@@ -74,8 +69,9 @@ def test_unity_service_resolve_existing_service(mock_resolve_message, mock_ros_s
 @mock.patch.object(sys, "modules", return_value="unity_interfaces.msg")
 @mock.patch.object(importlib, "import_module")
 def test_resolve_message_name(mock_import_module, mock_sys_modules):
+    server = TcpServer(node_name="test-tcp-server", tcp_ip="127.0.0.1", tcp_port=10000)
     msg_name = "unity_interfaces.msg/UnityColor.msg"
-    result = resolve_message_name(msg_name)
+    result = SysCommands(server).resolve_message_name(msg_name)
     mock_import_module.assert_called_once
     mock_sys_modules.assert_called_once
     assert result is not None
@@ -85,98 +81,94 @@ def test_resolve_message_name(mock_import_module, mock_sys_modules):
 def test_publish_add_new_topic(mock_ros_publisher):
     server = TcpServer(node_name="test-tcp-server", tcp_ip="127.0.0.1", tcp_port=10000)
     result = SysCommands(server).publish("object_pos_topic", "std_msgs/Bool")
-    assert server.publishers != {}
+    assert server.publishers_table != {}
     mock_ros_publisher.assert_called_once
 
 
 @mock.patch.object(rospy, "Publisher")
 def test_publish_existing_topic(mock_ros_publisher):
     server = TcpServer(node_name="test-tcp-server", tcp_ip="127.0.0.1", tcp_port=10000)
-    server.publishers = {"object_pos_topic": mock.Mock()}
+    server.publishers_table = {"object_pos_topic": mock.Mock()}
     result = SysCommands(server).publish("object_pos_topic", "std_msgs/Bool")
-    assert server.publishers["object_pos_topic"] is not None
+    assert server.publishers_table["object_pos_topic"] is not None
     mock_ros_publisher.assert_called_once
 
 
 def test_publish_empty_topic_should_return_none():
     server = TcpServer(node_name="test-tcp-server", tcp_ip="127.0.0.1", tcp_port=10000)
     result = SysCommands(server).publish("", "pos")
     assert result is None
-    assert server.publishers == {}
+    assert server.publishers_table == {}
 
 
 def test_publish_empty_message_should_return_none():
     server = TcpServer(node_name="test-tcp-server", tcp_ip="127.0.0.1", tcp_port=10000)
     result = SysCommands(server).publish("test-topic", "")
     assert result is None
-    assert server.publishers == {}
+    assert server.publishers_table == {}
 
 
 @mock.patch.object(rospy, "Subscriber")
-@mock.patch.object(
-    ros_tcp_endpoint.server, "resolve_message_name", return_value="unity_interfaces.msg/Pos"
-)
+@mock.patch.object(SysCommands, "resolve_message_name", return_value="unity_interfaces.msg/Pos")
 def test_subscribe_to_new_topic(mock_resolve_msg, mock_ros_subscriber):
     server = TcpServer(node_name="test-tcp-server", tcp_ip="127.0.0.1", tcp_port=10000)
     result = SysCommands(server).subscribe("object_pos_topic", "pos")
-    assert server.subscribers != {}
+    assert server.subscribers_table != {}
     mock_ros_subscriber.assert_called_once
 
 
 @mock.patch.object(rospy, "Subscriber")
-@mock.patch.object(
-    ros_tcp_endpoint.server, "resolve_message_name", return_value="unity_interfaces.msg/Pos"
-)
+@mock.patch.object(SysCommands, "resolve_message_name", return_value="unity_interfaces.msg/Pos")
 def test_subscribe_to_existing_topic(mock_resolve_msg, mock_ros_subscriber):
     server = TcpServer(node_name="test-tcp-server", tcp_ip="127.0.0.1", tcp_port=10000)
-    server.subscribers = {"object_pos_topic": mock.Mock()}
+    server.subscribers_table = {"object_pos_topic": mock.Mock()}
     result = SysCommands(server).subscribe("object_pos_topic", "pos")
-    assert server.subscribers["object_pos_topic"] is not None
+    assert server.subscribers_table["object_pos_topic"] is not None
     mock_ros_subscriber.assert_called_once
 
 
 def test_subscribe_to_empty_topic_should_return_none():
     server = TcpServer(node_name="test-tcp-server", tcp_ip="127.0.0.1", tcp_port=10000)
     result = SysCommands(server).subscribe("", "pos")
     assert result is None
-    assert server.subscribers == {}
+    assert server.subscribers_table == {}
 
 
 def test_subscribe_to_empty_message_should_return_none():
     server = TcpServer(node_name="test-tcp-server", tcp_ip="127.0.0.1", tcp_port=10000)
     result = SysCommands(server).subscribe("test-topic", "")
     assert result is None
-    assert server.subscribers == {}
+    assert server.subscribers_table == {}
 
 
 @mock.patch.object(rospy, "ServiceProxy")
-@mock.patch.object(ros_tcp_endpoint.server, "resolve_message_name")
+@mock.patch.object(SysCommands, "resolve_message_name")
 def test_ros_service_new_topic(mock_resolve_msg, mock_ros_service):
     server = TcpServer(node_name="test-tcp-server", tcp_ip="127.0.0.1", tcp_port=10000)
     result = SysCommands(server).ros_service("object_pos_topic", "pos")
-    assert server.ros_services != {}
+    assert server.ros_services_table != {}
     mock_ros_service.assert_called_once
 
 
 @mock.patch.object(rospy, "ServiceProxy")
-@mock.patch.object(ros_tcp_endpoint.server, "resolve_message_name")
+@mock.patch.object(SysCommands, "resolve_message_name")
 def test_ros_service_existing_topic(mock_resolve_msg, mock_ros_service):
     server = TcpServer(node_name="test-tcp-server", tcp_ip="127.0.0.1", tcp_port=10000)
-    server.ros_services = {"object_pos_topic": mock.Mock()}
+    server.ros_services_table = {"object_pos_topic": mock.Mock()}
     result = SysCommands(server).ros_service("object_pos_topic", "pos")
-    assert server.ros_services["object_pos_topic"] is not None
+    assert server.ros_services_table["object_pos_topic"] is not None
     mock_ros_service.assert_called_once
 
 
 def test_ros_service_empty_topic_should_return_none():
     server = TcpServer(node_name="test-tcp-server", tcp_ip="127.0.0.1", tcp_port=10000)
     result = SysCommands(server).ros_service("", "pos")
     assert result is None
-    assert server.ros_services == {}
+    assert server.ros_services_table == {}
 
 
 def test_ros_service_empty_message_should_return_none():
     server = TcpServer(node_name="test-tcp-server", tcp_ip="127.0.0.1", tcp_port=10000)
     result = SysCommands(server).ros_service("test-topic", "")
     assert result is None
-    assert server.ros_services == {}
+    assert server.ros_services_table == {}

test/test_tcp_sender.py

@@ -1,12 +1,14 @@
 import queue
 import socket
 from unittest import mock
+from ros_tcp_endpoint import TcpServer
 import ros_tcp_endpoint
 
 
 @mock.patch("ros_tcp_endpoint.tcp_sender.rospy")
 def test_tcp_sender_constructor(mock_ros):
-    tcp_sender = ros_tcp_endpoint.tcp_sender.UnityTcpSender()
+    server = TcpServer(node_name="test-tcp-server", tcp_ip="127.0.0.1", tcp_port=10000)
+    tcp_sender = ros_tcp_endpoint.tcp_sender.UnityTcpSender(server)
     assert tcp_sender.sender_id == 1
     assert tcp_sender.time_between_halt_checks == 5
     assert tcp_sender.queue == None
@@ -26,7 +28,8 @@ def test_tcp_sender_constructor(mock_ros):
 
 @mock.patch.object(ros_tcp_endpoint.client.ClientThread, "serialize_message")
 def test_send_message_should_serialize_message(mock_serialize_msg):
-    sender = ros_tcp_endpoint.tcp_sender.UnityTcpSender()
+    server = TcpServer(node_name="test-tcp-server", tcp_ip="127.0.0.1", tcp_port=10000)
+    sender = ros_tcp_endpoint.tcp_sender.UnityTcpSender(server)
     sender.queue = queue.Queue()
     sender.send_unity_message("test topic", "test msg")
     mock_serialize_msg.assert_called_once()
@@ -44,15 +47,17 @@ def test_send_message_should_serialize_message(mock_serialize_msg):
 
 @mock.patch("ros_tcp_endpoint.thread_pauser.ThreadPauser")
 def test_send_unity_service_response_should_resume(mock_thread_pauser_class):
-    sender = ros_tcp_endpoint.tcp_sender.UnityTcpSender()
+    server = TcpServer(node_name="test-tcp-server", tcp_ip="127.0.0.1", tcp_port=10000)
+    sender = ros_tcp_endpoint.tcp_sender.UnityTcpSender(server)
     thread_pauser = mock_thread_pauser_class()
     sender.services_waiting = {"moveit": thread_pauser}
     sender.send_unity_service_response("moveit", "test data")
     thread_pauser.resume_with_result.assert_called_once()
 
 
 def test_start_sender_should_increase_sender_id():
-    sender = ros_tcp_endpoint.tcp_sender.UnityTcpSender()
+    server = TcpServer(node_name="test-tcp-server", tcp_ip="127.0.0.1", tcp_port=10000)
+    sender = ros_tcp_endpoint.tcp_sender.UnityTcpSender(server)
     init_sender_id = 1
     assert sender.sender_id == init_sender_id
     sender.start_sender(mock.Mock(), mock.Mock())