def test_call_service_fail(self):
        proto = Protocol("test_call_service_fail")
        s = CallService(proto)
        send_msg = loads(
            dumps({
                "op": "call_service",
                "service": "/rosout/set_logger_level",
                "args": '["ros", "invalid"]'
            }))

        received = {"msg": None, "arrived": False}

        def cb(msg, cid=None):
            received["msg"] = msg
            received["arrived"] = True

        proto.send = cb

        s.call_service(send_msg)

        timeout = 5.0
        start = rospy.Time.now()
        while rospy.Time.now() - start < rospy.Duration(timeout):
            if received["arrived"]:
                break
            time.sleep(0.1)

        self.assertFalse(received["msg"]["result"])
    def test_call_service_works(self):
        # First, call the service the 'proper' way
        p = rospy.ServiceProxy("/rosout/get_loggers", GetLoggers)
        ret = p()


        proto = Protocol("test_call_service_works")
        s = CallService(proto)
        msg = loads(dumps({"op": "call_service", "service": "/rosout/get_loggers"}))

        received = {"msg": None}

        def cb(msg, cid=None):
            received["msg"] = msg

        proto.send = cb

        s.call_service(msg)

        time.sleep(0.5)

        self.assertTrue(received["msg"]["result"])
        for x, y in zip(ret.loggers, received["msg"]["values"]["loggers"]):
            self.assertEqual(x.name, y["name"])
            self.assertEqual(x.level, y["level"])
    def test_call_service_works(self):
        # First, call the service the 'proper' way
        p = rospy.ServiceProxy("/rosout/get_loggers", GetLoggers)
        ret = p()

        proto = Protocol("test_call_service_works")
        s = CallService(proto)
        msg = loads(
            dumps({
                "op": "call_service",
                "service": "/rosout/get_loggers"
            }))

        received = {"msg": None}

        def cb(msg, cid=None):
            received["msg"] = msg

        proto.send = cb

        s.call_service(msg)

        time.sleep(0.5)

        for x, y in zip(ret.loggers, received["msg"]["values"]["loggers"]):
            self.assertEqual(x.name, y["name"])
            self.assertEqual(x.level, y["level"])
    def test_call_service_fail(self):
        # Dummy service that instantly fails
        service_server = rospy.Service("set_bool_fail", SetBool,
                                       lambda req: None)

        proto = Protocol("test_call_service_fail")
        s = CallService(proto)
        send_msg = loads(
            dumps({
                "op": "call_service",
                "service": rospy.get_name() + "/set_bool_fail",
                "args": '[ true ]'
            }))

        received = {"msg": None, "arrived": False}

        def cb(msg, cid=None):
            received["msg"] = msg
            received["arrived"] = True

        proto.send = cb

        s.call_service(send_msg)

        timeout = 5.0
        start = rospy.Time.now()
        while rospy.Time.now() - start < rospy.Duration(timeout):
            if received["arrived"]:
                break
            time.sleep(0.1)

        self.assertFalse(received["msg"]["result"])
Beispiel #5
0
    def test_subscribe_works(self):
        proto = Protocol("test_subscribe_works")
        sub = subscribe.Subscribe(proto)
        topic = "/test_subscribe_works"
        msg = String()
        msg.data = "test test_subscribe_works works"
        msg_type = "std_msgs/String"

        received = {"msg": None}

        def send(outgoing):
            received["msg"] = outgoing

        proto.send = send

        sub.subscribe(
            loads(dumps({
                "op": "subscribe",
                "topic": topic,
                "type": msg_type
            })))

        p = rospy.Publisher(topic, String)
        time.sleep(0.25)
        p.publish(msg)

        time.sleep(0.25)
        self.assertEqual(received["msg"]["msg"]["data"], msg.data)
Beispiel #6
0
    def test_invalid_arguments(self):
        proto = Protocol("test_invalid_arguments")
        sub = subscribe.Subscribe(proto)

        msg = {"op": "subscribe", "topic": 3}
        self.assertRaises(InvalidArgumentException, sub.subscribe, msg)

        msg = {"op": "subscribe", "topic": "/jon", "type": 3}
        self.assertRaises(InvalidArgumentException, sub.subscribe, msg)

        msg = {"op": "subscribe", "topic": "/jon", "throttle_rate": "fast"}
        self.assertRaises(InvalidArgumentException, sub.subscribe, msg)

        msg = {
            "op": "subscribe",
            "topic": "/jon",
            "fragment_size": "five cubits"
        }
        self.assertRaises(InvalidArgumentException, sub.subscribe, msg)

        msg = {"op": "subscribe", "topic": "/jon", "queue_length": "long"}
        self.assertRaises(InvalidArgumentException, sub.subscribe, msg)

        msg = {"op": "subscribe", "topic": "/jon", "compression": 9000}
        self.assertRaises(InvalidArgumentException, sub.subscribe, msg)
Beispiel #7
0
    def test_call_service_fail(self):
        proto = Protocol("test_call_service_fail")
        s = CallService(proto)
        send_msg = loads(dumps({"op": "call_service", "service": "/rosout/set_logger_level", "args": '["ros", "invalid"]'}))

        received = {"msg": None}

        def cb(msg, cid=None): 
            received["msg"] = msg

        proto.send = cb

        s.call_service(send_msg)

        time.sleep(0.5)

        self.assertFalse(received["msg"]["result"])
Beispiel #8
0
    def test_missing_arguments(self):
        proto = Protocol("hello")
        pub = Publish(proto)
        msg = {"op": "publish"}
        self.assertRaises(MissingArgumentException, pub.publish, msg)

        msg = {"op": "publish", "msg": {}}
        self.assertRaises(MissingArgumentException, pub.publish, msg)
    def test_call_service_fail(self):
        proto = Protocol("test_call_service_fail")
        s = CallService(proto)
        send_msg = loads(dumps({"op": "call_service", "service": "/rosout/set_logger_level", "args": '["ros", "invalid"]'}))

        received = {"msg": None}

        def cb(msg, cid=None): 
            received["msg"] = msg

        proto.send = cb

        s.call_service(send_msg)

        time.sleep(0.5)

        self.assertFalse(received["msg"]["result"])
Beispiel #10
0
    def test_do_advertise(self):
        proto = Protocol("hello")
        adv = Advertise(proto)
        topic = "/test_do_advertise"
        type = "std_msgs/String"

        msg = {"op": "advertise", "topic": topic, "type": type}
        adv.advertise(loads(dumps(msg)))
        self.assertTrue(self.is_topic_published(topic))
        adv.unadvertise(loads(dumps(msg)))
        self.assertFalse(self.is_topic_published(topic))
Beispiel #11
0
    def test_invalid_arguments(self):
        proto = Protocol("hello")
        adv = Advertise(proto)

        msg = {"op": "advertise", "topic": 3, "type": "std_msgs/String"}
        self.assertRaises(InvalidArgumentException, adv.advertise,
                          loads(dumps(msg)))

        msg = {"op": "advertise", "topic": "/jon", "type": 3}
        self.assertRaises(InvalidArgumentException, adv.advertise,
                          loads(dumps(msg)))
 def setUp(self):
     self.proto = Protocol(self._testMethodName)
     # change the log function so we can verify errors are logged
     self.proto.log = self.mock_log
     # change the send callback so we can access the rosbridge messages
     # being sent
     self.proto.send = self.local_send_cb
     self.advertise = AdvertiseService(self.proto)
     self.unadvertise = UnadvertiseService(self.proto)
     self.response = ServiceResponse(self.proto)
     self.received_message = None
     self.log_entries = []
    def test_call_service_works(self):
        # Prepare to call the service the 'proper' way
        p = rospy.ServiceProxy(rospy.get_name() + "/get_loggers", GetLoggers)
        p.wait_for_service()
        time.sleep(1.0)

        proto = Protocol("test_call_service_works")
        s = CallService(proto)
        msg = loads(
            dumps({
                "op": "call_service",
                "service": rospy.get_name() + "/get_loggers"
            }))

        received = {"msg": None, "arrived": False}

        def cb(msg, cid=None):
            received["msg"] = msg
            received["arrived"] = True

        proto.send = cb

        s.call_service(msg)

        timeout = 5.0
        start = rospy.Time.now()
        while rospy.Time.now() - start < rospy.Duration(timeout):
            if received["arrived"]:
                break
            time.sleep(0.1)

        # The rosbridge service call actually causes another logger to appear,
        # so do the "regular" service call after that.
        ret = p()

        self.assertTrue(received["msg"]["result"])
        for x, y in zip(ret.loggers, received["msg"]["values"]["loggers"]):
            self.assertEqual(x.name, y["name"])
            self.assertEqual(x.level, y["level"])
    def test_subscribe_works(self):
        proto = Protocol("test_subscribe_works")
        sub = subscribe.Subscribe(proto)
        topic = "/test_subscribe_works"
        msg = String()
        msg.data = "test test_subscribe_works works"
        msg_type = "std_msgs/String"

        received = {"msg": None}

        def send(outgoing):
            received["msg"] = outgoing

        proto.send = send

        sub.subscribe(loads(dumps({"op": "subscribe", "topic": topic, "type": msg_type})))

        p = rospy.Publisher(topic, String)
        time.sleep(0.25)
        p.publish(msg)

        time.sleep(0.25)
        self.assertEqual(received["msg"]["msg"]["data"], msg.data)
    def test_call_service_works(self):
        # First, call the service the 'proper' way
        p = rospy.ServiceProxy("/rosout/get_loggers", GetLoggers)
        p.wait_for_service()
        time.sleep(1.0)
        ret = p()

        proto = Protocol("test_call_service_works")
        s = CallService(proto)
        msg = loads(
            dumps({
                "op": "call_service",
                "service": "/rosout/get_loggers"
            }))

        received = {"msg": None, "arrived": False}

        def cb(msg, cid=None):
            received["msg"] = msg
            received["arrived"] = True

        proto.send = cb

        s.call_service(msg)

        timeout = 5.0
        start = rospy.Time.now()
        while rospy.Time.now() - start < rospy.Duration(timeout):
            if received["arrived"]:
                break
            time.sleep(0.1)

        self.assertTrue(received["msg"]["result"])
        for x, y in zip(ret.loggers, received["msg"]["values"]["loggers"]):
            self.assertEqual(x.name, y["name"])
            self.assertEqual(x.level, y["level"])
Beispiel #16
0
    def test_invalid_msg_module(self):
        no_msgs = [
            "roslib/Time", "roslib/Duration", "roslib/Header",
            "std_srvs/ConflictedMsg", "topic_tools/MessageMessage"
        ]

        proto = Protocol("hello")
        adv = Advertise(proto)

        for invalid_type in no_msgs:
            msg = {
                "op": "advertise",
                "topic": "/test_invalid_msg_module",
                "type": invalid_type
            }
            self.assertRaises(ros_loader.InvalidModuleException, adv.advertise,
                              loads(dumps(msg)))
Beispiel #17
0
    def test_invalid_msg_package(self):
        nonexistent = [
            "wangle_msgs/Jam", "whistleblower_msgs/Document",
            "sexual_harrassment_msgs/UnwantedAdvance", "coercion_msgs/Bribe",
            "airconditioning_msgs/Cold", "pr2thoughts_msgs/Escape"
        ]

        proto = Protocol("hello")
        adv = Advertise(proto)

        for invalid_type in nonexistent:
            msg = {
                "op": "advertise",
                "topic": "/test_invalid_msg_package",
                "type": invalid_type
            }
            self.assertRaises(ros_loader.InvalidPackageException,
                              adv.advertise, loads(dumps(msg)))
Beispiel #18
0
    def test_invalid_msg_classes(self):
        nonexistent = [
            "roscpp/Time", "roscpp/Duration", "roscpp/Header", "rospy/Time",
            "rospy/Duration", "rospy/Header", "std_msgs/Spool",
            "geometry_msgs/Tetrahedron", "sensor_msgs/TelepathyUnit"
        ]

        proto = Protocol("hello")
        adv = Advertise(proto)

        for invalid_type in nonexistent:
            msg = {
                "op": "advertise",
                "topic": "/test_invalid_msg_classes",
                "type": invalid_type
            }
            self.assertRaises(ros_loader.InvalidClassException, adv.advertise,
                              loads(dumps(msg)))
Beispiel #19
0
    def test_publish_works(self):
        proto = Protocol("hello")
        pub = Publish(proto)
        topic = "/test_publish_works"
        msg = {"data": "test publish works"}

        received = {"msg": None}

        def cb(msg):
            received["msg"] = msg

        rospy.Subscriber(topic, String, cb)

        pub_msg = loads(dumps({"op": "publish", "topic": topic, "msg": msg}))
        pub.publish(pub_msg)

        sleep(0.5)
        self.assertEqual(received["msg"].data, msg["data"])
Beispiel #20
0
    def test_invalid_msg_typestrings(self):
        invalid = [
            "", "/", "//", "///", "////", "/////", "bad", "stillbad",
            "not/better/still", "not//better//still", "not///better///still",
            "better/", "better//", "better///", "/better", "//better",
            "///better", "this\isbad", "\\"
        ]

        proto = Protocol("hello")
        adv = Advertise(proto)

        for invalid_type in invalid:
            msg = {
                "op": "advertise",
                "topic": "/test_invalid_msg_typestrings",
                "type": invalid_type
            }
            self.assertRaises(ros_loader.InvalidTypeStringException,
                              adv.advertise, loads(dumps(msg)))
Beispiel #21
0
    def test_valid_msg_classes(self):
        assortedmsgs = [
            "geometry_msgs/Pose", "actionlib_msgs/GoalStatus",
            "geometry_msgs/WrenchStamped", "stereo_msgs/DisparityImage",
            "nav_msgs/OccupancyGrid", "geometry_msgs/Point32",
            "std_msgs/String", "trajectory_msgs/JointTrajectoryPoint",
            "diagnostic_msgs/KeyValue",
            "visualization_msgs/InteractiveMarkerUpdate", "nav_msgs/GridCells",
            "sensor_msgs/PointCloud2"
        ]

        proto = Protocol("hello")
        adv = Advertise(proto)

        for valid_type in assortedmsgs:
            msg = {
                "op": "advertise",
                "topic": "/" + valid_type,
                "type": valid_type
            }
            adv.advertise(loads(dumps(msg)))
            adv.unadvertise(loads(dumps(msg)))
Beispiel #22
0
 def __init__(self, client_id):
     Protocol.__init__(self, client_id)
     for capability_class in self.rosbridge_capabilities:
         self.add_capability(capability_class)
Beispiel #23
0
    def test_invalid_arguments(self):
        proto = Protocol("hello")
        pub = Publish(proto)

        msg = {"op": "publish", "topic": 3}
        self.assertRaises(InvalidArgumentException, pub.publish, msg)
    def test_invalid_arguments(self):
        proto = Protocol("test_invalid_arguments")
        s = CallService(proto)

        msg = loads(dumps({"op": "call_service", "service": 3}))
        self.assertRaises(InvalidArgumentException, s.call_service, msg)
 def test_missing_arguments(self):
     proto = Protocol("test_missing_arguments")
     s = CallService(proto)
     msg = loads(dumps({"op": "call_service"}))
     self.assertRaises(MissingArgumentException, s.call_service, msg)
 def __init__(self, client_id, parameters = None):
     self.parameters = parameters
     Protocol.__init__(self, client_id)
     for capability_class in self.rosbridge_capabilities:
         self.add_capability(capability_class)
 def __init__(self, client_id, parameters=None):
     self.parameters = parameters
     Protocol.__init__(self, client_id)
     for capability_class in self.rosbridge_capabilities:
         self.add_capability(capability_class)
Beispiel #28
0
 def test_missing_arguments(self):
     proto = Protocol("test_missing_arguments")
     sub = subscribe.Subscribe(proto)
     msg = {"op": "subscribe"}
     self.assertRaises(MissingArgumentException, sub.subscribe, msg)