Add rosbridge_server tests for action feedback and goal sending

Author: sea-bass

rosbridge_library/src/rosbridge_library/capabilities/send_action_goal.py

@@ -133,6 +133,9 @@ def cancel_action_goal(self, message):
         cid = message.get("id", None)
         action = message["action"]
 
+        # Typecheck the args
+        self.basic_type_check(message, self.cancel_action_goal_msg_fields)
+
         # Pull out the ID
         # Check for deprecated action ID, eg. /rosbridge/topics#33
         cid = extract_id(action, cid)

rosbridge_library/src/rosbridge_library/capability.py

@@ -94,9 +94,7 @@ def basic_type_check(self, msg, types_info):
         """
         for mandatory, fieldname, fieldtypes in types_info:
             if mandatory and fieldname not in msg:
-                raise MissingArgumentException(
-                    "Expected a %s field but none was found." % fieldname
-                )
+                raise MissingArgumentException(f"Expected a {fieldname} field but none was found.")
             elif fieldname in msg:
                 if not isinstance(fieldtypes, tuple):
                     fieldtypes = (fieldtypes,)

rosbridge_library/test/capabilities/test_action_capabilities.py

@@ -157,7 +157,7 @@ def test_execute_advertised_action(self):
                     "op": "action_feedback",
                     "action": action_path,
                     "id": self.received_message["id"],
-                    "values": {"sequence": [1, 1, 2]},
+                    "values": {"sequence": [0, 1, 1]},
                 }
             )
         )
@@ -170,7 +170,7 @@ def test_execute_advertised_action(self):
                 self.fail("Timed out waiting for action feedback message.")
 
         self.assertIsNotNone(self.latest_feedback)
-        self.assertEqual(list(self.latest_feedback.feedback.sequence), [1, 1, 2])
+        self.assertEqual(list(self.latest_feedback.feedback.sequence), [0, 1, 1])
 
         # Now send the result
         result_msg = loads(
@@ -179,7 +179,7 @@ def test_execute_advertised_action(self):
                     "op": "action_result",
                     "action": action_path,
                     "id": self.received_message["id"],
-                    "values": {"sequence": [1, 1, 2, 3, 5]},
+                    "values": {"sequence": [0, 1, 1, 2, 3, 5]},
                     "result": True,
                 }
             )
@@ -196,7 +196,7 @@ def test_execute_advertised_action(self):
 
         self.assertIsNotNone(self.received_message)
         self.assertEqual(self.received_message["op"], "action_result")
-        self.assertEqual(self.received_message["values"]["result"]["sequence"], [1, 1, 2, 3, 5])
+        self.assertEqual(self.received_message["values"]["result"]["sequence"], [0, 1, 1, 2, 3, 5])
 
     def test_cancel_advertised_action(self):
         # Advertise the action
@@ -218,7 +218,7 @@ def test_cancel_advertised_action(self):
         goal_msg = loads(
             dumps(
                 {
-                    "op": "call_service",
+                    "op": "send_action_goal",
                     "id": "foo",
                     "action": action_path,
                     "action_type": "example_interfaces/Fibonacci",
@@ -286,7 +286,7 @@ def test_unadvertise_action(self):
         goal_msg = loads(
             dumps(
                 {
-                    "op": "call_service",
+                    "op": "send_action_goal",
                     "id": "foo",
                     "action": action_path,
                     "action_type": "example_interfaces/Fibonacci",

rosbridge_server/CMakeLists.txt

@@ -24,8 +24,10 @@ install(FILES
 if(BUILD_TESTING)
   find_package(launch_testing_ament_cmake REQUIRED)
   add_launch_test(test/websocket/advertise_action.test.py)
+  add_launch_test(test/websocket/advertise_action_feedback.test.py)
   add_launch_test(test/websocket/advertise_service.test.py)
   add_launch_test(test/websocket/call_service.test.py)
+  add_launch_test(test/websocket/send_action_goal.test.py)
   add_launch_test(test/websocket/smoke.test.py)
   add_launch_test(test/websocket/transient_local_publisher.test.py)
   add_launch_test(test/websocket/best_effort_publisher.test.py)

rosbridge_server/test/websocket/advertise_action.test.py

@@ -67,7 +67,7 @@ async def test_two_concurrent_calls(self, node: Node, make_client):
             {
                 "op": "action_result",
                 "action": "/test_fibonacci_action",
-                "values": {"sequence": [1, 1, 2]},
+                "values": {"sequence": [0, 1, 1, 2]},
                 "id": requests[0]["id"],
                 "result": True,
             }
@@ -81,15 +81,15 @@ async def test_two_concurrent_calls(self, node: Node, make_client):
             {
                 "op": "action_result",
                 "action": "/test_fibonacci_action",
-                "values": {"sequence": [1, 1, 2, 3, 5]},
+                "values": {"sequence": [0, 1, 1, 2, 3, 5]},
                 "id": requests[1]["id"],
                 "result": True,
             }
         )
 
         result1 = await self.goal1_result_future
-        self.assertEqual(result1.result, Fibonacci.Result(sequence=[1, 1, 2]))
+        self.assertEqual(result1.result, Fibonacci.Result(sequence=[0, 1, 1, 2]))
         result2 = await self.goal2_result_future
-        self.assertEqual(result2.result, Fibonacci.Result(sequence=[1, 1, 2, 3, 5]))
+        self.assertEqual(result2.result, Fibonacci.Result(sequence=[0, 1, 1, 2, 3, 5]))
 
         node.destroy_client(client)

rosbridge_server/test/websocket/advertise_action_feedback.test.py

@@ -0,0 +1,87 @@
+#!/usr/bin/env python
+import os
+import sys
+import unittest
+
+from example_interfaces.action import Fibonacci
+from rclpy.action import ActionClient
+from rclpy.node import Node
+from twisted.python import log
+
+sys.path.append(os.path.dirname(__file__))  # enable importing from common.py in this directory
+
+import common  # noqa: E402
+from common import expect_messages, websocket_test  # noqa: E402
+
+log.startLogging(sys.stderr)
+
+generate_test_description = common.generate_test_description
+
+
+class TestActionFeedback(unittest.TestCase):
+    def goal_response_callback(self, future):
+        goal_handle = future.result()
+        if not goal_handle.accepted:
+            return
+        self.goal_result_future = goal_handle.get_result_async()
+
+    def feedback_callback(self, msg):
+        self.latest_feedback = msg
+
+    @websocket_test
+    async def test_feedback(self, node: Node, make_client):
+        ws_client = await make_client()
+        ws_client.sendJson(
+            {
+                "op": "advertise_action",
+                "action": "/test_fibonacci_action",
+                "type": "example_interfaces/Fibonacci",
+            }
+        )
+        client = ActionClient(node, Fibonacci, "/test_fibonacci_action")
+        client.wait_for_server()
+
+        requests_future, ws_client.message_handler = expect_messages(
+            1, "WebSocket", node.get_logger()
+        )
+        requests_future.add_done_callback(lambda _: node.executor.wake())
+
+        self.goal_result_future = None
+        goal_future = client.send_goal_async(
+            Fibonacci.Goal(order=5),
+            feedback_callback=self.feedback_callback,
+        )
+        goal_future.add_done_callback(self.goal_response_callback)
+
+        requests = await requests_future
+
+        self.assertEqual(requests[0]["op"], "send_action_goal")
+        self.assertEqual(requests[0]["action"], "/test_fibonacci_action")
+        self.assertEqual(requests[0]["action_type"], "example_interfaces/Fibonacci")
+        self.assertEqual(requests[0]["args"], {"order": 5})
+
+        self.latest_feedback = None
+        ws_client.sendJson(
+            {
+                "op": "action_feedback",
+                "action": "/test_fibonacci_action",
+                "values": {"sequence": [0, 1, 1, 2]},
+                "id": requests[0]["id"],
+            }
+        )
+        ws_client.sendJson(
+            {
+                "op": "action_result",
+                "action": "/test_fibonacci_action",
+                "values": {"sequence": [0, 1, 1, 2, 3, 5]},
+                "id": requests[0]["id"],
+                "result": True,
+            }
+        )
+
+        result = await self.goal_result_future
+        self.assertIsNotNone(self.latest_feedback)
+        self.assertEqual(self.latest_feedback.feedback, Fibonacci.Feedback(sequence=[0, 1, 1, 2]))
+        self.assertEqual(result.result, Fibonacci.Result(sequence=[0, 1, 1, 2, 3, 5]))
+
+        node.destroy_client(client)

rosbridge_server/test/websocket/send_action_goal.test.py

@@ -0,0 +1,71 @@
+#!/usr/bin/env python
+import os
+import sys
+import time
+import unittest
+
+from example_interfaces.action import Fibonacci
+from rclpy.action import ActionServer
+from rclpy.callback_groups import ReentrantCallbackGroup
+from rclpy.node import Node
+from twisted.python import log
+
+sys.path.append(os.path.dirname(__file__))  # enable importing from common.py in this directory
+
+import common  # noqa: E402
+from common import expect_messages, websocket_test  # noqa: E402
+
+log.startLogging(sys.stderr)
+
+generate_test_description = common.generate_test_description
+
+
+class TestSendActionGoal(unittest.TestCase):
+    def execute_callback(self, goal):
+        feedback_msg = Fibonacci.Feedback()
+        feedback_msg.sequence = [0, 1]
+
+        for i in range(1, goal.request.order):
+            feedback_msg.sequence.append(feedback_msg.sequence[i] + feedback_msg.sequence[i - 1])
+            goal.publish_feedback(feedback_msg)
+            time.sleep(0.1)
+
+        goal.succeed()
+        result = Fibonacci.Result()
+        result.sequence = feedback_msg.sequence
+        return result
+
+    @websocket_test
+    async def test_one_call(self, node: Node, make_client):
+        action_server = ActionServer(
+            node,
+            Fibonacci,
+            "/test_fibonacci_action",
+            self.execute_callback,
+            callback_group=ReentrantCallbackGroup(),
+        )
+
+        ws_client = await make_client()
+        responses_future, ws_client.message_handler = expect_messages(
+            1, "WebSocket", node.get_logger()
+        )
+        responses_future.add_done_callback(lambda _: node.executor.wake())
+
+        ws_client.sendJson(
+            {
+                "op": "send_action_goal",
+                "action": "/test_fibonacci_action",
+                "action_type": "example_interfaces/Fibonacci",
+                "args": {"order": 5},
+                "feedback": True,
+            }
+        )
+
+        responses = await responses_future
+        self.assertEqual(len(responses), 1)
+        self.assertEqual(responses[0]["op"], "action_result")
+        self.assertEqual(responses[0]["action"], "/test_fibonacci_action")
+        self.assertEqual(responses[0]["values"]["result"]["sequence"], [0, 1, 1, 2, 3, 5])
+        self.assertEqual(responses[0]["result"], True)
+
+        action_server.destroy()