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)