class TestSiamCiAdapterProxyAsync(SiamCiTestCase):
@defer.inlineCallbacks
def setUp(self):
yield self._start_container(sysname="siamci")
self.siamci = SiamCiAdapterProxy(SiamCiTestCase.pid,
SiamCiTestCase.port)
yield self.siamci.start()
self.receiver_client = yield self._start_receiver_service(
receiver_service_name)
@defer.inlineCallbacks
def tearDown(self):
yield self.siamci.stop()
yield self._stop_container()
@defer.inlineCallbacks
def test_list_ports_async(self):
self._check_skip()
#
# @todo: more robust assignment of publish IDs
#
publish_id = "list_ports;"
# prepare to receive result:
yield self.receiver_client.expect(publish_id)
# make request:
ret = yield self.siamci.list_ports(publish_stream="siamci." +
receiver_service_name)
self.assertIsSuccessFail(ret)
self.assertEquals(ret.result, OK)
# check that all expected were received
expected = yield self.receiver_client.getExpected()
self.assertEquals(len(expected), 0)
# actual response should indicate OK:
response = yield self.receiver_client.getAccepted(publish_id)
self.assertIsSuccessFail(response)
self.assertEquals(response.result, OK)
@defer.inlineCallbacks
def test_get_status_async(self):
self._check_skip()
#
# @todo: more robust assignment of publish IDs
#
publish_id = "get_status;port=" + SiamCiTestCase.port
# prepare to receive result:
yield self.receiver_client.expect(publish_id)
# make request:
ret = yield self.siamci.get_status(publish_stream="siamci." +
receiver_service_name)
self.assertIsSuccessFail(ret)
self.assertEquals(ret.result, OK)
# check that all expected were received
expected = yield self.receiver_client.getExpected()
self.assertEquals(len(expected), 0)
# actual response should indicate OK:
response = yield self.receiver_client.getAccepted(publish_id)
self.assertIsSuccessFail(response)
self.assertEquals(response.result, OK)
@defer.inlineCallbacks
def test_get_last_sample_async(self):
self._check_skip()
#
# @todo: more robust assignment of publish IDs
#
publish_id = "get_last_sample;port=" + SiamCiTestCase.port
# prepare to receive result:
yield self.receiver_client.expect(publish_id)
# make request:
ret = yield self.siamci.get_last_sample(publish_stream="siamci." +
receiver_service_name)
self.assertIsSuccessFail(ret)
self.assertEquals(ret.result, OK)
# check that all expected were received
expected = yield self.receiver_client.getExpected()
self.assertEquals(len(expected), 0)
# actual response should indicate OK:
response = yield self.receiver_client.getAccepted(publish_id)
self.assertIsSuccessFail(response)
self.assertEquals(response.result, OK)
@defer.inlineCallbacks
def test_get_channels_async(self):
self._check_skip()
#
# @todo: more robust assignment of publish IDs
#
publish_id = "get_channels;port=" + SiamCiTestCase.port
# prepare to receive result:
yield self.receiver_client.expect(publish_id)
# make request:
ret = yield self.siamci.get_channels(publish_stream="siamci." +
receiver_service_name)
self.assertIsSuccessFail(ret)
self.assertEquals(ret.result, OK)
# check that all expected were received
expected = yield self.receiver_client.getExpected()
self.assertEquals(len(expected), 0)
# actual response should indicate OK:
response = yield self.receiver_client.getAccepted(publish_id)
self.assertIsSuccessFail(response)
self.assertEquals(response.result, OK)
@defer.inlineCallbacks
def test_fetch_params_some_good_async(self):
self._check_skip()
#
# @todo: more robust assignment of publish IDs
#
publish_id = "fetch_params;port=" + SiamCiTestCase.port
# prepare to receive result:
yield self.receiver_client.expect(publish_id)
ret = yield self.siamci.fetch_params(['startDelayMsec'],
publish_stream="siamci." +
receiver_service_name)
self.assertIsSuccessFail(ret)
self.assertEquals(ret.result, OK)
# check that all expected were received
expected = yield self.receiver_client.getExpected()
self.assertEquals(len(expected), 0)
# actual response should indicate OK:
response = yield self.receiver_client.getAccepted(publish_id)
self.assertIsSuccessFail(response)
self.assertEquals(response.result, OK)
@defer.inlineCallbacks
def test_fetch_params_some_wrong_async(self):
self._check_skip()
#
# @todo: more robust assignment of publish IDs
#
publish_id = "fetch_params;port=" + SiamCiTestCase.port
# prepare to receive result:
yield self.receiver_client.expect(publish_id)
ret = yield self.siamci.fetch_params(['startDelayMsec', 'WRONG_PARAM'],
publish_stream="siamci." +
receiver_service_name)
self.assertIsSuccessFail(ret)
self.assertEquals(ret.result,
OK) # NOTE the immediate reply should be OK ...
# check that all expected were received
expected = yield self.receiver_client.getExpected()
self.assertEquals(len(expected), 0)
# ... but the actual response should indicate ERROR:
response = yield self.receiver_client.getAccepted(publish_id)
self.assertIsSuccessFail(response)
self.assertEquals(response.result, ERROR)
@defer.inlineCallbacks
def test_fetch_params_all_async(self):
self._check_skip()
#
# @todo: more robust assignment of publish IDs
#
publish_id = "fetch_params;port=" + SiamCiTestCase.port
# prepare to receive result:
yield self.receiver_client.expect(publish_id)
ret = yield self.siamci.fetch_params(publish_stream="siamci." +
receiver_service_name)
self.assertIsSuccessFail(ret)
self.assertEquals(ret.result, OK)
# check that all expected were received
expected = yield self.receiver_client.getExpected()
self.assertEquals(len(expected), 0)
# actual response should indicate OK:
response = yield self.receiver_client.getAccepted(publish_id)
self.assertIsSuccessFail(response)
self.assertEquals(response.result, OK)
@defer.inlineCallbacks
def test_set_params_good_async_timeout_30(self):
self._check_skip()
#
# @todo: more robust assignment of publish IDs
#
publish_id = "set_params;port=" + SiamCiTestCase.port
# prepare to receive result:
yield self.receiver_client.expect(publish_id)
ret = yield self.siamci.set_params({'startDelayMsec': '1000'},
publish_stream="siamci." +
receiver_service_name)
self.assertIsSuccessFail(ret)
self.assertEquals(ret.result, OK)
# check that all expected were received
expected = yield self.receiver_client.getExpected(timeout=30)
self.assertEquals(len(expected), 0)
# actual response should indicate OK:
response = yield self.receiver_client.getAccepted(publish_id)
self.assertIsSuccessFail(response)
self.assertEquals(response.result, OK)
@defer.inlineCallbacks
def test_set_params_wrong_async(self):
self._check_skip()
#
# @todo: more robust assignment of publish IDs
#
publish_id = "set_params;port=" + SiamCiTestCase.port
# prepare to receive result:
yield self.receiver_client.expect(publish_id)
ret = yield self.siamci.set_params(
{
'startDelayMsec': '1000',
'WRONG_PARAM': 'fooVal'
},
publish_stream="siamci." + receiver_service_name)
self.assertIsSuccessFail(ret)
self.assertEquals(ret.result, OK)
# check that all expected were received
expected = yield self.receiver_client.getExpected()
self.assertEquals(len(expected), 0)
# actual response should indicate ERROR:
response = yield self.receiver_client.getAccepted(publish_id)
self.assertIsSuccessFail(response)
self.assertEquals(response.result, ERROR)
class TestSiamCiAdapterProxyAsync(SiamCiTestCase):
@defer.inlineCallbacks
def setUp(self):
yield self._start_container(sysname="siamci")
self.siamci = SiamCiAdapterProxy(SiamCiTestCase.pid, SiamCiTestCase.port)
yield self.siamci.start()
self.receiver_client = yield self._start_receiver_service(receiver_service_name)
@defer.inlineCallbacks
def tearDown(self):
yield self.siamci.stop()
yield self._stop_container()
@defer.inlineCallbacks
def test_list_ports_async(self):
self._check_skip()
#
# @todo: more robust assignment of publish IDs
#
publish_id = "list_ports;"
# prepare to receive result:
yield self.receiver_client.expect(publish_id)
# make request:
ret = yield self.siamci.list_ports(publish_stream="siamci." + receiver_service_name)
self.assertIsSuccessFail(ret)
self.assertEquals(ret.result, OK)
# check that all expected were received
expected = yield self.receiver_client.getExpected()
self.assertEquals(len(expected), 0)
# actual response should indicate OK:
response = yield self.receiver_client.getAccepted(publish_id)
self.assertIsSuccessFail(response)
self.assertEquals(response.result, OK)
@defer.inlineCallbacks
def test_get_status_async(self):
self._check_skip()
#
# @todo: more robust assignment of publish IDs
#
publish_id = "get_status;port=" + SiamCiTestCase.port
# prepare to receive result:
yield self.receiver_client.expect(publish_id)
# make request:
ret = yield self.siamci.get_status(publish_stream="siamci." + receiver_service_name)
self.assertIsSuccessFail(ret)
self.assertEquals(ret.result, OK)
# check that all expected were received
expected = yield self.receiver_client.getExpected()
self.assertEquals(len(expected), 0)
# actual response should indicate OK:
response = yield self.receiver_client.getAccepted(publish_id)
self.assertIsSuccessFail(response)
self.assertEquals(response.result, OK)
@defer.inlineCallbacks
def test_get_last_sample_async(self):
self._check_skip()
#
# @todo: more robust assignment of publish IDs
#
publish_id = "get_last_sample;port=" + SiamCiTestCase.port
# prepare to receive result:
yield self.receiver_client.expect(publish_id)
# make request:
ret = yield self.siamci.get_last_sample(publish_stream="siamci." + receiver_service_name)
self.assertIsSuccessFail(ret)
self.assertEquals(ret.result, OK)
# check that all expected were received
expected = yield self.receiver_client.getExpected()
self.assertEquals(len(expected), 0)
# actual response should indicate OK:
response = yield self.receiver_client.getAccepted(publish_id)
self.assertIsSuccessFail(response)
self.assertEquals(response.result, OK)
@defer.inlineCallbacks
def test_get_channels_async(self):
self._check_skip()
#
# @todo: more robust assignment of publish IDs
#
publish_id = "get_channels;port=" + SiamCiTestCase.port
# prepare to receive result:
yield self.receiver_client.expect(publish_id)
# make request:
ret = yield self.siamci.get_channels(publish_stream="siamci." + receiver_service_name)
self.assertIsSuccessFail(ret)
self.assertEquals(ret.result, OK)
# check that all expected were received
expected = yield self.receiver_client.getExpected()
self.assertEquals(len(expected), 0)
# actual response should indicate OK:
response = yield self.receiver_client.getAccepted(publish_id)
self.assertIsSuccessFail(response)
self.assertEquals(response.result, OK)
@defer.inlineCallbacks
def test_fetch_params_some_good_async(self):
self._check_skip()
#
# @todo: more robust assignment of publish IDs
#
publish_id = "fetch_params;port=" + SiamCiTestCase.port
# prepare to receive result:
yield self.receiver_client.expect(publish_id)
ret = yield self.siamci.fetch_params(["startDelayMsec"], publish_stream="siamci." + receiver_service_name)
self.assertIsSuccessFail(ret)
self.assertEquals(ret.result, OK)
# check that all expected were received
expected = yield self.receiver_client.getExpected()
self.assertEquals(len(expected), 0)
# actual response should indicate OK:
response = yield self.receiver_client.getAccepted(publish_id)
self.assertIsSuccessFail(response)
self.assertEquals(response.result, OK)
@defer.inlineCallbacks
def test_fetch_params_some_wrong_async(self):
self._check_skip()
#
# @todo: more robust assignment of publish IDs
#
publish_id = "fetch_params;port=" + SiamCiTestCase.port
# prepare to receive result:
yield self.receiver_client.expect(publish_id)
ret = yield self.siamci.fetch_params(
["startDelayMsec", "WRONG_PARAM"], publish_stream="siamci." + receiver_service_name
)
self.assertIsSuccessFail(ret)
self.assertEquals(ret.result, OK) # NOTE the immediate reply should be OK ...
# check that all expected were received
expected = yield self.receiver_client.getExpected()
self.assertEquals(len(expected), 0)
# ... but the actual response should indicate ERROR:
response = yield self.receiver_client.getAccepted(publish_id)
self.assertIsSuccessFail(response)
self.assertEquals(response.result, ERROR)
@defer.inlineCallbacks
def test_fetch_params_all_async(self):
self._check_skip()
#
# @todo: more robust assignment of publish IDs
#
publish_id = "fetch_params;port=" + SiamCiTestCase.port
# prepare to receive result:
yield self.receiver_client.expect(publish_id)
ret = yield self.siamci.fetch_params(publish_stream="siamci." + receiver_service_name)
self.assertIsSuccessFail(ret)
self.assertEquals(ret.result, OK)
# check that all expected were received
expected = yield self.receiver_client.getExpected()
self.assertEquals(len(expected), 0)
# actual response should indicate OK:
response = yield self.receiver_client.getAccepted(publish_id)
self.assertIsSuccessFail(response)
self.assertEquals(response.result, OK)
@defer.inlineCallbacks
def test_set_params_good_async_timeout_30(self):
self._check_skip()
#
# @todo: more robust assignment of publish IDs
#
publish_id = "set_params;port=" + SiamCiTestCase.port
# prepare to receive result:
yield self.receiver_client.expect(publish_id)
ret = yield self.siamci.set_params({"startDelayMsec": "1000"}, publish_stream="siamci." + receiver_service_name)
self.assertIsSuccessFail(ret)
self.assertEquals(ret.result, OK)
# check that all expected were received
expected = yield self.receiver_client.getExpected(timeout=30)
self.assertEquals(len(expected), 0)
# actual response should indicate OK:
response = yield self.receiver_client.getAccepted(publish_id)
self.assertIsSuccessFail(response)
self.assertEquals(response.result, OK)
@defer.inlineCallbacks
def test_set_params_wrong_async(self):
self._check_skip()
#
# @todo: more robust assignment of publish IDs
#
publish_id = "set_params;port=" + SiamCiTestCase.port
# prepare to receive result:
yield self.receiver_client.expect(publish_id)
ret = yield self.siamci.set_params(
{"startDelayMsec": "1000", "WRONG_PARAM": "fooVal"}, publish_stream="siamci." + receiver_service_name
)
self.assertIsSuccessFail(ret)
self.assertEquals(ret.result, OK)
# check that all expected were received
expected = yield self.receiver_client.getExpected()
self.assertEquals(len(expected), 0)
# actual response should indicate ERROR:
response = yield self.receiver_client.getAccepted(publish_id)
self.assertIsSuccessFail(response)
self.assertEquals(response.result, ERROR)
class TestSiamCiAdapterProxyDataAsync(SiamCiTestCase):
# increase timeout for Trial tests
timeout = 120
@defer.inlineCallbacks
def setUp(self):
yield self._start_container(sysname=sysname)
self.siamci = SiamCiAdapterProxy(SiamCiTestCase.pid,
SiamCiTestCase.port)
yield self.siamci.start()
@defer.inlineCallbacks
def tearDown(self):
yield self.siamci.stop()
yield self._stop_container()
@defer.inlineCallbacks
def test_acquisition_start_verify_data(
self, receiver_service_name='test_acquisition_start_verify_data'):
"""
- start receiver service and set expected publish id
- start acquisition
- get expected elements with some timeout
- verify all exptected were received.
Note that this test does not stop the acquisition. Unless this is explicitly stopped
by a caller (see next test), the receiver service will shutdown during tearDown, but
also note that the SIAM-CI service will also eventually stop sending the notifications
because they won't be delivered successfully anymore.
"""
self._check_skip()
receiver_client = yield self._start_receiver_service(
receiver_service_name)
# @todo: capture channel from some parameter?
channel = "val"
#
# @todo: more robust assignment of publish IDs
#
publish_id = "data_acquisition;port=" + SiamCiTestCase.port + ";channel=" + channel
# prepare to receive result:
yield receiver_client.expect(publish_id)
ret = yield self.siamci.execute_StartAcquisition(
channel=channel,
publish_stream=sysname + "." + receiver_service_name)
self.assertIsSuccessFail(ret)
self.assertEquals(ret.result, OK)
# check that all expected were received
expected = yield receiver_client.getExpected(timeout=30)
self.assertEquals(len(expected), 0)
# actual response should indicate OK:
response = yield receiver_client.getAccepted(publish_id)
self.assertIsSuccessFail(response)
self.assertEquals(response.result, OK)
defer.returnValue((receiver_client, channel, publish_id))
@defer.inlineCallbacks
def test_acquisition_start_wait_stop(self):
"""
- start acquisition by calling test_acquisition_start_verify_data
- wait for a few seconds
- stop acquisition
"""
self._check_skip()
receiver_service_name = 'test_acquisition_start_wait_stop'
# start acquisition
(receiver_client, channel, publish_id) = \
yield self.test_acquisition_start_verify_data(receiver_service_name)
# wait for a few samples to be notified to the receiver service
yield pu.asleep(20)
# stop acquisition
ret = yield self.siamci.execute_StopAcquisition(
channel=channel,
publish_stream=sysname + "." + receiver_service_name)
self.assertIsSuccessFail(ret)
self.assertEquals(ret.result, OK)
class TestSiamCiAdapterProxy(SiamCiTestCase):
@defer.inlineCallbacks
def setUp(self):
yield self._start_container()
self.siamci = SiamCiAdapterProxy(SiamCiTestCase.pid,
SiamCiTestCase.port)
yield self.siamci.start()
@defer.inlineCallbacks
def tearDown(self):
yield self.siamci.stop()
yield self._stop_container()
@defer.inlineCallbacks
def test_ping(self):
self._check_skip()
ret = yield self.siamci.ping()
self.assertTrue(ret)
@defer.inlineCallbacks
def test_list_ports(self):
self._check_skip()
ret = yield self.siamci.list_ports()
self.assertIsSuccessFail(ret)
self.assertEquals(ret.result, OK)
@defer.inlineCallbacks
def test_get_channels(self):
self._check_skip()
ret = yield self.siamci.get_channels()
self.assertIsSuccessFail(ret)
self.assertEquals(ret.result, OK)
@defer.inlineCallbacks
def test_get_status(self):
self._check_skip()
ret = yield self.siamci.get_status()
@defer.inlineCallbacks
def test_get_last_sample(self):
self._check_skip()
ret = yield self.siamci.get_last_sample()
self.assertIsSuccessFail(ret)
self.assertEquals(ret.result, OK)
@defer.inlineCallbacks
def test_fetch_params_some_good(self):
"""fetch specific list of parameters"""
self._check_skip()
ret = yield self.siamci.fetch_params(['startDelayMsec'])
self.assertIsSuccessFail(ret)
self.assertEquals(ret.result, OK)
@defer.inlineCallbacks
def test_fetch_params_some_wrong(self):
"""fetch specific list of parameters"""
self._check_skip()
ret = yield self.siamci.fetch_params(['startDelayMsec', 'WRONG_PARAM'])
self.assertIsSuccessFail(ret)
self.assertEquals(ret.result, ERROR)
@defer.inlineCallbacks
def test_fetch_params_all(self):
"""fetch all parameters"""
self._check_skip()
ret = yield self.siamci.fetch_params()
self.assertIsSuccessFail(ret)
self.assertEquals(ret.result, OK)
@defer.inlineCallbacks
def test_set_params_good(self):
self._check_skip()
ret = yield self.siamci.set_params({'startDelayMsec': '1000'})
self.assertIsSuccessFail(ret)
self.assertEquals(ret.result, OK)
@defer.inlineCallbacks
def test_set_params_wrong(self):
self._check_skip()
ret = yield self.siamci.set_params({
'startDelayMsec': '1000',
'WRONG_PARAM': 'fooVal'
})
self.assertIsSuccessFail(ret)
self.assertEquals(ret.result, ERROR)
class TestSiamCiAdapterProxy(SiamCiTestCase):
@defer.inlineCallbacks
def setUp(self):
yield self._start_container()
self.siamci = SiamCiAdapterProxy(SiamCiTestCase.pid, SiamCiTestCase.port)
yield self.siamci.start()
@defer.inlineCallbacks
def tearDown(self):
yield self.siamci.stop()
yield self._stop_container()
@defer.inlineCallbacks
def test_ping(self):
self._check_skip()
ret = yield self.siamci.ping()
self.assertTrue(ret)
@defer.inlineCallbacks
def test_list_ports(self):
self._check_skip()
ret = yield self.siamci.list_ports()
self.assertIsSuccessFail(ret)
self.assertEquals(ret.result, OK)
@defer.inlineCallbacks
def test_get_channels(self):
self._check_skip()
ret = yield self.siamci.get_channels()
self.assertIsSuccessFail(ret)
self.assertEquals(ret.result, OK)
@defer.inlineCallbacks
def test_get_status(self):
self._check_skip()
ret = yield self.siamci.get_status()
@defer.inlineCallbacks
def test_get_last_sample(self):
self._check_skip()
ret = yield self.siamci.get_last_sample()
self.assertIsSuccessFail(ret)
self.assertEquals(ret.result, OK)
@defer.inlineCallbacks
def test_fetch_params_some_good(self):
"""fetch specific list of parameters"""
self._check_skip()
ret = yield self.siamci.fetch_params(['startDelayMsec'])
self.assertIsSuccessFail(ret)
self.assertEquals(ret.result, OK)
@defer.inlineCallbacks
def test_fetch_params_some_wrong(self):
"""fetch specific list of parameters"""
self._check_skip()
ret = yield self.siamci.fetch_params(['startDelayMsec', 'WRONG_PARAM'])
self.assertIsSuccessFail(ret)
self.assertEquals(ret.result, ERROR)
@defer.inlineCallbacks
def test_fetch_params_all(self):
"""fetch all parameters"""
self._check_skip()
ret = yield self.siamci.fetch_params()
self.assertIsSuccessFail(ret)
self.assertEquals(ret.result, OK)
@defer.inlineCallbacks
def test_set_params_good(self):
self._check_skip()
ret = yield self.siamci.set_params({'startDelayMsec' : '1000' })
self.assertIsSuccessFail(ret)
self.assertEquals(ret.result, OK)
@defer.inlineCallbacks
def test_set_params_wrong(self):
self._check_skip()
ret = yield self.siamci.set_params({'startDelayMsec' : '1000'
, 'WRONG_PARAM' : 'fooVal'
})
self.assertIsSuccessFail(ret)
self.assertEquals(ret.result, ERROR)
class TestSiamCiAdapterProxyDataAsync(SiamCiTestCase):
# increase timeout for Trial tests
timeout = 120
@defer.inlineCallbacks
def setUp(self):
yield self._start_container(sysname=sysname)
self.siamci = SiamCiAdapterProxy(SiamCiTestCase.pid, SiamCiTestCase.port)
yield self.siamci.start()
@defer.inlineCallbacks
def tearDown(self):
yield self.siamci.stop()
yield self._stop_container()
@defer.inlineCallbacks
def test_acquisition_start_verify_data(self, receiver_service_name='test_acquisition_start_verify_data'):
"""
- start receiver service and set expected publish id
- start acquisition
- get expected elements with some timeout
- verify all exptected were received.
Note that this test does not stop the acquisition. Unless this is explicitly stopped
by a caller (see next test), the receiver service will shutdown during tearDown, but
also note that the SIAM-CI service will also eventually stop sending the notifications
because they won't be delivered successfully anymore.
"""
self._check_skip()
receiver_client = yield self._start_receiver_service(receiver_service_name)
# @todo: capture channel from some parameter?
channel = "val"
#
# @todo: more robust assignment of publish IDs
#
publish_id = "data_acquisition;port=" + SiamCiTestCase.port + ";channel=" + channel
# prepare to receive result:
yield receiver_client.expect(publish_id);
ret = yield self.siamci.execute_StartAcquisition(channel=channel,
publish_stream=sysname + "." + receiver_service_name)
self.assertIsSuccessFail(ret)
self.assertEquals(ret.result, OK)
# check that all expected were received
expected = yield receiver_client.getExpected(timeout=30)
self.assertEquals(len(expected), 0)
# actual response should indicate OK:
response = yield receiver_client.getAccepted(publish_id)
self.assertIsSuccessFail(response)
self.assertEquals(response.result, OK)
defer.returnValue((receiver_client, channel, publish_id))
@defer.inlineCallbacks
def test_acquisition_start_wait_stop(self):
"""
- start acquisition by calling test_acquisition_start_verify_data
- wait for a few seconds
- stop acquisition
"""
self._check_skip()
receiver_service_name='test_acquisition_start_wait_stop'
# start acquisition
(receiver_client, channel, publish_id) = \
yield self.test_acquisition_start_verify_data(receiver_service_name)
# wait for a few samples to be notified to the receiver service
yield pu.asleep(20)
# stop acquisition
ret = yield self.siamci.execute_StopAcquisition(channel=channel,
publish_stream=sysname + "." + receiver_service_name)
self.assertIsSuccessFail(ret)
self.assertEquals(ret.result, OK)
