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_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_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"])
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_advertised_service(self):
service_path = "/set_bool_2"
advertise_msg = loads(dumps({"op": "advertise_service",
"type": "std_srvs/SetBool",
"service": service_path}))
self.advertise.advertise_service(advertise_msg)
# Call the service via rosbridge because rospy.ServiceProxy.call() is
# blocking
call_service = CallService(self.proto)
call_service.call_service(loads(dumps({"op": "call_service",
"id": "foo",
"service": service_path,
"args": [True]})))
loop_iterations = 0
while self.received_message is None:
rospy.sleep(rospy.Duration(0.5))
loop_iterations += 1
if loop_iterations > 3:
self.fail("did not receive service call rosbridge message "
"after waiting 2 seconds")
self.assertFalse(self.received_message is None)
self.assertTrue("op" in self.received_message)
self.assertTrue(self.received_message["op"] == "call_service")
self.assertTrue("id" in self.received_message)
# Now send the response
response_msg = loads(dumps({"op": "service_response",
"service": service_path,
"id": self.received_message["id"],
"values": {"success": True,
"message": ""},
"result": True}))
self.received_message = None
self.response.service_response(response_msg)
loop_iterations = 0
while self.received_message is None:
rospy.sleep(rospy.Duration(0.5))
loop_iterations += 1
if loop_iterations > 3:
self.fail("did not receive service response rosbridge message "
"after waiting 2 seconds")
self.assertFalse(self.received_message is None)
# Rosbridge should forward the response message to the "client"
# (i.e. our custom send function, see setUp())
self.assertEqual(self.received_message["op"], "service_response")
self.assertTrue(self.received_message["result"])
def test_unadvertise_with_live_request(self):
service_path = "/set_bool_3"
advertise_msg = loads(dumps({"op": "advertise_service",
"type": "std_srvs/SetBool",
"service": service_path}))
self.advertise.advertise_service(advertise_msg)
# Call the service via rosbridge because rospy.ServiceProxy.call() is
# blocking
call_service = CallService(self.proto)
call_service.call_service(loads(dumps({"op": "call_service",
"id": "foo",
"service": service_path,
"args": [True]})))
loop_iterations = 0
while self.received_message is None:
rospy.sleep(rospy.Duration(0.5))
loop_iterations += 1
if loop_iterations > 3:
self.fail("did not receive service call rosbridge message "
"after waiting 2 seconds")
self.assertFalse(self.received_message is None)
self.assertTrue("op" in self.received_message)
self.assertTrue(self.received_message["op"] == "call_service")
self.assertTrue("id" in self.received_message)
# Now send the response
response_msg = loads(dumps({"op": "unadvertise_service",
"service": service_path}))
self.received_message = None
self.unadvertise.unadvertise_service(response_msg)
loop_iterations = 0
while self.received_message is None:
rospy.sleep(rospy.Duration(0.5))
loop_iterations += 1
if loop_iterations > 3:
self.fail("did not receive service response rosbridge message "
"after waiting 2 seconds")
self.assertFalse(self.received_message is None)
# Rosbridge should abort the existing service call with an error
# (i.e. "result" should be False)
self.assertEqual(self.received_message["op"], "service_response")
self.assertFalse(self.received_message["result"])
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"])
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"])
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_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"])
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)
