class BasePoolTestCase(object): """Abstract class for pool DS testing. """ pool_ds_name = getattr(sardanacustomsettings, 'UNITTEST_POOL_DS_NAME') pool_name = getattr(sardanacustomsettings, 'UNITTEST_POOL_NAME') def setUp(self): """Start Pool DS and register extensions. """ # Discover the Pool launcher script poolExec = whichexecutable.whichfile("Pool") # register Pool server pool_ds_name = "Pool/" + self.pool_ds_name pool_free_ds_name = get_free_server(PyTango.Database(), pool_ds_name) self._starter = ProcessStarter(poolExec, pool_free_ds_name) # register Pool device dev_name_parts = self.pool_name.split('/') prefix = '/'.join(dev_name_parts[0:2]) start_from = int(dev_name_parts[2]) self.pool_name = get_free_device( PyTango.Database(), prefix, start_from) self._starter.addNewDevice(self.pool_name, klass='Pool') # start Pool server self._starter.startDs() # register extensions so the test methods can use them self.pool = PyTango.DeviceProxy(self.pool_name) def tearDown(self): """Remove the Pool instance. """ self._starter.cleanDb(force=True) self._starter = None self.pool = None self.pool_name = None
def taurus_test_ds(): """ A pytest fixture that launches TangoSchemeTest for the test It provides the device name as the fixture value. Usage:: from taurus.core.tango.test import taurus_test_ds def test_foo(taurus_test_ds): import taurus d = taurus.Device(taurus_test_ds) assert d["string_scalar"].rvalue == "hello world" """ ds_name = 'TangoSchemeTest/unittest/temp-{:08d}'.format( randint(0, 99999999)) # get path to DS and executable device = getResourcePath('taurus.core.tango.test.res', 'TangoSchemeTest') # create starter for the device server _starter = ProcessStarter(device, 'TangoSchemeTest/unittest') # register _starter.addNewDevice(ds_name, klass='TangoSchemeTest') # start device server _starter.startDs() yield ds_name d = PyTango.DeviceProxy(ds_name) d.Reset() _starter.stopDs(hard_kill=True) # remove server _starter.cleanDb(force=True)
class TaurusCommandButtonTest2(BaseWidgetTestCase, unittest.TestCase): _klass = TaurusCommandButton initkwargs = dict(command='TimeoutCmd') def setUp(self): ''' Requisites: - instantiate the widget - make sure that the the timeout server is ready ''' # Call base class setup (instantiate the widget,...) BaseWidgetTestCase.setUp(self) # get path to DS and executable timeoutExec = getResourcePath('taurus.qt.qtgui.button.test.res', 'Timeout') # create starter for the Timeout server self._starter = ProcessStarter(timeoutExec, 'Timeout/unittest') # register timeoutserver #TODO: guarantee that devname is not in use devname = 'unittests/timeout/temp-1' self._starter.addNewDevice(devname, klass='Timeout') # start Timeout server self._starter.startDs() # Configure the widget self._widget.setModel(devname) def tearDown(self): '''Stop the timeout server and undo changes to the database''' self._widget.setModel(None) # remove timeoutserver self._starter.cleanDb(force=True) def testTimeOutError(self): '''Check that the timeout property works''' # lets use commands that take at least 200ms in returning self._widget.setParameters([.2]) # With a long timeout it should work... self._widget.setTimeout(10) ret = self._widget._onClicked() msg = 'expected return None when timeout >> command response time' self.assertIsNone(ret, msg) #...but with a shorter timeout we expect a timeout exception self._widget.setTimeout(.1) self.assertRaises(CommunicationFailed, self._widget._onClicked)
class BaseMacroServerTestCase(object): """Abstract class for macroserver DS testing. """ ms_ds_name = getattr(sardanacustomsettings, 'UNITTEST_MS_DS_NAME', "unittest1") ms_name = getattr(sardanacustomsettings, 'UNITTEST_MS_NAME', "macroserver/demo1/1") door_name = getattr(sardanacustomsettings, 'UNITTEST_DOOR_NAME', "door/demo1/1") def setUp(self, properties=None): """ Start MacroServer DS. :param properties: dictionary with the macroserver properies. """ try: db = PyTango.Database() # Discover the MS launcher script msExec = whichexecutable.whichfile("MacroServer") # register MS server ms_ds_name_base = "MacroServer/" + self.ms_ds_name self.ms_ds_name = get_free_server(db, ms_ds_name_base) self._msstarter = ProcessStarter(msExec, self.ms_ds_name) # register MS device dev_name_parts = self.ms_name.split('/') prefix = '/'.join(dev_name_parts[0:2]) start_from = int(dev_name_parts[2]) self.ms_name = get_free_device(db, prefix, start_from) self._msstarter.addNewDevice(self.ms_name, klass='MacroServer') # register Door device dev_name_parts = self.door_name.split('/') prefix = '/'.join(dev_name_parts[0:2]) start_from = int(dev_name_parts[2]) self.door_name = get_free_device(db, prefix, start_from) self._msstarter.addNewDevice(self.door_name, klass='Door') # Add properties if properties: for key, values in list(properties.items()): db.put_device_property(self.ms_name, {key: values}) # start MS server self._msstarter.startDs(wait_seconds=20) self.door = PyTango.DeviceProxy(self.door_name) except Exception as e: # force tearDown in order to eliminate the MacroServer print(e) self.tearDown() def tearDown(self): """Remove the MacroServer instance and its properties file. """ self._msstarter.cleanDb(force=True) self._msstarter = None self.macroserver = None self.door = None db = PyTango.Database() prop = db.get_device_property(self.ms_name, "EnvironmentDb") ms_properties = prop["EnvironmentDb"] if not ms_properties: dft_ms_properties = os.path.join( MacroServerClass.DefaultEnvBaseDir, MacroServerClass.DefaultEnvRelDir) ds_inst_name = self.ms_ds_name.split("/")[1] ms_properties = dft_ms_properties % { "ds_exec_name": "MacroServer", "ds_inst_name": ds_inst_name } ms_properties = os.path.normpath(ms_properties) extensions = [".bak", ".dat", ".dir"] for ext in extensions: name = ms_properties + ext if not os.path.exists(name): continue try: os.remove(name) except Exception as e: msg = "Not possible to remove macroserver environment file" print(msg) print(("Details: %s" % e))