class PoolDummyTriggerGateTestCase(unittest.TestCase):
"""Parameterizable integration test of the PoolSynchronization action and
the DummTriggerGateController.
Using insertTest decorator, one can add tests of a particular trigger/gate
characteristic.
"""
def setUp(self):
"""Create a Controller, TriggerGate and PoolSynchronization objects from
dummy configurations
"""
unittest.TestCase.setUp(self)
pool = FakePool()
dummy_tg_ctrl = createPoolController(pool, dummyPoolTGCtrlConf01)
self.dummy_tg = createPoolTriggerGate(pool, dummy_tg_ctrl,
dummyTriggerGateConf01)
# marrying the element with the controller
dummy_tg_ctrl.add_element(self.dummy_tg)
self.ctrl_conf = createControllerConfiguration(dummy_tg_ctrl,
[self.dummy_tg])
# marrying the element with the action
self.tg_action = PoolSynchronization(self.dummy_tg)
self.tg_action.add_element(self.dummy_tg)
def generation(self, synchronization):
"""Verify that the created PoolTGAction start_action starts correctly
the involved controller."""
args = ([self.ctrl_conf], synchronization)
self.tg_action.start_action(*args)
self.tg_action.action_loop()
# TODO: add asserts applicable to a dummy controller e.g. listen to
# state changes and verify if the change ON->MOVING-ON was emitted
def tearDown(self):
unittest.TestCase.tearDown(self)
class SynchronizationTestCase(object):
"""Base class for integration tests of PoolSynchronization class and any
PoolTriggerGateController. Test is parameterized using trigger parameters.
.. seealso:: :meth:`taurus.test.base.insertTest`"""
def createElements(self, ctrl_klass, ctrl_lib, ctrl_props):
# create controller and element
ctrl_conf = createCtrlConf(self.pool, 'tgctrl01', ctrl_klass, ctrl_lib,
ctrl_props)
elem_conf = createElemConf(self.pool, 1, 'tg01')
self.tg_ctrl = createPoolController(self.pool, ctrl_conf)
self.tg_elem = createPoolTriggerGate(self.pool, self.tg_ctrl,
elem_conf)
# add controller and elements to containers
self.tg_ctrl.add_element(self.tg_elem)
self.pool.add_element(self.tg_ctrl)
self.pool.add_element(self.tg_elem)
# create Synchronization action and its configuration
self.tg_cfg = createPoolSynchronizationConfiguration(
(self.tg_ctrl, ),
((self.tg_elem, ), ),
)
self.tgaction = PoolSynchronization(self.tg_elem)
self.tgaction.add_element(self.tg_elem)
def setUp(self):
"""Create a FakePool object.
"""
self.pool = FakePool()
def tggeneration(self, ctrl_lib, ctrl_klass, ctrl_props, synchronization):
"""Helper method to verify trigger element states before and after
trigger/gate generation.
:param ctrl_lib: controller library used for the test
:type ctrl_lib: :obj:`str`
:param ctrl_klass: controller class used for the test
:type ctrl_klass: :obj:`str`
:param offset: temporal offset before beginning the trigger generation
:type offset: float
:param active_interval: signal at which triggers will be generated
:type active_interval: float
:param passive_interval: temporal passive period between two active periods
:type passive_interval: float
:param repetitions: number of generated triggers
:type repetitions: int
"""
# create controller and trigger element
self.createElements(ctrl_klass, ctrl_lib, ctrl_props)
# create start_action arguments
args = ()
kwargs = {'config': self.tg_cfg, 'synchronization': synchronization}
# starting action
self.tgaction.start_action(*args, **kwargs)
# verifying that the elements involved in action changed its state
element_state = self.tg_elem.get_state()
msg = ("State after start_action is '%s'. (Expected: '%s')" %
(State.get(element_state), "Moving"))
self.assertEqual(element_state, State.Moving, msg)
# entering action loop
self.tgaction.action_loop()
# verifying that the elements involved in action changed its state
element_state = self.tg_elem.get_state()
msg = ("State after action_loop shall be different than Moving")
self.assertNotEqual(element_state, State.Moving, msg)
def stopGeneration(self):
"""Method used to change the controller (mock) state"""
self.tgaction.stop_action()
def abort_tggeneration(self, ctrl_lib, ctrl_klass, ctrl_props,
synchronization, abort_time):
"""Helper method to verify trigger element states before and after
trigger/gate generation when aborting the trigger generation.
:param ctrl_lib: controller library used for the test
:type ctrl_lib: :obj:`str`
:param ctrl_klass: controller class used for the test
:type ctrl_klass: :obj:`str`
:param offset: temporal offset before beginning the trigger generation
:type offset: float
:param active_interval: signal at which triggers will be generated
:type active_interval: float
:param passive_interval: temporal passive period between two active periods
:type passive_interval: float
:param repetitions: number of generated triggers
:type repetitions: int
:param abort_time: wait this time before stopping the trigger generation.
:type abort_time: float
"""
# create controller and trigger element
self.createElements(ctrl_klass, ctrl_lib, ctrl_props)
# create start_action arguments
args = ()
kwargs = {'config': self.tg_cfg, 'synchronization': synchronization}
# starting action
self.tgaction.start_action(*args, **kwargs)
# verifying that the elements involved in action changed its state
element_state = self.tg_elem.get_state()
msg = ("State after start_action is '%s'. (Expected: '%s')" %
(State.get(element_state), "Moving"))
self.assertEqual(element_state, State.Moving, msg)
# starting timer (abort_time) stop the trigger generation
threading.Timer(abort_time, self.stopGeneration).start()
# entering action loop
self.tgaction.action_loop()
# verifying that the elements involved in action changed its state
element_state = self.tg_elem.get_state()
msg = ("State after action_loop shall be different than Moving")
self.assertNotEqual(element_state, State.Moving, msg)
def tearDown(self):
self.tgaction = None
self.tg_ctrl = None
self.tg_cfg = None
self.tg_elem = None
class SynchronizationTestCase(object):
"""Base class for integration tests of PoolSynchronization class and any
PoolTriggerGateController. Test is parameterized using trigger parameters.
.. seealso:: :meth:`taurus.test.base.insertTest`"""
def createElements(self, ctrl_klass, ctrl_lib, ctrl_props):
# create controller and element
ctrl_conf = createCtrlConf(self.pool, 'tgctrl01', ctrl_klass,
ctrl_lib, ctrl_props)
elem_conf = createElemConf(self.pool, 1, 'tg01')
self.tg_ctrl = createPoolController(self.pool, ctrl_conf)
self.tg_elem = createPoolTriggerGate(self.pool, self.tg_ctrl,
elem_conf)
# add controller and elements to containers
self.tg_ctrl.add_element(self.tg_elem)
self.pool.add_element(self.tg_ctrl)
self.pool.add_element(self.tg_elem)
# create Synchronization action and its configuration
self.conf_ctrl = createControllerConfiguration(self.tg_ctrl,
[self.tg_elem])
self.ctrls = get_acq_ctrls([self.conf_ctrl])
self.tgaction = PoolSynchronization(self.tg_elem)
self.tgaction.add_element(self.tg_elem)
def setUp(self):
"""Create a FakePool object.
"""
self.pool = FakePool()
def tggeneration(self, ctrl_lib, ctrl_klass, ctrl_props,
synchronization):
"""Helper method to verify trigger element states before and after
trigger/gate generation.
:param ctrl_lib: controller library used for the test
:type ctrl_lib: :obj:`str`
:param ctrl_klass: controller class used for the test
:type ctrl_klass: :obj:`str`
:param offset: temporal offset before beginning the trigger generation
:type offset: float
:param active_interval: signal at which triggers will be generated
:type active_interval: float
:param passive_interval: temporal passive period between two active
periods
:type passive_interval: float
:param repetitions: number of generated triggers
:type repetitions: int
"""
# create controller and trigger element
self.createElements(ctrl_klass, ctrl_lib, ctrl_props)
# create start_action arguments
args = (self.ctrls, synchronization)
kwargs = {}
# starting action
self.tgaction.start_action(*args, **kwargs)
# verifying that the elements involved in action changed its state
element_state = self.tg_elem.get_state()
msg = ("State after start_action is '%s'. (Expected: '%s')" %
(State.get(element_state), "Moving"))
self.assertEqual(element_state, State.Moving, msg)
# entering action loop
self.tgaction.action_loop()
# verifying that the elements involved in action changed its state
element_state = self.tg_elem.get_state()
msg = ("State after action_loop shall be different than Moving")
self.assertNotEqual(element_state, State.Moving, msg)
def stopGeneration(self):
"""Method used to change the controller (mock) state"""
self.tgaction.stop_action()
def abort_tggeneration(self, ctrl_lib, ctrl_klass, ctrl_props,
synchronization, abort_time):
"""Helper method to verify trigger element states before and after
trigger/gate generation when aborting the trigger generation.
:param ctrl_lib: controller library used for the test
:type ctrl_lib: :obj:`str`
:param ctrl_klass: controller class used for the test
:type ctrl_klass: :obj:`str`
:param offset: temporal offset before beginning the trigger generation
:type offset: float
:param active_interval: signal at which triggers will be generated
:type active_interval: float
:param passive_interval: temporal passive period between two active
periods
:type passive_interval: float
:param repetitions: number of generated triggers
:type repetitions: int
:param abort_time: wait this time before stopping the trigger generation
:type abort_time: float
"""
# create controller and trigger element
self.createElements(ctrl_klass, ctrl_lib, ctrl_props)
# create start_action arguments
args = (self.ctrls, synchronization)
kwargs = {}
# starting action
self.tgaction.start_action(*args, **kwargs)
# verifying that the elements involved in action changed its state
element_state = self.tg_elem.get_state()
msg = ("State after start_action is '%s'. (Expected: '%s')" %
(State.get(element_state), "Moving"))
self.assertEqual(element_state, State.Moving, msg)
# starting timer (abort_time) stop the trigger generation
threading.Timer(abort_time, self.stopGeneration).start()
# entering action loop
self.tgaction.action_loop()
# verifying that the elements involved in action changed its state
element_state = self.tg_elem.get_state()
msg = ("State after action_loop shall be different than Moving")
self.assertNotEqual(element_state, State.Moving, msg)
def tearDown(self):
self.tgaction = None
self.tg_ctrl = None
self.tg_cfg = None
self.tg_elem = None
class AcquisitionTestCase(BasePoolTestCase):
def setUp(self):
"""Create a Controller, TriggerGate and PoolSynchronization objects from
dummy configurations.
"""
BasePoolTestCase.setUp(self)
self.l = AttributeListener()
self.channel_names = []
def createPoolSynchronization(self, tg_list):
self.main_element = FakeElement(self.pool)
self.tggeneration = PoolSynchronization(self.main_element)
for tg in tg_list:
self.tggeneration.add_element(tg)
self.tggeneration.add_listener(self)
def hw_continuous_acquisition(self, offset, active_interval,
passive_interval, repetitions, integ_time):
"""Executes measurement running the TGGeneration and Acquisition
actions according the test parameters. Checks the lengths of the
acquired data.
"""
# obtaining elements created in the BasePoolTestCase.setUp
tg = self.tgs[self.tg_elem_name]
tg_ctrl = tg.get_controller()
# crating configuration for TGGeneration
tg_cfg = createPoolSynchronizationConfiguration((tg_ctrl,),
((tg,),))
# creating PoolSynchronization action
self.createPoolSynchronization([tg])
channels = []
for name in self.channel_names:
channels.append(self.cts[name])
ct_ctrl = self.ctrls[self.chn_ctrl_name]
# add_listeners
self.addListeners(channels)
# creating acquisition configurations
self.hw_acq_cfg = createCTAcquisitionConfiguration((ct_ctrl,),
(channels,))
# creating acquisition actions
self.hw_acq = PoolAcquisitionHardware(channels[0])
for channel in channels:
self.hw_acq.add_element(channel)
# get the current number of jobs
jobs_before = get_thread_pool().qsize
ct_ctrl.set_ctrl_par('synchronization', AcqSynch.HardwareTrigger)
hw_acq_args = ()
hw_acq_kwargs = {
'integ_time': integ_time,
'repetitions': repetitions,
'config': self.hw_acq_cfg,
}
self.hw_acq.run(hw_acq_args, **hw_acq_kwargs)
tg_args = ()
tg_kwargs = {
'offset': offset,
'active_interval': active_interval,
'passive_interval': passive_interval,
'repetitions': repetitions,
'config': tg_cfg
}
self.tggeneration.run(*tg_args, **tg_kwargs)
# waiting for acquisition and tggeneration to finish
while self.hw_acq.is_running() or self.tggeneration.is_running():
time.sleep(1)
self.do_asserts(self.channel_names, repetitions, jobs_before)
def hw_step_acquisition(self, repetitions, integ_time):
"""Executes measurement running the TGGeneration and Acquisition
actions according the test parameters. Checks the lengths of the
acquired data.
"""
channels = []
for name in self.channel_names:
channels.append(self.cts[name])
ct_ctrl = self.ctrls[self.chn_ctrl_name]
# creating acquisition configurations
self.acq_cfg = createCTAcquisitionConfiguration((ct_ctrl,),
(channels,))
# creating acquisition actions
main_element = FakeElement(self.pool)
self.ct_acq = PoolAcquisitionSoftware(main_element)
for channel in channels:
self.ct_acq.add_element(channel)
ct_ctrl.set_ctrl_par('synchronization', AcqSynch.SoftwareTrigger)
ct_acq_args = ()
ct_acq_kwargs = {
'integ_time': integ_time,
'repetitions': repetitions,
'config': self.acq_cfg,
}
self.ct_acq.run(ct_acq_args, **ct_acq_kwargs)
# waiting for acquisition
while self.ct_acq.is_running():
time.sleep(0.02)
for channel in channels:
name = channel.name
value = channel.value.value
print 'channel: %s = %s' % (name, value)
msg = ('Value for channel %s is of type %s, should be <float>' %
(name, type(value)))
self.assertIsInstance(value, float, msg)
def addListeners(self, chn_list):
for chn in chn_list:
chn.add_listener(self.l)
def do_asserts(self, channel_names, repetitions, jobs_before):
# print acquisition records
table = self.l.get_table()
header = table.dtype.names
print header
n_rows = table.shape[0]
for row in xrange(n_rows):
print row, table[row]
# checking if all channels produced data
for channel in channel_names:
msg = 'data from channel %s were not acquired' % channel
self.assertIn(channel, header, msg)
# checking if all the data were acquired
for ch_name in header:
ch_data_len = len(table[ch_name])
msg = 'length of data for channel %s is %d and should be %d' %\
(ch_name, ch_data_len, repetitions)
self.assertEqual(ch_data_len, repetitions, msg)
# checking if there are no pending jobs
jobs_after = get_thread_pool().qsize
msg = ('there are %d jobs pending to be done after the acquisition ' +
'(before: %d)') % (jobs_after, jobs_before)
self.assertEqual(jobs_before, jobs_after, msg)
def tearDown(self):
BasePoolTestCase.tearDown(self)
self.l = None
self.channel_names = None
class PoolTriggerGateTestCase(unittest.TestCase):
"""Unittest of PoolSynchronization class"""
def setUp(self):
"""Create a Controller, TriggerGate and PoolSynchronization objects from
dummy configurations
"""
unittest.TestCase.setUp(self)
try:
from mock import Mock
except ImportError:
self.skipTest("mock module is not available")
pool = FakePool()
dummy_tg_ctrl = createPoolController(pool, dummyPoolTGCtrlConf01)
self.dummy_tg = createPoolTriggerGate(pool, dummy_tg_ctrl,
dummyTriggerGateConf01)
dummy_tg_ctrl.add_element(self.dummy_tg)
pool.add_element(dummy_tg_ctrl)
pool.add_element(self.dummy_tg)
self.cfg = createPoolSynchronizationConfiguration(
(dummy_tg_ctrl, ),
((self.dummy_tg, ), ),
)
# Create mock and define its functions
ctrl_methods = [
'PreStartAll', 'StartAll', 'PreStartOne', 'StartOne',
'PreStateAll', 'StateAll', 'PreStateOne', 'StateOne',
'PreSynchAll', 'PreSynchOne', 'SynchOne', 'SynchAll'
]
self.mock_tg_ctrl = Mock(spec=ctrl_methods)
self.mock_tg_ctrl.StateOne.return_value = (State.Moving, 'triggering')
dummy_tg_ctrl.ctrl = self.mock_tg_ctrl
self.tgaction = PoolSynchronization(self.dummy_tg)
self.tgaction.add_element(self.dummy_tg)
def stopGeneration(self):
"""Method used to change the controller (mock) state"""
self.mock_tg_ctrl.StateOne.return_value = (State.On, 'On')
def test_tggeneration(self):
"""Verify trigger element states before and after action_loop."""
from mock import call
args = ()
kwargs = {'config': self.cfg}
# starting action
self.tgaction.start_action(*args, **kwargs)
# verifying that the action correctly started the involved controller
self.mock_tg_ctrl.assert_has_calls([
call.PreStartAll(), (call.PreStartOne(1, )), (call.StartOne(1, )),
(call.StartAll())
])
# verifying that the elements involved in action changed its state
element_state = self.dummy_tg.get_state()
msg = ("State after start_action is '%s'. (Expected: '%s')" %
(State.get(element_state), "Moving"))
self.assertEqual(element_state, State.Moving, msg)
# starting timer (1 s) which will change the controller state
threading.Timer(1, self.stopGeneration).start()
# entering action loop
self.tgaction.action_loop()
# verifying that the action checked the controller states
self.mock_tg_ctrl.assert_has_calls([
call.PreStateAll(),
call.PreStateOne(1, ),
call.StateAll(),
call.StateOne(1, )
])
# verifying that the elements involved in action changed its state
element_state = self.dummy_tg.get_state()
msg = ("State after action_loop shall be different than Moving")
self.assertNotEqual(element_state, State.Moving, msg)
def tearDown(self):
self.tgaction = None
self.mock_tg_ctrl = None
self.cfg = None
self.dummy_tg = None
unittest.TestCase.tearDown(self)
class PoolTriggerGateTestCase(unittest.TestCase):
"""Unittest of PoolSynchronization class"""
def setUp(self):
"""Create a Controller, TriggerGate and PoolSynchronization objects from
dummy configurations
"""
unittest.TestCase.setUp(self)
try:
from mock import Mock
except ImportError:
self.skipTest("mock module is not available")
pool = FakePool()
dummy_tg_ctrl = createPoolController(pool, dummyPoolTGCtrlConf01)
self.dummy_tg = createPoolTriggerGate(pool, dummy_tg_ctrl,
dummyTriggerGateConf01)
dummy_tg_ctrl.add_element(self.dummy_tg)
pool.add_element(dummy_tg_ctrl)
pool.add_element(self.dummy_tg)
self.conf_ctrl = createControllerConfiguration(dummy_tg_ctrl,
[self.dummy_tg])
self.ctrls = get_acq_ctrls([self.conf_ctrl])
# self.cfg = createPoolSynchronizationConfiguration((dummy_tg_ctrl,),
# ((self.dummy_tg,),),)
# Create mock and define its functions
ctrl_methods = ['PreStartAll', 'StartAll', 'PreStartOne', 'StartOne',
'PreStateAll', 'StateAll', 'PreStateOne', 'StateOne',
'PreSynchAll', 'PreSynchOne', 'SynchOne', 'SynchAll']
self.mock_tg_ctrl = Mock(spec=ctrl_methods)
self.mock_tg_ctrl.StateOne.return_value = (State.Moving, 'triggering')
dummy_tg_ctrl.ctrl = self.mock_tg_ctrl
self.tgaction = PoolSynchronization(self.dummy_tg)
self.tgaction.add_element(self.dummy_tg)
def stopGeneration(self):
"""Method used to change the controller (mock) state"""
self.mock_tg_ctrl.StateOne.return_value = (State.On, 'On')
def test_tggeneration(self):
"""Verify trigger element states before and after action_loop."""
from mock import call, MagicMock
# starting action
synchronization = MagicMock()
self.tgaction.start_action(self.ctrls, synchronization)
# verifying that the action correctly started the involved controller
self.mock_tg_ctrl.assert_has_calls([call.PreStartAll(),
(call.PreStartOne(1,)),
(call.StartOne(1,)),
(call.StartAll())])
# verifying that the elements involved in action changed its state
element_state = self.dummy_tg.get_state()
msg = ("State after start_action is '%s'. (Expected: '%s')" %
(State.get(element_state), "Moving"))
self.assertEqual(element_state, State.Moving, msg)
# starting timer (1 s) which will change the controller state
threading.Timer(1, self.stopGeneration).start()
# entering action loop
self.tgaction.action_loop()
# verifying that the action checked the controller states
self.mock_tg_ctrl.assert_has_calls([call.PreStateAll(),
call.PreStateOne(1,),
call.StateAll(),
call.StateOne(1,)])
# verifying that the elements involved in action changed its state
element_state = self.dummy_tg.get_state()
msg = ("State after action_loop shall be different than Moving")
self.assertNotEqual(element_state, State.Moving, msg)
def tearDown(self):
self.tgaction = None
self.mock_tg_ctrl = None
self.cfg = None
self.dummy_tg = None
unittest.TestCase.tearDown(self)